为每个类创建一个石纸剪刀游戏

Question

今天的任务很艰巨。我已经绕了大约五个小时了。我就是不能把头绕在这上面，看不见这上面的雾气。这是我们老师今晚分配的作业：

创建名为RockPaperScissors的新Visual控制台应用程序。 游戏石/纸/剪刀有以下规则：

• 剪刀总是战胜纸业
• 石头总是战胜剪刀
• 纸业总是战胜岩石

创建以下三个遵循以下规则的类：

• PlayerRock --总是执行“摇滚法案”()。
• PlayerScissors --总是执行剪刀的动作()。
• PlayerPaper --总是执行纸的法令()。

创建一个Game类，它有一个名为that ()的方法来满足这些需求：

• Fight()方法接受两个参数: Player1和Player2。
• both ()方法调用两个player's Act()方法。
• Fight()方法使用上面的Rock/纸质/剪刀规则返回获胜的玩家。

经过100轮，哪个选手赢了？

我可以轻松地做游戏逻辑和脚本这个游戏出来，没有问题。如何使它对每一种武器开火？同时传递一个player1和player2？我需要类来创建新的player对象吗？我有岩石，纸，剪刀的课程，但他们基本上只有一个方法，在他们返回岩石，纸和剪刀。我没有要求任何人为我做这场比赛，但是有人能让我朝着正确的方向前进吗？谢谢大家！

Answer 1

听起来，您需要一个名为abstract的Player基类，它带有一个返回GameAction的抽象Act()方法(可能只是一个enum，除非您想在GameAction类中编码游戏逻辑，这很好)。

您可以从PlayerRock等三个类中派生出Player，并覆盖每个派生类中的Act()方法。

调用Game.Fight(Player player1, Player player2)，传入派生player类的两个实例。在Fight(...)中，您应该对两个玩家调用Act()方法，并根据结果来决定谁赢了(如果有人赢)。

同样的球员每次都会赢，不需要100回合就能证明这一点。也许你应该随机地生成一些玩家，或者有一些玩家稍后会有更微妙的策略？

抽象类和具体类的示例：

namespace RockPaperScissors
{
    enum GameAction
    {
        Rock,
        Paper,
        Scissors
    }

    abstract class Player
    {
        public abstract GameAction Act();
    }

    class PlayerRock : Player
    {
        public override GameAction Act()
        {
            return GameAction.Rock;
        }
    }

Answer 2

这里有一个5分钟以上的版本。(供参考)。

namespace RockPaperScissors
{
    class Program
    {
        private static void Main(string[] args)
        {

            var player1 = new PlayerPaper()
            {
                Name = "Derek",

            };

            var player2 = new PlayerScissors()
            {
                Name = "Jonny"
            };

            var winner = new Battle(player1, player2).PlayMatchUp();

            if (winner == null)
            {
                Console.WriteLine("The Game was a draw.");
            }
            else
            {
                Console.WriteLine("The Winner of this battle : {0}", winner.Name);
            }

            Console.ReadKey();
        }

    }

    public abstract class Player
    {
        public string Name { get; set; }
        public abstract GameAction Act();
    }

    public class PlayerRock : Player
    {
        public override GameAction Act()
        {
            return GameAction.Rock;
        }
    }

    public class PlayerPaper : Player
    {
        public override GameAction Act()
        {
            return GameAction.Paper;
        }
    }

    public class PlayerScissors : Player
    {
        public override GameAction Act()
        {
            return GameAction.Scissors;
        }
    }

    public enum GameAction
    {
        Rock,
        Paper,
        Scissors
    }

    public class Battle
    {
        private readonly Player _player1;
        private readonly Player _player2;

        public Battle(Player player1, Player player2)
        {
            this._player1 = player1;
            this._player2 = player2;
        }

        public  Player PlayMatchUp()
        {

            var result = WinningHand(_player1.Act(), _player2.Act());

            if (_player1.Act() == result)
            {
                return _player1;
            }

            if (_player2.Act() == result)
            {
                return _player2;
            }

            return null;
        }
        private  GameAction? WinningHand(GameAction p1, GameAction p2)
        {
            if (p1 == GameAction.Paper && p2 == GameAction.Rock)
            {
                return GameAction.Paper;
            }

            if (p1 == GameAction.Paper && p2 == GameAction.Scissors)
            {
                return GameAction.Scissors;
            }

            if (p1 == GameAction.Scissors && p2 == GameAction.Paper)
            {
                return GameAction.Scissors;
            }

            if (p1 == GameAction.Scissors && p2 == GameAction.Rock)
            {
                return GameAction.Rock;
            }

            if (p1 == GameAction.Rock && p2 == GameAction.Paper)
            {
                return GameAction.Paper;
            }

            if (p1 == GameAction.Rock && p2 == GameAction.Scissors)
            {
                return GameAction.Rock;
            }

            return null;
        }


    }
}

Answer 3

按部就班地走。首先，对于Rock、Paper等您不需要单独的类。enum就足够了：

  public enum Action {
    Rock,
    Paper,
    Scissors
  }

  public static class ActionExtensions {
    // +1 left wins, 0 - draw, -1 right wins
    public static int Outcome(this Action left, Action right) {
      if (left == right)
        return 0;
      else if ((left == Action.Rock) && (right == Action.Scissors) ||
               (left == Action.Paper) && (right == Action.Rock) ||
               (left == Action.Scissors) && (right == Action.Paper))
        return 1;
      else
        return -1;
    }
  } 

然后实现Player及其后代

  public abstract class Player {
    public abstract Action Act();
  }

  public sealed class PlayerRock: Player {
    public override Action Act() {
      return Action.Rock;
    }

    public override String ToString() {
      return "I'm Rock player; I always say 'Rock'";
    }
  }
  ...

最后Game

  public static class Game {
    public static Player Fight(Player player1, Player player2) {
      if (null == player1)
        throw new ArgumentNullException("player1"); 
      else if (null == player2)
        throw new ArgumentNullException("player2"); 

      int score1 = 0;
      int score2 = 0;

      const int upToScore = 100;
      const int maxParties = 1000;

      for (int match = 0; match < maxParties; ++maxParties) {
        if (score1 >= upToScore)
          return player1;
        else if (score2 >= upToScore)
          return player2;

        int outcome = player1.Act().Outcome(player2.Act());

        if (outcome > 0)
          score1 += 1;
        else if (outcome < 0)
          score2 += 1;
      }

      // maxParties passed, and no-one has won; so no winner
      return null;
    }
  }

别忘了测试

  var player1 = new PlayerRock();
  var player2 = new PlayerScissors(); 

  Console.Write(Game.Fight(player1, player2).ToString());