daoqi/youlegames
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

添加spine的支持

Browse Source
This commit is contained in:
Joywayer
2026-04-09 17:31:46 +08:00
parent c3ab6e8a0d
commit a221d681ab
69 changed files with 40197 additions and 134 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1089
codes/games/server/games/erqiwang/class.arith.js Normal file
View File

File diff suppressed because it is too large Load Diff

185
codes/games/server/games/erqiwang/class.desk.js Normal file
View File

@@ -0,0 +1,185 @@
///////////////////////////////////////////////////
////////// cls_youle_erqiwang_desk: 牌桌 //////////
///////////////////////////////////////////////////
var cls_youle_erqiwang_desk = cls_youle_erqiwang_desk || {
countdown_jiaofen: 15, //叫分倒计时
countdown_xuanzhu: 20, //选主倒计时
countdown_maipai: 25, //埋牌倒计时
countdown_chupai: 30, //出牌倒计时
//创建牌桌对象
new: function(o_room){
var desk = {};
desk.o_room = o_room; //桌所属的房间对象
desk.seatlist = []; //玩家得分
desk.seatlist.push([0, []]); //第一位为累积得分，第二位为每局得分
desk.seatlist.push([0, []]);
desk.seatlist.push([0, []]);
desk.prepare = [0,0,0]; //玩家准备状态
desk.paiju_list = []; //牌局列表
//方法
desk.method = {};
//当前牌局
desk.method.curr_paiju = function(){
return desk.paiju_list[desk.paiju_list.length - 1];
}
//新牌局
desk.method.do_new_paiju = function(firstseat){
cls_youle_erqiwang_desk.do_new_paiju(desk, firstseat);
}
//叫分倒计时
desk.method.get_countdown_jiaofen = function(){
return cls_youle_erqiwang_desk.countdown_jiaofen;
}
//叫主倒计时
desk.method.get_countdown_xuanzhu = function(){
return cls_youle_erqiwang_desk.countdown_xuanzhu;
}
//埋牌倒计时
desk.method.get_countdown_maipai = function(){
return cls_youle_erqiwang_desk.countdown_maipai;
}
//出牌倒计时
desk.method.get_countdown_chupai = function(){
return cls_youle_erqiwang_desk.countdown_chupai;
}
//准备
desk.method.do_prepare = function(seat){
return cls_youle_erqiwang_desk.do_prepare(desk, seat);
}
//获取大局结算包
desk.method.get_desk_account = function(msg){
return cls_youle_erqiwang_desk.get_desk_account(desk, msg);
}
return desk;
},
//新开一局
do_new_paiju: function(o_desk, firstseat){
//恢复玩家准备状态
o_desk.prepare = [0,0,0];
if (o_desk.paiju_list.length > 0){
delete o_desk.paiju_list[o_desk.paiju_list.length - 1].tmp_jiesuan_aset;
}
//新开一局
cls_youle_erqiwang_paiju.new(o_desk, firstseat);
var msg = {};
msg.app = "youle";
msg.route = "erqiwang";
msg.rpc = "fapai";
msg.data = {};
msg.data.asetidx = o_desk.paiju_list.length;
msg.data.asetcount = o_desk.o_room.asetcount;
msg.data.seat = o_desk.method.curr_paiju().method.get_callgrade_seat();
msg.data.countdown = o_desk.method.get_countdown_jiaofen();
for (var i = 0; i < o_desk.o_room.seatlist.length; i++) {
msg.conmode = o_desk.o_room.seatlist[i].conmode;
msg.fromid = o_desk.o_room.seatlist[i].fromid;
msg.data.cards = o_desk.method.curr_paiju().method.get_seat_cards(i);
youle_erqiwang.app.SendPack(msg);
}
},
//准备
do_prepare: function(o_desk, seat){
o_desk.prepare[seat] = 1;
if (o_desk.prepare[0] && o_desk.prepare[1] && o_desk.prepare[2]){
//新开一局
var paiju = o_desk.method.curr_paiju();
var firstseat = paiju.banker;
if (paiju.result == 1 || paiju.result == 2){
firstseat = (firstseat + 1) % 3;
}
cls_youle_erqiwang_desk.do_new_paiju(o_desk, firstseat);
} else {
var msg = {};
msg.app = "youle";
msg.route = "erqiwang";
msg.rpc = "zhunbei";
msg.data = {};
msg.data.seat = seat;
o_desk.o_room.method.sendpack_toother(msg, -1);
}
},
//大局结算包
get_desk_account: function(o_desk, msg){
//保存战绩
var do_save_grade = function(){
var o_gameinfo1 = {};
o_gameinfo1.roomcode = o_desk.o_room.roomcode;
o_gameinfo1.asetcount = o_desk.paiju_list.length;
o_gameinfo1.createtime = o_desk.o_room.createtime;
o_gameinfo1.makewartime = o_desk.o_room.makewartime;
o_gameinfo1.players = [];
for (var i = 0; i < o_desk.o_room.seatlist.length; i++){
var _player = {};
_player.seat = i;
_player.playerid = o_desk.o_room.seatlist[i].playerid;
_player.name = o_desk.o_room.seatlist[i].nickname;
_player.avatar = o_desk.o_room.seatlist[i].avatar;
_player.score = o_desk.seatlist[i][0];
o_gameinfo1.players.push(_player);
}
var o_gameinfo2 = [];
for (var i = 0; i < o_desk.paiju_list.length; i++) {
var _paiju = {};
_paiju.starttime = o_desk.paiju_list[i].starttime;
_paiju.endtime = o_desk.paiju_list[i].endtime;
_paiju.seatlist = [0, 0, 0];
_paiju.seatlist[0] = o_desk.seatlist[0][1][i];
_paiju.seatlist[1] = o_desk.seatlist[1][1][i];
_paiju.seatlist[2] = o_desk.seatlist[2][1][i];
_paiju.callproc = o_desk.paiju_list[i].callproc;
_paiju.banker = o_desk.paiju_list[i].banker;
_paiju.call = o_desk.paiju_list[i].call;
_paiju.flower = o_desk.paiju_list[i].flower;
_paiju.result = o_desk.paiju_list[i].result;
//数据量太多，json转数组后进行存储
_paiju.cards = [];
for (var j = 0; j < o_desk.paiju_list[i].cards.length; j++) {
var _pai = o_desk.paiju_list[i].cards[j];
var _card = [];
_card.push(_pai.id);
_card.push(_pai.flower);
_card.push(_pai.number);
_card.push(_pai.score);
_card.push(_pai.dealowner);
_card.push(_pai.playround);
_card.push(_pai.playindex);
_card.push(_pai.playowner);
_paiju.cards.push(_card);
}
o_gameinfo2.push(_paiju);
}
//累积游戏得分
for (var i = 0; i < o_desk.o_room.seatlist.length; i++) {
o_desk.o_room.seatlist[i].gameinfo.grade = o_desk.seatlist[i][0];
}
//保存战绩
youle_erqiwang.import.save_grade(o_desk.o_room, o_gameinfo1, o_gameinfo2, 1);
}
min_ontimeout(do_save_grade, 1000);
msg.data.account = o_desk.seatlist;
return msg;
}
}

273
codes/games/server/games/erqiwang/class.export.js Normal file
View File

@@ -0,0 +1,273 @@
///////////////////////////////////////////////////
/////// cls_youle_erqiwang_export: 输出接口 ///////
///////////////////////////////////////////////////
var cls_youle_erqiwang_export = cls_youle_erqiwang_export || {
new: function() {
var exp = {};
//解析roomtype获取开房所需房卡
exp.get_needroomcard = function(roomtype){
switch (roomtype[2])
{
case 1: //房主扣卡
switch (roomtype[0])
{
case 1:
return 1;
break;
case 2:
return 2;
break;
default:
return 1;
break;
}
break;
case 2: //每人扣卡
switch (roomtype[0])
{
case 1:
return 1;
break;
case 2:
return 2;
break;
default:
return 1;
break;
}
break;
}
}
//解析roomtype获取总局数
exp.get_asetcount = function(roomtype){
switch (roomtype[0])
{
case 1:
return 2;
break;
case 2:
return 4;
break;
default:
return 4;
break;
}
}
//加入房间时根据roomtype获取需要的房卡数量
exp.get_needroomcard_joinroom = function(roomtype){
switch (roomtype[2])
{
case 1: //房主扣卡
return 0;
break;
case 2: //每人扣卡
switch (roomtype[0])
{
case 1:
return 1;
break;
case 2:
return 2;
break;
default:
return 1;
break;
}
break;
}
}
//开战
exp.makewar = function(o_room){
//牌桌对象
o_room.o_desk = cls_youle_erqiwang_desk.new(o_room);
for (var i = 0; i < o_room.seatlist.length; i++) {
o_room.seatlist[i].gameinfo.isbet = 1;
}
//开始第一局
var do_newpaiju = function(){
o_room.o_desk.method.do_new_paiju(0);
}
min_ontimeout(do_newpaiju, 1000);
}
//获取某个玩家的牌桌整桌当前信息
exp.get_deskinfo = function(o_room, seat){
if (!o_room.o_desk){
return null;
}
var paiju = o_room.o_desk.method.curr_paiju();
var deskinfo = {};
deskinfo.count = o_room.asetcount; //总局数
deskinfo.idx = paiju.idx; //当前局数
deskinfo.PlayerInfo = []; //玩家当前累积得分
for (var i = 0; i < o_room.o_desk.seatlist.length; i++) {
deskinfo.PlayerInfo.push(o_room.o_desk.seatlist[i][0]);
};
deskinfo.step = paiju.step; //牌局状态
deskinfo.MyCards = paiju.method.get_seat_cards(seat); //我手上的牌
switch (paiju.step){
case 1: //发完牌叫分
deskinfo.CallRun = {};
//当前叫分位置
deskinfo.CallRun.seat = paiju.method.get_callgrade_seat();
//叫分倒计时
deskinfo.CallRun.countdown = o_room.o_desk.method.get_countdown_jiaofen();
//当前叫分
deskinfo.CallRun.nowcall = paiju.method.get_callgrade_value();
//当前叫分倍数
deskinfo.CallRun.multiple = cls_youle_erqiwang_arith.get_multiple_bycall(deskinfo.CallRun.nowcall);
//所有玩家的叫分情况
deskinfo.CallRun.call = [null, null, null];
deskinfo.CallRun.call[0] = paiju.method.get_seat_callgrade(0);
deskinfo.CallRun.call[1] = paiju.method.get_seat_callgrade(1);
deskinfo.CallRun.call[2] = paiju.method.get_seat_callgrade(2);
break;
case 2: //选主
deskinfo.ChooseMain = {};
//庄家
deskinfo.ChooseMain.banker = paiju.banker;
//庄家叫分
deskinfo.ChooseMain.call = paiju.call;
//庄家叫分倍数
deskinfo.ChooseMain.multiple = cls_youle_erqiwang_arith.get_multiple_bycall(paiju.call);
//选主倒计时
deskinfo.ChooseMain.countdown = o_room.o_desk.method.get_countdown_xuanzhu();
//底牌
deskinfo.ChooseMain.bottomcards = paiju.method.get_bottomcards();
//是否可投降
if (paiju.call < 65){
deskinfo.ChooseMain.touxiang = 0;
} else {
deskinfo.ChooseMain.touxiang = 1;
}
break;
case 3: //埋牌
deskinfo.BuryCards = {};
//庄家
deskinfo.BuryCards.banker = paiju.banker;
//庄家叫分
deskinfo.BuryCards.call = paiju.call;
//庄家叫分倍数
deskinfo.BuryCards.multiple = cls_youle_erqiwang_arith.get_multiple_bycall(paiju.call);
//埋牌倒计时
deskinfo.BuryCards.countdown = o_room.o_desk.method.get_countdown_maipai();
//底牌
deskinfo.BuryCards.bottomcards = paiju.method.get_bottomcards();
//主牌花色
deskinfo.BuryCards.flower = paiju.flower;
//是否可投降
if (paiju.call < 65){
deskinfo.BuryCards.touxiang = 0;
} else {
deskinfo.BuryCards.touxiang = 1;
}
break;
case 4: //投降
deskinfo.Surrender = {};
//庄家
deskinfo.Surrender.banker = paiju.banker;
//庄家叫分
deskinfo.Surrender.call = paiju.call;
//庄家叫分倍数
deskinfo.Surrender.multiple = cls_youle_erqiwang_arith.get_multiple_bycall(paiju.call);
//出牌倒计时
deskinfo.Surrender.countdown = o_room.o_desk.method.get_countdown_chupai();
//主牌花色
deskinfo.Surrender.flower = paiju.flower;
if (seat == paiju.banker){
//埋的牌
deskinfo.Surrender.bottomcards = paiju.method.get_burycard();
}
//是否可投降
if (paiju.call < 65){
deskinfo.Surrender.touxiang = 0;
} else {
deskinfo.Surrender.touxiang = 1;
}
break;
case 5: //出牌
deskinfo.PushCards = {};
//庄家
deskinfo.PushCards.banker = paiju.banker;
//庄家叫分
deskinfo.PushCards.call = paiju.call;
//庄家叫分倍数
deskinfo.PushCards.multiple = cls_youle_erqiwang_arith.get_multiple_bycall(paiju.call);
//出牌倒计时
deskinfo.PushCards.countdown = o_room.o_desk.method.get_countdown_chupai();
//主牌花色
deskinfo.PushCards.flower = paiju.flower;
//捡分
var jian_grade = paiju.method.get_jian_grade();
if (seat == paiju.banker){
//埋的牌
deskinfo.PushCards.bottomcards = paiju.method.get_burycard();
} else {
//闲家当前的捡分分牌
deskinfo.PushCards.gradecards = jian_grade.cards;
}
//闲家当前的捡分分数
deskinfo.PushCards.grade = jian_grade.grade;
//当前的出牌情况
deskinfo.PushCards.playproc = paiju.playproc;
//座位列表
deskinfo.PushCards.seatlist = paiju.seatlist;
//出牌历史
deskinfo.PushCards.pushlist = [];
for (var i = 0; i < paiju.cards.length; i++) {
var pai = paiju.cards[i];
if (pai.playround > 0){
if (deskinfo.PushCards.pushlist.length < pai.playround){
deskinfo.PushCards.pushlist.length = pai.playround;
}
if (!deskinfo.PushCards.pushlist[pai.playround - 1]){
deskinfo.PushCards.pushlist[pai.playround - 1] = [[], [], []];
}
var owner = pai.dealowner;
if (owner == 0){
owner = paiju.banker + 1;
}
deskinfo.PushCards.pushlist[pai.playround - 1][owner - 1].push(i);
}
}
//按大小排序
for (var i = 0; i < deskinfo.PushCards.pushlist.length; i++) {
for (var j = 0; j < deskinfo.PushCards.pushlist.length; j++) {
deskinfo.PushCards.pushlist[i][j] = cls_youle_erqiwang_arith.order_cards(pai.flower, deskinfo.PushCards.pushlist[i][j]);
}
}
break;
case 6: //结算
deskinfo.Balance = {};
//玩家的准备状态
deskinfo.Balance.readystate = o_room.o_desk.prepare;
if (o_room.o_desk.prepare[seat] == 0){
//结算情况
deskinfo.Balance.aset = paiju.tmp_jiesuan_aset;
}
break;
}
return deskinfo;
}
//解散房间
exp.get_disbandRoom = function(o_room){
var msg = {};
return o_room.o_desk.method.curr_paiju().method.get_paiju_account(2, msg);
}
return exp;
}
}
//对内输出接口
youle_erqiwang.export = cls_youle_erqiwang_export.new();

30
codes/games/server/games/erqiwang/class.import.js Normal file
View File

@@ -0,0 +1,30 @@
///////////////////////////////////////////////////
/////// cls_youle_platform_import: 输入接口 ///////
///////////////////////////////////////////////////
var cls_youle_erqiwang_import = cls_youle_erqiwang_import || {
new: function() {
var imp = {};
//检查玩家
imp.check_player = function(agentid, gameid, roomcode, seat, playerid, conmode, fromid){
return youle_erqiwang.app.youle_room.export.check_player(agentid, gameid, roomcode, seat, playerid, conmode, fromid);
}
//第一局结算扣除房卡
imp.deduct_roomcard = function(o_room){
return youle_erqiwang.app.youle_room.export.deduct_roomcard(o_room);
}
//保存战绩
imp.save_grade = function(o_room, o_gameinfo1, o_gameinfo2, freeroomflag){
youle_erqiwang.app.youle_room.export.save_grade(o_room, o_gameinfo1, o_gameinfo2, freeroomflag);
}
return imp;
}
}
// 输入接口
youle_erqiwang.import = cls_youle_erqiwang_import.new();

61
codes/games/server/games/erqiwang/class.pai.js Normal file
View File

@@ -0,0 +1,61 @@
///////////////////////////////////////////////////
////////// cls_youle_erqiwang_pai: 牌 //////////
///////////////////////////////////////////////////
var cls_youle_erqiwang_pai = cls_youle_erqiwang_pai || {
//创建单张牌对象
new: function(id, flower, number, score, dealowner){
/*
参数说明：
id 绝对id
flower 牌面花色
number 牌面数值
code 牌编码
扑克牌的统一编码规则：
1，牌面花色的定义 5:王 4:黑桃 3:红心 2:梅花 1:方块
2，牌面数值的定义 01:A 02:2 03:3 ... 09:9 10:10 11:J 12:Q 13:K 53:小王 54:大王
3，牌编码的定义
3.1 常主的牌编码定义：
未叫主之前:
2的牌编码定义 黑桃2:2402 红心2:2302 梅花2:2202 方块2:2102
7的牌编码定义 黑桃7:7407 红心2:7307 梅花7:7207 方块7:7107
王的牌编码定义 小王:9553 大王:9554
叫主之后:
主2牌编码定义 原有牌编码的基础上+1000，例如红心为主牌，则红心2的牌编码变为3302
主7牌编码定义 原有牌编码的基础上+1000，例如红心为主牌，则红心7的牌编码变为8307
3.2 普通牌的牌编码定义
A的定义：14
未叫主之前:
3位数字 第一位为牌面花色 第二三位为牌面数值
叫主之后:
主牌花色 4位数字，即在原有牌编码的基础上+1000，表示是主牌
非主牌花色 3位数字，即原有牌编码不变
3.3 综上所述
牌编码是3位的，即小于1000的都是非主牌
牌编码是4位的，即大于1000的都是主牌
可根据牌编码进行牌大小的比较和排序
4 牌型定义
>100: 单张， 101一张单张，102两张单张，103三张单张 ...
>200: 对子， 201一对，202两对，203三对 ...
>300: 拖拉机，302两连对拖拉机，303三连对拖拉机 ...
*/
var pai = {};
pai.id = id; //绝对id，即数组下标，从0开始计数
pai.flower = flower; //牌面花色
pai.number = number; //牌面数值
pai.score = score; //牌在游戏中的分值
pai.dealowner = dealowner; //发牌状态
//-1:规则去除的牌
// 0:未发的牌，即底牌
//>0:发牌发到谁手上，从1开始计数，即位置编号+1，位置编号是从0开始计数的
pai.playround = -1; //出牌状态
//-1:未出的牌
// 0:埋牌
//>0:牌是第几轮出出去的，从1开始计数
pai.playindex = -1; //本轮中的出牌顺序，从1开始计数
pai.playowner = -1; //出牌后被谁得到，与位置编号对应
return pai;
}
}

863
codes/games/server/games/erqiwang/class.paiju.js Normal file
View File

@@ -0,0 +1,863 @@
///////////////////////////////////////////////////
////////// cls_youle_erqiwang_paiju: 牌局 /////////
///////////////////////////////////////////////////
var cls_youle_erqiwang_paiju = cls_youle_erqiwang_paiju || {
new: function(o_desk, firstseat) {
var paiju = {};
o_desk.paiju_list.push(paiju);
// ================= 实例的私有属性 ================= //
//发牌过程中待发的位置列表
var tmpdeal = [];
//三家需要各发28张牌
for (var i = 0; i < 28; i++){
tmpdeal.push(0); //0表示第一个玩家的位置
tmpdeal.push(1); //1表示第二个玩家的位置
tmpdeal.push(2); //2表示第三个玩家的位置
}
//8张底牌
for (var i = 0; i < 8; i++){
tmpdeal.push(-1); //-1 表示是底牌
}
// ================= 实例的私有方法 ================= //
//初始化座位列表
var init_seatlist = function(){
//第一层是玩家列表，与位置序号对应
//第二层前4个数组是花色列表，与花色-1对应
//第三层的第一位是无该花色的牌标志
//第三层的第二位是该花色无对标志
//第二层第5个数组是报副情况
//第三层的第一位是剩余主牌数量
//第三层的第二位是剩余主牌对子
//0号位
paiju.seatlist.push([[0,0],[0,0],[0,0],[0,0],[-1,-1]]);
//1号位
paiju.seatlist.push([[0,0],[0,0],[0,0],[0,0],[-1,-1]]);
//2号位
paiju.seatlist.push([[0,0],[0,0],[0,0],[0,0],[-1,-1]]);
}
//初始化牌列表并发牌
var init_cards = function(){
//两副牌
for (var i = 1; i <= 2; i++){
//四种花色
for (var j = 1; j <= 4; j++){
for (var k = 1; k <= 13; k++){
//牌id
var id = (i - 1) * 54 + (j - 1) * 13 + k - 1;
//分值
var score = 0;
//发牌状态
var dealowner = 0;
//特殊处理
switch (k)
{
case 5:
score = 5;
break;
case 10:
score = 10;
break;
case 13:
score = 10;
break;
case 3:
dealowner = -1;
break;
case 4:
dealowner = -1;
break;
}
var pai = cls_youle_erqiwang_pai.new(id, j, k, score, dealowner);
paiju.cards.push(pai);
//发牌
if (k != 3 && k != 4){
do_dealpai(pai);
}
}
}
//小王
var pai = cls_youle_erqiwang_pai.new((i - 1) * 54 + 53 - 1, 5, 53, 0, 0);
paiju.cards.push(pai);
do_dealpai(pai);
//大王
var pai = cls_youle_erqiwang_pai.new((i - 1) * 54 + 54 - 1, 5, 54, 0, 0);
paiju.cards.push(pai);
do_dealpai(pai);
}
}
//将单张牌随机发到玩家手中或成为底牌
var do_dealpai = function(o_pai){
var idx = min_random(0, tmpdeal.length - 1);
if (tmpdeal[idx] == -1) { //底牌
o_pai.dealowner = 0;
} else {
o_pai.dealowner = tmpdeal[idx] + 1;
}
//将数组的最后一位至该位置
if (idx < tmpdeal.length - 1) {
tmpdeal[idx] = tmpdeal[tmpdeal.length - 1];
};
//数组长度减一
tmpdeal.length = tmpdeal.length - 1;
}
//进入叫分阶段
var start_call = function(){
paiju.step = 1;
var o_call = {};
o_call.seat = paiju.firstseat;
o_call.call = null; //null:未叫分 0:不叫分 >0:叫分分数
paiju.callproc.push(o_call);
}
// ================= 实例的公有属性 ================= //
paiju.o_desk = o_desk;
//牌局号
paiju.idx = o_desk.paiju_list.length;
//第一个叫分者的位置
paiju.firstseat = firstseat;
//开始时间
paiju.starttime = min_now();
//结束时间
paiju.endtime = null;
//座位列表
paiju.seatlist = [];
//牌列表
paiju.cards = [];
//当前阶段
paiju.step = -1; //1发完牌叫分 2选主 3埋牌 4投降 5出牌 6结算
//叫分过程
paiju.callproc = [];
//庄家位置
paiju.banker = -1;
//庄家叫分
paiju.call = -1;
//主牌花色
paiju.flower = -1;
//当前出牌情况
paiju.playproc = {};
//输赢结果 0:庄赢 1:闲赢 2:庄投降 3:中途解散
paiju.result = null;
//结算包，供断线重连时使用，新开一局时清除
paiju.tmp_jiesuan_aset = null;
//初始化座位列表
init_seatlist();
//初始化牌列表并发牌
init_cards();
//进入叫分阶段
start_call();
// ================= 实例的公有方法 ================= //
paiju.method = {};
//获取某个位置玩家手上的牌
paiju.method.get_seat_cards = function(seat){
return cls_youle_erqiwang_paiju.get_seat_cards(paiju, seat);
}
//获取当前的叫分位置
paiju.method.get_callgrade_seat = function(){
return paiju.callproc[paiju.callproc.length - 1].seat;
}
//获取当前的叫分分数
paiju.method.get_callgrade_value = function(){
return cls_youle_erqiwang_paiju.get_callgrade_value(paiju);
}
//获取某个玩家的当前叫分情况
paiju.method.get_seat_callgrade = function(seat){
return cls_youle_erqiwang_paiju.get_seat_callgrade(paiju, seat);
}
//叫分或不叫
paiju.method.do_callgrade = function(call){
cls_youle_erqiwang_paiju.do_callgrade(paiju, call);
}
//获取底牌
paiju.method.get_bottomcards = function(){
return cls_youle_erqiwang_paiju.get_bottomcards(paiju);
}
//选主
paiju.method.do_choiceflower = function(flower){
cls_youle_erqiwang_paiju.do_choiceflower(paiju, flower);
}
//判断牌是否在玩家手上
paiju.method.check_cards_inhand = function(cards, seat){
return cls_youle_erqiwang_paiju.check_cards_inhand(paiju, cards, seat);
}
//埋牌
paiju.method.do_burycard = function(cards){
cls_youle_erqiwang_paiju.do_burycard(paiju, cards);
}
//检查选中的牌是否可出，并出牌
paiju.method.do_playcard = function(cards){
return cls_youle_erqiwang_paiju.do_playcard(paiju, cards);
}
//是否有人报副
paiju.method.have_baofu = function(){
return (paiju.seatlist[0][4][0] == 0 || paiju.seatlist[1][4][0] == 0 || paiju.seatlist[2][4][0] == 0);
}
//在牌列表中获取分牌和分值
paiju.method.get_grade_incard = function(cards){
return cls_youle_erqiwang_paiju.get_grade_incard(paiju, cards);
}
//获取埋牌
paiju.method.get_burycard= function(){
return cls_youle_erqiwang_paiju.get_burycard(paiju);
}
//获取抠底包
paiju.method.get_bottom_account = function(msg){
return cls_youle_erqiwang_paiju.get_bottom_account(paiju, msg);
}
//小局结算，type 0正常结算 1投降结算 2解散结算
paiju.method.get_paiju_account = function(type, msg){
return cls_youle_erqiwang_paiju.get_paiju_account(paiju, type, msg);
}
//获取闲家当前的捡分分数和分牌
paiju.method.get_jian_grade = function(){
return cls_youle_erqiwang_paiju.get_jian_grade(paiju);
}
return paiju;
},
//下一个位置
get_nextseat: function(seat){
return (seat + 1) % 3;
},
//获取某个位置玩家手上的牌
get_seat_cards: function(o_paiju, seat){
var aryCardIDs = [];
for (var i = 0; i < o_paiju.cards.length; i++){
var o_card = o_paiju.cards[i];
if (o_card.playround == -1){ //未出的牌
if ((o_card.dealowner == seat + 1) || //发到手上
(o_card.dealowner == 0 && seat == o_paiju.banker)){ //庄家包括底牌
aryCardIDs.push(o_paiju.cards[i].id);
}
}
}
return cls_youle_erqiwang_arith.order_cards(o_paiju.flower, aryCardIDs);
},
//获取某个位置玩家发到手上的牌
get_seat_cards_deal: function(o_paiju, seat){
var aryCardIDs = [];
for (var i = 0; i < o_paiju.cards.length; i++){
var o_card = o_paiju.cards[i];
if (o_card.dealowner == seat + 1){
aryCardIDs.push(o_paiju.cards[i].id);
}
}
return cls_youle_erqiwang_arith.order_cards(o_paiju.flower, aryCardIDs);
},
//获取某个位置玩家发到手上的牌(庄家包含底牌)
get_seat_cards_owner: function(o_paiju, seat){
var aryCardIDs = [];
for (var i = 0; i < o_paiju.cards.length; i++){
var o_card = o_paiju.cards[i];
if ((o_card.dealowner == seat + 1) || //发到手上
(o_card.dealowner == 0 && seat == o_paiju.banker)){ //庄家包括底牌
aryCardIDs.push(o_paiju.cards[i].id);
}
}
return cls_youle_erqiwang_arith.order_cards(o_paiju.flower, aryCardIDs);
},
//获取某个位置玩家手上的主牌
get_seat_zhucards: function(o_paiju, seat){
var aryCardIDs = [];
for (var i = 0; i < o_paiju.cards.length; i++){
var o_card = o_paiju.cards[i];
if (o_card.playround == -1){ //未出的牌
if ((o_card.dealowner == seat + 1) || //发到手上
(o_card.dealowner == 0 && seat == o_paiju.banker)){ //庄家包括底牌
if (o_card.flower == o_paiju.flower || o_card.flower == 5 || o_card.number == 2 || o_card.number == 7){
aryCardIDs.push(o_paiju.cards[i].id);
}
}
}
}
return cls_youle_erqiwang_arith.order_cards(o_paiju.flower, aryCardIDs);
},
//获取当前的叫分分数
get_callgrade_value: function(o_paiju){
var value = 0;
for (var i = o_paiju.callproc.length - 2; i >= 0; i--) {
if (o_paiju.callproc[i].call) {
value = o_paiju.callproc[i].call;
break;
}
}
return value;
},
//获取某个位置的叫分 返回值:null未叫 0不叫 >0当前叫分
get_seat_callgrade: function(o_paiju, seat){
for (var i = o_paiju.callproc.length - 2; i >= 0; i--){
if (o_paiju.callproc[i].seat == seat){
return o_paiju.callproc[i].call;
}
}
return null;
},
//叫分
do_callgrade: function(o_paiju, call){
var o_call = o_paiju.callproc[o_paiju.callproc.length - 1];
o_call.call = call;
//等待下一个叫分者叫分
var do_wait_nextseat_call = function(seat){
var o_call = {};
o_call.seat = seat;
o_call.call = null;
o_paiju.callproc.push(o_call);
}
//上庄
var do_up_banker = function(seat, call){
//庄家位置
o_paiju.banker = seat;
//庄家叫分
o_paiju.call = call;
//进入选主阶段
o_paiju.step = 2;
}
//叫了5分直接上庄
if (call == 5){
do_up_banker(o_call.seat, call);
return;
}
//叫了分
if (call > 0){
//下一个位置
var nextseat = cls_youle_erqiwang_paiju.get_nextseat(o_call.seat);
//下一个位置的叫分
var nextcall = cls_youle_erqiwang_paiju.get_seat_callgrade(o_paiju, nextseat);
//下一个位置不叫分
if (nextcall == 0){
//再下一个位置
nextseat = cls_youle_erqiwang_paiju.get_nextseat(nextseat);
}
//等待下一个叫分者叫分
do_wait_nextseat_call(nextseat);
return;
}
//不叫
if (call == 0){
//下一个位置
var nextseat_1 = cls_youle_erqiwang_paiju.get_nextseat(o_call.seat);
//下一个位置的叫分
var nextcall_1 = cls_youle_erqiwang_paiju.get_seat_callgrade(o_paiju, nextseat_1);
//再下一个位置
var nextseat_2 = cls_youle_erqiwang_paiju.get_nextseat(nextseat_1);
//再下一个位置的叫分
var nextcall_2 = cls_youle_erqiwang_paiju.get_seat_callgrade(o_paiju, nextseat_2);
if (nextcall_1 != 0 && nextcall_2 != 0){
//另外两家都没有不叫分
do_wait_nextseat_call(nextseat_1);
return;
}
if (nextcall_1 != 0 && nextcall_2 == 0){
//nextseat_1上庄
do_up_banker(nextseat_1, nextcall_1);
return;
}
if (nextcall_1 == 0 && nextcall_2 != 0){
//nextseat_2上庄
do_up_banker(nextseat_2, nextcall_2);
return;
}
}
},
//获取底牌
get_bottomcards: function(o_paiju){
var aryCardIDs = [];
for (var i = 0; i < o_paiju.cards.length; i++){
if (o_paiju.cards[i].dealowner == 0){
aryCardIDs.push(o_paiju.cards[i].id);
}
}
return cls_youle_erqiwang_arith.order_cards(o_paiju.flower, aryCardIDs);
},
//选主
do_choiceflower: function(o_paiju, flower){
o_paiju.flower = flower;
//修改主牌的牌编码
for (var i = 1; i <= 2; i++){ //两副牌
for (var j = 0; j < 13; j++){
var o_card = o_paiju.cards[(i - 1) * 54 + (flower - 1) * 13 + j];
}
}
//进入埋牌阶段
o_paiju.step = 3;
},
//判断牌是否在玩家手上
check_cards_inhand: function(o_paiju, cards, seat){
for (var i = 0; i < cards.length; i++) {
var o_card = o_paiju.cards[cards[i]];
if (o_card.playround != -1){
return;
}
if (seat == o_paiju.banker){
//是庄家
if (o_card.dealowner != seat + 1 && o_card.dealowner != 0){
return false;
}
} else {
//是闲家
if (o_card.dealowner != seat + 1){
return false;
}
}
}
return true;
},
//埋牌
do_burycard: function(o_paiju, cards){
for (var i = 0; i < cards.length; i++) {
o_paiju.cards[cards[i]].playround = 0;
};
//进入投降阶段
o_paiju.step = 4;
cls_youle_erqiwang_paiju.new_playround(o_paiju, 1, o_paiju.banker);
},
//新一轮出牌
new_playround: function(o_paiju, round, startseat){
o_paiju.playproc.round = round; //第几轮
o_paiju.playproc.start = startseat; //本轮的起始出牌位置
o_paiju.playproc.currseat = startseat; //本轮的当前的出牌位置
o_paiju.playproc.startcount = -1; //本轮第一个出牌的张数
o_paiju.playproc.startflower = -1; //本轮第一个出牌的花色
o_paiju.playproc.starttype = -1; //本轮第一个出牌的牌型
o_paiju.playproc.maxseat = -1; //谁的牌最大，位置
o_paiju.playproc.maxcard = -1; //满足第一个玩家出牌的牌型最大牌
o_paiju.playproc.cards = []; //本轮各位置出的牌，数组与位置序号对应
o_paiju.playproc.cards.length= 3;
},
//在牌列表中获取分牌和分值
get_grade_incard: function(o_paiju, cards){
var re = {};
re.grade = 0;
re.cards = [];
for (var i = 0; i < cards.length; i++) {
if (o_paiju.cards[cards[i]].score > 0){
re.grade = re.grade + o_paiju.cards[cards[i]].score;
re.cards.push(cards[i]);
}
}
return re;
},
//检查选中的牌是否可出，并出牌
do_playcard: function(o_paiju, cards){
//出牌
var doplay = function(playindex){
for (var i = 0; i < cards.length; i++) {
o_paiju.cards[cards[i]].playround = o_paiju.playproc.round;
o_paiju.cards[cards[i]].playindex = playindex;
};
o_paiju.playproc.cards[o_paiju.playproc.currseat] = cards;
//进入出牌阶段
o_paiju.step = 5;
//是否报副处理
if (o_paiju.seatlist[o_paiju.playproc.currseat][4][0] != 0){
var _zhu = cls_youle_erqiwang_paiju.get_seat_zhucards(o_paiju, o_paiju.playproc.currseat);
if (_zhu.length == 0){
o_paiju.seatlist[o_paiju.playproc.currseat][4][0] = 0;
o_paiju.seatlist[o_paiju.playproc.currseat][4][1] = 0;
}
if (o_paiju.method.have_baofu()){
var _parilist = cls_youle_erqiwang_arith.get_pairlist(o_paiju.flower, _zhu);
o_paiju.seatlist[o_paiju.playproc.currseat][4][0] = _zhu.length;
o_paiju.seatlist[o_paiju.playproc.currseat][4][1] = _parilist.length;
if (o_paiju.seatlist[o_paiju.playproc.currseat][4][0] == 0){
o_paiju.seatlist[o_paiju.playproc.currseat][o_paiju.flower - 1][0] = 1;
o_paiju.seatlist[o_paiju.playproc.currseat][o_paiju.flower - 1][1] = 1;
} else if (o_paiju.seatlist[o_paiju.playproc.currseat][4][1] == 0){
o_paiju.seatlist[o_paiju.playproc.currseat][o_paiju.flower - 1][1] = 1;
}
}
}
}
//本轮中的第二个出牌位置
var nextseat_1 = cls_youle_erqiwang_paiju.get_nextseat(o_paiju.playproc.start);
//本轮中的第三个出牌位置
var nextseat_2 = cls_youle_erqiwang_paiju.get_nextseat(nextseat_1);
if (o_paiju.playproc.currseat == o_paiju.playproc.start){ //是本轮的第一个出牌
var can = cls_youle_erqiwang_arith.can_playcard(o_paiju.flower, cards, o_paiju.playproc.currseat, o_paiju.seatlist);
if (!can.result){
var re = {};
re.result = false;
return re;
}
//出牌
doplay(1);
//记录下牌型、花色、牌型最大牌
o_paiju.playproc.startcount = cards.length;
o_paiju.playproc.startflower = can.flower;
o_paiju.playproc.starttype = can.cardtype;
o_paiju.playproc.maxseat = o_paiju.playproc.currseat;
o_paiju.playproc.maxcard = can.cardvalue;
o_paiju.playproc.currseat = nextseat_1;
//返回结果
var re1 = {};
re1.result = true;
re1.idx = 1;
re1.count = cards.length;
re1.flower = can.flower;
re1.cardtype = can.cardtype;
return re1;
}
//不是本轮中的第一个出牌，是跟牌
var cardsinhand = cls_youle_erqiwang_paiju.get_seat_cards(o_paiju, o_paiju.playproc.currseat);
var can = cls_youle_erqiwang_arith.can_followcard(o_paiju.flower, cardsinhand, cards, o_paiju.playproc.startcount, o_paiju.playproc.startflower, o_paiju.playproc.starttype);
if (!can.result){
var re = {};
re.result = false;
return re;
}
//与之前的出牌比较大小
if (can.cardvalue > o_paiju.playproc.maxcard){
o_paiju.playproc.maxseat = o_paiju.playproc.currseat;
o_paiju.playproc.maxcard = can.cardvalue;
}
//无花色、无对子处理
if (can.nopair){
o_paiju.seatlist[o_paiju.playproc.currseat][o_paiju.playproc.startflower - 1][1] = 1;
}
if (can.noflower){
o_paiju.seatlist[o_paiju.playproc.currseat][o_paiju.playproc.startflower - 1][0] = 1;
o_paiju.seatlist[o_paiju.playproc.currseat][o_paiju.playproc.startflower - 1][1] = 1;
}
//是本轮中的第二个出牌
if (o_paiju.playproc.currseat == nextseat_1){
//出牌
doplay(2);
//下一个出牌者
o_paiju.playproc.currseat = nextseat_2;
//返回结果
var re2 = {};
re2.idx = 2;
re2.result = true;
return re2;
}
//是本轮中的第三个出牌
//出牌
doplay(3);
//本轮出牌结束
for (var i = 0; i < o_paiju.playproc.cards.length; i++) {
for (var j = 0; j < o_paiju.playproc.cards[i].length; j++) {
o_paiju.cards[o_paiju.playproc.cards[i][j]].playowner = o_paiju.playproc.maxseat;
}
}
//返回结果
var re3 = {};
re3.result = true;
re3.idx = 3;
re3.maxseat = o_paiju.playproc.maxseat;
if (o_paiju.playproc.maxseat != o_paiju.banker){
re3.grade = 0;
// re3.gradecards = [];
for (var i = 0; i < o_paiju.playproc.cards.length; i++) {
var grade_incards = cls_youle_erqiwang_paiju.get_grade_incard(o_paiju, o_paiju.playproc.cards[i]);
re3.grade = re3.grade + grade_incards.grade;
// re3.gradecards = re3.gradecards.concat(grade_incards.cards);
}
}
//判断是否还有牌在玩家手上未出
var havecard_inhand = function(){
for (var i = 0; i < o_paiju.cards.length; i++) {
if (o_paiju.cards[i].playround == -1 && o_paiju.cards[i].number != 3 && o_paiju.cards[i].number != 4){
return true;
}
}
return false;
}
// if (!havecard_inhand() || o_paiju.playproc.round == 2){ //测试用
if (!havecard_inhand()){
//进入结算阶段
o_paiju.step = 6;
} else {
//新一轮出牌
cls_youle_erqiwang_paiju.new_playround(o_paiju, o_paiju.playproc.round + 1, o_paiju.playproc.maxseat);
}
return re3;
},
//获取埋牌
get_burycard: function(o_paiju){
var aryCardIDs = [];
for (var i = 0; i < o_paiju.cards.length; i++){
if (o_paiju.cards[i].playround == 0){
aryCardIDs.push(o_paiju.cards[i].id);
}
}
return cls_youle_erqiwang_arith.order_cards(o_paiju.flower, aryCardIDs);
},
//获取抠底包
get_bottom_account: function(o_paiju, msg){
msg.data.bottom = {};
msg.data.bottom.cards = o_paiju.method.get_burycard();
if (o_paiju.playproc.maxseat != o_paiju.banker){ //闲家抠底
var multiple = cls_youle_erqiwang_arith.get_bottom_multiple(o_paiju.flower, o_paiju.playproc.cards[o_paiju.playproc.maxseat]);
if (multiple > 0){
msg.data.bottom.multiple = multiple;
var get = o_paiju.method.get_grade_incard(msg.data.bottom.cards);
msg.data.bottom.grade1 = get.grade;
msg.data.bottom.grade2 = multiple * msg.data.bottom.grade1;
}
}
return msg;
},
//获取闲家捡分（不包含抠底）
get_jian_grade: function(o_paiju){
var re = {};
re.grade = 0;
re.cards = [];
for (var i = 0; i < o_paiju.cards.length; i++){
if (o_paiju.cards[i].playowner > -1 && o_paiju.cards[i].playowner != o_paiju.banker){
if (o_paiju.cards[i].score > 0){
re.grade = re.grade + o_paiju.cards[i].score;
re.cards.push(i);
}
}
}
return re;
},
//获取小局结算包，type 0正常结算 1投降结算 2解散结算
get_paiju_account: function(o_paiju, type, msg){
o_paiju.endtime = min_now();
//第一局结算扣除房卡
if (o_paiju.idx == 1 && type != 2){
var do_deduct_roomcard = function(){
youle_erqiwang.import.deduct_roomcard(o_paiju.o_desk.o_room);
}
min_ontimeout(do_deduct_roomcard, 1000);
}
if (msg.rpc != "jiesuan"){
msg.rpc = "jiesuan";
}
if (!msg.data){
msg.data = {};
}
msg.data.aset = {};
msg.data.aset.banker = o_paiju.banker;
msg.data.aset.call = o_paiju.call;
msg.data.aset.multiple = cls_youle_erqiwang_arith.get_multiple_bycall(o_paiju.call);
msg.data.aset.flower = o_paiju.flower;
var jian_grade = cls_youle_erqiwang_paiju.get_jian_grade(o_paiju);
msg.data.aset.grade = jian_grade.grade;
if (msg.data.bottom && msg.data.bottom.grade2){
msg.data.aset.grade = msg.data.aset.grade + msg.data.bottom.grade2;
}
switch (type){
case 0:
msg.data.aset.upgrade = cls_youle_erqiwang_arith.get_upgrade(o_paiju.call, msg.data.aset.grade);
if (msg.data.aset.upgrade > 0){
o_paiju.result = 0;
} else {
o_paiju.result = 1;
}
break;
case 1:
msg.data.aset.upgrade = -99;
o_paiju.result = 2;
break;
case 2:
msg.data.aset.upgrade = 0;
o_paiju.result = 3;
break;
}
msg.data.aset.seatlist = [];
var _player0 = {};
var _player1 = {};
var _player2 = {};
//获取玩家的牌
var _card0 = cls_youle_erqiwang_paiju.get_seat_cards_owner(o_paiju, 0);
var _card1 = cls_youle_erqiwang_paiju.get_seat_cards_owner(o_paiju, 1);
var _card2 = cls_youle_erqiwang_paiju.get_seat_cards_owner(o_paiju, 2);
//计算冲关或王牌
var _flower = o_paiju.flower;
if (type != 2){
_flower = -1;
}
var _chongguan0 = cls_youle_erqiwang_arith.get_chongguan(_flower, _card0);
var _chongguan1 = cls_youle_erqiwang_arith.get_chongguan(_flower, _card1);
var _chongguan2 = cls_youle_erqiwang_arith.get_chongguan(_flower, _card2);
//冲关的牌或王牌
_player0.cards = _chongguan0.cards;
_player1.cards = _chongguan1.cards;
_player2.cards = _chongguan2.cards;
//关数
_player0.chongguan = _chongguan0.count;
_player1.chongguan = _chongguan1.count;
_player2.chongguan = _chongguan2.count;
//是否作废
_player0.obsolete = 0;
_player1.obsolete = 0;
_player2.obsolete = 0;
//根据叫分判断冲关是否作废
var do_obsolete_with_call = function(player, seat){
var _dealcards = cls_youle_erqiwang_paiju.get_seat_cards_deal(o_paiju, seat);
var _dealchongguan = cls_youle_erqiwang_arith.get_chongguan(-1, _dealcards);
if (_dealchongguan.count == 0){
return;
}
var _call = null;
for (var i = 0; i < o_paiju.callproc.length; i++){
if (o_paiju.callproc[i].seat == seat){
_call = o_paiju.callproc[i].call;
break;
}
}
if (!_call){ //冲关必叫
player.obsolete = 1;
} else if (_dealchongguan.wang == 4 && _call > 60){ //四王必踢
player.obsolete = 1;
}
}
do_obsolete_with_call(_player0, 0);
do_obsolete_with_call(_player1, 1);
do_obsolete_with_call(_player2, 2);
//计算冲关得分
var _cg0 = _player0.chongguan;
var _cg1 = _player1.chongguan;
var _cg2 = _player2.chongguan;
if (_player0.obsolete){
_cg0 = 0;
}
if (_player1.obsolete){
_cg1 = 0;
}
if (_player2.obsolete){
_cg2 = 0;
}
_player0.grade_cg = _cg0 * 2 - _cg1 - _cg2;
_player1.grade_cg = _cg1 * 2 - _cg2 - _cg0;
_player2.grade_cg = _cg2 * 2 - _cg0 - _cg1;
//计算傍王得分
var _w0 = _chongguan0.wang;
var _w1 = _chongguan1.wang;
var _w2 = _chongguan2.wang;
if (_player0.obsolete){
_w0 = 0;
}
if (_player1.obsolete){
_w1 = 0;
}
if (_player2.obsolete){
_w2 = 0;
}
_player0.grade_w = _w0 * 2 - _w1 - _w2;
_player1.grade_w = _w1 * 2 - _w2 - _w0;
_player2.grade_w = _w2 * 2 - _w0 - _w1;
//计算捡分得分
var _upgrade = msg.data.aset.upgrade;
if (_upgrade == -99){
_upgrade = -2;
}
switch (o_paiju.banker){
case -1:
_player0.grade_jf = 0;
_player1.grade_jf = 0;
_player2.grade_jf = 0;
break;
case 0:
_player0.grade_jf = _upgrade * msg.data.aset.multiple * 2;
_player1.grade_jf = _upgrade * msg.data.aset.multiple * -1;
_player2.grade_jf = _player1.grade_jf;
break;
case 1:
_player0.grade_jf = _upgrade * msg.data.aset.multiple * -1;
_player1.grade_jf = _upgrade * msg.data.aset.multiple * 2;
_player2.grade_jf = _player0.grade_jf;
break;
case 2:
_player0.grade_jf = _upgrade * msg.data.aset.multiple * -1;
_player1.grade_jf = _player0.grade_jf;
_player2.grade_jf = _upgrade * msg.data.aset.multiple * 2;
break;
}
//计算本局总得分
_player0.grade = _player0.grade_cg + _player0.grade_w + _player0.grade_jf;
_player1.grade = _player1.grade_cg + _player1.grade_w + _player1.grade_jf;
_player2.grade = _player2.grade_cg + _player2.grade_w + _player2.grade_jf;
//大局累积得分
o_paiju.o_desk.seatlist[0][0] = o_paiju.o_desk.seatlist[0][0] + _player0.grade;
o_paiju.o_desk.seatlist[1][0] = o_paiju.o_desk.seatlist[1][0] + _player1.grade;
o_paiju.o_desk.seatlist[2][0] = o_paiju.o_desk.seatlist[2][0] + _player2.grade;
_player0.score = o_paiju.o_desk.seatlist[0][0];
_player1.score = o_paiju.o_desk.seatlist[1][0];
_player2.score = o_paiju.o_desk.seatlist[2][0];
//保存每局得分
o_paiju.o_desk.seatlist[0][1].push(_player0.grade);
o_paiju.o_desk.seatlist[1][1].push(_player1.grade);
o_paiju.o_desk.seatlist[2][1].push(_player2.grade);
msg.data.aset.seatlist.push(_player0);
msg.data.aset.seatlist.push(_player1);
msg.data.aset.seatlist.push(_player2);
if (o_paiju.idx >= o_paiju.o_desk.o_room.asetcount || type == 2){
msg = o_paiju.o_desk.method.get_desk_account(msg);
}
//保存结算包，供断线重连时使用
o_paiju.tmp_jiesuan_aset = msg.data.aset;
return msg;
}
}

457
codes/games/server/games/erqiwang/mod.js Normal file
View File

@@ -0,0 +1,457 @@
//////////////////////////////////////////////////////////////////
/////////////////////////////咻一咻/////////////////////////////
//////////////////////////////////////////////////////////////////
var youle_erqiwang = youle_erqiwang || cls_mod.new("youle_erqiwang", "erqiwang", youle_app);
//牌类
min_loadJsFile("games2/erqiwang/class.pai.js", function(){
//牌局类
min_loadJsFile("games2/erqiwang/class.paiju.js", function(){
//牌桌类
min_loadJsFile("games2/erqiwang/class.desk.js", function(){
//算法类
min_loadJsFile("games2/erqiwang/class.arith.js", function(){
//对内的输入接口类
min_loadJsFile("games2/erqiwang/class.import.js", function(){
//对内的输出接口类
min_loadJsFile("games2/erqiwang/class.export.js", function(){
});
});
});
});
});
});
//对内的输入接口类（需要的外部接口）
youle_erqiwang.import = null;
//对内的输出接口类（提供给外部使用的接口）
youle_erqiwang.export = null;
//叫分或不叫
youle_erqiwang.jiaofen = function(pack){
var agentid = pack.data.agentid;
var playerid = parseInt(pack.data.playerid);
var gameid = pack.data.gameid;
var roomcode = parseInt(pack.data.roomcode);
var seat = parseInt(pack.data.seat);
var call = parseInt(pack.data.call);
//检查玩家的位置是否正确
var o_room = youle_erqiwang.import.check_player(agentid, gameid, roomcode, seat, playerid, pack.conmode, pack.fromid);
if (!o_room){
return;
}
//牌桌
var o_desk = o_room.o_desk;
if (!o_desk){
return;
}
//牌局
var o_paiju = o_desk.method.curr_paiju();
if (!o_paiju){
return;
}
//检查当前的游戏阶段是否是叫分阶段
if (o_paiju.step != 1){
return;
}
//检查当前的叫分位置
if (o_paiju.method.get_callgrade_seat() != seat){
return;
}
//检查当前的叫分分值必须大于0，且是5的整数倍
if (call < 0 || call % 5 != 0){
return;
}
var curr_call = o_paiju.method.get_callgrade_value();
//第一家不能不叫分
if (curr_call == 0 && call == 0){
return;
}
//叫分必须小于之前的叫分
if (curr_call != 0 && call >= curr_call){
return;
}
//叫分成功
o_paiju.method.do_callgrade(call);
//返回前端
if (o_paiju.step == 1){
//等待下一家叫分
var msg = {};
msg.app = "youle";
msg.route = "erqiwang";
msg.rpc = "jiaofen";
msg.data = {};
msg.data.seat = seat;
msg.data.call = call;
msg.data.currcall = o_paiju.method.get_callgrade_value();
msg.data.multiple = cls_youle_erqiwang_arith.get_multiple_bycall(msg.data.currcall);
msg.data.nextseat = o_paiju.method.get_callgrade_seat();
msg.data.countdown = o_desk.method.get_countdown_jiaofen();
o_room.method.sendpack_toother(msg, -1);
return;
}
if (o_paiju.step == 2){
//等待庄家叫主
var msg = {};
msg.app = "youle";
msg.route = "erqiwang";
msg.rpc = "shangzhuang";
msg.data = {};
msg.data.seat = seat;
msg.data.call = call;
msg.data.banker = o_paiju.banker;
msg.data.grade = o_paiju.call;
msg.data.multiple = cls_youle_erqiwang_arith.get_multiple_bycall(msg.data.grade);
msg.data.bottomcards = o_paiju.method.get_bottomcards();
msg.data.countdown = o_desk.method.get_countdown_xuanzhu();
if (o_paiju.call < 65){
msg.data.touxiang = 0;
} else {
msg.data.touxiang = 1;
}
for (var i = 0; i < o_room.seatlist.length; i++) {
msg.conmode = o_room.seatlist[i].conmode;
msg.fromid = o_room.seatlist[i].fromid;
if (i == o_paiju.banker){
msg.data.cards = o_paiju.method.get_seat_cards(i);
} else {
delete msg.data.cards;
}
youle_erqiwang.app.SendPack(msg);
}
return;
}
}
//选主
youle_erqiwang.xuanzhu = function(pack){
var agentid = pack.data.agentid;
var playerid = parseInt(pack.data.playerid);
var gameid = pack.data.gameid;
var roomcode = parseInt(pack.data.roomcode);
var seat = parseInt(pack.data.seat);
var flower = parseInt(pack.data.flower);
//检查玩家的位置是否正确
var o_room = youle_erqiwang.import.check_player(agentid, gameid, roomcode, seat, playerid, pack.conmode, pack.fromid);
if (!o_room){
return;
}
//牌桌
var o_desk = o_room.o_desk;
if (!o_desk){
return;
}
//牌局
var o_paiju = o_desk.method.curr_paiju();
if (!o_paiju){
return;
}
//检查当前的游戏阶段是否是选主阶段
if (o_paiju.step != 2){
return;
}
//检查庄家位置
if (o_paiju.banker != seat){
return;
}
//检查花色
if (flower != 1 && flower != 2 && flower != 3 && flower != 4){
return;
}
//选主成功
o_paiju.method.do_choiceflower(flower);
//返回前端
var msg = {};
msg.app = "youle";
msg.route = "erqiwang";
msg.rpc = "xuanzhu";
msg.data = {};
msg.data.banker = o_paiju.banker;
msg.data.flower = flower;
msg.data.countdown = o_desk.method.get_countdown_maipai();
for (var i = 0; i < o_room.seatlist.length; i++) {
msg.conmode = o_room.seatlist[i].conmode;
msg.fromid = o_room.seatlist[i].fromid;
msg.data.cards = o_paiju.method.get_seat_cards(i);
youle_erqiwang.app.SendPack(msg);
}
}
//埋牌
youle_erqiwang.maipai = function(pack){
var agentid = pack.data.agentid;
var playerid = parseInt(pack.data.playerid);
var gameid = pack.data.gameid;
var roomcode = parseInt(pack.data.roomcode);
var seat = parseInt(pack.data.seat);
var cards = pack.data.cards;
//检查玩家的位置是否正确
var o_room = youle_erqiwang.import.check_player(agentid, gameid, roomcode, seat, playerid, pack.conmode, pack.fromid);
if (!o_room){
return;
}
//牌桌
var o_desk = o_room.o_desk;
if (!o_desk){
return;
}
//牌局
var o_paiju = o_desk.method.curr_paiju();
if (!o_paiju){
return;
}
//检查当前的游戏阶段是否是埋牌阶段
if (o_paiju.step != 3){
return;
}
//检查庄家位置
if (o_paiju.banker != seat){
return;
}
//检查埋牌是否是8张
if (cards.length != 8){
return;
}
//检查埋牌是否都在庄家手上
if (!o_paiju.method.check_cards_inhand(cards, seat)){
return;
}
//埋牌成功
o_paiju.method.do_burycard(cards);
//返回前端
var msg = {};
msg.app = "youle";
msg.route = "erqiwang";
msg.rpc = "maipai";
msg.data = {};
msg.data.seat = o_paiju.playproc.currseat;
msg.data.countdown = o_desk.method.get_countdown_chupai();
for (var i = 0; i < o_room.seatlist.length; i++) {
msg.conmode = o_room.seatlist[i].conmode;
msg.fromid = o_room.seatlist[i].fromid;
if (i == o_paiju.banker){
msg.data.cards = o_paiju.method.get_seat_cards(i);
msg.data.bottomcards = cards;
} else {
delete msg.data.cards;
delete msg.data.bottomcards;
}
youle_erqiwang.app.SendPack(msg);
}
}
//投降
youle_erqiwang.touxiang = function(pack){
var agentid = pack.data.agentid;
var playerid = parseInt(pack.data.playerid);
var gameid = pack.data.gameid;
var roomcode = parseInt(pack.data.roomcode);
var seat = parseInt(pack.data.seat);
//检查玩家的位置是否正确
var o_room = youle_erqiwang.import.check_player(agentid, gameid, roomcode, seat, playerid, pack.conmode, pack.fromid);
if (!o_room){
return;
}
//牌桌
var o_desk = o_room.o_desk;
if (!o_desk){
return;
}
//牌局
var o_paiju = o_desk.method.curr_paiju();
if (!o_paiju){
return;
}
//检查当前的游戏阶段是否是叫分、埋牌、投降阶段
if (o_paiju.step != 2 && o_paiju.step != 3 && o_paiju.step != 4){
return;
}
//检查庄家位置
if (o_paiju.banker != seat){
return;
}
//检查是否允许投降
if (o_paiju.call < 65){
return;
}
//投降结算
o_paiju.step = 6;
var msg = {};
msg.app = "youle";
msg.route = "erqiwang";
msg.rpc = "jiesuan";
msg.data = {};
msg = o_paiju.method.get_paiju_account(1, msg);
o_room.method.sendpack_toother(msg, -1);
}
//出牌
youle_erqiwang.chupai = function(pack){
var agentid = pack.data.agentid;
var playerid = parseInt(pack.data.playerid);
var gameid = pack.data.gameid;
var roomcode = parseInt(pack.data.roomcode);
var seat = parseInt(pack.data.seat);
var cards = pack.data.cards;
//检查玩家的位置是否正确
var o_room = youle_erqiwang.import.check_player(agentid, gameid, roomcode, seat, playerid, pack.conmode, pack.fromid);
if (!o_room){
return;
}
//牌桌
var o_desk = o_room.o_desk;
if (!o_desk){
return;
}
//牌局
var o_paiju = o_desk.method.curr_paiju();
if (!o_paiju){
return;
}
//检查当前的游戏阶段是否是出牌阶段
if (o_paiju.step != 4 && o_paiju.step != 5){
return;
}
//检查出牌位置
if (seat != o_paiju.playproc.currseat){
return;
}
//检查出牌
if (cards.length == 0){
return;
}
//检查出牌是否都在玩家手上
if (!o_paiju.method.check_cards_inhand(cards, seat)){
return;
}
//检查选中的牌是否可出，并出牌
var re = o_paiju.method.do_playcard(cards);
if (!re.result){
return;
}
//返回前端
var msg = {};
msg.app = "youle";
msg.route = "erqiwang";
msg.data = {};
msg.data.seat = seat;
msg.data.cards = cards;
msg.data.info = o_paiju.seatlist[seat];
msg.data.nextseat = o_paiju.playproc.currseat;
msg.data.countdown = o_desk.method.get_countdown_chupai();
if (o_paiju.method.have_baofu()){
msg.data.baozhu = 1;
} else {
msg.data.baozhu = 0;
}
switch (re.idx)
{
case 1: //第一个出牌
msg.rpc = "chupai1";
msg.data.count = re.count;
msg.data.flower = re.flower;
msg.data.cardtype = re.cardtype;
break;
case 2: //第二个出牌
msg.rpc = "chupai2";
break;
case 3: //第三个出牌
msg.rpc = "chupai3";
msg.data.maxseat = re.maxseat;
if (re.grade > 0){
msg.data.grade = re.grade;
// msg.data.gradecards = re.gradecards;
}
break;
}
if (o_paiju.step == 5){
for (var i = 0; i < o_room.seatlist.length; i++){
msg.conmode = o_room.seatlist[i].conmode;
msg.fromid = o_room.seatlist[i].fromid;
if (i == seat){
msg.data.cardsinhand = o_paiju.method.get_seat_cards(i);
} else {
delete msg.data.cardsinhand;
}
youle_erqiwang.app.SendPack(msg);
}
} else if (o_paiju.step == 6){
//小局结算
//出牌包的调整
msg.data.chupai = {};
msg.data.chupai.seat = msg.data.seat;
msg.data.chupai.cards = msg.data.cards;
msg.data.chupai.maxseat = msg.data.maxseat;
if (msg.data.grade){
msg.data.chupai.grade = msg.data.grade;
}
if (msg.data.gradecards){
msg.data.chupai.gradecards = msg.data.gradecards;
}
delete msg.data.seat;
delete msg.data.cards;
delete msg.data.info;
delete msg.data.nextseat;
delete msg.data.countdown;
delete msg.data.baozhu;
delete msg.data.cardsinhand;
delete msg.data.maxseat;
delete msg.data.grade;
delete msg.data.gradecards;
//获取抠底包
msg = o_paiju.method.get_bottom_account(msg);
//获取小局结算包
msg = o_paiju.method.get_paiju_account(0, msg);
o_room.method.sendpack_toother(msg, -1);
}
}
//准备
youle_erqiwang.zhunbei = function(pack){
var agentid = pack.data.agentid;
var playerid = parseInt(pack.data.playerid);
var gameid = pack.data.gameid;
var roomcode = parseInt(pack.data.roomcode);
var seat = parseInt(pack.data.seat);
//检查玩家的位置是否正确
var o_room = youle_erqiwang.import.check_player(agentid, gameid, roomcode, seat, playerid, pack.conmode, pack.fromid);
if (!o_room){
return;
}
//牌桌
var o_desk = o_room.o_desk;
if (!o_desk){
return;
}
//牌局
var o_paiju = o_desk.method.curr_paiju();
if (!o_paiju){
return;
}
//检查当前的游戏阶段是否是结算阶段
if (o_paiju.step != 6){
return;
}
//检查当前局数小于总局数
if (o_desk.paiju_list.length >= o_room.asetcount){
return;
}
//准备成功
o_desk.method.do_prepare(seat);
}

BIN
codes/games/server/games/erqiwang/二七王接口.xlsx Normal file
View File

Binary file not shown.