Loading...
SIGN IN
2 400 000 000
2,4
billion
gamers regularly play video games
>30% of humanity
Thousands of hours gamers spend in virtual worlds developing their skills and abilities:
  • Multitasking
  • Concentration
  • Reaction
  • System thinking
  • Neuroplasticity
  • Online cooperation
The potential of gamers is realized when the focus of their attention switches to the real world
“I happily played World of Warcraft during 2007-2010, but one day Blizzard removed the damage component from my beloved warlock's Siphon Life spell. I cried myself to sleep, and on that day I realized what horrors centralized services can bring.” /Vitalik Buterin/
"I definitely wouldn't have gotten into programming if I hadn't played games." /Mark Zuckerberg/
"The chance we are not living in a computer simulation is one in billions." /Elon Musk/
Our system created for involving gamers in real activity
Platform for introduce mechanics of computer games in the real world

Game mechanics

Experience points
Levels
Achievements
Ratings
Characteristics
Game currency
Missions
Competitions
Contests
Virtual property

How it works

Use-cases

HR

Introduction of motivating game elements in to employee's ordinary duties.
  • Increase of workforce productivity
  • Team building
  • Reduction of employee turnover

MARKETING

Using game and social mechanics in marketing can enhance brand appeal.
  • Increase in sales
  • Formation of a community brand
  • Increase of customer loyalty

EDUCATION

Gamification in education is an innovative educational technology that implements the process of learning in a game format.
  • Involving students in learning
  • Warm up motivation by awarding for right actions

BEHAVIOUR PREDICTION

Neural network detects patterns of behaviour and characteristics of participants.
  • Prediction of Behaviour
  • Selection of target groups for targeted campaigns
  • Formation of a psychological portrait of audience

WEB SERVICES

Evolution+ provides developers tools for fast and profitable implementation of game mechanics for a projects.
  • Platform for managing game mechanics
  • API, SDK, Webhooks
  • Widgets
  • Plugins

SOCIAL RANKING

Quantity of rating points is determined by such things as: socially useful activities, professional achievements, education, violations and crimes, feedback, etc.
  • Increase in level of trust in society
  • Motivation for positive achievement
  • Involvement in public activity

EVP Token

CURRENT PRICE
0.000137 BTC 0.001994 ETH
GET EVP TOKENS

EVP TOKEN DISTRIBUTION

Offered for sale
Remain for Evolution+ Team
Reserved for Bounty Program
60%
20%
20%

SMART CONTRACT

0xcfa5316cb6cf924736523d5241bef4d6cbe92c25

pragma solidity ^0.4.18;

// Math operations with safety checks that throw on error
library SafeMath {
	
	function mul(uint256 a, uint256 b) internal pure returns (uint256) {
		if (a == 0) {
			return 0;
		}
		uint256 c = a * b;
		assert(c / a == b);
		return c;
	}

	function div(uint256 a, uint256 b) internal pure returns (uint256) {
		assert(b > 0);
		uint256 c = a / b;
		assert(a == b * c + a % b);
		return c;
	}

	function sub(uint256 a, uint256 b) internal pure returns (uint256) {
		assert(b <= a);
		return a - b;
	}

	function add(uint256 a, uint256 b) internal pure returns (uint256) {
		uint256 c = a + b;
		assert(c >= a);
		return c;
	}
	
}

// Simpler version of ERC20 interface
contract ERC20Basic {
	
	uint256 public totalSupply;
	function balanceOf(address who) public constant returns (uint256);
	function transfer(address to, uint256 value) public returns (bool);
	event Transfer(address indexed from, address indexed to, uint256 value);
	
}

// Basic version of StandardToken, with no allowances.
contract BasicToken is ERC20Basic {
	
	using SafeMath for uint256;
	mapping(address => uint256) balances;

	function transfer(address _to, uint256 _value) public returns (bool) {
		require(_to != address(0));
		require(_value <= balances[msg.sender]);

		// SafeMath.sub will throw if there is not enough balance.
		balances[msg.sender] = balances[msg.sender].sub(_value);
		balances[_to] = balances[_to].add(_value);
		Transfer(msg.sender, _to, _value);
		return true;
	}

	//Gets the balance of the specified address.
	function balanceOf(address _owner) public view returns (uint256 balance) {
		return balances[_owner];
	}

}

//ERC20 interface
// see https://github.com/ethereum/EIPs/issues/20
contract ERC20 is ERC20Basic {
	
	function allowance(address owner, address spender) public view returns (uint256);
	function transferFrom(address from, address to, uint256 value) public returns (bool);
	function approve(address spender, uint256 value) public returns (bool);
	event Approval(address indexed owner, address indexed spender, uint256 value);
	
}

// Standard ERC20 token
contract StandardToken is ERC20, BasicToken {

	mapping (address => mapping (address => uint256)) allowed;

	// Transfer tokens from one address to another
	function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
		
		var _allowance = allowed[_from][msg.sender];
		require (_value <= _allowance);
		balances[_to] = balances[_to].add(_value);
		balances[_from] = balances[_from].sub(_value);
		allowed[_from][msg.sender] = _allowance.sub(_value);
		Transfer(_from, _to, _value);
		return true;

	}

	//Aprove the passed address to spend the specified amount of tokens on behalf of msg.sender.
	function approve(address _spender, uint256 _value) public returns (bool) {

		// To change the approve amount you first have to reduce the addresses`
		// allowance to zero by calling `approve(_spender, 0)` if it is not
		// already 0 to mitigate the race condition described here:
		// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
		require((_value == 0) || (allowed[msg.sender][_spender] == 0));

		allowed[msg.sender][_spender] = _value;
		Approval(msg.sender, _spender, _value);
		return true;
	}

	//Function to check the amount of tokens that an owner allowed to a spender.
	function allowance(address _owner, address _spender) constant public returns (uint256 remaining) {
		return allowed[_owner][_spender];
	}
	
}

// The Ownable contract has an owner address, and provides basic authorization control
// functions, this simplifies the implementation of "user permissions".
contract Ownable {
	
	address public owner;

	// The Ownable constructor sets the original `owner` of the contract to the sender account.
	function Ownable() public {
		owner = msg.sender;
	}

	// Throws if called by any account other than the owner.
	modifier onlyOwner() {
		require(msg.sender == owner);
		_;
	}

	// Allows the current owner to transfer control of the contract to a newOwner.
	function transferOwnership(address newOwner) public onlyOwner {
		if (newOwner != address(0)) {
			owner = newOwner;
		}
	}

}

// Base contract which allows children to implement an emergency stop mechanism.
contract Pausable is Ownable {
	
	event Pause();
	event Unpause();

	bool public paused = false;

	modifier whenNotPaused() {
		require(!paused);
		_;
	}

	modifier whenPaused {
		require(paused);
		_;
	}

	function pause() public onlyOwner whenNotPaused returns (bool) {
		paused = true;
		Pause();
		return true;
	}

	function unpause() public onlyOwner whenPaused returns (bool) {
		paused = false;
		Unpause();
		return true;
	}
	
}

// Evolution+ Token
contract EVPToken is StandardToken, Pausable {
	
	uint256 public totalSupply = 22000000 * 1 ether;
	string public name = "Evolution+ Token"; 
	uint8 public decimals = 18; 
	string public symbol = "EVP";
	
	// Contract constructor function sets initial token balances
	function EVPToken() public {
		balances[msg.sender] = totalSupply;
	}

	function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
		return super.transfer(_to, _value);
	}

	function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
		return super.transferFrom(_from, _to, _value);
	}

	function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
		return super.approve(_spender, _value);
	}

}

ROADMAP

2015
  • Hypotheses testing
  • Start of development
2016
  • First implementations
  • Formation of concepts
  • Functionality development
2017
  • Business model formation
  • Integration with Ethereum blockchain
  • Cryptotoken emission
2018
  • Release of Artificial Intelligence
  • Formation of the Evolution+ Ecosystem
  • Preparation for entering worldwide markets
2019
  • Access to the markets of Europe, USA, Asia

DEVELOPMENT

EVOLUTION+
Gamification Platform
CLOSED BETA
  • Management of game scenarios
  • Web-interface
  • Widgets
  • Analytics
  • API
REACHED
Artificial Intelligence
CLOSED BETA
  • Activity analytics
  • Behavior prediction
  • Psychoanalysis
  • Audience segmentation
Q3 2018
EVOLUTION+
Gamification Platform
OPEN BETA
  • Smart-contracts support
  • Artificial Intelligence
  • Gamification Wizard
  • Security and stress-resistance
  • Plugins and integrations
Q4 2018

PEOPLE BEHIND EVOLUTION+ PROJECT

Alex Black
Creator & Founder
Sergey Kuznetsov
Digital Marketing Executive
Valentin Bese
Sales representative
in Germany