Arcado Network Brings Decentralized Reward Systems to Video Games

const errors = [];
const genesis = store.account.get("16313739661670634666L");
let asset = {
    games: [],
    ...genesis.asset
}

asset.games.push({
    createdBy: this.asset.address,
    name: this.asset.name,
    roomId: this.asset.roomId,
    gameId: this.asset.gameId,
    entryFee: this.asset.entryFee, // string
    participants: [this.asset.address],
    distribution: this.asset.distribution,
    maxPlayers: this.asset.maxPlayers,
    status: 0 // 0 open to join, 1 started, 2 ended
})

const updatedGenesis = {
    ...genesis,
    asset
};
store.account.set(genesis.address, updatedGenesis);

const player = store.account.get(this.asset.address);
const playerBalance = new utils.BigNum(player.balance);
const entryFeeBalance = new utils.BigNum(this.asset.entryFee)
const updatedPlayerBalance = playerBalance.sub(entryFeeBalance);
const updatedPlayer = {
    ...player,
    balance: updatedPlayerBalance.toString()
}

store.account.set(player.address, updatedPlayer);

const game = genesis.asset.games.find(game => game.roomId === this.asset.roomId)
if (!game) {
    errors.push(
        new TransactionError(
            '"asset.roomId" does not exist',
            this.id,
            '.asset.roomId',
            this.asset.roomId
        )
    );
    return errors;
}

if (game.participants.length >= game.maxPlayers) {
    errors.push(
        new TransactionError(
            'Game is already full',
            this.id,
            '.asset.maxPlayers',
            game.maxPlayers
        )
    );
    return errors;
}

const playerBalance = new utils.BigNum(player.balance);
if (playerBalance.lt(game.entryFee)) {
    errors.push(
        new TransactionError(
            'Insufficient balance for player',
            this.id,
            '.asset.entryFee',
            player.balance
        )
    );
    return errors;
}

const genesis = store.account.get("16313739661670634666L");

// Check if sender is the owner of the room otherwise reject
const game = genesis.asset.games.find(game => game.roomId === this.asset.roomId)
if (game.createdBy !== this.asset.address) {
    errors.push(
        new TransactionError(
            '"asset.address" does not match createdBy field for room - you are not the owner of the room',
            this.id,
            '.asset.address',
            this.asset.address,
            game.createdBy
        )
    );
    return errors;
}

// Pay out the winnings
const distribution = asset.games[gameIndex].distribution
const numOfParticipants = asset.games[gameIndex].participants.length
const entryFeeBalance = new utils.BigNum(asset.games[gameIndex].entryFee)
const total = entryFeeBalance.mul(numOfParticipants)
const firstWinnings = total.div(100).mul(distribution.first)
const secondWinnings = total.div(100).mul(distribution.second)
const thirdWinnings = total.div(100).mul(distribution.third)

// First player
const firstPlayer = store.account.get(this.asset.first);
const firstBalance = new utils.BigNum(firstPlayer.balance);
const updatedFirstBalance = firstBalance.plus(firstWinnings)
const updatedFirstPlayer = {
    ...firstPlayer,
    balance: updatedFirstBalance.toString()
}
store.account.set(firstPlayer.address, updatedFirstPlayer);