Public-Method-CardGame-NiuNiu - 牛牛纸牌最优算法

项目说明

/**

* 牛牛

* 纸牌游戏牛牛的最优算法

* 1.计算5张牌(10-K都是0)之和，获得余数X

* 2.查询组成余数X的2张牌(策划穷举，X为1-9全部只有45种牌)是否存在，高大上说话用正则表达式

* 3.存在即有牛，余数为牛X

* 五小牛 > 五花牛 > 牛牛

*/

public function niu()
{
header("Content-Type: text/html;charset=utf-8");

$res = M('niu')->select();
//10所对应的id
$tun_id = array(37,38,39,40);

//取第一人牌
$seek = $this->randarr($res, 5);//随机取5张牌
//将随机取的5张牌转一维数组
$seek_one = array();
$chess_one = array();
$more_one = array();
foreach ($seek as $k => $v) {
$seek_one[] = $v['id'];
$chess_one[] = $v['niu'];
$more_one[] = $v['size'];
}
foreach ($res as $key => $val) {
if (in_array($val['id'], $seek_one)) {
unset($res[$key]);
}
}
$res_one = array_($res);//重置键名剩余47张牌

$sum_one = 0;
$sum_one_1 = 0;
for($i = 0; $i < count($seek); $i++) {
$sum_one += $seek[$i]['sorce'];
if ($seek[$i]['sorce'] == 0) {
$seek[$i]['sorce'] = 10;
}
$sum_one_1 += $seek[$i]['sorce'];
}

if ($sum_one <= 10 && $sum_one_1 <= 10) {
$n_one = "五小牛"."\n";
} else if ($sum_one_1 == 50 && !in_array($seek_one[0], $tun_id) && !in_array($seek_one[1], $tun_id) && !in_array($seek_one[2], $tun_id) && !in_array($seek_one[3], $tun_id) && !in_array($seek_one[4], $tun_id)) {//判断里面是否有10a,10b,10c,10d
$n_one = "五花牛"."\n";
} else {
$remain_one = intval($sum_one%10);//求余
if ($remain_one == 0) {
$n_one = "牛牛"."\n";
} else {
//二维数组转一维
$nums_one = array();
foreach ($seek as $k => $v) {
if ($v['sorce'] == 10) {
$v['sorce'] = 0;
}
$nums_one[] = $v['sorce'];
}

$m_one = 0;
for($i =0 ; $i < 4 ; $i++){
for($j = $i + 1; $j < 5; $j++){
//判断是否存在
if(intval(($nums_one[$i] + $nums_one[$j])%10) == $remain_one) {
//正常情况
$m_one++;
}
}
}
if ($m_one == 0) {
$n_one = "无牛"."\n";
$n_than_one = "";
//无牛取最大的那张牌
$n_more_one = $this->getMax($more_one);
} else {
$n_one = "有牛，牛".$remain_one."\n";
$n_than_one = $remain_one;
}
}
}

//------------------------------------------------------------------------------------------------------------------------------------------------------

//取第二人牌
$seek_2 = $this->randarr($res_one, 5);//再随机取5张牌
//将随机取的5张牌转一维数组
$seek_two = array();
$chess_two = array();
$more_two = array();
foreach ($seek_2 as $k => $v) {
$seek_two[] = $v['id'];
$chess_two[] = $v['niu'];
$more_two[] = $v['size'];
}
foreach ($res_one as $key => $val) {
if (in_array($val['id'], $seek_two)) {
unset($res_one[$key]);
}
}
$res_two = array_($res_one);//重置键名剩余42张牌

$sum_two = 0;
$sum_two_2 = 0;
for($i = 0; $i < count($seek_2); $i++) {
$sum_two += $seek_2[$i]['sorce'];
if ($seek_2[$i]['sorce'] == 0) {
$seek_2[$i]['sorce'] = 10;
}
$sum_two_2 += $seek_2[$i]['sorce'];
}
if ($sum_two <= 10 && $sum_two_2 <= 10) {
$n_two = "五小牛"."\n";
} else if ($sum_two_2 == 50 && !in_array($seek_two[0], $tun_id) && !in_array($seek_two[1], $tun_id) && !in_array($seek_two[2], $tun_id) && !in_array($seek_two[3], $tun_id) && !in_array($seek_two[4], $tun_id)) {
$n_two = "五花牛"."\n";
} else {
$remain_two = intval($sum_two%10);//求余
if ($remain_two == 0) {
$n_two = "牛牛"."\n";
} else {
//二维数组转一维
$nums_two = array();
foreach ($seek_2 as $k => $v) {
if ($v['sorce'] == 10) {
$v['sorce'] = 0;
}
$nums_two[] = $v['sorce'];
}

$m_two = 0;
for($i =0 ; $i < 4 ; $i++){
for($j = $i + 1; $j < 5; $j++){
//判断是否存在
if(intval(($nums_two[$i] + $nums_two[$j])%10) == $remain_two) {
//正常情况
$m_two++;
}
}
}
if ($m_two == 0) {
$n_two = "无牛"."\n";
$n_than_two = "";
//无牛取最大的那张牌
$n_more_two = $this->getMax($more_two);
} else {
$n_two = "有牛，牛".$remain_two."\n";
$n_than_two = $remain_two;
}
}
}

//---------------------------------------------------------------------------------------------------------------------------------------------

//取第三人牌
$seek_3 = $this->randarr($res_two, 5);//再随机取5张牌
//将随机取的5张牌转一维数组
$seek_three = array();
$chess_three = array();
$more_three = array();
foreach ($seek_3 as $k => $v) {
$seek_three[] = $v['id'];
$chess_three[] = $v['niu'];
$more_three[] = $v['size'];
}
foreach ($res_two as $key => $val) {
if (in_array($val['id'], $seek_three)) {
unset($res_two[$key]);
}
}
$res_three = array_($res_two);//重置键名剩余37张牌

$sum_three = 0;
$sum_three_3 = 0;
for($i = 0; $i < count($seek_3); $i++) {
$sum_three += $seek_3[$i]['sorce'];
if ($seek_3[$i]['sorce'] == 0) {
$seek_3[$i]['sorce'] = 10;
}
$sum_three_3 += $seek_3[$i]['sorce'];
}
if ($sum_three <= 10 && $sum_three_3 <= 10) {
$n_three = "五小牛"."\n";
} else if ($sum_three_3 == 50 && !in_array($seek_three[0], $tun_id) && !in_array($seek_three[1], $tun_id) && !in_array($seek_three[2], $tun_id) && !in_array($seek_three[3], $tun_id) && !in_array($seek_three[4], $tun_id)) {
$n_three = "五花牛"."\n";
} else {
$remain_three = intval($sum_three%10);//求余
if ($remain_three == 0) {
$n_three = "牛牛"."\n";
} else {
//二维数组转一维
$nums_three = array();
foreach ($seek_3 as $k => $v) {
if ($v['sorce'] == 10) {
$v['sorce'] = 0;
}
$nums_three[] = $v['sorce'];
}

$m_three = 0;
for($i =0 ; $i < 4 ; $i++){
for($j = $i + 1; $j < 5; $j++){
//判断是否存在
if(intval(($nums_three[$i] + $nums_three[$j])%10) == $remain_three) {
//正常情况
$m_three++;
}
}
}
if ($m_three == 0) {
$n_three = "无牛"."\n";
$n_than_three = "";
//无牛取最大的那张牌
$n_more_three = $this->getMax($more_three);
} else {
$n_three = "有牛，牛".$remain_three."\n";
$n_than_three = $remain_three;
}
}
}

//----------------------------------------------------------------------------------------------------------------------------------------------

//取第四人牌
$seek_4 = $this->randarr($res_three, 5);//再随机取5张牌
//将随机取的5张牌转一维数组
$seek_four = array();
$chess_four = array();
$more_four = array();
foreach ($seek_4 as $k => $v) {
$seek_four[] = $v['id'];
$chess_four[] = $v['niu'];
$more_four[] = $v['size'];
}
foreach ($res_three as $key => $val) {
if (in_array($val['id'], $seek_four)) {
unset($res_three[$key]);
}
}
$res_four = array_($res_three);//重置键名剩余32张牌

$sum_four = 0;
$sum_four_4 = 0;
for($i = 0; $i < count($seek_4); $i++) {
$sum_four += $seek_4[$i]['sorce'];
if ($seek_4[$i]['sorce'] == 0) {
$seek_4[$i]['sorce'] = 10;
}
$sum_four_4 += $seek_4[$i]['sorce'];
}
if ($sum_four <= 10 && $sum_four_4 <= 10) {
$n_four = "五小牛"."\n";
} else if ($sum_four_4 == 50 && !in_array($seek_four[0], $tun_id) && !in_array($seek_four[1], $tun_id) && !in_array($seek_four[2], $tun_id) && !in_array($seek_four[3], $tun_id) && !in_array($seek_four[4], $tun_id)) {
$n_four = "五花牛"."\n";
} else {
$remain_four = intval($sum_four%10);//求余
if ($remain_four == 0) {
$n_four = "牛牛"."\n";
} else {
//二维数组转一维
$nums_four = array();
foreach ($seek_4 as $k => $v) {
if ($v['sorce'] == 10) {
$v['sorce'] = 0;
}
$nums_four[] = $v['sorce'];
}

$m_four = 0;
for($i =0 ; $i < 4 ; $i++){
for($j = $i + 1; $j < 5; $j++){
//判断是否存在
if(intval(($nums_four[$i] + $nums_four[$j])%10) == $remain_four) {
//正常情况
$m_four++;
}
}
}
if ($m_four == 0) {
$n_four = "无牛"."\n";
$n_than_four = "";
//无牛取最大的那张牌
$n_more_four = $this->getMax($more_four);
} else {
$n_four = "有牛，牛".$remain_four."\n";
$n_than_four = $remain_four;
}
}
}

//-------------------------------------------------------------------------------------------------------------------------------------------

//取第五人牌
$seek_5 = $this->randarr($res_four, 5);//再随机取5张牌
//将随机取的5张牌转一维数组
$seek_five = array();
$chess_five = array();
$more_five = array();
foreach ($seek_5 as $k => $v) {
$seek_five[] = $v['id'];
$chess_five[] = $v['niu'];
$more_five[] = $v['size'];
}
foreach ($res_four as $key => $val) {
if (in_array($val['id'], $seek_five)) {
unset($res_four[$key]);
}
}
$res_five = array_($res_four);//重置键名剩余27张牌

$sum_five = 0;
$sum_five_5 = 0;
for($i = 0; $i < count($seek_5); $i++) {
$sum_five += $seek_5[$i]['sorce'];
if ($seek_5[$i]['sorce'] == 0) {
$seek_5[$i]['sorce'] = 10;
}
$sum_five_5 += $seek_5[$i]['sorce'];
}
if ($sum_five <= 10 && $sum_five_5 <= 10) {
$n_five = "五小牛"."\n";
} else if ($sum_five_5 == 50 && !in_array($seek_five[0], $tun_id) && !in_array($seek_five[1], $tun_id) && !in_array($seek_five[2], $tun_id) && !in_array($seek_five[3], $tun_id) && !in_array($seek_five[4], $tun_id)) {
$n_five = "五花牛"."\n";
} else {
$remain_five = intval($sum_five%10);//求余
if ($remain_five == 0) {
$n_five = "牛牛"."\n";
} else {
//二维数组转一维
$nums_five = array();
foreach ($seek_5 as $k => $v) {
if ($v['sorce'] == 10) {
$v['sorce'] = 0;
}
$nums_five[] = $v['sorce'];
}

$m_five = 0;
for($i =0 ; $i < 4 ; $i++){
for($j = $i + 1; $j < 5; $j++){
//判断是否存在
if(intval(($nums_five[$i] + $nums_five[$j])%10) == $remain_five) {
//正常情况
$m_five++;
}
}
}
if ($m_five == 0) {
$n_five = "无牛"."\n";
$n_than_five = "";
//无牛取最大的那张牌
$n_more_five = $this->getMax($more_five);
} else {
$n_five = "有牛，牛".$remain_five."\n";
$n_than_five = $remain_five;
}
}
}

//---------------------------------------------------------------------------------------------------------------------------------------------------

//取第六人牌
$seek_6 = $this->randarr($res_five, 5);//再随机取5张牌
//将随机取的5张牌转一维数组
$seek_six = array();
$chess_six = array();
$more_six = array();
foreach ($seek_6 as $k => $v) {
$seek_six[] = $v['id'];
$chess_six[] = $v['niu'];
$more_six[] = $v['size'];
}
foreach ($res_five as $key => $val) {
if (in_array($val['id'], $seek_six)) {
unset($res_five[$key]);
}
}
$res_six = array_($res_five);//重置键名剩余22张牌

$sum_six = 0;
$sum_six_6 = 0;
for($i = 0; $i < count($seek_6); $i++) {
$sum_six += $seek_6[$i]['sorce'];
if ($seek_6[$i]['sorce'] == 0) {
$seek_6[$i]['sorce'] = 10;
}
$sum_six_6 += $seek_6[$i]['sorce'];
}
if ($sum_six <= 10 && $sum_six_6 <= 10) {
$n_six = "五小牛"."\n";
} else if ($sum_six_6 == 50 && !in_array($seek_six[0], $tun_id) && !in_array($seek_six[1], $tun_id) && !in_array($seek_six[2], $tun_id) && !in_array($seek_six[3], $tun_id) && !in_array($seek_six[4], $tun_id)) {
$n_six = "五花牛"."\n";
} else {
$remain_six = intval($sum_six%10);//求余
if ($remain_six == 0) {
$n_six = "牛牛"."\n";
} else {
//二维数组转一维
$nums_six = array();
foreach ($seek_6 as $k => $v) {
if ($v['sorce'] == 10) {
$v['sorce'] = 0;
}
$nums_six[] = $v['sorce'];
}

$m_six = 0;
for($i =0 ; $i < 4 ; $i++){
for($j = $i + 1; $j < 5; $j++){
//判断是否存在
if(intval(($nums_six[$i] + $nums_six[$j])%10) == $remain_six) {
//正常情况
$m_six++;
}
}
}
if ($m_six == 0) {
$n_six = "无牛"."\n";
$n_than_six = "";
//无牛取最大的那张牌
$n_more_six = $this->getMax($more_six);
} else {
$n_six = "有牛，牛".$remain_six."\n";
$n_than_six = $remain_six;
}
}
}

//--------------------------------------------------------------------------------------------------------------------------------------------

//取第七人牌
$seek_7 = $this->randarr($res_six, 5);//再随机取5张牌
//将随机取的5张牌转一维数组
$seek_seven = array();
$chess_seven = array();
$more_seven = array();
foreach ($seek_7 as $k => $v) {
$seek_seven[] = $v['id'];
$chess_seven[] = $v['niu'];
$more_seven[] = $v['size'];
}
foreach ($res_six as $key => $val) {
if (in_array($val['id'], $seek_seven)) {
unset($res_six[$key]);
}
}
$res_seven = array_($res_six);//重置键名剩余17张牌

$sum_seven = 0;
$sum_seven_7 = 0;
for($i = 0; $i < count($seek_7); $i++) {
$sum_seven += $seek_7[$i]['sorce'];
if ($seek_7[$i]['sorce'] == 0) {
$seek_7[$i]['sorce'] = 10;
}
$sum_seven_7 += $seek_7[$i]['sorce'];
}
if ($sum_seven <= 10 && $sum_seven_7 <= 10) {
$n_seven = "五小牛"."\n";
} else if ($sum_seven_7 == 50 && !in_array($seek_seven[0], $tun_id) && !in_array($seek_seven[1], $tun_id) && !in_array($seek_seven[2], $tun_id) && !in_array($seek_seven[3], $tun_id) && !in_array($seek_seven[4], $tun_id)) {
$n_seven = "五花牛"."\n";
} else {
$remain_seven = intval($sum_seven%10);//求余
if ($remain_seven == 0) {
$n_seven = "牛牛"."\n";
} else {
//二维数组转一维
$nums_seven = array();
foreach ($seek_7 as $k => $v) {
if ($v['sorce'] == 10) {
$v['sorce'] = 0;
}
$nums_seven[] = $v['sorce'];
}

$m_seven = 0;
for($i =0 ; $i < 4 ; $i++){
for($j = $i + 1; $j < 5; $j++){
//判断是否存在
if(intval(($nums_seven[$i] + $nums_seven[$j])%10) == $remain_seven) {
//正常情况
$m_seven++;
}
}
}
if ($m_seven == 0) {
$n_seven = "无牛"."\n";
$n_than_seven = "";
//无牛取最大的那张牌
$n_more_seven = $this->getMax($more_seven);
} else {
$n_seven = "有牛，牛".$remain_seven."\n";
$n_than_seven = $remain_seven;
}
}
}

//-------------------------------------------------------------------------------------------------------------------------------------

//取第八人牌
$seek_8 = $this->randarr($res_seven, 5);//再随机取5张牌
//将随机取的5张牌转一维数组
$seek_eight = array();
$chess_eight = array();
$more_eight = array();
foreach ($seek_8 as $k => $v) {
$seek_eight[] = $v['id'];
$chess_eight[] = $v['niu'];
$more_eight[] = $v['size'];
}
foreach ($res_seven as $key => $val) {
if (in_array($val['id'], $seek_eight)) {
unset($res_seven[$key]);
}
}
$res_eight = array_($res_seven);//重置键名剩余12张牌

$sum_eight = 0;
$sum_eight_8 = 0;
for($i = 0; $i < count($seek_8); $i++) {
$sum_eight += $seek_8[$i]['sorce'];
if ($seek_8[$i]['sorce'] == 0) {
$seek_8[$i]['sorce'] = 10;
}
$sum_eight_8 += $seek_8[$i]['sorce'];
}
if ($sum_eight <= 10 && $sum_eight_8 <= 10) {
$n_eight = "五小牛"."\n";
} else if ($sum_eight_8 == 50 && !in_array($seek_eight[0], $tun_id) && !in_array($seek_eight[1], $tun_id) && !in_array($seek_eight[2], $tun_id) && !in_array($seek_eight[3], $tun_id) && !in_array($seek_eight[4], $tun_id)) {
$n_eight = "五花牛"."\n";
} else {
$remain_eight = intval($sum_eight%10);//求余
if ($remain_eight == 0) {
$n_eight = "牛牛"."\n";
} else {
//二维数组转一维
$nums_eight = array();
foreach ($seek_8 as $k => $v) {
if ($v['sorce'] == 10) {
$v['sorce'] = 0;
}
$nums_eight[] = $v['sorce'];
}

$m_eight = 0;
for($i =0 ; $i < 4 ; $i++){
for($j = $i + 1; $j < 5; $j++){
//判断是否存在
if(intval(($nums_eight[$i] + $nums_eight[$j])%10) == $remain_eight) {
//正常情况
$m_eight++;
}
}
}
if ($m_eight == 0) {
$n_eight = "无牛"."\n";
$n_than_eight = "";
//无牛取最大的那张牌
$n_more_eight = $this->getMax($more_eight);
} else {
$n_eight = "有牛，牛".$remain_eight."\n";
$n_than_eight = $remain_eight;
}
}
}

//----------------------------------------------------------------------------------------------------------------------------------

//取第九人牌
$seek_9 = $this->randarr($res_eight, 5);//再随机取5张牌
//将随机取的5张牌转一维数组
$seek_nine = array();
$chess_nine = array();
$more_nine = array();
foreach ($seek_9 as $k => $v) {
$seek_nine[] = $v['id'];
$chess_nine[] = $v['niu'];
$more_nine[] = $v['size'];
}
foreach ($res_eight as $key => $val) {
if (in_array($val['id'], $seek_nine)) {
unset($res_eight[$key]);
}
}
$res_nine = array_($res_eight);//重置键名剩余7张牌

$sum_nine = 0;
$sum_nine_9 = 0;
for($i = 0; $i < count($seek_9); $i++) {
$sum_nine += $seek_9[$i]['sorce'];
if ($seek_9[$i]['sorce'] == 0) {
$seek_9[$i]['sorce'] = 10;
}
$sum_nine_9 += $seek_9[$i]['sorce'];
}
if ($sum_nine <= 10 && $sum_nine_9 <= 10) {
$n_nine = "五小牛"."\n";
} else if ($sum_nine_9 == 50 && !in_array($seek_nine[0], $tun_id) && !in_array($seek_nine[1], $tun_id) && !in_array($seek_nine[2], $tun_id) && !in_array($seek_nine[3], $tun_id) && !in_array($seek_nine[4], $tun_id)) {
$n_nine = "五花牛"."\n";
} else {
$remain_nine = intval($sum_nine%10);//求余
if ($remain_nine == 0) {
$n_nine = "牛牛"."\n";
} else {
//二维数组转一维
$nums_nine = array();
foreach ($seek_9 as $k => $v) {
if ($v['sorce'] == 10) {
$v['sorce'] = 0;
}
$nums_nine[] = $v['sorce'];
}

$m_nine = 0;
for($i =0 ; $i < 4 ; $i++){
for($j = $i + 1; $j < 5; $j++){
//判断是否存在
if(intval(($nums_nine[$i] + $nums_nine[$j])%10) == $remain_nine) {
//正常情况
$m_nine++;
}
}
}
if ($m_nine == 0) {
$n_nine = "无牛"."\n";
$n_than_nine = "";
//无牛取最大的那张牌
$n_more_nine = $this->getMax($more_nine);
} else {
$n_nine = "有牛，牛".$remain_nine."\n";
$n_than_nine = $remain_nine;
}
}
}

echo "玩家一"."\n";
print_r($nums_one)."\n";
print_r($chess_one)."\n";
echo $sum_one."\n";
echo $sum_one_1."\n";
echo $n_one."\n\n";

echo "玩家二"."\n";
print_r($nums_two)."\n";
print_r($chess_two)."\n";
echo $sum_two."\n";
echo $sum_two_2."\n";
echo $n_two."\n\n";

echo "玩家三"."\n";
print_r($nums_three)."\n";
print_r($chess_three)."\n";
echo $sum_three."\n";
echo $sum_three_3."\n";
echo $n_three."\n\n";

echo "玩家四"."\n";
print_r($nums_four)."\n";
print_r($chess_four)."\n";
echo $sum_four."\n";
echo $sum_four_4."\n";
echo $n_four."\n\n";

echo "玩家五"."\n";
print_r($nums_five)."\n";
print_r($chess_five)."\n";
echo $sum_five."\n";
echo $sum_five_5."\n";
echo $n_five."\n\n";

echo "玩家六"."\n";
print_r($nums_six)."\n";
print_r($chess_six)."\n";
echo $sum_six."\n";
echo $sum_six_6."\n";
echo $n_six."\n\n";

echo "玩家七"."\n";
print_r($nums_seven)."\n";
print_r($chess_seven)."\n";
echo $sum_seven."\n";
echo $sum_seven_7."\n";
echo $n_seven."\n\n";

echo "玩家八"."\n";
print_r($nums_eight)."\n";
print_r($chess_eight)."\n";
echo $sum_eight."\n";
echo $sum_eight_8."\n";
echo $n_eight."\n\n";

echo "玩家九"."\n";
print_r($nums_nine)."\n";//手牌对应分
print_r($chess_nine)."\n";//手牌
echo $sum_nine."\n";//分数
echo $sum_nine_9."\n";//最大分数
echo $n_nine."\n\n";//输出牛

print_r($res_nine)."\n";

//比大小
//五小牛-12 > 五花牛-11 > 牛牛-10 > 牛九-9 > 牛八-8 > 牛七-7 > 牛六-6 > 牛五-5 > 牛四-4 > 牛三-3 > 牛二-2 > 牛一-1 > 无牛-0
//相同的比最大的那张牌，谁的大谁赢
//第一步,比牛
//将玩家、牛、最大那张牌合并数组
$arr = array(
array(
'name' => '玩家一',
'niu' => $n_than_one ? $n_than_one + 100 : $n_more_one,
'more' => $n_more_one,
),
array(
'name' => '玩家二',
'niu' => $n_than_two ? $n_than_two + 100 : $n_more_two,
'more' => $n_more_two,
),
array(
'name' => '玩家三',
'niu' => $n_than_three ? $n_than_three + 100 : $n_more_three,
'more' => $n_more_three,
),
array(
'name' => '玩家四',
'niu' => $n_than_four ? $n_than_four + 100 : $n_more_four,
'more' => $n_more_four,
),
array(
'name' => '玩家五',
'niu' => $n_than_five ? $n_than_five + 100 : $n_more_five,
'more' => $n_more_five,
),
array(
'name' => '玩家六',
'niu' => $n_than_six ? $n_than_six + 100 : $n_more_six,
'more' => $n_more_six,
),
array(
'name' => '玩家七',
'niu' => $n_than_seven ? $n_than_seven + 100 : $n_more_seven,
'more' => $n_more_seven,
),
array(
'name' => '玩家八',
'niu' => $n_than_eight ? $n_than_eight + 100 : $n_more_eight,
'more' => $n_more_eight,
),
array(
'name' => '玩家九',
'niu' => $n_than_nine ? $n_than_nine + 100 : $n_more_nine,
'more' => $n_more_nine,
)
);
print_r($arr);
}

//随机取5张牌
public function randarr($arr, $num) {
$arrid = array_rand($arr, $num);
foreach ($arrid as $v) {
$newarr [] = $arr [$v];
}
return $newarr;
}
//php取出数组中的最大值
public function getMax($arr) {
$max = $arr[0];
foreach ($arr as $k => $v) {
if($v > $max){
$max = $v;
}
}
return $max;
}

   数据表

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for niu
-- ----------------------------
DROP TABLE IF EXISTS niu;
CREATE TABLE niu (
id int(11) NOT NULL AUTO_INCREMENT COMMENT '主键id',
sorce int(2) NOT NULL COMMENT '对应分数',
niu (3) NOT NULL,
PRIMARY KEY (id)
) ENGINE=MyISAM AUTO_INCREMENT=53 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of niu
-- ----------------------------
INSERT INTO niu ('1', '1', '1a');
INSERT INTO niu ('2', '1', '1b');
INSERT INTO niu ('3', '1', '1c');
INSERT INTO niu ('4', '1', '1d');
INSERT INTO niu ('5', '2', '2a');
INSERT INTO niu ('6', '2', '2b');
INSERT INTO niu ('7', '2', '2c');
INSERT INTO niu ('8', '2', '2d');
INSERT INTO niu ('9', '3', '3a');
INSERT INTO niu ('10', '3', '3b');
INSERT INTO niu ('11', '3', '3c');
INSERT INTO niu ('12', '3', '3d');
INSERT INTO niu ('13', '4', '4a');
INSERT INTO niu ('14', '4', '4b');
INSERT INTO niu ('15', '4', '4c');
INSERT INTO niu ('16', '4', '4d');
INSERT INTO niu ('17', '5', '5a');
INSERT INTO niu ('18', '5', '5b');
INSERT INTO niu ('19', '5', '5c');
INSERT INTO niu ('20', '5', '5d');
INSERT INTO niu ('21', '6', '6a');
INSERT INTO niu ('22', '6', '6b');
INSERT INTO niu ('23', '6', '6c');
INSERT INTO niu ('24', '6', '6d');
INSERT INTO niu ('25', '7', '7a');
INSERT INTO niu ('26', '7', '7b');
INSERT INTO niu ('27', '7', '7c');
INSERT INTO niu ('28', '7', '7d');
INSERT INTO niu ('29', '8', '8a');
INSERT INTO niu ('30', '8', '8b');
INSERT INTO niu ('31', '8', '8c');
INSERT INTO niu ('32', '8', '8d');
INSERT INTO niu ('33', '9', '9a');
INSERT INTO niu ('34', '9', '9b');
INSERT INTO niu ('35', '9', '9c');
INSERT INTO niu ('36', '9', '9d');
INSERT INTO niu ('37', '0', '10a');
INSERT INTO niu ('38', '0', '10b');
INSERT INTO niu ('39', '0', '10c');
INSERT INTO niu ('40', '0', '10d');
INSERT INTO niu ('41', '0', 'Ja');
INSERT INTO niu ('42', '0', 'Jb');
INSERT INTO niu ('43', '0', 'Jc');
INSERT INTO niu ('44', '0', 'Jd');
INSERT INTO niu ('45', '0', 'Qa');
INSERT INTO niu ('46', '0', 'Qb');
INSERT INTO niu ('47', '0', 'Qc');
INSERT INTO niu ('48', '0', 'Qd');
INSERT INTO niu ('49', '0', 'Ka');
INSERT INTO niu ('50', '0', 'Kb');
INSERT INTO niu ('51', '0', 'Kc');
INSERT INTO niu ('52', '0', 'Kd');

技术栈

开发语言：未知

项目类型：牛牛纸牌最优算法

Star 数：0

功能特点

这是一套牛牛纸牌最优算法，代码结构清晰，适合开发者学习棋牌游戏的服务端与客户端开发。项目涵盖了棋牌游戏的核心玩法逻辑、网络通信、用户管理、房间匹配等模块，对理解棋牌类游戏的完整开发流程具有较高的参考价值。

从技术实现角度看，棋牌类项目的难点在于：游戏逻辑的状态机设计、并发房间管理、牌型算法、以及服务端与客户端的协议同步。本项目在这些方面提供了可运行的实现，开发者可以在此基础上进行二次开发或学习研究。

部署说明

1. 下载源码压缩包，解压到本地开发环境。

2. 根据项目类型准备对应的运行环境（Node.js / Go / C++ / Java 等）。

3. 按照 README 中的步骤配置依赖、数据库和配置文件。

4. 先启动服务端，再启动客户端，即可进入游戏进行测试。

注意：本项目仅供学习研究使用，请勿用于商业或非法用途。

学习价值

对于想进入棋牌游戏开发领域的开发者来说，这套源码是一个很好的入门参考。通过阅读代码，可以学习到棋牌游戏的核心玩法实现、网络协议设计、房间与匹配机制、以及游戏状态管理等关键技术点。

同时，项目中的代码组织方式和模块划分，也展示了棋牌类项目在工程化方面的实践经验，值得开发者深入研究和借鉴。理解一个完整棋牌项目的架构，对后续开发其他实时对战类游戏也很有帮助。

免责声明

本资源来源于开源社区，仅供学习研究和技术交流使用，请勿用于任何商业或违法违规用途。使用本项目产生的一切后果由使用者自行承担。若涉及第三方权益，请联系删除。