斗地主

<?php
/*
 * 黑桃 @
 * 红桃 #
 * 片花 %
 * 梅花 *
 * */

//fwrite(STDOUT,'name ?'.PHP_EOL);
//fscanf(STDIN,"%s",$name);

/*
 * 可配置参数：
 * 一副牌54张
 * 一局n副牌
 * 一局m个人
 * 一局分成x组
 *
 * 0.是否开始
 * 1.初始化数据54张牌，抽出3张底牌，3个人，分成2组，A组1人，B组2人
 * 2.51张牌，发牌给3个人，先发给A组
 * 3.随机一人开始出牌
 * 4.接下来一人出牌
 * 5.一人手中无牌，该组胜利
 * 6.计算输赢，一张牌1分，把得分平均发给赢组的人员
 * */

class game
{
    private static $playCards = [
                    2,2,2,2,
                    3,3,3,3,
                    4,4,4,4,
                    5,5,5,5,
                    6,6,6,6,
                    7,7,7,7,
                    8,8,8,8,
                    9,9,9,9,
                    10,10,10,10,
                    11,11,11,11,  //J
                    12,12,12,12,  //Q
                    13,13,13,13,  //K
                    14,14,14,14,  //A
                    20,           //小王
                    21            //大王
                ];
    public  $playCardsNum;
    public  $peopleNum;
    public  $termNum;
    public  $people = array();
    private  $landlord=null;    //当前地主id做个标记
    private  $prevPerson=null;  //上个出牌人的id
    private  $currPerson=null;  //当前出牌人id
    private  $prevCard;         //上个人出的牌
    private  $prevCardType;     //上个人出牌型
    private  $cardTpyeObj;

    public  static $input=null;
    public  static $start;


    public function __construct($playCardsNum=1, $peopleNum=3, $termNum=2)
    {
        $this->playCardsNum = $playCardsNum;
        $this->peopleNum    = $peopleNum;
        $this->termNum      = $termNum;
        $this->cardTpyeObj  = CardTpye::obj();

        self::start() && $this->run();
    }

    public function run()
    {
        $this->peopleInit();

        while(self::$start)
        {
            //发牌
            $this->cardInit();
            //争地主
            $this->landlord();
            $this->showPerson();
            //出牌
             $this->playHand();
            //清空每局的垃圾信息
            $this->clean();
            //重新开始
            self::start();
        }

        self::notice("bye ~");
    }



    //询问是否开始
    public static function start()
    {
        self::notice("start   or  close ?");
        self::notice("start:1     close:0");
        self::getInput();
        if(self::$input == 0)
        {
            self::$start = false;
            self::delInput();
            return false;
        }else{
            self::$start = true;
            self::delInput();
            return true;
        }
    }

    //初始化人员
    public function peopleInit()
    {
        //初始化人员
        for($peoson=0; $peoson<$this->peopleNum; $peoson++)
        {
            self::notice($peoson." name ?");
            self::getInput();
            $peosonInfo = array(
                "name"  => self::$input,
                "win"   => 0,
                "status" => 0,  //0农民  1地主
                "cards" => array()
            );
            if(empty(self::$input))
            {
                $peoson--;
            }else {
                array_push($this->people, $peosonInfo);
            }
            self::delInput();
        }
    }

    //开始发牌
    public  function cardInit()
    {
        shuffle(self::$playCards);
        foreach(self::$playCards as $key=>$card)
        {
            $tmpNum = $key % $this->peopleNum;
            array_push($this->people[$tmpNum]['cards'], $card);
        }

        array_walk($this->people,function(&$peoson){
            sort($peoson['cards']);
        });
    }

    //显示每个人的牌
    public function showPerson($id=null)
    {
        $status = array("peasant","landlord");

        if($id === null){
            array_walk($this->people,function(&$peoson) use($status){
                 $notice = $status[$peoson['status']]."  ".$peoson['name'].": ".implode(',',$peoson['cards']);
                 self::notice($notice);
            });
        }else{
            $notice = $status[$this->people[$id]['status']]."  ".$this->people[$id]['name'].": ".implode(',',$this->people[$id]['cards']);
            self::notice($notice);
        }
    }

    //争地主
    public function landlord()
    {
        $id = 0;
        $score = 0;
        foreach($this->people as $key=>$peoson)
        {
            self::notice($key." ".$peoson['name']." ".": please input score [1,2,3]");
            self::getInput();
            if(self::$input>$score) {
                $score=self::$input;
                $id=$key;
            }
            self::notice("s:".$score."  id:".$id);
        }
        $this->people[$id]['status'] = 1;
        $this->landlord = $id;
        self::delInput();
    }

    //出牌
    public function playHand()
    {
        $play = true;
        while($play)
        {
            //计算该谁出牌了
            if(is_null($this->currPerson)){
                $this->currPerson = $this->landlord;
            }else{
                $needPlay = $this->currPerson + 1;
                $this->currPerson = !isset($this->people[$needPlay]) ? 0:$needPlay;
            }


            //没通过就重出
            do {
                self::notice(PHP_EOL . PHP_EOL . "please play");
                $this->showPerson($this->currPerson);
                self::getInput();
                //验证出牌规则
                $pass = $this->ruleCheck();
                !$pass && self::notice("error.");
            }while(!$pass);

            //把出的牌删除
            if(!empty(self::$input))
            {
                self::notice("play: " . self::$input);
                $playCards = explode(',', self::$input);
                foreach ($playCards as $card) {
                    $key = array_search($card, $this->people[$this->currPerson]['cards']);
                    unset($this->people[$this->currPerson]['cards'][$key]);
                }

                //记录下出的牌和个人id
                $this->prevPerson = $this->currPerson;
                $this->prevCard = self::$input;
                self::log("p:".$this->prevPerson."  c:".$this->prevCard);
            }

            //赢了
            if(empty($this->people[$this->currPerson]['cards']))
            {
                $this->people[$this->currPerson]['win'] ++ ;
                self::notice($this->people[$this->currPerson]['name']." win");
                $play = false;
            }

            self::delInput();
        }

        self::notice("game over");
    }

    //验证规则
    public function ruleCheck()
    {

        /*
         * 牌型验证，和上局人出的牌型一致
         * 0.单张    一张牌一样
         * 1.两对    两张牌一样
         * 2.三对    三张牌一样
         * 3.三队带一
         * 4.三队带二对
         * 5.四张炸
         * 6.炸带单张
         * 6.炸带两队
         * 7.单顺最小5张   连续的牌，差为1
         * 8.两对顺 最小三对
         * 9.三队顺 最小2对
         * 10.三队顺带2个单牌
         * 11.三队顺带2个两对
         * 12.四炸顺
         * 13.四炸顺带两个单牌
         * 14.四炸顺带两个对
         * */

        //如果出空
        if(is_null(self::$input))
        {
            //第一次不能出空
            if(empty($this->prevCard)){
                return false;
            }
            //转一圈到自己了，不能出空
            if($this->currPerson == $this->prevPerson){
                return false;
            }

            return true;
        }


        $cards = explode(',',self::$input);
        $type = $this->cardTpyeObj->getType($cards);
        //第一次出，或其他人都不要，转一圈到自己了
        if(is_null($this->prevPerson)  ||  $this->currPerson==$this->prevPerson)
        {
            if($type==0){
                return false;
            }else{
                $this->prevCardType = $type;
                return true;
            }
        }else{
            //根据类型验证大小
            if($type==0 || $type!=$this->prevCardType){
                return false;
            }else{
                $prevCards = explode(",",$this->prevCard);
                $big = $this->cardTpyeObj->size($type, $prevCards, $cards);
                return $big;
            }
        }


    }

    //清空每局的垃圾信息
    public function clean()
    {
        array_walk($this->people,function(&$person){
            $person['staus'] = 0;
            $person['cards'] = array();
        });
        $this->landlord = null;
        $this->prevPerson = null;
        $this->prevCard = "";
    }



    public static function notice($message)
    {
        fwrite(STDOUT,$message.PHP_EOL);
    }
    public static function getInput()
    {
        fscanf(STDIN,'%s',self::$input);
    }
    public static function delInput()
    {
        self::$input = null;
    }
    public static function log($message)
    {
        $str = time()."  ".$message."
";
        file_put_contents("log.txt", $str, FILE_APPEND);
    }

}

$game = new game();



class CardTpye
{
    private static $obj;

    private function __construct(){}
    private function __clone(){}
    public static function obj()
    {
        if(!isset(self::$obj))
        {
            self::$obj = new self;
        }
        return self::$obj;
    }

    //类型验证
    public function getType(array $cards)
    {
        $type = 0;
        switch(count($cards)){
            case 1:
                $type=1;break;
            case 2:
                $this->dui_2($cards) && $type=2;
                break;
            case 3:
                $this->dui_3($cards) && $type=3;
                break;
            case 4:
                $this->dui_3_1($cards) && $type=4;
                $this->bomb_4($cards) && $type=5;
                break;
            case 5:
                $this->dui_3_2($cards) && $type=6;
                $this->bomb_4_1($cards) && $type=7;
                break;
            default:
                $type=0;
        }

        return $type;
    }
    //大小验证
    public function size($type, array $prev, array $current)
    {
        $big = false;
        switch($type){
            case 1:
                $big = $this->one_size($prev, $current);
                break;
            case 2:
                $big = $this->dui_2_size($prev, $current);
                break;
            case 3:
                $big = $this->dui_3_size($prev, $current);
                break;
            case 4:
                $big = $this->dui_3_1_size($prev, $current);
                break;
            case 5:
                $big = $this->bomb_4_size($prev, $current);
                break;
            case 6:
                $big = $this->dui_3_2_size($prev, $current);
                break;
            case 7:
                $big = $this->bomb_4_1_size($prev, $current);
                break;
            default:
                break;
        }

        return $big;
    }



    /********************验证大小***************************/
    private function one_size(array $prev, array $current)
    {
        return self::bigOrSmall($prev[0],$current[0]);
    }

    private function dui_2_size(array $prev, array $current)
    {
        return self::bigOrSmall($prev[0],$current[0]);
    }

    private function dui_3_size(array $prev, array $current)
    {
        return self::bigOrSmall($prev[0],$current[0]);
    }

    private function dui_3_1_size(array $prev, array $current)
    {
        //获取三张
        $getDui_3 = function (array $cards){
            if($cards[0] == $cards[1]){
                return array_slice($cards,0,3);
            }else{
                return array_slice($cards,1,3);
            }
        };

        $prevDui_3 = $getDui_3($prev);
        $currDui_3 = $getDui_3($current);
        return self::bigOrSmall($prevDui_3[0], $currDui_3[0]);
    }

    private function bomb_4_size(array $prev, array $current)
    {
        return self::bigOrSmall($prev[0], $current[0]);
    }

    private function dui_3_2_size(array $prev, array $current)
    {
        $getDui_3 = function (array $cards)
        {
            sort($cards);
            if($cards[0]==$cards[1] && $cards[1]==$cards[2])
            {
                return array_slice($cards, 0, 3);
            }else{
                return array_slice($cards, 2, 3);
            }
        };
        $prevDui_3 = $getDui_3($prev);
        $currDui_3 = $getDui_3($current);
        return self::bigOrSmall($prevDui_3[0], $currDui_3[0]);
    }

    private function bomb_4_1_size(array $prev, array $current)
    {
        $getDui_4 = function (array $cards)
        {
            sort($cards);
            if($cards[0] == $cards[1])
            {
                return array_slice($cards, 0, 4);
            }else{
                return array_slice($cards, 1, 4);
            }
        };

        $prevDui_4 = $getDui_4($prev);
        $currDui_4 = $getDui_4($current);
        return self::bigOrSmall($prevDui_4[0], $currDui_4[0]);
    }



    private static function bigOrSmall($pre, $cur)
    {
        if($cur <= $pre)
        {
            return false;
        }else{
            return true;
        }
    }

    /*****************验证牌型*************************/
    /*
     * type=2
     * 两张牌---对子验证
     * 规则：两张牌型一样
     * */
    private function dui_2(array $input)
    {
        if($input[0] == $input[1])
        {
            return true;
        }else{
            return false;
        }
    }

    /*
     * type=3
     * 三张牌---三对验证
     * 规则：三张牌一样
     * */
    private function dui_3(array $input)
    {
        if($input[0]==$input[1] && $input[1]==$input[2])
        {
            return true;
        }else{
            return false;
        }
    }

    /*
     * type=4
     * 四张牌---三带一
     * 规则：前三张一样，第四张随便
     * */
    private function dui_3_1(array $input)
    {
        //前三张一样
        if($input[0]==$input[1])
        {
            if($input[1]==$input[2])
            {
                return true;
            }else{
                return false;
            }
        }else{
            if($input[1]==$input[2] && $input[2]==$input[3])
            {
                return true;
            }else{
                return false;
            }
        }
    }


    /*
     * type=5
     * 四张牌---炸弹
     * 规则：四张一样
     * */
    private function bomb_4(array $input)
    {
        if($input[0]==$input[1] && $input[1]==$input[2] && $input[2]==$input[3])
        {
            return true;
        }else{
            return false;
        }
    }

    /*
     * type=6
     * 五张牌---三带二
     * 规则：前三张一样，后两张一样
     * */
    private function dui_3_2(array $input)
    {
        sort($input);
        if($input[0]==$input[1] && $input[1]==$input[2])
        {
            $dui_3 = array_slice($input, 0, 3);
            $dui_2 = array_slice($input, 3, 2);
        }else{
            $dui_2 = array_slice($input, 0, 2);
            $dui_3 = array_slice($input, 2, 3);
        }

        if($this->dui_3($dui_3) && $this->dui_2($dui_2))
        {
            return true;
        }else{
            return false;
        }

    }

    /*
     * type=7
     * 五张牌---四带一
     * 规则：四张一样的，一张单个
     * */
    private function bomb_4_1(array $input)
    {
        if($input[0] == $input[1])
        {
            if($input[1]==$input[2] && $input[2]==$input[3]){
                return true;
            }else{
                return false;
            }
        }else{
            if($input[1]==$input[2] && $input[2]==$input[3] && $input[3]==$input[4])
            {
                return true;
            }else{
                return false;
            }
        }
    }



}