EASYCLUB is just a game for blockchain,see https://ecgame.github.io.
- = 46% static incomes
- <=46% dynamic incomes
- 5% recommended champion prize pool
- 3% platform fee
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function div(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
/**
* @dev gives square root of given x.
*/
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
//10000×(1-5%)^180≈0.98
/**
* @dev gives square. multiplies x by x
*/
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
/**
* @dev x to the power of y
*/
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
}
contract EasyClub is Referrer {
using SafeMath for *;
uint256 dynamicRate = 10;
uint256 public stcPerior = 1 days;
uint256 public poltime = 24 hours;
uint256 public zeroPerior = 10 days;
uint256 divpool = 5;
uint256 icmFndTms = 31;
uint256 public dyFloor = 10;
uint256 public poitProfit;
string constant public name = "Easy Club";
mapping (uint256 => uint256) id2Mask;
mapping (address => mapping (uint256 => Data.PlayerRound)) public playerRnds;
mapping (uint256 => Data.Round) public round;
mapping (address => Data.Player) public player;
function referral4Skp(address _pAddress_, address _referrer_)
private
{
if(_referrer_ != address(0)
&& _pAddress_ != _referrer_
&& !isExitsReferrer(_pAddress_)
&& player[_referrer_].t > 0
&& isCanRegist(_pAddress_)
&& !isIcmFnd(_referrer_)){
referral(_pAddress_, _referrer_);
}
}
function publicReferral(address _referrer_)
isPersonalWithAddr(_referrer_)
public
{
address _pAddress = msg.sender;
require(_referrer_ != address(0) && _pAddress != _referrer_);
require(!isExitsReferrer(_pAddress));
require(player[_referrer_].t > 0);
require(isCanRegist(_pAddress));
require(!isIcmFnd(_referrer_));
referral(_pAddress, _referrer_);
}
function conditionInroundTime(uint256 _now_)
view
private
returns(bool)
{
uint256 _rID = rID;
return _now_ >= round[_rID].strt && (_now_ <= round[_rID].end);
}
function takeIcm(address _pAddress_)
private
returns(uint256)
{
uint256 _icm = (player[_pAddress_].win).add(player[_pAddress_].gen).add(player[_pAddress_].dy);
uint256 _res;
if (_icm > 2)
{
player[_pAddress_].win = 0;
player[_pAddress_].gen = 1;
//default 1
player[_pAddress_].dy = 1;
_res = _icm.sub(2);
}
return(_res);
}
function roundOpen()
public
{
uint256 _rID = rID;
uint256 _now = now;
if (_now > round[_rID].end && round[_rID].ended == false)
{
round[_rID].ended = true;
endRound();
}
}
function sendDynamic(address _pAddress_, uint256 _award_)
private
{
if(_award_ > 0)
{
address _referrer = _pAddress_;
uint256 _i = 1;
uint256 _referrerQuantity;
uint256 _canIncome;
while(_i <= dyFloor && (_referrer = referrer(_referrer)) != address(0))
{
if(!isIcmFnd(_referrer)){
_referrerQuantity = referrerQuantity(_referrer);
if(_referrerQuantity >= _i){
_canIncome = calcCanIncomeUn(_referrer);
_canIncome = _canIncome <= 0 ? 0 : _canIncome < _award_ ? _canIncome : _award_;
player[_referrer].dy = _canIncome.add(player[_referrer].dy);
player[_referrer].tdy = _canIncome.add(player[_referrer].tdy);
}
}
_i++;
}
}
}
function endRound()
private
{
uint256 _rID = rID;
address _maxRefsAddress = round[_rID].maxRefsAddress;
uint256 _win;
uint256 _pot = round[_rID].pot;
if(_pot > 0)
{
if(_maxRefsAddress != address(0)){
_win = (_pot.mul(10)).div(100);
if(_win > 0){
player[_maxRefsAddress].win = _win.add(player[_maxRefsAddress].win);
}
}
}
rID++;
_rID++;
round[_rID].strt = now;
round[_rID].end = now.add(poltime);
round[_rID].pot = _pot.sub(_win);
}
}