/** *Submitted for verification at Etherscan.io on 2020-01-31*//****   ,d8888b                                                    
*   88P'                                                       
*d888888P                                                      
*  ?88'     d8888b   88bd88b .d888b, d888b8b   d888b8b   d8888b*  88P     d8P' ?88  88P'  ` ?8b,   d8P' ?88  d8P' ?88  d8b_,dP* d88      88b  d88 d88        `?8b 88b  ,88b 88b  ,88b 88b    
*d88'      `?8888P'd88'     `?888P' `?88P'`88b`?88P'`88b`?888P'*                                                    )88       
*                                                   ,88P       
*                                               `?8888P        
** 
* SmartWay Forsage* https://forsage.smartway.run* (only for SmartWay.run members)* 
**/// Forsage源码解析// 代码版本定义pragma solidity >=0.4.23 <0.6.0;// 合约名称：智能矩阵【为智者】contract SmartMatrixForsage {
    // 用户    struct User {
        uint id; // 用户ID        address referrer; // 推荐人地址        uint partnersCount; // 团队总人数
        mapping(uint8 => bool) activeX3Levels; // X3模块：记录X3点位是否开通        mapping(uint8 => bool) activeX6Levels; // X6模块：记录X6点位是否开通
        mapping(uint8 => X3) x3Matrix; // 对应X3的12个矩阵        mapping(uint8 => X6) x6Matrix; // 对应X6的12个矩阵    }
    struct X3 {
        address currentReferrer; // 当前落座点位的上级地址        address[] referrals; // 矩阵内已占点位的地址（下级地址）        bool blocked; // 是否阻塞        uint reinvestCount; // 复投次数    }
    struct X6 {
        address currentReferrer; // 当前落座点位的上级地址        address[] firstLevelReferrals; // 第一级点位地址        address[] secondLevelReferrals; // 第二级点位地址        bool blocked; // 是否阻塞（烧伤）        uint reinvestCount; // 复投次数
        address closedPart; //  封锁的地址    }
    uint8 public constant LAST_LEVEL = 12; // 定义每模块矩阵个数为12个
    mapping(address => User) public users; // 所有用户数据：地址——>用户数据    mapping(uint => address) public idToAddress; // 所有ID数据：ID——>地址    mapping(uint => address) public userIds; // 
    mapping(address => uint) public balances; // 所有地址数据：地址——>余额
    uint public lastUserId = 2; // 最新的ID，目前为2    address public owner; // 合约拥有者地址
    mapping(uint8 => uint) public levelPrice; // 矩阵价格：矩阵位数——>激活矩阵的价格
    // 以下event为事件，意思是当用户触发了某些条件的时候，合约就会给用户发送一些数据，这里也可以理解为给用户发送消息    // 注册消息：发送用户地址、用户推荐人地址、用户ID、推荐人ID    event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
    // 复投消息：用户地址、用户当前推荐人地址、调用者、矩阵模块（X3 or X6）、矩阵等级    event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
    // 矩阵升级（激活）消息：用户地址、用户推荐人地址、矩阵模块（X3 or X6）、矩阵等级    event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
    // 
    event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
    // 烧伤消息：接收者地址、点位来源地址、矩阵模块（X3 or X6）、矩阵等级    event MissedEthReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
    // 发送ETH消息：ETH来源地址、ETH接收者地址、矩阵模块（X3 or X6）、矩阵等级    event SentExtraEthDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);
    // 构造函数：合约刚开始部署到以太坊上需要首先输入的内容——>传入创始人地址，之后无法修改    // 创始人就是合约拥有者，这里为了方便大家观看，以下我就说创始人    constructor(address ownerAddress) public {
        // 第一个矩阵价格：0.025以太币        levelPrice[1] = 0.025 ether;
        // 第二个矩阵的价格是前一个矩阵的两倍，一共12矩阵，循环计算11次        for (uint8 i = 2; i <= LAST_LEVEL; i++) {
            levelPrice[i] = levelPrice[i-1] * 2;
        }
        // 记录创始人        owner = ownerAddress;
        // 把创始人定义为ID为1的用户        User memory user = User({
            id: 1, // ID为1            referrer: address(0), // 推荐人为空            partnersCount: uint(0) // 团队成员目前为0            });
        // 把创始人记到用户总册里        users[ownerAddress] = user;
        // 把创始人记到ID总册里        idToAddress[1] = ownerAddress;
        // 创始人的X3、X6的所有矩阵全部开通，没有花钱        for (uint8 i = 1; i <= LAST_LEVEL; i++) {
            users[ownerAddress].activeX3Levels[i] = true;
            users[ownerAddress].activeX6Levels[i] = true;
        }
        // 用户ID为1的记录为创始人        userIds[1] = ownerAddress;
    }
    // 系统定义，外部调用可以转账的方法【不懂代码不需要理解】    function() external payable {
        // 判断新用户是否有推荐人，如果没有，则默认推荐人为创始人        if(msg.data.length == 0) {
            return registration(msg.sender, owner);
        }
        // 如果有推荐人地址，则开始注册，传入 新用户地址、推荐人地址        registration(msg.sender, bytesToAddress(msg.data));
    }
    // 新用户注册：传入推荐人地址    function registrationExt(address referrerAddress) external payable {
        // 使用新用户地址、推荐人地址开始注册        registration(msg.sender, referrerAddress);
    }
    // 购买新的矩阵等级：输入X3 或 X6模块，矩阵等级序列    function buyNewLevel(uint8 matrix, uint8 level) external payable {
        // 调用者必须是激活用户        require(isUserExists(msg.sender), "user is not exists. Register first.");
        // 必须选择X3 或 X6矩阵        require(matrix == 1 || matrix == 2, "invalid matrix");
        // 购买价格必须符合等级对应要求        require(msg.value == levelPrice[level], "invalid price");
        // 1 < 已开通矩阵等级必须小于 < 12        require(level > 1 && level <= LAST_LEVEL, "invalid level");
        // 选择购买的是X3模块        if (matrix == 1) {
            // 用户X3对应的矩阵必须是未激活状态            require(!users[msg.sender].activeX3Levels[level], "level already activated");
            // 如果用户的前一级矩阵被阻塞，这里给他打开，之后就可以继续获得收益            if (users[msg.sender].x3Matrix[level-1].blocked) {
                users[msg.sender].x3Matrix[level-1].blocked = false;
            }
            // 获取该用户已经激活同矩阵的实际推荐人            address freeX3Referrer = findFreeX3Referrer(msg.sender, level);
            // 将实际推荐人填入用户的X3对应矩阵的推荐人地址中            users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;
            // 激活用户对应X3矩阵            users[msg.sender].activeX3Levels[level] = true;
            // 更新实际推荐人的X3矩阵            updateX3Referrer(msg.sender, freeX3Referrer, level);
            // 发送升级消息：用户地址、实际推荐人地址、X3模块、对应等级            emit Upgrade(msg.sender, freeX3Referrer, 1, level);
        // 选择购买的是X6矩阵        } else {
            // 用户X6对应的矩阵必须是未激活状态            require(!users[msg.sender].activeX6Levels[level], "level already activated");
            // 如果用户的前一级矩阵被阻塞，这里给他打开，之后就可以继续获得收益            if (users[msg.sender].x6Matrix[level-1].blocked) {
                users[msg.sender].x6Matrix[level-1].blocked = false;
            }
            // 获取该用户已经激活同矩阵的实际推荐人            address freeX6Referrer = findFreeX6Referrer(msg.sender, level);
            // 激活用户对应X6矩阵            users[msg.sender].activeX6Levels[level] = true;
            // 更新实际推荐人的X6矩阵            updateX6Referrer(msg.sender, freeX6Referrer, level);
            // 发送升级消息：用户地址、实际推荐人地址、X6模块、对应等级            emit Upgrade(msg.sender, freeX6Referrer, 2, level);
        }
    }
    // 新用户注册：新用户地址、推荐人地址    function registration(address userAddress, address referrerAddress) private {
        // 注册必须有0.05个ETH（不含手续费），否则出错        require(msg.value == 0.05 ether, "registration cost 0.05");
        // 注册用户必须为新用户，如果是老用户，出错        require(!isUserExists(userAddress), "user exists");
        // 推荐人必须是老用户，如果不是老用户，出错        require(isUserExists(referrerAddress), "referrer not exists");
        // 计算新用户地址长度（大小）        uint32 size;
        assembly {
            size := extcodesize(userAddress)
        }
        // 如果长度（大小）为0，出错        require(size == 0, "cannot be a contract");
        // 创建新用户对象        User memory user = User({
            id: lastUserId, // 新用户的ID为最新ID            referrer: referrerAddress, // 推荐人地址为传入的推荐人地址            partnersCount: 0 // 团队人数为0            });
        users[userAddress] = user; // 保存新用户数据：新用户地址——>新用户数据        idToAddress[lastUserId] = userAddress; // 新用户ID——>新用户地址
        // 再记录一次新用户的推荐人地址        users[userAddress].referrer = referrerAddress;
        // 激活（打开）X3和X6第一个矩阵        users[userAddress].activeX3Levels[1] = true;
        users[userAddress].activeX6Levels[1] = true;
        // 把新用户地址记录到ID总册里，然后最新的ID+1，等待下一个新用户        userIds[lastUserId] = userAddress;
        lastUserId++;
        // 推荐人的团队人数+1        users[referrerAddress].partnersCount++;
        // 确认X3推荐人地址，如果是前两个点位，就是直推人地址；如果是第三个点位，就是直推人的推荐人地址；如果推荐人是创始人，ID为1，那第三个点位的推荐人还是创始人        // 传入 新用户地址，X3模块        address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
        // 将确认到的X3推荐人地址填入新用户X3第一个矩阵的推荐人地址中        users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;