斗地主算法的终极思路及伪代码实现

一、最重要的事情

分阶段
在C#中，你可以使用枚举（Enum）来表示斗地主游戏的四个阶段。枚举用于定义一个具有一组命名常量的类型。在这种情况下，我们可以定义一个名为GamePhase的枚举来表示游戏的四个阶段。

下面是一个示例：

public enum GamePhase
{
    DealCards, // 发牌阶段
    Bid, // 抢地主阶段
    Play, // 斗地主阶段
    End // 结束阶段（判定输赢）
}

二、每个阶段的任务

1、发牌阶段

在斗地主游戏中，发牌阶段的主要任务包括创建一副扑克牌、洗牌和将牌发给玩家。下面是一个示例代码，展示了如何使用C#来完成这些任务：

using System;
using System.Collections.Generic;

public enum Suit
{
    Spades,
    Hearts,
    Diamonds,
    Clubs
}

public enum Rank
{
    Ace = 1, // A
    Two,
    Three,
    Four,
    Five,
    Six,
    Seven,
    Eight,
    Nine,
    Ten,
    Jack,
    Queen,
    King
}

public class Card
{
    public Suit Suit { get; set; }
    public Rank Rank { get; set; }

    public override string ToString()
    {
        return $"{Rank} of {Suit}";
    }
}

public class Deck
{
    private List<Card> cards;

    public Deck()
    {
        Reset();
    }

    public void Reset()
    {
        cards = new List<Card>();

        foreach (Suit suit in Enum.GetValues(typeof(Suit)))
        {
            foreach (Rank rank in Enum.GetValues(typeof(Rank)))
            {
                cards.Add(new Card { Suit = suit, Rank = rank });
            }
        }
    }

    public void Shuffle()
    {
        Random rand = new Random();
        int n = cards.Count;

        while (n > 1)
        {
            n--;
            int k = rand.Next(n + 1);
            Card temp = cards[k];
            cards[k] = cards[n];
            cards[n] = temp;
        }
    }

    public List<Card> Deal(int numCards)
    {
        List<Card> dealtCards = new List<Card>();

        for (int i = 0; i < numCards; i++)
        {
            dealtCards.Add(cards[0]);
            cards.RemoveAt(0);
        }

        return dealtCards;
    }
}

public class Program
{
    public static void Main()
    {
        Deck deck = new Deck();
        deck.Shuffle();

        List<Card> player1Hand = deck.Deal(17);
        List<Card> player2Hand = deck.Deal(17);
        List<Card> player3Hand = deck.Deal(17);
        List<Card> landlordHand = deck.Deal(3);

        Console.WriteLine("Player 1 hand:");
        foreach (Card card in player1Hand)
        {
            Console.WriteLine(card);
        }

        Console.WriteLine("Player 2 hand:");
        foreach (Card card in player2Hand)
        {
            Console.WriteLine(card);
        }

        Console.WriteLine("Player 3 hand:");
        foreach (Card card in player3Hand)
        {
            Console.WriteLine(card);
        }

        Console.WriteLine("Landlord hand:");
        foreach (Card card in landlordHand)
        {
            Console.WriteLine(card);
        }
    }
}

上面代码定义了Suit和Rank枚举来表示扑克牌的花色和点数。Card类表示一张扑克牌，并有对应的花色和点数属性。Deck类表示一副牌，并具有创建、洗牌和发牌的功能。最后，我们在Program类的Main方法中创建了一个新的牌组对象deck，对其进行洗牌，然后使用Deal方法逐个发牌给不同的玩家。

可以根据实际需要对发牌阶段的逻辑进行扩展和修改。

2、抢地主

在斗地主游戏中，抢地主阶段的任务包括判断玩家是否叫地主或者抢地主，并确定最后谁成为了地主。下面是一个示例代码，展示了如何使用C#处理抢地主阶段的逻辑：

using System;
using System.Collections.Generic;

public enum Player
{
    Player1,
    Player2,
    Player3
}

public class LandlordGame
{
    private List<Player> players;

    public LandlordGame()
    {
        players = new List<Player> { Player.Player1, Player.Player2, Player.Player3 };
    }

    public Player DetermineLandlord()
    {
        Random rand = new Random();
        int lastBidderIndex = -1;
        int currentPlayerIndex = rand.Next(players.Count);

        while (players.Count > 1)
        {
            Console.WriteLine("Current player: " + players[currentPlayerIndex]);

            Console.Write("Bid or Pass? (B/P): ");
            string bidOrPass = Console.ReadLine().ToUpper();

            if (bidOrPass == "B")
            {
                lastBidderIndex = currentPlayerIndex;
                Console.WriteLine("Player " + players[currentPlayerIndex] + " bids.");

                if (currentPlayerIndex < players.Count - 1)
                {
                    currentPlayerIndex++;
                }
                else
                {
                    currentPlayerIndex = 0;
                }
            }
            else if (bidOrPass == "P")
            {
                Console.WriteLine("Player " + players[currentPlayerIndex] + " passes.");

                players.RemoveAt(currentPlayerIndex);
                if (currentPlayerIndex >= players.Count)
                {
                    currentPlayerIndex = 0;
                }
            }
            else
            {
                Console.WriteLine("Invalid input. Please enter 'B' to bid or 'P' to pass.");
            }
        }

        Player landlord = players[0];
        Console.WriteLine("Player " + landlord + " becomes the landlord!");

        return landlord;
    }
}

public class Program
{
    public static void Main()
    {
        LandlordGame game = new LandlordGame();
        Player landlord = game.DetermineLandlord();
    }
}

上面代码中定义了一个Player枚举来表示玩家。LandlordGame类表示斗地主游戏，其中，我们使用一个List来存储当前还在游戏中的玩家。DetermineLandlord方法根据每位玩家的选择进行判断，如果玩家选择叫地主则继续轮到下一位玩家，如果玩家选择抢地主，则该玩家成为地主，并返回地主结果。

在Main方法中，创建了一个LandlordGame对象，并调用DetermineLandlord方法确定地主。

3、斗地主

在C#中，可以使用代码来实现斗地主阶段的任务。下面是一个例子：

using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        List<string> players = new List<string>() { "地主", "农民1", "农民2" };
        bool isGameOver = false;
        int currentPlayerIndex = new Random().Next(0, 3); // 随机选择一个玩家先出牌

        while (!isGameOver)
        {
            string currentPlayer = players[currentPlayerIndex];
            Console.WriteLine(currentPlayer + "出牌...");

            // 若当前玩家为地主或上一把最后出牌的人，则先出牌
            if (currentPlayer == "地主" || currentPlayer == players[(currentPlayerIndex - 1 + 3) % 3])
            {
                // 根据预先设计的策略选择出牌
                List<string> cardsToPlay = ChooseCardsToPlay();

                // 出牌操作，此处仅打印出牌信息，需要根据实际情况做适当调整
                Console.WriteLine("出牌：" + string.Join(", ", cardsToPlay));
            }
            else // 跟出牌
            {
                // 获取上一个人出的牌
                List<string> previousCards = GetPreviousCards();

                if (ShouldPlayCards(previousCards)) // 判断是否要出牌
                {
                    List<string> cardsToPlay = ChooseCardsToPlay(previousCards);

                     // 出牌操作，此处仅打印出牌信息，需要根据实际情况做适当调整
                     Console.WriteLine("出牌：" + string.Join(", ", cardsToPlay));
                }
                else // pass
                {
                    Console.WriteLine(currentPlayer + "选择不出牌。");
                }
            }

            // 判断出牌是否结束，此处仅为示例
            bool isRoundOver = IsRoundOver();

            if (isRoundOver)
            {
                // 判断是否应该结束游戏，此处仅为示例
                isGameOver = IsGameOver();

                if (!isGameOver)
                {
                    // 下一轮游戏的先出牌玩家
                    currentPlayerIndex = (currentPlayerIndex + 1) % 3;
                }
            }
            else
            {
                // 下一个玩家出牌
                currentPlayerIndex = (currentPlayerIndex + 1) % 3;
            }
        }

        Console.WriteLine("游戏结束！");
    }

    // 根据预先设计的策略选择出牌
    static List<string> ChooseCardsToPlay()
    {
        // TODO: 实现出牌策略，根据当前手牌选择合适的牌进行出牌
        // 返回一个List，表示要出的牌
        return new List<string>() { "3", "4", "5" }; // 示例代码中随便选择了三张牌
    }

    // 获取上一个人出的牌
    static List<string> GetPreviousCards()
    {
        // TODO: 根据具体情况获取上一个人出的牌
        // 返回一个List，表示上一个人出的牌
        return new List<string>() { "6", "7", "8" }; // 示例代码中随便选择了三张牌
    }

    // 判断是否要出牌
    static bool ShouldPlayCards(List<string> previousCards)
    {
        // TODO: 根据当前手牌和上一个人出的牌判断是否应该出牌
        // 返回一个bool值，表示是否要出牌
        return true; // 示例代码中默认选择出牌
    }

    // 根据上一个人的出牌选择出牌
    static List<string> ChooseCardsToPlay(List<string> previousCards)
    {
        // TODO: 根据上一个人出的牌选择要出的牌
        // 返回一个List，表示要出的牌
        return new List<string>() { "9", "10", "J" }; // 示例代码中随便选择了三张牌
    }

    // 判断本轮出牌是否结束
    static bool IsRoundOver()
    {
        // TODO: 根据游戏规则判断本轮出牌是否结束
        // 返回一个bool值，表示本轮出牌是否结束
        return true; // 示例代码中将本轮出牌设为结束
    }

    // 判断是否应该结束游戏
    static bool IsGameOver()
    {
        // TODO: 根据游戏规则判断是否应该结束游戏
        // 返回一个bool值，表示是否应该结束游戏
        return true; // 示例代码中将游戏设为结束
    }
}

具体的出牌逻辑、判断条件和结束游戏的规则需要根据实际情况进行补充和修改。

4、结束

在斗地主结束阶段，可以通过判断玩家的手牌是否为空来确定赢家，调整玩家的积分，并确定下一局的发牌首家和叫地主首家。下面是一个示例代码：

using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        List<Player> players = new List<Player>()
        {
            new Player("地主"),
            new Player("农民1"),
            new Player("农民2")
        };

        // 游戏结束后的处理
        GameOver(players);

        // 下一局游戏的发牌首家和叫地主首家
        string nextDealer = GetNextDealer(players);
        string nextLandlordCaller = GetNextLandlordCaller(players);

        Console.WriteLine("下一局发牌首家：" + nextDealer);
        Console.WriteLine("下一局叫地主首家：" + nextLandlordCaller);

        // 输出玩家积分
        foreach (var player in players)
        {
            Console.WriteLine(player.Name + " 积分：" + player.Score);
        }
    }

    // 游戏结束的处理
    static void GameOver(List<Player> players)
    {
        // 判断赢家
        Player winner = null;
        foreach (var player in players)
        {
            if (player.Hand.Count == 0)
            {
                winner = player;
                break;
            }
        }

        // 调整玩家的积分
        foreach (var player in players)
        {
            if (player == winner)
            {
                player.Score += 10; // 赢家得10分
            }
            else
            {
                player.Score -= 5; // 输家扣5分
            }
        }
    }

    // 获取下一局的发牌首家
    static string GetNextDealer(List<Player> players)
    {
        int currentIndex = -1;
        for (int i = 0; i < players.Count; i++)
        {
            if (players[i].Name == "地主")
            {
                currentIndex = i;
                break;
            }
        }
        
        // 下一局的发牌首家是当前地主的下家
        string nextDealer = players[(currentIndex + 1) % players.Count].Name;

        return nextDealer;
    }

    // 获取下一局的叫地主首家
    static string GetNextLandlordCaller(List<Player> players)
    {
        int currentIndex = -1;
        for (int i = 0; i < players.Count; i++)
        {
            if (players[i].Name == "地主")
            {
                currentIndex = i;
                break;
            }
        }
        
        // 下一局的叫地主首家是当前地主的对家
        string nextLandlordCaller = players[(currentIndex + 2) % players.Count].Name;

        return nextLandlordCaller;
    }
}

class Player
{
    public string Name { get; }
    public List<string> Hand { get; } // 玩家手牌
    public int Score { get; set; } // 玩家积分

    public Player(string name)
    {
        Name = name;
        Hand = new List<string>();
        Score = 0;
    }
}

上面通过GameOver方法判断赢家并调整玩家的积分。GetNextDealer方法和GetNextLandlordCaller方法分别用来计算下一局的发牌首家和叫地主首家。然后，输出玩家的积分情况。

结论

我最中意的还是最后我想到了分阶段的问题，把一些问题分而化之。这样代码设计的难度一下子就降了下来。
最后我猜测，网络版斗地主，如果排除了网络通信这部分的难度的话，其实从逻辑判断这个难度来说，是低于单机斗地主的。网络斗地主的关键是对玩家的管理。单机斗地主关键是ai玩家的出牌算法是否优秀。