Jim's
Tutorials

pragma solidity ^0.4.17;

// factory for deploying individual rock-paper-scissors contracts
contract RockPaperScissorsFactory {
    address[] public deployedRockPaperScissors;  // an array that holds the addresses
    // of each deployed contract

    // takes a wager and game name, deploys a rockpaperscissors contract, adds it to array
    function createRockPaperScissors(uint wager, string gameName) public {
        address newRockPaperScissors = new RockPaperScissors(wager, msg.sender, gameName);
        deployedRockPaperScissors.push(newRockPaperScissors);
    }

    function getDeployedRockPaperScissors() public view returns(address[]) {
        return deployedRockPaperScissors;
    }
}


contract RockPaperScissors {

  // data structure that holds info about an individual game
    struct Game {
        string title;
        uint wager;
        address playerOne;
        address playerTwo;
        uint playerOneMove;
        uint playerTwoMove;
        address winner;
    }

    address public manager;  // creator of game
    uint public gameWager;  // wager amount
    string public gameName;
    Game public game;

    // constructor
     function RockPaperScissors(uint wager, address creator, string name) public {
        manager = creator;
        gameWager = wager;
        gameName = name;
    }

    // creates a new game of rock paper scissors, sets initial values of mapping
    function createGame() public payable{
        require(msg.sender == manager);
        require(msg.value == gameWager);
        Game memory newGame = Game({
            title: gameName,
            wager: gameWager,
            playerOne: manager,
            playerTwo: 0,
            playerOneMove: 0,
            playerTwoMove: 0,
            winner: 0
        });
        game = newGame;
    }

    // function to join a game of rock paper scissors
    function joinGame() public payable{
        require(msg.value == game.wager);
        game.playerTwo = msg.sender;
    }

    // function to declare first players move
    function playOneMove(uint move) public{
        require(msg.sender == game.playerOne);
        require(move == 1 || move == 2 || move == 3);
        require(game.playerOneMove == 0);
        game.playerOneMove = move;
        if(game.playerTwoMove != 0){    // if both players have acted, selectwinner
            selectWinner();
        }
    }

    // function to declare second players move
    function playerTwoMove(uint move) public {
        require(msg.sender == game.playerTwo);
        require(move == 1 || move == 2 || move == 3);
        require(game.playerTwoMove == 0);
        game.playerTwoMove = move;
        if(game.playerOneMove != 0){
            selectWinner();
        }
    }

    // game logic to select a winner based on selected moves
    function selectWinner() private {
        if(game.playerOneMove == game.playerTwoMove){  // reset the moves if tied
            game.playerOneMove = 0;
            game.playerTwoMove = 0;
        }
        else if(game.playerOneMove == 1 && game.playerTwoMove == 2){
            game.winner = game.playerOne;
        }
        else if(game.playerOneMove == 1 && game.playerTwoMove == 3){
            game.winner = game.playerTwo;
        }
        else if(game.playerOneMove == 2 && game.playerTwoMove == 1){
            game.winner = game.playerTwo;
        }
        else if(game.playerOneMove == 2 && game.playerTwoMove == 3){
            game.winner = game.playerOne;
        }
        else if(game.playerOneMove == 3 && game.playerTwoMove == 2){
            game.winner = game.playerTwo;
        }
        else if(game.playerOneMove == 3 && game.playerTwoMove == 1){
            game.winner = game.playerTwo;
        }
        if(game.winner != 0){                             // send winner balance
            game.winner.transfer(this.balance);           // delete contract
            selfdestruct(this);
        }
    }
}

/* TODO Refactor to include support for best of x games - SelectWinner increments
a counter, value is sent when that counter reaches a set thresh-hold