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

目录结构调整

Browse Source
This commit is contained in:
Joywayer
2026-02-04 23:47:45 +08:00
parent 6938c911c3
commit 6b22238c6e
8780 changed files with 15333 additions and 574 deletions
Download Patch File Download Diff File Expand all files Collapse all files

381
codes/games/backstage/YouLeGamesServer.html Normal file
View File

@@ -0,0 +1,381 @@
<!DOCTYPE HTML>
<html>
<head>
<meta charset="utf-8">
<meta http-equiv="Expires" content="0">
<meta http-equiv="Pragma" content="no-cache">
<meta http-equiv="Cache-Control" content="no-cache, must-revalidate">
<meta name="viewport" content="width=device-width,initial-scale=1 user-scalable=0"/>
<title>后台接口表</title>
</head>
<body>
<div id="divChat">
<textarea name="txtChatMain" id="txtChatMain" readonly="readonly" class="txtarea"></textarea>
</div>
<style type='text/css'>
div#divChat { width:30em; }
textarea.txtarea { float:left; width: 34em; height: 20em;}
</style>
<script type="text/javascript" src="md5.js"></script>
<script type="text/javascript" src="indexDb.js"></script>
<script type="text/javascript" src="lz-string.js"></script>
<script type="text/javascript" src="minhttp.js"></script>
<script type="text/javascript" src="packet.js"></script>
<script type="text/javascript">
// Websocket object
var ws = null;
// Websocket 连接地址
var ws_url = "ws://127.0.0.1:56000";
//临时屏蔽某个游戏的数据包
var blacknamelist_game = [];
// Helper functions
function $() {
return document.getElementById(arguments[0]);
}
function logMsg(msg) {
$('txtChatMain').value += msg + '\n';
}
function logmsg(msg) {
$('txtChatMain').value += msg + '\n';
}
function sendMsg(msg) {
try{
ws.send(msg);
}catch(e){
console.log(min_now() + "发包报错。");
console.log(msg);
console.log(e);
}
}
function sendmsg(msg) {
try{
ws.send(msg);
}catch(e){
console.log(min_now() + "发包报错。");
console.log(msg);
console.log(e);
}
}
//重新连接
function reconnect(){
ws = null;
connectWebSocket();
}
// Websocket functions
function connectWebSocket() {
OnBeginConnectedServerChat();
if ("WebSocket" in window) {
// Create new websocket connection
ws = new WebSocket(ws_url);
// Called after connection is established
ws.onopen = function() {
logMsg(min_now() + ' tcp connected to: ' + ws.url);
sendMsg('dfw19770109'); //告诉ServerChat.exe我是逻辑服务器
ws.wsisclose = false;
};
// Called when connection is closed
ws.onclose = function() {
ws.wsisclose = true;
logMsg(min_now() + " Connection closed!");
ws.reconnecttimer = min_ontimeout(reconnect, 5000);
};
// Called when a new message is received
ws.sendall = function (msg) {
if (ws.wsisclose){
return;
}
if (typeof(msg) == 'string') {
sendMsg('@toallall:' + msg);
}
else
{
var s = JSON.stringify(msg);
sendMsg('@toallall:' + s);
}
}
//Send message to HTTP client
ws.sendtou = function (head, msg) {
if (ws.wsisclose){
return;
}
sendMsg(head + msg);
}
//Send message to TCP client
ws.sendbyids = function(ids, msg) {
if (ws.wsisclose){
return;
}
var s = '@tooneone:';
var str_ids;
if (typeof(msg) == 'string')
{}
else
{
msg = JSON.stringify(msg);
}
if (typeof(ids) == 'string')
{
str_ids = ids;
}
else
{
//ids:[1,5,8] 要转成字符串 1,5,8
str_ids = ids[0];
for (var i=1; i<ids.length; i++)
{
str_ids = str_ids + ',' + ids[i];
}
}
s = s + str_ids + ':' + msg;
sendMsg(s);
}
ws.sendclosetcp = function(ids) {
if (ws.wsisclose){
return;
}
var s = '@toclosed:';
var str_ids;
if (typeof(ids) == 'string') {
str_ids = ids;
}else{
//ids:[1,5,8] 要转成字符串 1,5,8
str_ids = ids[0];
for (var i=1; i<ids.length; i++)
{
str_ids = str_ids + ',' + ids[i];
}
}
s = s + str_ids+ ':a';
sendMsg(s);
}
ws.onmessage = function (msg) {
if (msg.data)
{
// logMsg(msg.data);
var arr = msg.data;
var tou = arr.substr(10, 5);
// var arrs = arr.split(":");
//取前面50个字符，以免全字符split，提高效率
var arr50 = arr.substr(0, 50);
var arrs = arr50.split(":");
if (tou == 'http_')
{//http
var s1 = '@tooneone' + ':' + arrs[1] + ':';
var s2 = "";
if (arrs.length > 2)
{//是数据，否则是命令
s2 = msg.data.substr(s1.length, msg.data.length-s1.length);
}
OnHttpMessage(s1, s2);
}
else
{//tcp
var ss0 = arrs[0];
var ss1 = arrs[1];
var sip = arrs[2];
var s01 = ss0 + ':' + ss1 + ':' + sip + ':';
var ss2 = "";
if (arrs.length > 3)
{//是数据，否则是命令
ss2 = msg.data.substr(s01.length, msg.data.length - s01.length);
}
OnTcpMessage(ss0, ss1, sip, ss2);
// var ss0 = arrs[0];
// var ss1 = arrs[1];
// var s01 = ss0 + ':' + ss1 + ':';
// var ss2 = "";
// if (arrs.length > 2)
// {//是数据，否则是命令
// ss2 = msg.data.substr(s01.length, msg.data.length - s01.length);
// }
// OnTcpMessage(ss0, ss1, "", ss2);
}
};
return;
};
}
else
{
logMsg('Browser doesn\'t support websockets!');
}
OnAfterConnectedServerChat();
}
//server.html连接ServerChat.exe前的事件
function OnBeginConnectedServerChat()
{
}
//server.html连接ServerChat.exe后的事件
function OnAfterConnectedServerChat()
{
//给packet_face传递发包函数
if (typeof(packet_face) != "undefined")
{
global.packet_face.SendPack_Tcp = ws.sendbyids;
global.packet_face.SendPack_Http = ws.sendtou;
}
}
//收到客户端http发包触发的事件
function OnHttpMessage(str_httpid, str_data)
{
try
{
str_data = min_replaceAll(str_data, "%", "");
str_data = decodeURIComponent(str_data); //解码
}
catch(e)
{
console.log("OnHttpMessage_decodeURIComponent:" + str_data);
return;
}
var s = "";
s = str_data.substr(0, 6);
if (s == "&data=") {
str_data = str_data.replace("&data=", "");
}
s = str_data.substr(0, 5);
if (s == "data=") {
str_data = str_data.replace("data=", "");
}
s = str_data.substr(0, 2);
if (s == "&=") {
str_data = str_data.replace("&=", "");
}
s = str_data.substr(0, 1);
if (s == "&") {
str_data = str_data.replace("&", "");
}
if (typeof(packet_face) != "undefined") {
if (str_data) {
try
{
var json_data = JSON.parse(str_data);
if (json_data){
json_data.conmode = "http";
json_data.fromid = str_httpid;
packet_face.ReceivePack(json_data);
}
}
catch(e)
{
console.log(min_now() + " str_data:" + str_data);
console.log(e);
}
}
}
}
//收到客户端tcp发包触发的事件
function OnTcpMessage(str_com, str_tcpid, str_ip, str_data)
{
switch (str_com)
{
case "@toconcon": //连上ServerChat.exe
break;
case "@tologin1": //客户端连接上
if (typeof(packet_face) != "undefined")
{
packet_face.OnTcpConnected(str_tcpid);
}
break;
case "@toleave1": //客户端断开
if (typeof(packet_face) != "undefined")
{
packet_face.OnTcpDisConnected(str_tcpid);
}
break;
case "@toserver": //客户端发包
if (typeof(packet_face) != "undefined")
{
try
{
//去除%，否则decodeURIComponent(str_data)会报错
str_data = min_replaceAll(str_data, "%", "");
//解码
str_data = decodeURIComponent(str_data);
var json_data = JSON.parse(str_data);
}
catch(e)
{
console.log(min_now() + "非法的TCP连接");
var errlog = {};
errlog.com = str_com;
errlog.tcpid = str_tcpid;
errlog.ip = str_ip;
errlog.data = str_data;
console.log(errlog);
//断开tcp连接
ws.sendclosetcp(str_tcpid);
return;
}
if (json_data){
try
{
//屏蔽某个有错的route
if (json_data.route){
if (min_ary_indexof(blacknamelist_game, json_data.route) > -1){
return;
}
}
}
catch(e)
{}
json_data.conmode = "tcp";
json_data.fromid = str_tcpid;
json_data.ip = str_ip;
try
{
packet_face.ReceivePack(json_data);
}
catch(e)
{
console.log(min_now() + "执行rpc出错");
console.log(json_data);
console.log(e);
}
}
}
break;
default:
console.log(min_now() + "非法的TCP连接");
var errlog = {};
errlog.com = str_com;
errlog.tcpid = str_tcpid;
errlog.ip = str_ip;
errlog.data = str_data;
console.log(errlog);
//断开tcp连接
ws.sendclosetcp(str_tcpid);
break;
}
}
window.onload = connectWebSocket();
</script>
</body>
</html>

13
codes/games/backstage/applist.js Normal file
View File

@@ -0,0 +1,13 @@
///////////////////////////////////////////////////
//////////////////////应用列表/////////////////////
///////////////////////////////////////////////////
//系统服务
min_loadJsFile("server/app.js", function (){
//友乐游戏
min_loadJsFile("youle/app.js", function (){
//动态更新模块
min_loadJsFile("update/app.js", function (){
});
});
});

77
codes/games/backstage/class/class.app.js Normal file
View File

@@ -0,0 +1,77 @@
///////////////////////////////////////////////////
//////////////cls_app: 应用基础类//////////////////
///////////////////////////////////////////////////
var cls_app = cls_app || {
//构造函数
new: function(_str_appname, _obj_packet) {
/*
参数说明：
_str_appname 应用名称
_obj_packet 所有应用的总包接口对象
*/
//创建一个实例
var app = {};
// ================= 实例的公有属性 ================= //
//应用名称
app.appname = _str_appname;
//总包接口
app.packet_face = _obj_packet;
//给客户端发包函数
app.SendPack = app.packet_face.SendPack;
//给http客户端发包函数
app.SendPack_Http = app.packet_face.SendPack_Http;
//给tcp客户端发包函数
app.SendPack_Tcp = app.packet_face.SendPack_Tcp;
//将app添加到packet_face的应用列表中
app.packet_face.applist.push(app);
//模块列表 [{"face":room_face,"facename":"room_face","routename":"room"}]
app.modlist = [];
// ================= 实例的公有方法 ================= //
//TCP客户端断开
app.OnTcpDisConnected = function(_str_tcpid) {
cls_app.OnTcpDisConnected(app, _str_tcpid);
}
//处理数据包
app.ReceivePack = function(_pack) {
return cls_app.ReceivePack(app, _pack);
}
return app;
},
// ================= 所有实例的共享方法 ================= //
//TCP客户端断开
OnTcpDisConnected: function(_obj_app, _str_tcpid) {
for (var i = 0; i < _obj_app.modlist.length; i++) {
if (_obj_app.modlist[i].OnTcpDisConnected) {
_obj_app.modlist[i].OnTcpDisConnected(_str_tcpid);
}
}
},
//处理数据包
ReceivePack: function(_obj_app, _pack) {
if (typeof(_pack) == "string") {
_pack = JSON.parse(_pack); //转换json
}
//路由各个模块
for (var i = 0; i < _obj_app.modlist.length; i++) {
if (_pack.route == _obj_app.modlist[i].routename) {
if (_obj_app.modlist[i].DoPack) {
var repack = _obj_app.modlist[i].DoPack(_pack);
//发包
if (repack && _obj_app.SendPack) {
_obj_app.SendPack(repack);
}
return repack;
}
break;
}
}
}
}

463
codes/games/backstage/class/class.aset2.js Normal file
View File

@@ -0,0 +1,463 @@
/*================= cls_aset2: 小局基础类 =================
注意：
1，此牌类是基础小局类；各子游戏需要继承此基础类后下编写自己的小局类。
2，子游戏开发人员不能修改该文件。
=========================================================*/
var cls_aset2 = {
//================ 新建一小局 ================
New: function(){
//定义小局
var o_aset = this.declare();
//初始化牌列表
this.initcardlist(o_aset);
//除掉不要的牌
this.deletecard(o_aset);
//设置每张牌的分值
this.setcardscore(o_aset);
return o_aset;
},
//小局的数据定义
declare: function(){
var o_aset = {};
//玩家列表
o_aset.playerlist = []; //在此定义和存储玩家的状态，比如准备状态、叫分的分值、游戏的得分等等，格式如[[], [], ...], [{}, {}, ...], [player, player, ...]
//牌列表
o_aset.cardlist = []; //格式为[[], [], [], ...]，里面的每个小数组就是一张牌
//庄(位置)
o_aset.zhuang = -1;
//控制权(位置)
o_aset.control = -1;
//当前是第几轮出牌
o_aset.play = 0;
//当前是本轮的第几个出牌
o_aset.index = 0;
return o_aset;
},
//初始化牌列表
initcardlist: function(o_aset){
//几副牌
var card_count = this.get_cardcount();
//牌类
var card_class = this.get_cardclass();
//初始化
for (var i = 1; i <= card_count; i++){ //几副牌
for (var j = 1; j <= 4; j++){ //方块、梅花、红心、黑桃四种花色
for (var k = 1; k <= 13; k++){ //A到K
var id = (i - 1) * 54 + (j - 1) * 13 + k - 1; //牌的绝对id
//新建一张牌
var card_object = card_class.New(id);
o_aset.cardlist.push(card_object);
}
}
//小王
var card_object = card_class.New((i - 1) * 54 + 53 - 1);
o_aset.cardlist.push(card_object);
//大王
var card_object = card_class.New((i - 1) * 54 + 54 - 1);
o_aset.cardlist.push(card_object);
}
},
//几副牌
get_cardcount: function(){
return 1;
},
//小局对应的牌类
get_cardclass: function(){
return cls_card2;
},
//除掉不要的牌
deletecard: function(o_aset){
for (var i = 0; i < o_aset.cardlist.length; i++){
var o_card = o_aset.cardlist[i];
this.get_cardclass().SetDeal(o_card, -1);
}
//下面的代码是3人二七王除掉3、4的例子。类似功能需要在子游戏中重写该方法
// for (var i = 0; i < o_aset.cardlist.length; i++){
// var o_card = o_aset.cardlist[i];
// var card_number = this.get_cardclass().GetNumber(o_card);
// if (card_number == 3 || card_number == 4){
// this.get_cardclass().SetDeal(o_card, -2);
// }
// }
},
//设置每张牌的分值
setcardscore: function(o_aset){
for (var i = 0; i < o_aset.cardlist.length; i++){
var o_card = o_aset.cardlist[i];
var card_deal = this.get_cardclass().GetDeal(o_card);
if (card_deal != -2){
this.get_cardclass().SetScore(o_card, 0);
}
}
//下面的代码是设置5、10、K分值的例子。类似功能需要在子游戏中重写该方法
// for (var i = 0; i < o_aset.cardlist.length; i++){
// var o_card = o_aset.cardlist[i];
// var card_deal = this.get_cardclass().GetDeal(o_card);
// if (card_deal != -2){
// var card_number = this.get_cardclass().GetNumber(o_card);
// switch (card_number){
// case 5:
// this.get_cardclass().SetScore(o_card, 5);
// break;
// case 10:
// this.get_cardclass().SetScore(o_card, 10);
// break;
// case 13:
// this.get_cardclass().SetScore(o_card, 10);
// break;
// }
// }
// }
},
//===================== 发牌 =====================
DealCard: function(o_aset, o_desk){
//需要发牌的位置列表
var seatlist = this.get_dealseatlist(o_aset, o_desk);
//每人需要发多少张牌
var dealcount = this.get_dealcount(o_aset, o_desk);
//需要留几张底牌
var bottomcount = this.get_bottomcount(o_aset, o_desk);
//注意：dealcount * seatlist + bottomcount必须等于除掉不要的牌之后的牌的总数
//发牌数组
var tmplist = [];
for (var i = 0; i < seatlist.length; i++){
for (var j = 0; j < dealcount; j++){
tmplist.push(seatlist[i]);
}
}
for (var i = 0; i < bottomcount; i++){
tmplist.push(-1);
}
//随机发牌
for (var i = 0; i < o_aset.cardlist.length; i++){
var o_card = o_aset.cardlist[i];
var card_deal = this.get_cardclass().GetDeal(o_card);
if (card_deal != -2){
var idx = min_random(0, tmplist.length - 1);
this.get_cardclass().SetDeal(o_card, tmplist[idx]);
this.get_cardclass().SetStart(o_card, tmplist[idx]);
this.get_cardclass().SetPlay(o_card, -1);
this.get_cardclass().SetOver(o_card, tmplist[idx]);
//将发牌数组的最后一位移至该位置
if (idx < tmplist.length - 1) {
tmplist[idx] = tmplist[tmplist.length - 1];
};
//发牌数组长度减一
tmplist.length = tmplist.length - 1;
}
}
},
//需要发牌的位置列表
get_dealseatlist: function(o_aset, o_desk){
var seatlist = [];
for (var i = 0; i < o_desk.o_room.seatlist.length; i++){
if (o_desk.o_room.seatlist[i]){
if (o_desk.o_room.seatlist[i].gameinfo.isbet){
seatlist.push(i);
}
}
}
return seatlist;
},
//每人需要发多少张牌
get_dealcount: function(o_aset, o_desk){
return 0;
},
//需要留几张底牌
get_bottomcount: function(o_aset, o_desk){
return 0;
},
//==================== 拿底牌 ====================
PutBottomCard: function(o_aset, seat){
var bottomcardlist = this.GetBottomCards(o_aset);
for (var i = 0; i < bottomcardlist.length; i++) {
var o_card = bottomcardlist[i];
this.get_cardclass().SetStart(o_card, seat);
}
},
//===================== 埋牌 =====================
BuryCard: function(o_aset, seat, cardidlist){
/*参数:
seat:哪个位置要埋牌
cardidlist:要埋的牌的id
返回值：true表示执行成功，false表示执行失败。*/
if (this.canBuryCard(o_aset, seat, cardidlist)){
this.doBuryCard(o_aset, seat, cardidlist);
return true;
} else {
return false;
}
},
get_burycardcount: function(){
return 8;
},
//检查是否可埋牌
canBuryCard: function(o_aset, seat, cardidlist){
//检查控制权
if (seat != o_aset.control){
return false;
}
//检查埋牌数量
if (cardidlist.length != this.get_burycardcount()){
return false;
}
//检查要埋的牌是否在玩家手上
var inhandcardids = this.GetCardIdsInhand(o_aset, seat);
return min_ary_include(inhandcardids, cardidlist);
},
//埋牌
doBuryCard: function(o_aset, seat, cardidlist){
var cardlist = this.CardIdsToCards(o_aset, cardidlist);
for (var i = 0; i < cardlist.length; i++) {
var o_card = cardlist[i];
this.get_cardclass().SetPlay(o_card, -2);
}
},
//===================== 出牌 =====================
PlayCard: function(o_aset, seat, cardidlist, mode){
/*参数:
seat:哪个位置要出牌
cardidlist:要出的牌的id
mode:出牌模式 0-需要跟随上一家出牌 1-需要跟随第一家出牌
返回值:true表示执行成功，false表示执行失败。*/
var can = this.canPlayCard(o_aset, seat, cardidlist, mode); //检查是否可出
if (can.result){ //可出
this.doPlayCard(o_aset, seat, cardidlist); //出下去
return true;
} else { //不可出
return false;
}
},
//检查是否可出牌
canPlayCard: function(o_aset, seat, cardidlist, mode){
var can = {}; //返回的结果
can.result = false; //是否可以出出去
can.cards = null; //牌（对象）
can.cardtype = null; //牌型
can.value = null; //大小
can.flower = null; //花色
//检查控制权
if (seat != o_aset.control){
can.result = false;
return can;
}
//检查要出的牌是否在玩家手上
var inhandcardids = this.GetCardIdsInhand(o_aset, seat);
if (!min_ary_include(inhandcardids, cardidlist)){
can.result = false;
return can;
}
return can;
},
//第一个出牌时分析选中的牌是否可以出出去（主要是分析牌型）
canPlayCard_first: function(o_aset, cardidlist){
var can = {}; //返回的结果
can.result = false; //是否可以出出去
can.cards = null; //牌（对象）
can.cardtype = null; //牌型
can.value = null; //大小
can.flower = null; //花色
return can;
},
//不是第一个出牌时分析选中的牌是否可以出出去（主要是分析牌型是否符合前面出牌的牌型）
canPlayCard_second: function(o_aset, cardidlist, mode){
var can = {}; //返回的结果
can.result = false; //是否可以出出去
can.cards = null; //牌（对象）
can.cardtype = null; //牌型
can.value = null; //大小
can.flower = null; //花色
return can;
},
//出牌
doPlayCard: function(o_aset, seat, cardidlist){
var cardlist = this.CardIdsToCards(o_aset, cardidlist);
for (var i = 0; i < cardlist.length; i++) {
var o_card = cardlist[i];
this.get_cardclass().SetPlay(o_card, o_aset.play);
this.get_cardclass().SetIndex(o_card, o_aset.index);
}
},
//=================== 可跟随的牌 ===================
CanFollowCard: function(o_aset, seat, mode){
//根据第一个人或上一个人出的牌，分析seat这个位置上的人必出的牌和可出的牌
},
//==================== 小局结算 =====================
CloseAccount: function(o_aset, o_desk){
},
//================ 获取各种情况的牌 ================
//获取开局时玩家发到手上的牌
GetDealCardsBySeat: function(o_aset, seat){
return this.GetCardsByDealstate(o_aset, seat);
},
GetDealCardIdsBySeat: function(o_aset, seat){
var cardlist = this.GetDealCardsBySeat(o_aset, seat);
return this.CardsToCardIds(cardlist);
},
//获取底牌
GetBottomCards: function(o_aset){
return this.GetCardsByDealstate(o_aset, -1);
},
GetBottomCardIds: function(o_aset){
var cardlist = this.GetBottomCards(o_aset);
return this.CardsToCardIds(cardlist);
},
//获取玩家当前手上有的牌
GetCardsInhand: function(o_aset, seat){
var cardlist = [];
for (var i = 0; i < o_aset.cardlist.length; i++){
var o_card = o_aset.cardlist[i];
var card_start = this.get_cardclass().GetStart(o_card);
if (card_start == seat){
var card_play = this.get_cardclass().GetPlay(o_card);
if (card_play == -1 || card_play == null){
cardlist.push(o_card);
}
}
}
return cardlist;
},
GetCardIdsInhand: function(o_aset, seat){
var cardlist = this.GetCardsInhand(o_aset, seat);
return this.CardsToCardIds(cardlist);
},
//获取埋牌 参数：seat谁埋的牌，可以不传，默认只有一个人会埋牌
GetBuryCards: function(o_aset, seat){
return this.GetCardsByPlaystate(o_aset, -2, seat);
},
GetBuryCardIds: function(o_aset, seat){
var cardlist = this.GetBuryCards(o_aset, seat);
return this.CardsToCardIds(cardlist);
},
//获取上一轮出牌
GetPriorPlayCard: function(o_aset, round){
},
//获取下一轮出牌
GetNextPlayCard: function(o_aset, round){
},
//================== 各种底层函数 ==================
//根据发牌状态获取牌列表
GetCardsByDealstate: function(o_aset, dealstate){
var cardlist = [];
for (var i = 0; i < o_aset.cardlist.length; i++){
var o_card = o_aset.cardlist[i];
var card_deal = this.get_cardclass().GetDeal(o_card);
if (card_deal == dealstate){
cardlist.push(o_card);
}
}
return cardlist;
},
//根据出牌状态获取牌列表
GetCardsByPlaystate: function(o_aset, playstate, seat){
var cardlist = [];
for (var i = 0; i < o_aset.cardlist.length; i++){
var o_card = o_aset.cardlist[i];
var card_play = this.get_cardclass().GetPlay(o_card);
if (card_play == playstate){
if (seat != null){
var card_start = this.get_cardclass().GetStart(o_card);
if (card_start == seat){
cardlist.push(o_card);
}
} else {
cardlist.push(o_card);
}
}
}
return cardlist;
},
//将牌对象列表转换成牌id列表
CardsToCardIds: function(cardlist){
var cardidlist = [];
for (var i = 0; i < cardlist.length; i++){
var o_card = cardlist[i];
var card_id = this.get_cardclass().GetId(o_card);
cardidlist.push(card_id);
}
return cardidlist;
},
//将牌id列表转换成牌对象列表
CardIdsToCards: function(o_aset, cardidlist){
var cardlist = [];
for (var i = 0; i < cardidlist.length; i++){
var o_card = o_aset.cardlist[cardidlist[i]];
cardlist.push(o_card);
}
return cardlist;
},
//新建小局类
NewClass: function(){
var cls = {};
cls.New = cls_aset2.New;
cls.declare = cls_aset2.declare;
cls.initcardlist = cls_aset2.initcardlist;
cls.get_cardcount = cls_aset2.get_cardcount;
cls.get_cardclass = cls_aset2.get_cardclass;
cls.deletecard = cls_aset2.deletecard;
cls.setcardscore = cls_aset2.setcardscore;
cls.DealCard = cls_aset2.DealCard;
cls.get_dealseatlist = cls_aset2.get_dealseatlist;
cls.get_dealcount = cls_aset2.get_dealcount;
cls.get_bottomcount = cls_aset2.get_bottomcount;
cls.PutBottomCard = cls_aset2.PutBottomCard;
cls.BuryCard = cls_aset2.BuryCard;
cls.get_burycardcount = cls_aset2.get_burycardcount;
cls.canBuryCard = cls_aset2.canBuryCard;
cls.doBuryCard = cls_aset2.doBuryCard;
cls.PlayCard = cls_aset2.PlayCard;
cls.canPlayCard = cls_aset2.canPlayCard;
cls.canPlayCard_first = cls_aset2.canPlayCard_first;
cls.canPlayCard_second = cls_aset2.canPlayCard_second;
cls.doPlayCard = cls_aset2.doPlayCard;
cls.CanFollowCard = cls_aset2.CanFollowCard;
cls.CloseAccount = cls_aset2.CloseAccount;
cls.GetDealCardsBySeat = cls_aset2.GetDealCardsBySeat;
cls.GetDealCardIdsBySeat = cls_aset2.GetDealCardIdsBySeat;
cls.GetBottomCards = cls_aset2.GetBottomCards;
cls.GetBottomCardIds = cls_aset2.GetBottomCardIds;
cls.GetCardsInhand = cls_aset2.GetCardsInhand;
cls.GetCardIdsInhand = cls_aset2.GetCardIdsInhand;
cls.GetBuryCards = cls_aset2.GetBuryCards;
cls.GetBuryCardIds = cls_aset2.GetBuryCardIds;
cls.GetPriorPlayCard = cls_aset2.GetPriorPlayCard;
cls.GetNextPlayCard = cls_aset2.GetNextPlayCard;
cls.GetCardsByDealstate = cls_aset2.GetCardsByDealstate;
cls.GetCardsByPlaystate = cls_aset2.GetCardsByPlaystate;
cls.CardsToCardIds = cls_aset2.CardsToCardIds;
cls.CardIdsToCards = cls_aset2.CardIdsToCards;
return cls;
}
}

742
codes/games/backstage/class/class.card2.js Normal file
View File

@@ -0,0 +1,742 @@
/*===================== cls_card2: 牌的基础类 ======================
扑克牌的统一定义：
1，单张牌的定义是一个长度为14的数组 [Id, Flower, Number, ArithF, ArithN, Score, Deal, Start, Play, Index, Over, Tag1, Tag2, Tag3]
第一位：Id，牌的绝对id，即数组下标，从0开始计数。
第二位：Flower，牌的物理花色，5:王 4:黑桃 3:红心 2:梅花 1:方块。
第三位：Number，牌的物理大小，1:A 2:2 ... 9:9 10:10 11:J 12:Q 13:K 53:小王 54:大王。
第四位：ArithF，牌的算法花色，区别于物理花色，用于牌型计算和比较牌的大小。
要求是大于0的整数，不能等于0或小于0，默认等于物理花色。
第五位：ArithN，牌的算法大小，区别于物理大小，用于牌型计算和比较牌的大小。
要求是大于0的整数，不能等于0或小于0，默认等于物理大小。
第六位：Score，牌的分值，如5、10、K。
第七位：Deal，发牌状态。
-2：规则去除的牌；
-1：未发的牌（底牌）；
>=0：发牌发到谁手上，即座位号。
第八位：Start，开局状态，开局时牌在谁手上，与座位编号对应。
第九位：Play，出牌状态。
-2：埋的牌；
-1：未出的牌（手上的牌）；
>=0：牌是第几轮出出去的，从0开始计数。
第十位：Index，本轮中的出牌顺序号，从0开始计数。
第十一位：Over，牌局结束时被谁得到，与座位编号对应。
第十二位：Tag1，扩展属性1。
第十三位：Tag2，扩展属性2。
第十四位：Tag3，扩展属性3。
2，基础牌型的统一定义：
所有基础牌型都由两个值表示：tong，同，表示一样的牌；shun，顺，表示连续的牌。
单张：tong=1，shun=1
对子：tong=2，shun=1
两连对：tong=2，shun=2
三连对：tong=2，shun=3
三个：tong=3，shun=1
飞机：tong=3，shun=2
四个：tong=4，shun=1
五连顺：tong=1，shun=5
六连顺：tong=1，shun=6
其他基础牌型以此类推
注意：
1，此牌类是基础扑克牌类、通用扑克牌类；各子游戏可以直接使用，也可以继承此基础类后下编写自己的牌类。
2，子游戏开发人员不能修改该文件。
3，访问牌的属性时要求使用Get和Set方法，不能直接通过数组下标的形式访问。
===================================================================*/
var cls_card2 = {
//新建一张牌
New: function(id){
return this.declare(id);
},
//牌的数据定义
declare: function(id){
//id转物理花色
var IdToFlower = function(cardid){
var yu = cardid % 54;
if (yu == 52 || yu == 53){
return 5;
}
return parseInt(yu / 13) + 1;
}
//id转物理数值
var IdToNumber = function(cardid){
var yu = cardid % 54;
if (yu == 52){
return 53;
}
if (yu == 53){
return 54;
}
return yu % 13 + 1;
}
var o_card = [];
o_card[0] = id;
o_card[1] = IdToFlower(id);
o_card[2] = IdToNumber(id);
o_card[3] = o_card[1];
o_card[4] = o_card[2];
o_card[5] = null;
o_card[6] = null;
o_card[7] = null;
o_card[8] = null;
o_card[9] = null;
o_card[10] = null;
o_card[11] = null;
o_card[12] = null;
o_card[13] = null;
return o_card;
},
//牌的id，整型，只读
GetId: function(o_card){
return o_card[0];
},
//牌的物理花色，整型，只读
GetFlower: function(o_card){
return o_card[1];
},
//牌的物理大小，整型，只读
GetNumber: function(o_card){
return o_card[2];
},
//牌的算法花色，整型
GetArithF: function(o_card){
return o_card[3];
},
SetArithF: function(o_card, value){
o_card[3] = value;
},
//牌的算法大小，整型
GetArithN: function(o_card){
return o_card[4];
},
SetArithN: function(o_card, value){
o_card[4] = value;
},
//牌的分值，整型
GetScore: function(o_card){
return o_card[5];
},
SetScore: function(o_card, value){
o_card[5] = value;
},
//发牌状态，整型
GetDeal: function(o_card){
return o_card[6];
},
SetDeal: function(o_card, value){
o_card[6] = value;
},
//开局状态，整型
GetStart: function(o_card){
return o_card[7];
},
SetStart: function(o_card, value){
o_card[7] = value;
},
//出牌状态，整型
GetPlay: function(o_card){
return o_card[8];
},
SetPlay: function(o_card, value){
o_card[8] = value;
},
//出牌顺序，整型
GetIndex: function(o_card){
return o_card[9];
},
SetIndex: function(o_card, value){
o_card[9] = value;
},
//结束时被谁得到，整型
GetOver: function(o_card){
return o_card[10];
},
SetOver: function(o_card, value){
o_card[10] = value;
},
//扩展属性
GetTag1: function(o_card){
return o_card[11];
},
SetTag1: function(o_card, value){
o_card[11] = value;
},
GetTag2: function(o_card){
return o_card[12];
},
SetTag2: function(o_card, value){
o_card[12] = value;
},
GetTag3: function(o_card){
return o_card[13];
},
SetTag3: function(o_card, value){
o_card[13] = value;
},
/*
以下提供几个针对牌数组的基础算法，这两个方法是基于牌的算法花色和算法大小实现的，各子游戏在调用前需要将牌的算法花色和算法大小先设置好。
设置算法花色的原则是：
1，如果对花色没要求则需要将所有牌的算法花色统一。比如斗地主中的五连顺是任何花色都可以一起连顺子的，则需要将所有牌的算法花色全部设置成0，表示都是同一花色，然后在同一花色下取顺子。
2，如果对花色有要求则需要根据实际情况区分算法花色。比如升级中的两连对是指同一花色下的两连对，则需要将算法花色设置成不同的值，表示不同算法花色之间是不能组成两连对的。
设置算法大小的原则是：算法大小即可表示是否连牌，也可表示牌的大小关系。
1，设置算法大小时要求做到数字连续则表示是连牌。比如A的物理大小是1，K的物理大小是13，1和13是不连续的，此时需要将A的算法大小设置成14，将K的算法大小设置成13，14和13是连续的，表示A和K可以连牌。再比如王牌和A是不能作为连牌出现的，则需要将王的算法大小设置成16，将A的算法大小设置成14，16和14不是连续的，表示王和A不能连牌。
2，设置算法大小时要求做到数字大小则表示是牌的大小。比如A的物理大小是1，K的物理大小是13，1比13小，但A比K大，此时需要将A的算法大小设置成14，将K的算法大小设置成13，14比13大，表示A比K大。再比如王牌比A大，则需要将王的算法大小设置成16，将A的算法大小设置成14，16大于14，表示王比A大。
*/
//根据算法花色筛选牌
FilterCardListByArithF: function(o_cardlist, ArithF){
/*参数说明
o_cardlist：需要进行筛选的牌数组
ArithF：要筛选的算法花色，默认不筛选
返回值：筛选后的牌数组*/
var result = [];
for (var i = 0; i < o_cardlist.length; i++) {
var o_card = o_cardlist[i];
var card_ArithF = this.GetArithF(o_card);
if (!ArithF || card_ArithF == ArithF) {
result.push(o_cardlist[i]);
}
}
return result;
},
//根据算法大小筛选牌
FilterCardListByArithN: function(o_cardlist, min_ArithN, max_ArithN){
/*参数说明
o_cardlist：需要进行筛选的牌数组
min_ArithN：要筛选的算法大小最小值，>=，默认不限制
max_ArithN：要筛选的算法大小最大值，<=，默认不限制
返回值：筛选后的牌数组*/
var result = [];
for (var i = 0; i < o_cardlist.length; i++) {
var o_card = o_cardlist[i];
var card_ArithN = this.GetArithN(o_card);
if ((!min_ArithN || card_ArithN >= min_ArithN) &&
(!max_ArithN || card_ArithN <= max_ArithN)) {
result.push(o_cardlist[i]);
}
}
return result;
},
//根据算法大小对牌数组进行排序(冒泡排序法)
SortCardList: function(o_cardlist, options){
/*参数说明
o_cardlist: 需要进行排序的牌数组
options : 排序选项，长度为2的数组，结构为[大小排序方向，花色排序方向]
第一位: 算法大小排序方向，0-从小到大排序 1-从大到小排序，默认为0。
第二位: 物理花色排序方向，算法大小相同时是否再按物理花色排序，默认为0。
0-根据算法大小排序方向默认选择物理花色排序方向，
options[0]=0时，物理花色默认按“方块->梅花->红心->黑桃”排序；
options[0]=1时，物理花色默认按“黑桃->红心->梅花->方块”排序。
1-不按物理花色排序，在o_cardlist中是什么顺序就什么顺序。
2-按物理花色从小到大，方块->梅花->红心->黑桃
3-按物理花色从大到小，黑桃->红心->梅花->方块
返回值: 排序后的牌数组*/
var ArithN_direct = 0; //算法大小排序方向
var Flower_direct = 0; //物理花色排序方向
if (options) {
ArithN_direct = parseInt(options[0]);
Flower_direct = parseInt(options[1]);
}
if (!Flower_direct){
if (ArithN_direct) {
//算法大小从大到小排序时，默认按“黑桃->红心->梅花->方块”排序
Flower_direct = 3;
} else {
//算法大小从小到大排序时，默认按“方块->梅花->红心->黑桃”排序
Flower_direct = 2;
}
}
//j与j+1互换位置
var doChangej = function(){
var tmp = o_cardlist[j];
o_cardlist[j] = o_cardlist[j + 1];
o_cardlist[j + 1] = tmp;
}
for (var i = 0; i < o_cardlist.length; i++){
for (var j = 0; j < o_cardlist.length - i - 1; j++){
var ArithN_j = this.GetArithN(o_cardlist[j]);
var ArithN_j1 = this.GetArithN(o_cardlist[j + 1]);
if (ArithN_direct == 0 && ArithN_j > ArithN_j1){
//从小到大排序
doChangej();
continue;
}
if (ArithN_direct == 1 && ArithN_j < ArithN_j1){
//从大到小排序
doChangej();
continue;
}
if (ArithN_j == ArithN_j1){
//算法大小相同时
if (Flower_direct == 1){
//不按物理花色排序
continue;
}
var Flower_j = this.GetFlower(o_cardlist[j]);
var Flower_j1 = this.GetFlower(o_cardlist[j + 1]);
if (Flower_direct == 2 && Flower_j > Flower_j1){
//按“方块->梅花->红心->黑桃”排序
doChangej();
continue;
}
if (Flower_direct == 3 && Flower_j < Flower_j1){
//按“黑桃->红心->梅花->方块”排序
doChangej();
continue;
}
}
}
}
return o_cardlist;
},
//获取指定牌型(基础牌型)的各种组合(只组合，无排列)
GetCardListByCardType: function(o_cardlist, cardtype, options){
/*参数说明
o_cardlist:在这些牌中获取指定牌型，必须是经过了从小到大排序后的牌数组。
cardtype :目标牌型，长度为2的数组，结构为[同，顺]。
例如单张为[1,1]，对子为[2,1]，五连顺为[1,5]。
options :取牌选项，长度为4的数组，结构为[结果数量，取牌方向，拆牌标志，一次标志]
第一位:结果数量，0-获取所有可能的结果，>0要取的结果数量，默认为0。
比如，牌数组为[2,3,5,7]时，
当options[0]=0时，则取单张的结果为2，3，5，7；
当options[0]=1时，则取单张的结果为2；
当options[0]=3时，则取单张的结果为2，3，5。
第二位:取牌方向，0-从小到大取结果，1-从大到小取结果，默认为0。
第三位:拆牌标志，0-不拆牌，1-拆牌，默认为0。
比如，牌数组为[2,2,3,5,5,5,7]，
当options[2]=0时，则取单张时会不取对子的牌和三张的牌，即结果为3，7；
当options[2]=1时，则取单张时会拆掉对子的牌和三张的牌，即结果为2，3，5，7。
第四位:一次标志，0-相同大小的牌只取一次，1-取所有情况，默认为0。
比如，牌数组为[红心2, 黑桃2, 方块3, 方块5, 红心5, 黑桃5, 方块7]，
当options[3]=0时，则取单张的结果为：红心2, 方块3, 方块5, 方块7；
当options[3]=1时，则取单张时结果为：红心2, 黑桃2, 方块3, 方块5, 红心5, 黑桃5, 方块7。
返回值：满足牌型要求的牌组合数组。
格式如
[
[o_card, o_card, o_card, ...],
[o_card, o_card, o_card, ...],
[o_card, o_card, o_card, ...],
...
]
注意：统一用第一张牌的算法大小值表示牌型大小，比如34567是顺子，56789也是顺子，用3表示34567顺子的大小，用5表示56789顺子的大小，5大于3，表示56789的顺子比34567的顺子大*/
var cardtype_tong = parseInt(cardtype[0]); //牌型-同
var cardtype_shun = parseInt(cardtype[1]); //牌型-顺
var options_count = 0; //结果数量
var options_direct= 0; //取牌方向
var options_split = 0; //拆牌标志
var options_once = 0; //一次标志
if (options){
options_count = parseInt(options[0]);
options_direct= parseInt(options[1]);
options_split = parseInt(options[2]);
options_once = parseInt(options[3]);
}
//将牌按大小分组，即相同大小的牌归为一组。如，将[2,2,3,5,5,5,7]这样的牌数组转成[[2,2],[3],[5,5,5],[7]]
var SameGroupList = [];
var SameGroup = [];
for (var i = 0; i < o_cardlist.length; i++){
var o_card = o_cardlist[i];
if (SameGroup.length == 0){
SameGroup.push(o_card);
} else {
var card_ArithN = this.GetArithN(o_card);
var SameGroup_ArithN = this.GetArithN(SameGroup[0]);
if (card_ArithN == SameGroup_ArithN){
SameGroup.push(o_card);
} else {
SameGroupList.push(SameGroup);
SameGroup = [];
SameGroup.push(o_card);
}
}
}
if (SameGroup.length > 0){
SameGroupList.push(SameGroup);
}
//将牌分组按牌型的“同”获取各自的组合。例如，将[[2,2],[3],[5,5,5],[7]]这样的牌分组按“同”等于2转成[[[2,2]], [[方5,梅5],[方5,红5],[梅5,红5]]]
var TongGroupList = [];
for (var i = 0; i < SameGroupList.length; i++){
if (SameGroupList[i].length < cardtype_tong){
// TongGroupList.push([]);
continue;
}
if (SameGroupList[i].length == cardtype_tong){
TongGroupList.push([SameGroupList[i]]);
continue;
}
if (SameGroupList[i].length > cardtype_tong){
if (!options_split){ //不允许拆牌
// TongGroupList.push([]);
continue;
}
if (!options_once){ //同样大小的牌只取一次
TongGroupList.push([SameGroupList[i].slice(0, cardtype_tong)]);
} else {
TongGroupList.push(min_CombineInAry(SameGroupList[i], cardtype_tong));
}
}
}
//返回结果
var resultlist = [];
var ShunGroup = [];
//检查ShunGroup是否是连顺，如果是连顺则在ShunGroup取结果保存到resultlist中
var check_return_ShunGroup = function(){
var isShun = true;
for (var j = 0; j < ShunGroup.length; j++){
if (ShunGroup[j].length == 0) {
isShun = false;
break;
}
if (j > 0) {
var j1_ArithN = this.GetArithN(ShunGroup[j-1][0][0]);
var j_ArithN = this.GetArithN(ShunGroup[j][0][0]);
//相减等于1表示是顺
if (j_ArithN - j1_ArithN != 1){
isShun = false;
break;
}
}
}
if (!isShun){
return false;
}
var result = min_CombineByArys(ShunGroup);
for (var j = 0; j < result.length; j++) {
var temp = [];
for (var k = 0; k < result[j].length; k++) {
temp = temp.concat(result[j][k]);
}
resultlist.push(temp);
if (options_count && resultlist.length >= options_count) {
//达到了要取的结果数量
return true;
}
}
return false;
}.bind(this);
//按牌型的“顺”获取符合要求的结果
if (!options_direct){
//从小到大取结果
for (var i = 0; i <= TongGroupList.length - cardtype_shun; i++){
ShunGroup = TongGroupList.slice(i, i + cardtype_shun);
if (check_return_ShunGroup()){
return resultlist;
}
}
} else {
//从大到小取结果
for (var i = TongGroupList.length - cardtype_shun; i >= 0; i--){
ShunGroup = TongGroupList.slice(i, i + cardtype_shun);
if (check_return_ShunGroup()){
return resultlist;
}
}
}
return resultlist;
},
GetCardListByCardTypeA: function(o_cardlist, cardtype, options, min_ArithN, max_ArithN){
/*参数说明
o_cardlist:同GetCardListByCardType中的参数说明。
cardtype :同GetCardListByCardType中的参数说明。
options :同GetCardListByCardType中的参数说明。
min_ArithN:同FilterCardListByArithN中的参数说明。
max_ArithN:同FilterCardListByArithN中的参数说明。
返回值：同GetCardListByCardType中的参数说明。*/
var cardlist = this.FilterCardListByArithN(o_cardlist, min_ArithN, max_ArithN);
return this.GetCardListByCardType(cardlist, cardtype, options);
},
GetCardListByCardTypeB: function(o_cardlist, cardtype, options, ArithF, min_ArithN, max_ArithN){
/*参数说明
o_cardlist:可以是未排序的牌数组，该函数会实现排序。
cardtype :同GetCardListByCardType中的参数说明。
options :同GetCardListByCardType中的参数说明。
ArithF :同FilterCardListByArithF中的参数说明。
min_ArithN:同FilterCardListByArithN中的参数说明。
max_ArithN:同FilterCardListByArithN中的参数说明。
返回值：同GetCardListByCardType中的参数说明。*/
var cardlist = this.FilterCardListByArithF(o_cardlist, ArithF);
this.SortCardList(cardlist);
cardlist = this.FilterCardListByArithN(cardlist, min_ArithN, max_ArithN);
return this.GetCardListByCardType(cardlist, cardtype, options);
},
//获取指定牌型(扩展牌型)的一种组合(只取一种组合)
GetCardListByExtendCardTypeA: function(o_cardlist, cardtypelist){
/*参数说明
o_cardlist :同GetCardListByCardTypeA中的参数说明。
cardtypelist:扩展牌型和取牌选项。
结构为[
[cardtype, options, min_ArithN, max_ArithN],
[cardtype, options, min_ArithN, max_ArithN],
[cardtype, options, min_ArithN, max_ArithN]
]
其中cardtype、options、min_ArithN、max_ArithN同GetCardListByCardTypeA中的参数说明。
例如3带1，cardtypelist=[
[[3,1], [1,x,x,x], min_ArithN, max_ArithN],
[[1,1], [1,x,x,x], min_ArithN, max_ArithN]
]
3带2，cardtypelist=[
[[3,1], [1,x,x,x], min_ArithN, max_ArithN],
[[1,1], [1,x,x,x], min_ArithN, max_ArithN],
[[1,1], [1,x,x,x], min_ArithN, max_ArithN]
]
3带1对，cardtypelist=[
[[3,1], [1,x,x,x], min_ArithN, max_ArithN],
[[2,1], [1,x,x,x], min_ArithN, max_ArithN]
]
注意：options中第一参数一定为1，表示只取一个结果，如果传的值不等于1，也会按等于1处理。
返回值：同GetCardListByCardTypeA中的参数说明。*/
var cardlist = o_cardlist;
var result = [];
for (var i = 0; i < cardtypelist.length; i++){
var cardtype = cardtypelist[i][0];
var options = cardtypelist[i][1];
if (options[0] != 1){
options[0] = 1;
}
var min_ArithN = cardtypelist[i][2];
var max_ArithN = cardtypelist[i][3];
var BaseCardGroup = this.GetCardListByCardTypeA(cardlist, cardtype, options, min_ArithN, max_ArithN);
if (BaseCardGroup.length == 0){
return [];
}
result = result.concat(BaseCardGroup[0]);
cardlist = min_ary_deduct(cardlist, BaseCardGroup[0]);
}
return [result];
},
//获取牌数组的最大牌型
GetMaxCardTypeByCardList: function(o_cardlist, option){
/*参数说明
o_cardlist: 必须是经过了从小到大排序后的牌数组。
option: 选项，默认为0
0-返回"同"最多的最大牌型(如果"同"相同则取"顺"最多的，如果"顺"也相同则取"值"最大的)
1-返回"顺"最多的最大牌型(如果"顺"相同则取"同"最多的，如果"同"也相同则取"值"最大的)
返回值：结构为[cardtype, cardlist]。其中，
cardtype为基础牌型，结构为[同，顺]；
cardlist为满足cardtype的牌数组，牌型相同时取最大值的牌。
例如，当option=0时，
牌数组为[3,7,7,7,9,9,J,J,J,Q,Q]， 返回值为[[3,1], [J,J,J]]
牌数组为[3,7,7,7,8,8,8,9,9,J,J,J,Q,Q]， 返回值为[[3,2], [7,7,7,8,8,8]]
牌数组为[3,7,7,7,8,8,8,9,9,J,J,J,Q,Q,Q]，返回值为[[3,2], [J,J,J,Q,Q,Q]]
当option=1时，
牌数组为[2,4,5,6,8,9,J,J,Q,Q,K]， 返回值为[[1,3], [J,Q,K]]
牌数组为[2,4,4,5,5,6,6,8,9,J,J,Q,Q,K]， 返回值为[[2,3], [4,4,5,5,6,6]]
牌数组为[2,4,4,5,5,6,6,8,9,J,J,Q,Q,K,K]，返回值为[[3,2], [J,J,Q,Q,K,K]]*/
var result = [];
//将o_cardlist按大小分组。
//如，将[2,2,3,5,5,5,7]这样的牌数组转成[[2,2],[3],[5,5,5],[7]]
var changeto_SameGroupList = function(){
var SameGroupList = [];
var SameGroup = [];
for (var i = 0; i < o_cardlist.length; i++){
var o_card = o_cardlist[i];
if (SameGroup.length == 0){
SameGroup.push(o_card);
} else {
var card_ArithN = this.GetArithN(o_card);
var SameGroup_ArithN = this.GetArithN(SameGroup[0]);
if (card_ArithN == SameGroup_ArithN){
SameGroup.push(o_card);
} else {
SameGroupList.push(SameGroup);
SameGroup = [];
SameGroup.push(o_card);
}
}
}
if (SameGroup.length > 0){
SameGroupList.push(SameGroup);
}
return SameGroupList;
}.bind(this);
var SameGroupList = changeto_SameGroupList();
switch (option){
case 0: //取"同"最多的牌型 [A,2,2,3,4,4,5,5,7,7,8,8,9,9,J,J,Q,Q,K,K]
//检查ShunGroup是否是连顺
var check_ShunGroup_isShun = function(){
for (var j = 0; j < ShunGroup.length; j++){
if (ShunGroup[j].length == 0) {
return false;
}
if (j > 0) {
var j1_ArithN = this.GetArithN(ShunGroup[j-1][0]);
var j_ArithN = this.GetArithN(ShunGroup[j][0]);
//相减等于1表示是顺
if (j_ArithN - j1_ArithN != 1){
return false;
}
}
}
return true;
}.bind(this);
result[0] = [SameGroupList[0].length, 1];
result[1] = SameGroupList[0];
for (var i = 1; i < SameGroupList.length; i++) {
if (SameGroupList[i].length > result[0][0]){
result[0] = [SameGroupList[i].length, 1];
result[1] = SameGroupList[i];
} else if (SameGroupList[i].length == result[0][0]){
var ArithN_i = this.GetArithN(SameGroupList[i][0]);
var ArithN_r = this.GetArithN(result[1][result[1].length - 1]);
if (ArithN_i - ArithN_r == 1){ //相减等于1表示是顺
result[0][1] = result[0][1] + 1;
result[1] = result[1].concat(SameGroupList[i]);
} else {
if (i + result[0][1] <= SameGroupList.length){
var ShunGroup = SameGroupList.slice(i, i + result[0][1]);
var isShun = check_ShunGroup_isShun();
if (isShun){
var check_Tong = true;
for (var j = 1; j < ShunGroup.length; j++) {
if (ShunGroup[j].length != result[0][0]){
check_Tong = false;
break;
}
}
if (check_Tong) {
result[1] = [];
for (var j = 0; j < ShunGroup.length; j++) {
result[1] = result[1].concat(ShunGroup[j]);
}
i = i + result[0][1] - 1;
}
}
}
}
}
}
break;
case 1: //取"顺"最多的牌型 [A,3,4,6,8,8,9,9,J,J,J,Q,Q,Q]
//将SameGroupList转成ShunGroupList
//如，将[[2,2],[3],[5,5,5],[6,6],[7],[9,9]]转成[[[2,2],[3]], [[5,5,5],[6,6],[7]], [[9,9]]]
var changeto_ShunGroupList = function(){
var ShunGroupList = [];
for (var i = 0; i < SameGroupList.length; i++) {
var ArithN_i = this.GetArithN(SameGroupList[i][0]);
var isFound = false;
for (var j = 0; j < ShunGroupList.length; j++) {
var ArithN_j = this.GetArithN(ShunGroupList[j][ShunGroupList[j].length - 1][0]);
if (ArithN_i - ArithN_j == 1) {
ShunGroupList[j].push(SameGroupList[i]);
isFound = true;
break;
}
}
if (!isFound){
ShunGroupList.push([SameGroupList[i]]);
}
}
return ShunGroupList;
}.bind(this);
//获取ShunGroup中最小的"同"数
var get_ShunGroup_minTong = function(){
var min_Tong = ShunGroup[0].length;
for (var j = 1; j < ShunGroup.length; j++) {
if (ShunGroup[j].length < min_Tong) {
min_Tong = ShunGroup[j].length;
}
}
return min_Tong;
}.bind(this);
//根据ShunGroup的min_Tong设置result
var set_result_byShunGroup_byMinTong = function(){
result[0] = [min_Tong, ShunGroup.length];
result[1] = [];
for (var j = 0; j < ShunGroup.length; j++) {
result[1] = result[1].concat(ShunGroup[j].slice(0, min_Tong));
}
}.bind(this);
var ShunGroupList = changeto_ShunGroupList();
//在ShunGroupList中取最长的"顺"
for (var i = 0; i < ShunGroupList.length; i++) {
var ShunGroup = ShunGroupList[i];
var min_Tong = get_ShunGroup_minTong();
if (i == 0){
set_result_byShunGroup_byMinTong();
} else {
if (ShunGroup.length > result[0][1]) {
set_result_byShunGroup_byMinTong();
} else if (ShunGroup.length == result[0][1]) {
if (min_Tong >= result[0][0]){
set_result_byShunGroup_byMinTong();
}
}
}
}
break;
}
return result;
},
GetMaxCardTypeByCardListA: function(o_cardlist){
/*参数说明 o_cardlist:可以是未排序的牌数组，该函数会实现排序。*/
this.SortCardList(o_cardlist);
return this.GetMaxCardTypeByCardList(o_cardlist);
},
//新建单张牌类
NewClass: function(){
var cls = {};
cls.New = cls_card2.New;
cls.declare = cls_card2.declare;
cls.GetId = cls_card2.GetId;
cls.GetFlower = cls_card2.GetFlower;
cls.GetNumber = cls_card2.GetNumber;
cls.GetArithF = cls_card2.GetArithF;
cls.SetArithF = cls_card2.SetArithF;
cls.GetArithN = cls_card2.GetArithN;
cls.SetArithN = cls_card2.SetArithN;
cls.GetScore = cls_card2.GetScore;
cls.SetScore = cls_card2.SetScore;
cls.GetDeal = cls_card2.GetDeal;
cls.SetDeal = cls_card2.SetDeal;
cls.GetStart = cls_card2.GetStart;
cls.SetStart = cls_card2.SetStart;
cls.GetPlay = cls_card2.GetPlay;
cls.SetPlay = cls_card2.SetPlay;
cls.GetIndex = cls_card2.GetIndex;
cls.SetIndex = cls_card2.SetIndex;
cls.GetOver = cls_card2.GetOver;
cls.SetOver = cls_card2.SetOver;
cls.GetTag1 = cls_card2.GetTag1;
cls.SetTag1 = cls_card2.SetTag1;
cls.GetTag2 = cls_card2.GetTag2;
cls.SetTag2 = cls_card2.SetTag2;
cls.GetTag3 = cls_card2.GetTag3;
cls.SetTag3 = cls_card2.SetTag3;
cls.FilterCardListByArithF = cls_card2.FilterCardListByArithF;
cls.FilterCardListByArithN = cls_card2.FilterCardListByArithN;
cls.SortCardList = cls_card2.SortCardList;
cls.GetCardListByCardType = cls_card2.GetCardListByCardType;
cls.GetCardListByCardTypeA = cls_card2.GetCardListByCardTypeA;
cls.GetCardListByCardTypeB = cls_card2.GetCardListByCardTypeB;
cls.GetCardListByExtendCardTypeA = cls_card2.GetCardListByExtendCardTypeA;
cls.GetMaxCardTypeByCardList = cls_card2.GetMaxCardTypeByCardList;
cls.GetMaxCardTypeByCardListA = cls_card2.GetMaxCardTypeByCardListA;
return cls;
}
}

225
codes/games/backstage/class/class.desk.js Normal file
View File

@@ -0,0 +1,225 @@
///////////////////////////////////////////////////
/////////////// cls_desk: 牌桌基础类 //////////////
///////////////////////////////////////////////////
var cls_desk = cls_desk || {
//创建单个牌桌实例
new: function(o_room){
/*
参数说明：
o_room 牌桌对应的房间对象
补充说明：
1，房间对象由框架负责创建和释放。
2，房间对象管理的是人，解决诸如谁在房间里，谁在哪个位置上，谁进了房间，谁离开了房间等问题。
3，牌桌对象由游戏负责创建，牌桌对象会随着房间的释放而释放，子游戏不用管牌桌的释放。
4，牌桌对象管理的是牌，解决诸如哪个位置上发了什么牌，出了什么牌等问题。
5，此牌桌类是基础牌桌类，各子游戏需要在继承此基础类的情况下编写自己的牌桌类。
*/
var desk = {};
//牌桌与房间互挂
o_room.o_desk = desk; //可通过房间对象的o_desk属性访问牌桌对象
desk.o_room = o_room; //可通过牌桌对象的o_desk属性访问房间对象
//数据
desk.data = {}; //要求data必须是纯数据，不能在data下面写方法、函数、定时器
//定时器
desk.timer = {}; //可根据实际需要在desk.timer下定义多个定时器
//收发包
desk.pack = []; //调试状态下记录牌桌的收包发包情况
//流程方法
desk.flow = {};
//算法方法
desk.arith = {};
//////////在下面定义实例的属性
//数据-小局列表
desk.data.asetlist = []; //每开一小局则往该数组中添加一个aset小局对象，[aset, aset, aset, ...], [{}, {}, {}, ...], [[], [], [], ...]，数组长度即可表示当前是第几小局，数组最后一个小局对象即是当前小局
/////////在下面定义实例的方法，要求实例的方法必须调用类的方法，以节省内存资源，要求实例的方法名要与类的方法名保持一致
//记录游戏的收包情况（不包括框架的收包），要求前端向服务器发包时根据配置参数的设置情况将前端内存数据一起发上来，数据放在pack.data.d里面，服务器收到包后必须调用该方法
desk.flow.save_receivepack = function(pack, seat, playerid){
return cls_desk.save_receivepack(desk, pack, seat, playerid);
}
//记录游戏的发包情况（不包括框架的发包），要求服务器向前端发包后一定要调用该方法
desk.flow.save_sendpack = function(pack, seat, playerid){
return cls_desk.save_sendpack(desk, pack, seat, playerid);
}
//将当前小局的收发包情况保存成TXT
desk.flow.save_pack_curraset = function(callback_succ, callback_fail){
return cls_desk.save_pack_curraset(desk, callback_succ, callback_fail);
}
//输出日志
desk.flow.save_log = function(dir, file, log){
return cls_desk.save_log(desk, dir, file, log);
}
//清日志
desk.flow.clear_log = function(dir, file){
return cls_desk.clear_log(desk, dir, file);
}
//获取当前小局对象
desk.flow.get_curraset = function(){
return cls_desk.get_curraset(desk); //必须调用类的方法，且需要将实例对象作为参数传入类方法，这里只能写一句代码
}
//获取当前小局局数
desk.flow.get_currasetnum = function(){
return cls_desk.get_currasetnum(desk); //必须调用类的方法，且需要将实例对象作为参数传入类方法，这里只能写一句代码
}
return desk;
},
////////////以下都是类的方法，要求所有的逻辑算法全部都要用类方法来实现
//记录收包情况
save_receivepack: function(o_desk, pack, seat, playerid){
try{
if (o_desk.o_room.o_game.method.isdebugger()){ //如果是调试状态下，则记录收包情况
var o_save = {};
o_save.time = min_now(); //时间
o_save.type = 0; //收包
o_save.seat = seat; //位置
o_save.playerid = playerid; //玩家id
o_save.data = {};
//前端内存数据
o_save.data.client = pack.data.d;
//服务器房间内存数据
o_save.data.room = o_desk.o_room.method.get_roominfo();
//服务器牌桌内存数据
o_save.data.desk = min_copyjson(o_desk.data);
for (var i = 0; i < o_save.data.desk.asetlist.length; i++) {
if (i < o_save.data.desk.asetlist.length - 1){
o_save.data.desk.asetlist[i] = null;
};
};
delete pack.data.d;
//接收到的数据包
o_save.pack = pack;
o_desk.pack.push(o_save);
}
}catch(e){};
},
//记录发包情况
save_sendpack: function(o_desk, pack, seat, playerid){
try{
if (o_desk.o_room.o_game.method.isdebugger()){ //如果是调试状态下，则记录发包情况
var o_save = {};
o_save.time = min_now(); //时间
o_save.type = 1; //发包
o_save.seat = seat; //位置
o_save.playerid = playerid; //玩家id
o_save.data = {};
//服务器房间内存数据
o_save.data.room = o_desk.o_room.method.get_roominfo();
//服务器牌桌内存数据
o_save.data.desk = min_copyjson(o_desk.data);
for (var i = 0; i < o_save.data.desk.asetlist.length; i++) {
if (i < o_save.data.desk.asetlist.length - 1){
o_save.data.desk.asetlist[i] = null;
};
};
//发送的数据包
o_save.pack = pack;
o_desk.pack.push(o_save);
}
}catch(e){};
},
//将当前小局的收发包情况保存成TXT
save_pack_curraset: function(o_desk, callback_succ, callback_fail){
try{
if (o_desk.o_room.o_game.method.isdebugger()){
for (var i = 0; i < o_desk.pack.length; i++) {
o_desk.pack[i].saveflag = 1;
};
var o_makewartime = new Date(o_desk.o_room.makewartime);
var yyyy = o_makewartime.getFullYear();
var mm = o_makewartime.getMonth() + 1;
var dd = o_makewartime.getDate();
var dir = yyyy + "-" + mm + "-" + dd;
var file = o_desk.o_room.o_game.o_agent.agentid + "-" + o_desk.o_room.o_game.gameid + "-" + o_desk.o_room.roomcode + "-" + o_desk.flow.get_currasetnum() + ".txt";
var data = JSON.stringify(o_desk.pack);
var cfg = {};
// cfg.url = "http://120.26.52.206:8080/debug.php";
cfg.url = "http://10.117.216.66:8080/debug.php";
cfg.data = "dir=" + dir + "&file=" + file + "&data=" + data;
cfg.type = "POST";
cfg.success = function(str){
for (var i = 0; i < o_desk.pack.length; i++) {
if (o_desk.pack[i].saveflag){
o_desk.pack.splice(i, 1);
i--;
};
};
if(callback_succ){
callback_succ();
};
};
cfg.error = function(str){
for (var i = 0; i < o_desk.pack.length; i++) {
if (o_desk.pack[i].saveflag){
delete o_desk.pack[i].saveflag;
};
};
console.log(min_now() + " 保存牌局调试数据失败1");
console.log("dir=" + dir);
console.log("file=" + file);
console.log(str);
if(callback_fail){
callback_fail();
};
};
min_http(cfg);
}
}catch(e){
console.log(min_now() + " 保存牌局调试数据失败2");
console.log("dir=" + dir);
console.log("file=" + file);
console.log(e);
};
},
//输出日志
save_log: function(o_desk, dir, file, log){
try{
var cfg = {};
// cfg.url = "http://120.26.52.206:8080/savelog.php";
cfg.url = "http://10.117.216.66:8080/savelog.php";
cfg.data = "dir=" + dir + "&file=" + file + "&data=" + log;
cfg.type = "POST";
cfg.success = function(str){};
cfg.error = function(str){
console.log(min_now() + " 输出日志失败:" + dir + "/" + file);
console.log(str);
};
min_http(cfg);
}catch(e){}
},
//清日志
clear_log: function(o_desk, dir, file){
try{
var cfg = {};
// cfg.url = "http://120.26.52.206:8080/clearlog.php";
cfg.url = "http://10.117.216.66:8080/clearlog.php";
cfg.data = "dir=" + dir + "&file=" + file;
cfg.type = "POST";
cfg.success = function(str){};
cfg.error = function(str){
console.log(min_now() + " 清空日志失败:" + dir + "/" + file);
console.log(str);
};
min_http(cfg);
}catch(e){}
},
//获取当前小局对象
get_curraset: function(o_desk){
return o_desk.data.asetlist[desk.data.asetlist.length - 1];
},
//获取当前小局局数
get_currasetnum: function(o_desk){
return o_desk.data.asetlist.length;
}
}

287
codes/games/backstage/class/class.desk2.js Normal file
View File

@@ -0,0 +1,287 @@
/*================= cls_desk2: 牌桌基础类 =================
说明：
1，房间对象由框架负责创建和释放。
2，房间对象管理的是人，解决诸如谁在房间里，谁在哪个位置上，谁进了房间，谁离开了房间等问题。
3，牌桌对象由游戏负责创建，牌桌对象会随着房间的释放而释放，子游戏不用管牌桌的释放。
4，牌桌对象管理的是牌，解决诸如哪个位置上发了什么牌，出了什么牌等问题。
注意：
1，此牌桌类是基础类；各子游戏需要在继承此基础类的情况下编写自己的牌桌类。
2，子游戏开发人员不能修改该文件。
3，子游戏只能调用实例方法，不能直接调用类方法。
=========================================================*/
var cls_desk2 = {
//debug服务器地址
// debugserver: "120.26.52.206:8080", //外网地址，开发人员本地调试时使用该地址
debugserver: "10.117.216.66:8080", //内网地址，正式服务器上使用该地址
//创建实例
new: function(object_room){//参数说明：object_room 牌桌对应的房间对象
var object = {};
//牌桌与房间互挂
object_room.o_desk = object; //可通过房间对象的o_desk属性访问牌桌对象
object.o_room = object_room; //可通过牌桌对象的o_desk属性访问房间对象
//=============== 在下面定义实例的属性 ===============
//数据
object.data = {}; //要求data必须是纯数据，不能在data下面写方法、函数、定时器
//定时器
object.timer = {}; //可根据实际需要在desk.timer下定义多个定时器
//收发包
object.pack = []; //调试状态下记录牌桌的收包发包情况
//bug调试方法
object.debug = {};
//游戏内容方法
object.method = {};
//小局列表。每开一小局则往该数组中添加一个aset小局对象，格式如[aset, aset, aset, ...]，数组长度即可表示当前是第几小局，数组最后一个小局对象即是当前小局
object.data.asetlist = [];
//=============== 在下面定义实例的方法 ===============
/*1，要求实例的方法必须调用类的方法，以节省内存资源。
2，要求实例的方法必须只用一句代码调用类的方法，并将实例对象作为第一个参数传给类方法。
3，要求实例的方法名要与类的方法名保持一致。*/
//====================== bug调试 =====================
//记录游戏的收包情况（不包括框架的收包），要求前端向服务器发包时根据isdebugger参数的配置情况将前端的内存数据一起发上来，数据放在pack.data.d里面，服务器收到前端发来的包后必须调用该方法
//参数说明：pack前端发来的包，seat哪个位置发来的包，哪个玩家发来的包
object.debug.save_receivepack = function(pack, seat, playerid){
return cls_desk2.save_receivepack(object, pack, seat, playerid);
}
//记录游戏的发包情况（不包括框架的发包），要求服务器向前端发包后一定要调用该方法
/*参数说明：pack向前端发的包，seat给哪个位置发包，给哪个玩家发包。
如果是向所有玩家发包则seat传-1，playerid传null，
如果是向多个玩家发包则seat传位置数组，playerid传玩家id数组*/
object.debug.save_sendpack = function(pack, seat, playerid){
return cls_desk2.save_sendpack(object, pack, seat, playerid);
}
//将当前小局的收发包情况保存到debug服务器上，要求小局结算后，下一个小局新建前调用此方法
//参数说明：callback_succ保存成功的回调函数，callback_fail保存失败的回调函数
object.debug.save_pack_curraset = function(callback_succ, callback_fail){
return cls_desk2.save_pack_curraset(object, callback_succ, callback_fail);
}
//输出调试日志到debug服务器上，输入后可在debug服务器上或浏览器中查看日志内容
//参数说明：dir日志目录名，file日志文件名，log要输出的日志内容
object.debug.save_log = function(dir, file, log){
return cls_desk2.save_log(object, dir, file, log);
}
//清空debug服务器上的调试日志
//参数说明：dir日志目录名，file日志文件名
object.debug.clear_log = function(dir, file){
return cls_desk2.clear_log(object, dir, file);
}
//====================== 游戏内容 =====================
//对应的小局类
object.method.AsetClass = function(){
return cls_aset2;
}
//新建一小局
object.method.NewAset = function(){
return cls_desk2.NewAset(object);
}
//大局结算
object.method.CloseAccount = function(){
return cls_desk2.CloseAccount(object);
}
//获取当前小局对象
object.method.CurrAset = function(){
return cls_desk2.CurrAset(object);
}
//获取当前小局是第几小局
object.method.CurrAsetNum = function(){
return cls_desk2.CurrAsetNum(object);
}
//获取下一个有人的位置
object.method.GetNextSeat = function(seat){
return cls_desk2.GetNextSeat(object, seat);
}
return object;
},
//================ 在下面定义类的方法 ================
//===================== bug调试 ======================
//记录服务器收包情况
save_receivepack: function(o_desk, pack, seat, playerid){
try{
if (o_desk.o_room.o_game.method.isdebugger()){ //如果是调试状态下，则记录收包情况
var o_save = {};
o_save.time = min_now(); //记录的时间
o_save.type = 0; //服务器收到前端的发包
o_save.seat = seat; //哪个位置发来的包
o_save.playerid = playerid; //哪个玩家发来的包
o_save.data = {};
//前端内存数据
o_save.data.client = pack.data.d;
//服务器房间内存数据
o_save.data.room = o_desk.o_room.method.get_roominfo();
//服务器牌桌内存数据
o_save.data.desk = min_copyjson(o_desk.data);
for (var i = 0; i < o_save.data.desk.asetlist.length; i++) {
if (i < o_save.data.desk.asetlist.length - 1){
o_save.data.desk.asetlist[i] = null;
};
};
delete pack.data.d;
//接收到的数据包
o_save.pack = pack;
o_desk.pack.push(o_save);
}
}catch(e){};
},
//记录服务器发包情况
save_sendpack: function(o_desk, pack, seat, playerid){
try{
if (o_desk.o_room.o_game.method.isdebugger()){ //如果是调试状态下，则记录发包情况
var o_save = {};
o_save.time = min_now(); //记录的时间
o_save.type = 1; //服务器向前端发包
o_save.seat = seat; //服务器向哪个位置发包
o_save.playerid = playerid; //服务器向哪个玩家发包
o_save.data = {};
//服务器房间内存数据
o_save.data.room = o_desk.o_room.method.get_roominfo();
//服务器牌桌内存数据
o_save.data.desk = min_copyjson(o_desk.data);
for (var i = 0; i < o_save.data.desk.asetlist.length; i++) {
if (i < o_save.data.desk.asetlist.length - 1){
o_save.data.desk.asetlist[i] = null;
};
};
//发送的数据包
o_save.pack = pack;
o_desk.pack.push(o_save);
}
}catch(e){};
},
//将当前小局的收发包情况保存到debug服务器上
save_pack_curraset: function(o_desk, callback_succ, callback_fail){
try{
if (o_desk.o_room.o_game.method.isdebugger()){
for (var i = 0; i < o_desk.pack.length; i++) {
o_desk.pack[i].saveflag = 1;
};
var o_makewartime = new Date(o_desk.o_room.makewartime);
var yyyy = o_makewartime.getFullYear();
var mm = o_makewartime.getMonth() + 1;
var dd = o_makewartime.getDate();
var dir = yyyy + "-" + mm + "-" + dd;
var file = o_desk.o_room.o_game.o_agent.agentid + "-" + o_desk.o_room.o_game.gameid + "-" + o_desk.o_room.roomcode + "-" + o_desk.method.CurrAsetNum() + ".txt";
var data = JSON.stringify(o_desk.pack);
var cfg = {};
cfg.url = "http://" + cls_desk2.debugserver + "/debug.php";
cfg.data = "dir=" + dir + "&file=" + file + "&data=" + data;
cfg.type = "POST";
cfg.success = function(str){
for (var i = 0; i < o_desk.pack.length; i++) {
if (o_desk.pack[i].saveflag){
o_desk.pack.splice(i, 1);
i--;
};
};
if(callback_succ){
callback_succ();
};
};
cfg.error = function(str){
for (var i = 0; i < o_desk.pack.length; i++) {
if (o_desk.pack[i].saveflag){
delete o_desk.pack[i].saveflag;
};
};
console.log(min_now() + " 保存牌局调试数据失败1");
console.log("dir=" + dir);
console.log("file=" + file);
console.log(str);
if(callback_fail){
callback_fail();
};
};
min_http(cfg);
}
}catch(e){
console.log(min_now() + " 保存牌局调试数据失败2");
console.log("dir=" + dir);
console.log("file=" + file);
console.log(e);
};
},
//输出调试日志到debug服务器上
save_log: function(o_desk, dir, file, log){
try{
if (typeof(log) == "object"){
log = JSON.stringify(log);
}
var cfg = {};
cfg.url = "http://" + cls_desk2.debugserver + "/savelog.php";
cfg.data = "dir=" + dir + "&file=" + file + "&data=" + log;
cfg.type = "POST";
cfg.success = function(str){};
cfg.error = function(str){
console.log(min_now() + " 输出调试日志失败");
console.log(str);
};
min_http(cfg);
}catch(e){}
},
//清空debug服务器上的调试日志
clear_log: function(o_desk, dir, file){
try{
var cfg = {};
cfg.url = "http://" + cls_desk2.debugserver + "/clearlog.php";
cfg.data = "dir=" + dir + "&file=" + file;
cfg.type = "POST";
cfg.success = function(str){};
cfg.error = function(str){
console.log(min_now() + " 清空调试日志失败");
console.log(str);
};
min_http(cfg);
}catch(e){}
},
//===================== 游戏内容 ======================
//新建一小局
NewAset: function(o_desk){
var o_aset = o_desk.method.AsetClass().New();
o_desk.data.asetlist.push(o_aset);
return o_aset;
},
//获取当前小局对象
CurrAset: function(o_desk){
return o_desk.data.asetlist[o_desk.data.asetlist.length - 1];
},
//获取当前小局局数
CurrAsetNum: function(o_desk){
return o_desk.data.asetlist.length;
},
//获取下一个有人的位置
GetNextSeat: function(o_desk, seat){
if (seat < 0){
return -1;
}
var seatcount = o_desk.o_room.o_game.seatcount;
if (seat >= seatcount){
return -1;
}
var i = seat;
var o_nextplayer = null;
while (!o_nextplayer){
i = (i + 1) % seatcount;
o_nextplayer = o_desk.o_room.seatlist[i];
}
return i;
},
//大局结算
CloseAccount: function(o_desk){
}
}

135
codes/games/backstage/class/class.flow2.js Normal file
View File

@@ -0,0 +1,135 @@
/*=============== cls_flowMgr2: 流程管理类 ===============
注意：
1，子游戏开发人员不能修改该文件。
=========================================================*/
var cls_flowMgr2 = {
//创建实例
new: function(){
object = {};
//流程库
object.lib = [];
//流程配置
object.steplist = [];
//当前流程，即steplist的数组下标
object.idx = -1;
object.method = {};
//在流程库中添加一个流程
object.method.addflow = function(id, name, func_start, func_over, time, flag1, flag2){
/*参数说明:
id : 流程id，必须唯一
name : 流程名，主要起到说明和备注的作用
func_start: 进入该流程时执行的函数(先完成本流程的开始处理，再根据time开启定时器)
func_over : 该流程结束时执行的函数(先完成本流程的结束处理，再进入下一流程)
time : 进入该流程后开启的定时器(自动触发func_over结束该流程)时长，毫秒
-1: 不需要开启定时器，需要用户触发func_over结束流程
0: 不需要开启定时器，执行完func_start后立即执行func_over结束流程
>0: 需要开启定时器，定时器自动触发func_over结束流程
flag1: 进入流程时执行完func_start后，是否由子游戏开启本流程的定时器，默认为0
0: 由流程管理对象管理
1: 由子游戏管理
flag2: 结束流程时执行完func_over后，是否由子游戏关闭定时器并进入下一流程，默认为0
0: 由流程管理对象管理
1: 由子游戏管理*/
return cls_flowMgr2.addflow(object, id, name, func_start, func_over, time, flag1, flag2);
}
//设置流程。参数steplist为流程配置，是一个流程id数组，如[2,1,1,3,2,4]
object.method.set = function(steplist){
object.steplist = steplist;
}
//获取当前流程
object.method.currflow = function(){
cls_flowMgr2.currflow(object);
}
//开始按流程配置执行
object.method.startflow = function(){
cls_flowMgr2.startflow(object);
}
//进入下一流程
object.method.nextflow = function(){
cls_flowMgr2.nextflow(object);
}
return object;
},
//在流程库中添加一个流程
addflow: function(o_flowMgr, id, name, func_start, func_over, time, flag1, flag2){
var o_flow = {};
o_flow.id = id; //流程id
o_flow.name = name; //流程名
o_flow.func_start = func_start; //进入该流程是执行的函数
o_flow.func_over = func_over; //该流程结束时执行的函数
o_flow.time = time; //进入该流程后开启的定时器时长
o_flow.flag1 = flag1;
o_flow.flag2 = flag2;
o_flow.timer = null; //定时器id
o_flowMgr.lib.push(o_flow);
return o_flow;
},
//获取当前流程
currflow: function(o_flowMgr){
if (!o_flowMgr.steplist || o_flowMgr.steplist.length == 0){
return null;
}
if (o_flowMgr.idx == -1 || o_flowMgr.idx >= o_flowMgr.steplist.length){
return null;
}
var flowid = o_flowMgr.steplist[o_flowMgr.idx];
var flowidx = min_ary_indexof(o_flowMgr.lib, flowid, "id");
if (flowidx == -1){
return null;
}
return o_flowMgr.lib[flowidx];
},
//开始按流程配置执行程序
startflow: function(o_flowMgr){
if (o_flowMgr.lib.length == 0){
return;
}
if (o_flowMgr.steplist.length == 0){
return;
}
o_flowMgr.idx = 0;
this.exec(o_flowMgr);
},
//进入下一流程
nextflow: function(o_flowMgr){
var o_flow = this.currflow(o_flowMgr);
if (o_flow){
if (o_flow.func_over) {
o_flow.func_over();
}
if (!o_flow.flag2){
if (o_flow.timer){
clearTimeout(o_flow.timer);
o_flow.timer = null;
}
}
}
o_flowMgr.idx = o_flowMgr.idx + 1;
this.exec(o_flowMgr);
},
//执行当前流程
exec: function(o_flowMgr){
var o_flow = this.currflow(o_flowMgr);
if (!o_flow){
return;
}
if (!o_flow.func_start){
return;
}
o_flow.func_start();
if (o_flow.time == 0) {
this.nextflow(o_flowMgr);
} else if (o_flow.time > 0) {
//需要开启定时器
if (!o_flow.flag1) {
if (o_flow.func_over) {
o_flow.timer = setTimeout(o_flow.func_over, o_flow.time);
}
}
}
}
}

70
codes/games/backstage/class/class.mod.js Normal file
View File

@@ -0,0 +1,70 @@
///////////////////////////////////////////////////
//////////////cls_mod: 模块基础类//////////////////
///////////////////////////////////////////////////
var cls_mod = cls_mod || {
//构造函数
new: function(_str_modname, _str_routename, _obj_app) {
/*
_str_modname 模块名称
_str_routename 模块的路由名称
_obj_app 所属的应用对象
*/
//创建一个实例
var mod = {};
// ================= 实例的公有属性 ================= //
//模块名称
mod.modname = _str_modname;
//路由名称
mod.routename = _str_routename;
//所属的应用
mod.app = _obj_app;
//将mod对象添加到app的模块列表中
mod.app.modlist.push(mod);
mod.app[_str_modname] = mod;
// ================= 实例的公有方法 ================= //
//收包处理
mod.DoPack = function(_msg) {
return cls_mod.DoPack(mod, _msg);
}
//输出mod
cls_mod.OutputMod(mod);
return mod;
},
DoPack: function(_obj_mod, _msg) {
if (typeof(_msg) == "string") {
_msg = JSON.parse(_msg); //转换json
}
//执行rpc
if (_msg.rpc) {
if (min_ExitsFunction(_obj_mod[_msg.rpc])) {
return _obj_mod[_msg.rpc](_msg);
}
}
},
OutputMod: function(_obj_mod) {
if (typeof global !== "undefined")
{} else {
global = {};
}
if (typeof module !== "undefined")
{} else {
module = {};
module.exports = {};
}
global[_obj_mod.modname] = _obj_mod;
global[_obj_mod.modname].DoPack = _obj_mod.DoPack;
if (module) {
module.exports[_obj_mod.modname] = _obj_mod;
}
}
}

93
codes/games/backstage/class/class.mysql.js Normal file
View File

@@ -0,0 +1,93 @@
///////////////////////////////////////////////////
///////////// cls_mysql: 数据库操作 ///////////////
///////////////////////////////////////////////////
var cls_mysql = cls_mysql || {
//构造函数
new: function(url, func_fail_sendpack){
var mysql = {};
//php地址
mysql.url = url;
//发生错误时的回包函数
mysql.func_fail_sendpack = func_fail_sendpack;
//执行sql语句
mysql.execsql = function(method, sql, para, func_succ, pack) {
/*
method: php方法名 execsql/opensql
sql: 要执行的sql语句
para: 要执行的sql语句的参数数组
func_succ: sql语句执行成功后的回调函数
pack: 客户端发来的数据包，执行失败的话会根据pack返回客户端执行失败的结果
*/
var data = {}
data.m = method;
data.s = sql;
data.p = para;
var strdata = JSON.stringify(data);
//将=号替换为^，php收到后再替换回来，以避免=号POST传参会截断的问题
strdata = strdata.replace(/\=/g,"^");
//将+号替换为#，php收到后再替换回来，以避免+号POST传参会截断的问题
strdata = strdata.replace(/\+/g,"#");
//将&号替换为!，php收到后再替换回来，以避免&号POST传参会截断的问题
strdata = strdata.replace(/\&/g,"!");
var cfg = {};
cfg.url = mysql.url;
cfg.data = "data=" + strdata;
cfg.type = "POST";
cfg.success = function(str) {
try {
var result = JSON.parse(str);
} catch(e) {
console.log(min_now() + " 数据库执行结果转换json失败.");
console.log(str);
console.log(data);
return;
}
if (result.state != 0) {
console.log(min_now() + " 请求" + mysql.url + "失败.");
console.log(result);
console.log(data);
if (pack) {
console.log(JSON.stringify(pack));
//返回客户端执行失败的结果
if (mysql.func_fail_sendpack) {
pack.data = {};
pack.data.state = result.state;
pack.data.error = result.error;
mysql.func_fail_sendpack(pack);
}
}
} else {
//执行sql成功执行回调函数
// console.log(result);
if (func_succ) {
func_succ(result.data);
}
}
};
cfg.error = function(str){
console.log(min_now() + " 请求" + mysql.url + "失败.");
console.log(str);
console.log(data);
if (pack) {
console.log(JSON.stringify(pack));
//返回客户端执行失败的结果
if (mysql.func_fail_sendpack) {
pack.data = {};
pack.data.state = 99;
pack.data.error = "请求数据库失败.";
mysql.func_fail_sendpack(pack);
}
}
};
min_http(cfg);
}
return mysql;
}
}

70
codes/games/backstage/class/class.pai.js Normal file
View File

@@ -0,0 +1,70 @@
///////////////////////////////////////////////////
////////////////// cls_pai: 单张牌 ////////////////
///////////////////////////////////////////////////
var cls_pai = cls_pai || {
//创建单张牌实例
new: function(id, score, dealowner){
/*
参数说明：
id 牌的绝对id
score 牌在游戏中的分值
dealowner 发牌状态
扑克牌的统一编码规则：
1，牌面花色的定义 5:王 4:黑桃 3:红心 2:梅花 1:方块
2，牌面数值的定义 1:A 2:2 3:3 ... 9:9 10:10 11:J 12:Q 13:K 53:小王 54:大王
*/
var pai = {};
//属性
pai.id = id; //绝对id，即数组下标，从0开始计数
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; //出牌后被谁得到，与座位编号对应
//方法
pai.method = {};
//牌面花色
pai.method.get_flower = function(){
return cls_pai.get_flower(pai);
}
//牌面数值
pai.method.get_number = function(){
return cls_pai.get_number(pai);
}
return pai;
},
//获取牌面花色
get_flower: function(o_pai) {
var yu = o_pai.id % 54;
if (yu == 52 || yu == 53){ //小王大王
return 5;
}
return parseInt(yu / 13) + 1;
},
//获取牌面数值
get_number: function(o_pai) {
var yu = o_pai.id % 54;
if (yu == 52){ //小王
return 53;
}
if (yu == 53){ //大王
return 54;
}
return yu % 13 + 1;
}
}

308
codes/games/backstage/config/update中属性说明.txt Normal file
View File

@@ -0,0 +1,308 @@
showmessage
1，app启动提示，app用到。
2，所有层都有该属性。
scrollmsg
1，游戏中的滚动信息栏，游戏中用到。
2，所有层都有该属性。
noticemsg
1，游戏中的通知信息栏，以#号表示换行，游戏中用到。
2，所有层都有该属性。
topupurl
1，房卡充值的链接，该属性值不为空则跳转链接，游戏中用到。
2，顶层、代理agent、游戏game、渠道channel都有该属性。
logimage
1，log图片，游戏中用到。
2，代理agent、游戏game、渠道channel都有该属性。
logimage2
1，代理商的log图片，公众号页面中用到，页面右上角图标。
2，代理agent有该属性。
sharename
1，分享的内容名称，游戏中用到。
2，游戏game、渠道channel都有该属性。
game_version
1，游戏版本号，游戏热升级、游戏中登录拦截玩家时用到。
2，游戏game、渠道channel、市场market都有该属性。
game_zip
1，游戏zip文件，游戏热升级时用到。
2，游戏game、渠道channel、市场market都有该属性。
game_size
1，游戏zip文件大小，游戏大厅中用到。
2，游戏game、渠道channel、市场market都有该属性。
game_hall_image
1，大厅中子游戏的图标。
2，游戏game有该属性。
game_hall_dir
1，大厅中子游戏的目录。
2，游戏game有该属性。
game_down_image
1，下载页面的游戏图标。
2，游戏game有该属性。
game_down_state
1，下载页面的游戏状态，0-发布中 1-开发中 2-测试中。
2，游戏game有该属性。
game_down_memo
1，下载页面的游戏一句话描述。
2，游戏game有该属性。
ios_defdownload_marketid
1，苹果系统下载页面的对应的市场marketid。
2，渠道channel有该属性。
and_defdownload_marketid
1，安卓系统下载页面的对应的市场marketid。
2，渠道channel有该属性。
app_version
1，app版本号，app升级时用到。
2，市场market有该属性。
app_download
1，app下载地址，app升级时用到。
2，市场market有该属性。
app_size
1，app安装包大小，app升级时用到。
2，市场market有该属性。
url_match
1，比赛的链接地址。
2，顶层、代理agent、游戏game都有该属性。
url_match2
1，服务器比赛数据发送地址。
2，顶层、代理agent、游戏game都有该属性。
html_buyroomcard
1，公众号页面是否有购买房卡功能 1-没有 2-有。
2，顶层、代理agent都有该属性。
html_applysales
1，申请成为代理的方式 1-填写微信号并购买房卡 2-填写微信号。
2，顶层、代理agent都有该属性。
sale_qq、sale_wechat、sale_tel
1，代理后台页面显示的官方客服信息。
2，顶层、代理agent都有该属性。
agentmode
1，代理模式，1-无邀请码模式 2-有邀请码模式。
2，顶层、代理agent都有该属性。
relagentid
1，关联代理id，用于关联其他代理。
2，代理agent都有该属性。
isclose
1，关闭服务器标志，1-开启 2-关闭（不能创建和加入房间）。
2，顶层、代理agent、游戏game都有该属性。
pushrate
1，星星场房主抽成百分比，整数。
2，顶层、代理agent、游戏game都有该属性。
player_server_tcp
1，玩家服务器地址及端口号。
2，顶层、代理agent都有该属性。
player_server_http
1，玩家服务器地址及端口号。
2，顶层、代理agent都有该属性。
game_server_http
1，子游戏服务器地址及端口号。
2，顶层、代理agent、游戏game都有该属性。
visitor_server_tcp
1，游客服务器地址及端口号。
2，顶层、代理agent都有该属性。
visitor_server_http
1，游客服务器地址及端口号。
2，顶层、代理agent都有该属性。
system_room
1，星星争霸场系统房间列表。
2，只有游戏game这层有该属性。
3，结构为：
[
{
"type": 2,
"title": "初级场",
"image": "",
"roomtype": object,
"online": 99,
"robotGoldRange":[min,max],
"removeRobot":0,//是否屏蔽机器人
//"forbidEnter":0,//是否开战状态下屏蔽机器人
roomRate:80,//机器人所占房间百分比
ranMin:1,//随机机器人最小值
ranMax:1,//随机机器人最大值
roomLeave:0,//房间是否留一个真实玩家座位0不留1留
}, {}, {}
]
isdebugger
1，是否是调试状态 0：正式 1：调试。
2，只有游戏game这层有该属性。
surrender_min
1，星星场投降的最小数量。
2，顶层、代理agent、游戏game都有该属性。
surrender_unit
1，星星场投降的最小单位数。
2，顶层、代理agent、游戏game都有该属性。
starName
1，星星名称。
2，顶层、代理agent都有该属性。
roomCardName
1，房卡名称。
2，顶层、代理agent都有该属性。
aset_rebate
1，星星场房间小局系统抽成设置
a，星星场房间才会触发小局抽成功能。
b，如果触发了小局抽成功能则会按小局结算，大局结束后将不会进行大局结算。
{
infinite: [1, 1, 5], -- 无限局小局抽成设置，不设置表示无限局不进行小局抽成
finitude: [1, 2, 10] -- 有限局小局抽成设置，不设置表示有限局不进行小局抽成
数组中，
第一位：1-对大赢家抽成 2-对所有赢的人抽成 3-对所有玩家抽成
第二位：1-按玩家分数的百分比(第三位数值)抽成 2-按倍数的百分比抽成
第三位：抽成数值
}
2，顶层、代理agent都有该属性。
pushtoplayerid
1，大局抽成的星星给谁，如果设置了则给设置的玩家，如果没设置则给房主。只对非星星场设置了星星限进的房间有效。
是数组，格式为[普通房间的抽成玩家id, 短号房间的抽成玩家id]
2，顶层、代理agent都有该属性。
pushto
1，0-大局抽成的星星给到pushtoplayerid的玩家账号上。默认为0。
1-大局抽成的星星给到pushtoplayerid对应的代理账号上。
2-大局抽成的星星给到房主对应的代理账号上。
2，顶层、代理agent都有该属性。
xxroomdeduct
1，星星场是否要扣房卡。
0:星星场房间不扣房卡。默认为0。
1:星星场房间和房卡房间一样根据局数扣除房卡。
2，顶层、代理agent都有该属性。
noticelimit
1，玩家发布系统消息的金币数量限制，有这么多金币才能发系统消息。
2，顶层、代理agent都有该属性。
noticecost
1，玩家发布一次系统消息消耗的金币数量。
2，顶层、代理agent都有该属性。
sysroom_playercount
1，系统房间里机器人陪玩的真实玩家数量阈值。默认为20。
真实玩家数量小于等于该阈值时，一个房间内一个玩家配N个机器人，不会出现真实玩家和真实玩家在同一房间的情况。
真实玩家数量大于该阈值时，一个房间内可以进入多个真实玩家。
2，顶层、代理agent、游戏game都有该属性。
showrebate
1，系统房间是否提示金币抽成。0-不提示 1-提示，默认为0。
2，顶层、代理agent都有该属性。
matchlist
1，比赛排行榜
[
{
"id": 2018010101, -- 比赛id，格式必须为年月日+序号
"roomtype": [], -- 房间类型，根据子游戏的roomtype定义
"matchname": "", -- 比赛名称
"imageurl": "", -- 比赛图片地址，可以不配置，不配置时显示默认图片
"beginTime": "2018-01-01 12:00", -- 比赛开始时间，精确到分钟
"endTime": "2018-01-01 14:00", -- 比赛截止时间，精确到分钟
"playercount": 100, -- 开始比赛的人数要求
"playercount2": 10, -- 比赛开始后第一盘打完后再次排队达到多少人后再开始上桌
"bean": 0, -- 参加的金币费用
"roomcard": 0, -- 参加的房卡费用，要与roomtype中的房卡数量保持一致
"topcount": 10, -- 取前几名
"circulation": 0, -- 比赛循环次数 0:不循环 >0:再循环的次数
"interval": 0, -- 比赛循环的间隔时长，精确到秒
"gradename": "得分", -- 得分名称
"memo1": "", -- 文字说明1（第一名奖励说明）
"memo2": "", -- 文字说明2（比赛详情，以#作为换行符）
"memo3": "", -- 文字说明3
"haverobot": 0, -- 1：有机器人 <>1：没有机器人
"status": 0, -- 0: 需要代理后台开通比赛 1：配置文件中直接开通
"ranking": -- 排行榜内的系统成绩
[
{
"min": 100, -- 最低分数，包含等于
"max": 200, -- 最高分数，包含等于
"count": 3 -- 系统成绩个数
}
]
}, {}, {}
]
2，只有游戏game下有该属性。
reportRobotGold
纯机器人是否存储金币变动
0 or 1(非0也可以)
1.不配或者为0不存、非0存储
2.顶层、代理层、游戏层
robotGoldRange
机器人金币随机范围
[num1,num2]
1.不配或者为0按照与游戏内玩家金币数量相当、若配置则在num1、num2中随机(注：两个值差尽量大一点)
2.顶层、代理层、游戏层
videoConfig
视频房配置
{
type:1房卡2星星
profitMode:1固定值，2百分比
profit:百分比模式下如：50%则为50
}
无此属性为非视频房
顶层、代理层、游戏层
rebateConfig
1，大局结算抽成配置(只支持倍数百分比抽给系统)
{
from:抽谁的 1.大赢家 2.赢家 3.所有人
value:抽多少(只支持倍数的百分比抽成)，如50，抽倍数的50%
}
2，顶层、代理agent都有该属性。
brRebateUnit
1，百人vip房每多少人收取茶水费
2，顶层、代理agent都有该属性。
smm_message
1，手机短信验证码消息模板，默认：您的验证码是X。X表示验证码。
2，顶层、代理agent都有该属性。
smm_timeout
1，手机短信验证码时效，秒，默认60。
2，顶层、代理agent都有该属性。
invitecodetype
1，在游戏中绑定的邀请码（长度小于8时）的类型，0-个人代理id 1-玩家id，默认为0。
2，顶层、代理agent都有该属性。

31
codes/games/backstage/debug.php Normal file
View File

@@ -0,0 +1,31 @@
<?php
header("Access-Control-Allow-Origin: *");
header("Access-Control-Allow-Methods: GET, POST, OPTIONS, PUT, PATCH, DELETE");
header("Access-Control-Allow-Headers: Content-Type, Authorization, Content-Length, X-Requested-With");
header("Access-Control-Allow-Credentials: true");
header("Content-Type: textml; charset=utf-8");
$path = @$_REQUEST['dir'];
$file = @$_REQUEST['file'];
$data = @$_REQUEST['data'];
if (empty($path)){
die('para error: dir');
}
if (empty($file)){
die('para error: file');
}
if (empty($data)){
die('para error: data');
}
$path = dirname($_SERVER['SCRIPT_FILENAME']) . '/debug/' . $path;
if (!is_dir($path)){
mkdir($path, 0777);
}
file_put_contents($path . '/' . $file, $data);
die('debug save success');
?>

199
codes/games/backstage/indexDb.js Normal file
View File

@@ -0,0 +1,199 @@
(function(){
var dbObject = {};
dbObject.open = function(params){
//数据库名
dbObject.db_name = params.db_name;
//数据库版本
dbObject.db_version = params.db_version;
//存储对象名
dbObject.store_name = params.store_name;
//IndexedDB对象
dbObject.db = null;
if (!window.indexedDB){
console.log("你的浏览器不支持IndexedDB,请更换浏览器");
}
var request = indexedDB.open(dbObject.db_name, dbObject.db_version);
//打开数据库成功
request.onsuccess = function(event){
console.log("打开IndexedDB数据库" + dbObject.db_name + "成功");
dbObject.db = event.target.result;
if (params.success_callback){
params.success_callback();
}
}
//打开数据库失败
request.onerror = function(event) {
console.log("打开IndexedDB数据库" + dbObject.db_name + "失败");
console.log(event);
if (params.error_callback){
params.error_callback();
}
}
//当打开的数据库版本高于当前版本时触发
request.onupgradeneeded = function(event){
console.log("IndexedDB数据库" + dbObject.db_name + "版本升级到" + dbObject.db_version);
dbObject.db = event.target.result;
if(!dbObject.db.objectStoreNames.contains(dbObject.store_name)){
dbObject.db.createObjectStore(dbObject.store_name);
}
}
}
//添加或修改
dbObject.put = function(key, value){
try{
if (!dbObject.db){
return;
}
//此处必须显式声明事务
var transaction = dbObject.db.transaction(dbObject.store_name, "readwrite");
var store = transaction.objectStore(dbObject.store_name);
var request = store.put(value, key);
request.onsuccess = function(){
// console.log("编辑IndexedDB记录成功：" + key);
}
request.onerror = function(event){
console.log("编辑IndexedDB记录失败：" + key);
console.log(event);
}
}
catch(e){
console.log(min_now() + "添加或修改IndexedDB失败");
console.log(e);
console.log(key);
console.log(value);
}
}
//删除
dbObject.delete = function(key){
try{
if (!dbObject.db){
return;
}
var transaction = dbObject.db.transaction(dbObject.store_name, "readwrite");
var store = transaction.objectStore(dbObject.store_name);
var request = store.delete(key);
request.onsuccess = function(){
// console.log("删除IndexedDB记录成功：" + key);
}
request.onerror = function(event){
console.log("删除IndexedDB记录失败：" + key);
console.log(event);
}
}
catch(e){
console.log(min_now() + "删除IndexedDB失败");
console.log(e);
console.log(key);
}
}
//根据key获取value
dbObject.get = function(key, succ_callback){
try{
if (!dbObject.db){
return;
}
var transaction = dbObject.db.transaction(dbObject.store_name, "readwrite");
var store = transaction.objectStore(dbObject.store_name);
var request = store.get(key);
request.onsuccess = function(){
succ_callback(request.result);
}
request.onerror = function(event){
console.log("获取IndexedDB记录失败：" + key);
console.log(event);
}
}
catch(e){
console.log(min_now() + "获取IndexedDB失败");
console.log(e);
console.log(key);
}
}
//获取所有的value
dbObject.get_allvalue = function(success_callback, error_callback){
try{
if (!dbObject.db){
return;
}
var transaction = dbObject.db.transaction(dbObject.store_name, "readwrite");
var store = transaction.objectStore(dbObject.store_name);
var request = store.getAll();
request.onsuccess = function(){
if (success_callback){
success_callback(request.result);
}
}
request.onerror = function(event){
console.log("获取IndexedDB记录失败：all");
console.log(event);
if (error_callback){
error_callback();
}
}
}
catch(e){
console.log(min_now() + "获取全部的IndexedDB失败");
console.log(e);
}
}
//游标遍历
dbObject.get_cursor = function(success_callback, error_callback){
try{
if (!dbObject.db){
return;
}
var transaction = dbObject.db.transaction(dbObject.store_name, "readwrite");
var store = transaction.objectStore(dbObject.store_name);
var request = store.openCursor();
request.onsuccess = function(event){
if (success_callback){
success_callback(event.target.result);
}
}
request.onerror = function(event){
console.log("获取IndexedDB记录失败：游标");
console.log(event);
if (error_callback){
error_callback();
}
}
}
catch(e){
console.log(min_now() + "获取IndexedDB游标失败");
console.log(e);
}
}
//清除整个对象存储(表)
dbObject.clear = function(){
try{
if (!dbObject.db){
return;
}
var transaction = dbObject.db.transaction(dbObject.store_name, "readwrite");
var store = transaction.objectStore(dbObject.store_name);
var request = store.clear();
request.onsuccess = function(){
console.log("清空IndexedDB对象存储成功：" + dbObject.store_name);
}
request.onerror = function(event){
console.log("清空IndexedDB对象存储失败：" + dbObject.store_name);
console.log(event);
}
}
catch(e){
console.log(min_now() + "清除IndexedDB失败");
console.log(e);
}
}
window.dbObject = dbObject;
})();

506
codes/games/backstage/lz-string.js Normal file
View File

@@ -0,0 +1,506 @@
// Copyright (c) 2013 Pieroxy <pieroxy@pieroxy.net>
// This work is free. You can redistribute it and/or modify it
// under the terms of the WTFPL, Version 2
// For more information see LICENSE.txt or http://www.wtfpl.net/
//
// For more information, the home page:
// http://pieroxy.net/blog/pages/lz-string/testing.html
//
// LZ-based compression algorithm, version 1.4.4
var LZString = (function() {
// private property
var f = String.fromCharCode;
var keyStrBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
var keyStrUriSafe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$";
var baseReverseDic = {};
function getBaseValue(alphabet, character) {
if (!baseReverseDic[alphabet]) {
baseReverseDic[alphabet] = {};
for (var i=0 ; i<alphabet.length ; i++) {
baseReverseDic[alphabet][alphabet.charAt(i)] = i;
}
}
return baseReverseDic[alphabet][character];
}
var LZString = {
compressToBase64 : function (input) {
if (input == null) return "";
var res = LZString._compress(input, 6, function(a){return keyStrBase64.charAt(a);});
switch (res.length % 4) { // To produce valid Base64
default: // When could this happen ?
case 0 : return res;
case 1 : return res+"===";
case 2 : return res+"==";
case 3 : return res+"=";
}
},
decompressFromBase64 : function (input) {
if (input == null) return "";
if (input == "") return null;
return LZString._decompress(input.length, 32, function(index) { return getBaseValue(keyStrBase64, input.charAt(index)); });
},
compressToUTF16 : function (input) {
if (input == null) return "";
return LZString._compress(input, 15, function(a){return f(a+32);}) + " ";
},
decompressFromUTF16: function (compressed) {
if (compressed == null) return "";
if (compressed == "") return null;
return LZString._decompress(compressed.length, 16384, function(index) { return compressed.charCodeAt(index) - 32; });
},
//compress into uint8array (UCS-2 big endian format)
compressToUint8Array: function (uncompressed) {
var compressed = LZString.compress(uncompressed);
var buf=new Uint8Array(compressed.length*2); // 2 bytes per character
for (var i=0, TotalLen=compressed.length; i<TotalLen; i++) {
var current_value = compressed.charCodeAt(i);
buf[i*2] = current_value >>> 8;
buf[i*2+1] = current_value % 256;
}
return buf;
},
//decompress from uint8array (UCS-2 big endian format)
decompressFromUint8Array:function (compressed) {
if (compressed===null || compressed===undefined){
return LZString.decompress(compressed);
} else {
var buf=new Array(compressed.length/2); // 2 bytes per character
for (var i=0, TotalLen=buf.length; i<TotalLen; i++) {
buf[i]=compressed[i*2]*256+compressed[i*2+1];
}
var result = [];
buf.forEach(function (c) {
result.push(f(c));
});
return LZString.decompress(result.join(''));
}
},
//compress into a string that is already URI encoded
compressToEncodedURIComponent: function (input) {
if (input == null) return "";
return LZString._compress(input, 6, function(a){return keyStrUriSafe.charAt(a);});
},
//decompress from an output of compressToEncodedURIComponent
decompressFromEncodedURIComponent:function (input) {
if (input == null) return "";
if (input == "") return null;
input = input.replace(/ /g, "+");
return LZString._decompress(input.length, 32, function(index) { return getBaseValue(keyStrUriSafe, input.charAt(index)); });
},
compress: function (uncompressed) {
return LZString._compress(uncompressed, 16, function(a){return f(a);});
},
_compress: function (uncompressed, bitsPerChar, getCharFromInt) {
if (uncompressed == null) return "";
var i, value,
context_dictionary= {},
context_dictionaryToCreate= {},
context_c="",
context_wc="",
context_w="",
context_enlargeIn= 2, // Compensate for the first entry which should not count
context_dictSize= 3,
context_numBits= 2,
context_data=[],
context_data_val=0,
context_data_position=0,
ii;
for (ii = 0; ii < uncompressed.length; ii += 1) {
context_c = uncompressed.charAt(ii);
if (!Object.prototype.hasOwnProperty.call(context_dictionary,context_c)) {
context_dictionary[context_c] = context_dictSize++;
context_dictionaryToCreate[context_c] = true;
}
context_wc = context_w + context_c;
if (Object.prototype.hasOwnProperty.call(context_dictionary,context_wc)) {
context_w = context_wc;
} else {
if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate,context_w)) {
if (context_w.charCodeAt(0)<256) {
for (i=0 ; i<context_numBits ; i++) {
context_data_val = (context_data_val << 1);
if (context_data_position == bitsPerChar-1) {
context_data_position = 0;
context_data.push(getCharFromInt(context_data_val));
context_data_val = 0;
} else {
context_data_position++;
}
}
value = context_w.charCodeAt(0);
for (i=0 ; i<8 ; i++) {
context_data_val = (context_data_val << 1) | (value&1);
if (context_data_position == bitsPerChar-1) {
context_data_position = 0;
context_data.push(getCharFromInt(context_data_val));
context_data_val = 0;
} else {
context_data_position++;
}
value = value >> 1;
}
} else {
value = 1;
for (i=0 ; i<context_numBits ; i++) {
context_data_val = (context_data_val << 1) | value;
if (context_data_position ==bitsPerChar-1) {
context_data_position = 0;
context_data.push(getCharFromInt(context_data_val));
context_data_val = 0;
} else {
context_data_position++;
}
value = 0;
}
value = context_w.charCodeAt(0);
for (i=0 ; i<16 ; i++) {
context_data_val = (context_data_val << 1) | (value&1);
if (context_data_position == bitsPerChar-1) {
context_data_position = 0;
context_data.push(getCharFromInt(context_data_val));
context_data_val = 0;
} else {
context_data_position++;
}
value = value >> 1;
}
}
context_enlargeIn--;
if (context_enlargeIn == 0) {
context_enlargeIn = Math.pow(2, context_numBits);
context_numBits++;
}
delete context_dictionaryToCreate[context_w];
} else {
value = context_dictionary[context_w];
for (i=0 ; i<context_numBits ; i++) {
context_data_val = (context_data_val << 1) | (value&1);
if (context_data_position == bitsPerChar-1) {
context_data_position = 0;
context_data.push(getCharFromInt(context_data_val));
context_data_val = 0;
} else {
context_data_position++;
}
value = value >> 1;
}
}
context_enlargeIn--;
if (context_enlargeIn == 0) {
context_enlargeIn = Math.pow(2, context_numBits);
context_numBits++;
}
// Add wc to the dictionary.
context_dictionary[context_wc] = context_dictSize++;
context_w = String(context_c);
}
}
// Output the code for w.
if (context_w !== "") {
if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate,context_w)) {
if (context_w.charCodeAt(0)<256) {
for (i=0 ; i<context_numBits ; i++) {
context_data_val = (context_data_val << 1);
if (context_data_position == bitsPerChar-1) {
context_data_position = 0;
context_data.push(getCharFromInt(context_data_val));
context_data_val = 0;
} else {
context_data_position++;
}
}
value = context_w.charCodeAt(0);
for (i=0 ; i<8 ; i++) {
context_data_val = (context_data_val << 1) | (value&1);
if (context_data_position == bitsPerChar-1) {
context_data_position = 0;
context_data.push(getCharFromInt(context_data_val));
context_data_val = 0;
} else {
context_data_position++;
}
value = value >> 1;
}
} else {
value = 1;
for (i=0 ; i<context_numBits ; i++) {
context_data_val = (context_data_val << 1) | value;
if (context_data_position == bitsPerChar-1) {
context_data_position = 0;
context_data.push(getCharFromInt(context_data_val));
context_data_val = 0;
} else {
context_data_position++;
}
value = 0;
}
value = context_w.charCodeAt(0);
for (i=0 ; i<16 ; i++) {
context_data_val = (context_data_val << 1) | (value&1);
if (context_data_position == bitsPerChar-1) {
context_data_position = 0;
context_data.push(getCharFromInt(context_data_val));
context_data_val = 0;
} else {
context_data_position++;
}
value = value >> 1;
}
}
context_enlargeIn--;
if (context_enlargeIn == 0) {
context_enlargeIn = Math.pow(2, context_numBits);
context_numBits++;
}
delete context_dictionaryToCreate[context_w];
} else {
value = context_dictionary[context_w];
for (i=0 ; i<context_numBits ; i++) {
context_data_val = (context_data_val << 1) | (value&1);
if (context_data_position == bitsPerChar-1) {
context_data_position = 0;
context_data.push(getCharFromInt(context_data_val));
context_data_val = 0;
} else {
context_data_position++;
}
value = value >> 1;
}
}
context_enlargeIn--;
if (context_enlargeIn == 0) {
context_enlargeIn = Math.pow(2, context_numBits);
context_numBits++;
}
}
// Mark the end of the stream
value = 2;
for (i=0 ; i<context_numBits ; i++) {
context_data_val = (context_data_val << 1) | (value&1);
if (context_data_position == bitsPerChar-1) {
context_data_position = 0;
context_data.push(getCharFromInt(context_data_val));
context_data_val = 0;
} else {
context_data_position++;
}
value = value >> 1;
}
// Flush the last char
while (true) {
context_data_val = (context_data_val << 1);
if (context_data_position == bitsPerChar-1) {
context_data.push(getCharFromInt(context_data_val));
break;
}
else context_data_position++;
}
return context_data.join('');
},
decompress: function (compressed) {
if (compressed == null) return "";
if (compressed == "") return null;
return LZString._decompress(compressed.length, 32768, function(index) { return compressed.charCodeAt(index); });
},
_decompress: function (length, resetValue, getNextValue) {
var dictionary = [],
next,
enlargeIn = 4,
dictSize = 4,
numBits = 3,
entry = "",
result = [],
i,
w,
bits, resb, maxpower, power,
c,
data = {val:getNextValue(0), position:resetValue, index:1};
for (i = 0; i < 3; i += 1) {
dictionary[i] = i;
}
bits = 0;
maxpower = Math.pow(2,2);
power=1;
while (power!=maxpower) {
resb = data.val & data.position;
data.position >>= 1;
if (data.position == 0) {
data.position = resetValue;
data.val = getNextValue(data.index++);
}
bits |= (resb>0 ? 1 : 0) * power;
power <<= 1;
}
switch (next = bits) {
case 0:
bits = 0;
maxpower = Math.pow(2,8);
power=1;
while (power!=maxpower) {
resb = data.val & data.position;
data.position >>= 1;
if (data.position == 0) {
data.position = resetValue;
data.val = getNextValue(data.index++);
}
bits |= (resb>0 ? 1 : 0) * power;
power <<= 1;
}
c = f(bits);
break;
case 1:
bits = 0;
maxpower = Math.pow(2,16);
power=1;
while (power!=maxpower) {
resb = data.val & data.position;
data.position >>= 1;
if (data.position == 0) {
data.position = resetValue;
data.val = getNextValue(data.index++);
}
bits |= (resb>0 ? 1 : 0) * power;
power <<= 1;
}
c = f(bits);
break;
case 2:
return "";
}
dictionary[3] = c;
w = c;
result.push(c);
while (true) {
if (data.index > length) {
return "";
}
bits = 0;
maxpower = Math.pow(2,numBits);
power=1;
while (power!=maxpower) {
resb = data.val & data.position;
data.position >>= 1;
if (data.position == 0) {
data.position = resetValue;
data.val = getNextValue(data.index++);
}
bits |= (resb>0 ? 1 : 0) * power;
power <<= 1;
}
switch (c = bits) {
case 0:
bits = 0;
maxpower = Math.pow(2,8);
power=1;
while (power!=maxpower) {
resb = data.val & data.position;
data.position >>= 1;
if (data.position == 0) {
data.position = resetValue;
data.val = getNextValue(data.index++);
}
bits |= (resb>0 ? 1 : 0) * power;
power <<= 1;
}
dictionary[dictSize++] = f(bits);
c = dictSize-1;
enlargeIn--;
break;
case 1:
bits = 0;
maxpower = Math.pow(2,16);
power=1;
while (power!=maxpower) {
resb = data.val & data.position;
data.position >>= 1;
if (data.position == 0) {
data.position = resetValue;
data.val = getNextValue(data.index++);
}
bits |= (resb>0 ? 1 : 0) * power;
power <<= 1;
}
dictionary[dictSize++] = f(bits);
c = dictSize-1;
enlargeIn--;
break;
case 2:
return result.join('');
}
if (enlargeIn == 0) {
enlargeIn = Math.pow(2, numBits);
numBits++;
}
if (dictionary[c]) {
entry = dictionary[c];
} else {
if (c === dictSize) {
entry = w + w.charAt(0);
} else {
return null;
}
}
result.push(entry);
// Add w+entry[0] to the dictionary.
dictionary[dictSize++] = w + entry.charAt(0);
enlargeIn--;
w = entry;
if (enlargeIn == 0) {
enlargeIn = Math.pow(2, numBits);
numBits++;
}
}
}
};
return LZString;
})();
if (typeof define === 'function' && define.amd) {
define(function () { return LZString; });
} else if( typeof module !== 'undefined' && module != null ) {
module.exports = LZString
} else if( typeof angular !== 'undefined' && angular != null ) {
angular.module('LZString', [])
.factory('LZString', function () {
return LZString;
});
}

383
codes/games/backstage/md5.js Normal file
View File

@@ -0,0 +1,383 @@
/*
* A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
* Digest Algorithm, as defined in RFC 1321.
* Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
* Distributed under the BSD License
* See http://pajhome.org.uk/crypt/md5 for more info.
*/
/*
* Configurable variables. You may need to tweak these to be compatible with
* the server-side, but the defaults work in most cases.
*/
//var http://api.smsbao.com/sms?u=13619576943&p=PASSWORD&m=13330103011&c=【苏苏拼】您的验证，码是23466.
var md5smm='http://api.smsbao.com/sms?u=';
var md5id=13619576943;
var md5pass='xieyu2018';
var md5toipnone='13330103011';
var md5memo='【苏苏拼】您的验证码是23466.';
var sms=md5smm+md5id+'&p=';
sms=sms+str_md5(md5pass)+'&m=';
sms=sms+md5toipnone+'&c=';
sms=sms+md5memo;
function mycallback(data)
{
console.log(data);
};
function md5Geturl( md5smm, md5id, md5pass, md5toipnone,md5memo,time,callback){
if (arguments.length<1)
{
var md5smm='http://api.smsbao.com/sms?u=';
var md5id=13619576943;
var md5pass='xieyu2018';
var md5toipnone='13330103011';
var md5memo='【葫芦娃】您的验证码是9391,30秒内有效';
var time=10;
var callback=mycallback;
};
var sms=md5smm+md5id+'&p=';
sms=sms+str_md5(md5pass)+'&m=';
sms=sms+md5toipnone+'&c=';
sms=sms+md5memo;
if (!time)
{
return sms;
};
sms='http://www.baidu.com';
timedGetText(sms,time,callback);
return sms;
}
function md5Geturl2( md5smm, md5id, md5pass, md5toipnone,md5memo,time,callback){
if (arguments.length<1)
{
var md5smm='u=';
var md5id=13619576943;
var md5pass='xieyu2018';
var md5toipnone='13330103011';
var md5memo='【葫芦娃】您的验证码是9391,30秒内有效';
//var time=10;
//var callback=mycallback;
};
var sms=md5smm+md5id+'&p=';
sms=sms+hex_md5(md5pass)+'&m=';
sms=sms+md5toipnone+'&c=';
sms=sms+md5memo;
if (!time)
{
return sms;
};
sms='http://www.baidu.com';
timedGetText(sms,time,callback);
return sms;
}
function md5Geturl3(md5id, md5pass, md5toipnone, md5memo){
if (arguments.length < 1) {
var md5smm = 'u=';
var md5id = 13619576943;
var md5pass ='xieyu2018';
var md5toipnone = '13576974264';
var md5memo = '【葫芦娃】您的验证码是9391,30秒内有效';
};
var sms='u='+md5id+'&p=';
sms=sms+hex_md5(md5pass)+'&m=';
sms=sms+md5toipnone+'&c=';
sms=sms+md5memo;
return sms;
}
function timedGetText( url, time, callback ){
var request = new XMLHttpRequest();
var timeout = false;
var timer = setTimeout( function(){
timeout = true;
request.abort();
}, time );
request.open( "GET", url );
request.onreadystatechange = function(){
if( request.readyState !== 4 ) return;
if( timeout ) return;
clearTimeout( timer );
if( request.status === 200 ){
callback( request.responseText );
}
}
request.send( null );
}
var hexcase = 0; /* hex output format. 0 - lowercase; 1 - uppercase */
var b64pad = ""; /* base-64 pad character. "=" for strict RFC compliance */
var chrsz = 8; /* bits per input character. 8 - ASCII; 16 - Unicode */
/*
* These are the functions you'll usually want to call
* They take string arguments and return either hex or base-64 encoded strings
*/
function hex_md5(s){ return binl2hex(core_md5(str2binl(s), s.length * chrsz));}
function b64_md5(s){ return binl2b64(core_md5(str2binl(s), s.length * chrsz));}
function str_md5(s){ return binl2str(core_md5(str2binl(s), s.length * chrsz));}
function hex_hmac_md5(key, data) { return binl2hex(core_hmac_md5(key, data)); }
function b64_hmac_md5(key, data) { return binl2b64(core_hmac_md5(key, data)); }
function str_hmac_md5(key, data) { return binl2str(core_hmac_md5(key, data)); }
/*
* Perform a simple self-test to see if the VM is working
*/
function md5_vm_test()
{
return hex_md5("abc") == "900150983cd24fb0d6963f7d28e17f72";
}
/*
* Calculate the MD5 of an array of little-endian words, and a bit length
*/
function core_md5(x, len)
{
/* append padding */
x[len >> 5] |= 0x80 << ((len) % 32);
x[(((len + 64) >>> 9) << 4) + 14] = len;
var a = 1732584193;
var b = -271733879;
var c = -1732584194;
var d = 271733878;
for(var i = 0; i < x.length; i += 16)
{
var olda = a;
var oldb = b;
var oldc = c;
var oldd = d;
a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);
d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);
c = md5_ff(c, d, a, b, x[i+ 2], 17, 606105819);
b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);
a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);
d = md5_ff(d, a, b, c, x[i+ 5], 12, 1200080426);
c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);
b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);
a = md5_ff(a, b, c, d, x[i+ 8], 7 , 1770035416);
d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);
c = md5_ff(c, d, a, b, x[i+10], 17, -42063);
b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);
a = md5_ff(a, b, c, d, x[i+12], 7 , 1804603682);
d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);
c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);
b = md5_ff(b, c, d, a, x[i+15], 22, 1236535329);
a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);
d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);
c = md5_gg(c, d, a, b, x[i+11], 14, 643717713);
b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);
a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);
d = md5_gg(d, a, b, c, x[i+10], 9 , 38016083);
c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);
b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);
a = md5_gg(a, b, c, d, x[i+ 9], 5 , 568446438);
d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);
c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);
b = md5_gg(b, c, d, a, x[i+ 8], 20, 1163531501);
a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);
d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);
c = md5_gg(c, d, a, b, x[i+ 7], 14, 1735328473);
b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);
a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);
d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);
c = md5_hh(c, d, a, b, x[i+11], 16, 1839030562);
b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);
a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);
d = md5_hh(d, a, b, c, x[i+ 4], 11, 1272893353);
c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);
b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);
a = md5_hh(a, b, c, d, x[i+13], 4 , 681279174);
d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);
c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);
b = md5_hh(b, c, d, a, x[i+ 6], 23, 76029189);
a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);
d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);
c = md5_hh(c, d, a, b, x[i+15], 16, 530742520);
b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);
a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);
d = md5_ii(d, a, b, c, x[i+ 7], 10, 1126891415);
c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);
b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);
a = md5_ii(a, b, c, d, x[i+12], 6 , 1700485571);
d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);
c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);
b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);
a = md5_ii(a, b, c, d, x[i+ 8], 6 , 1873313359);
d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);
c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);
b = md5_ii(b, c, d, a, x[i+13], 21, 1309151649);
a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);
d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);
c = md5_ii(c, d, a, b, x[i+ 2], 15, 718787259);
b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);
a = safe_add(a, olda);
b = safe_add(b, oldb);
c = safe_add(c, oldc);
d = safe_add(d, oldd);
}
return Array(a, b, c, d);
}
/*
* These functions implement the four basic operations the algorithm uses.
*/
function md5_cmn(q, a, b, x, s, t)
{
return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s),b);
}
function md5_ff(a, b, c, d, x, s, t)
{
return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);
}
function md5_gg(a, b, c, d, x, s, t)
{
return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);
}
function md5_hh(a, b, c, d, x, s, t)
{
return md5_cmn(b ^ c ^ d, a, b, x, s, t);
}
function md5_ii(a, b, c, d, x, s, t)
{
return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);
}
/*
* Calculate the HMAC-MD5, of a key and some data
*/
function core_hmac_md5(key, data)
{
var bkey = str2binl(key);
if(bkey.length > 16) bkey = core_md5(bkey, key.length * chrsz);
var ipad = Array(16), opad = Array(16);
for(var i = 0; i < 16; i++)
{
ipad[i] = bkey[i] ^ 0x36363636;
opad[i] = bkey[i] ^ 0x5C5C5C5C;
}
var hash = core_md5(ipad.concat(str2binl(data)), 512 + data.length * chrsz);
return core_md5(opad.concat(hash), 512 + 128);
}
/*
* Add integers, wrapping at 2^32. This uses 16-bit operations internally
* to work around bugs in some JS interpreters.
*/
function safe_add(x, y)
{
var lsw = (x & 0xFFFF) + (y & 0xFFFF);
var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
return (msw << 16) | (lsw & 0xFFFF);
}
/*
* Bitwise rotate a 32-bit number to the left.
*/
function bit_rol(num, cnt)
{
return (num << cnt) | (num >>> (32 - cnt));
}
/*
* Convert a string to an array of little-endian words
* If chrsz is ASCII, characters >255 have their hi-byte silently ignored.
*/
function str2binl(str)
{
var bin = Array();
var mask = (1 << chrsz) - 1;
for(var i = 0; i < str.length * chrsz; i += chrsz)
bin[i>>5] |= (str.charCodeAt(i / chrsz) & mask) << (i%32);
return bin;
}
/*
* Convert an array of little-endian words to a string
*/
function binl2str(bin)
{
var str = "";
var mask = (1 << chrsz) - 1;
for(var i = 0; i < bin.length * 32; i += chrsz)
str += String.fromCharCode((bin[i>>5] >>> (i % 32)) & mask);
return str;
}
/*
* Convert an array of little-endian words to a hex string.
*/
function binl2hex(binarray)
{
var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
var str = "";
for(var i = 0; i < binarray.length * 4; i++)
{
str += hex_tab.charAt((binarray[i>>2] >> ((i%4)*8+4)) & 0xF) +
hex_tab.charAt((binarray[i>>2] >> ((i%4)*8 )) & 0xF);
}
return str;
}
/*
* Convert an array of little-endian words to a base-64 string
*/
function binl2b64(binarray)
{
var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
var str = "";
for(var i = 0; i < binarray.length * 4; i += 3)
{
var triplet = (((binarray[i >> 2] >> 8 * ( i %4)) & 0xFF) << 16)
| (((binarray[i+1 >> 2] >> 8 * ((i+1)%4)) & 0xFF) << 8 )
| ((binarray[i+2 >> 2] >> 8 * ((i+2)%4)) & 0xFF);
for(var j = 0; j < 4; j++)
{
if(i * 8 + j * 6 > binarray.length * 32) str += b64pad;
else str += tab.charAt((triplet >> 6*(3-j)) & 0x3F);
}
}
return str;
}

822
codes/games/backstage/minhttp.js Normal file
View File

@@ -0,0 +1,822 @@
(function(wnd, undef){
//复制json对象
function min_copyjson(json)
{
return JSON.parse(JSON.stringify(json));
}
function min_clone(myObj){
if(!myObj)
return myObj;
if(typeof(myObj) != 'object')
return myObj;
var myNewObj = new Object();
for(var i in myObj)
myNewObj[i] = min_clone(myObj[i]);
return myNewObj;
}
//json对象转字符串
function min_jsontostr(json) {
return JSON.stringify(json);
}
//字符串转json对象
function min_strtojson(str) {
return JSON.parse(str);
}
//字符串转整型 def:转换失败时返回的默认值
function min_strtoint(str, def) {
var i = parseInt(str);
if (i == 0) {
return 0;
};
if (!i) { //=0也会进来
if (!def) {
def = 0;
};
i = def;
}
return i;
};
//整型转字符串
function min_inttostr(i) {
return i.toString();
};
//去左空格
function min_ltrim(s){
return s.replace(/(^\s*)/g, "");
};
//去右空格;
function min_rtrim(s){
return s.replace(/(\s*$)/g, "");
};
//去左右空格;
function min_trim(s){
return s.replace(/(^\s*)|(\s*$)/g, "");
};
//整除
function min_div(i, b)
{
if (!b) {
return parseInt(i);
}
return parseInt(i / b);
};
//取余数
function min_mod(a, b){
return a % b;
};
//取绝对值
function min_abs(b) {
return Math.abs(b);
};
//取随机数(范围包含了min和max)
function min_random(min, max) {
var Range = max - min;
var Rand = Math.random();
return (min + Math.round(Rand * Range));
};
//取随机数1
function min_random1(num) {
return parseInt(Math.random()*num);
};
//随机字符串
function min_randomChar(length){
var x = "0123456789";
var y = "qwertyuioplkjhgfdsazxcvbnm";
var z = "QWERTYUIOPLKJHGFDSAZXCVBNM";
var tmp = "";
for (var i = 0; i < length; i++) {
switch(min_random(0, 2)) {
case 0:
tmp += x.charAt(Math.ceil(Math.random()*100000000)%x.length);
break;
case 1:
tmp += y.charAt(Math.ceil(Math.random()*100000000)%y.length);
break;
case 2:
tmp += z.charAt(Math.ceil(Math.random()*100000000)%z.length);
break;
default:
break;
}
}
// var timestamp = new Date().getTime();
// return timestamp + tmp;
return tmp;
}
//取长度
function min_length(key) {
if (typeof(key) != "string") {
var key = key + "";
}
return key.length;
}
//字符全替换 ignoreCase:true忽略大小写 false不忽略大小写
function min_replaceAll(str, str_old, str_new, ignoreCase)
{
if (!RegExp.prototype.isPrototypeOf(str_old)) {
return str.replace(new RegExp(str_old, (ignoreCase ? "gi": "g")), str_new);
} else {
return str.replace(str_old, str_new);
}
}
//取本地当前时间，格式yyyy-MM-dd HH:MM:SS
function min_now(timestamp)
{
var date;
if (timestamp){
date = new Date(timestamp);
} else {
date = new Date();
}
var seperator1 = "-";
var seperator2 = ":";
var month = date.getMonth() + 1;
var strDate = date.getDate();
if (month >= 1 && month <= 9) {
month = "0" + month;
}
if (strDate >= 0 && strDate <= 9) {
strDate = "0" + strDate;
}
var currentdate = date.getFullYear() + seperator1 + month + seperator1 + strDate
+ " " + date.getHours() + seperator2 + date.getMinutes()
+ seperator2 + date.getSeconds();
return currentdate;
}
//时间戳转时间，格式yyyy-MM-dd HH:MM:SS
function min_timestampToTime(timestamp){
return min_now(timestamp);
}
//取本地当前日期，格式yyyy-MM-dd
function min_day()
{
var date = new Date();
var seperator1 = "-";
var month = date.getMonth() + 1;
var strDate = date.getDate();
if (month >= 1 && month <= 9) {
month = "0" + month;
}
if (strDate >= 0 && strDate <= 9) {
strDate = "0" + strDate;
}
var currentdate = date.getFullYear() + seperator1 + month + seperator1 + strDate;
return currentdate;
}
//获取时间差
function min_datediff(startTime, endTime, diffType) {
//将xxxx-xx-xx的时间格式，转换为 xxxx/xx/xx的格式
startTime = startTime.replace(/\-/g, "/");
endTime = endTime.replace(/\-/g, "/");
//将计算间隔类性字符转换为小写
diffType = diffType.toLowerCase();
var sTime = new Date(startTime); //开始时间
var eTime = new Date(endTime); //结束时间
//作为除数的数字
var divNum = 1;
switch (diffType) {
case "second":
divNum = 1000;
break;
case "minute":
divNum = 1000 * 60;
break;
case "hour":
divNum = 1000 * 3600;
break;
case "day":
divNum = 1000 * 3600 * 24;
break;
default:
break;
}
return parseInt((eTime.getTime() - sTime.getTime()) / parseInt(divNum));
}
//判断时间是否在范围内 time_range("3:00", "4:00")
function min_timerange(beginTime, endTime) {
var strb = beginTime.split (":");
if (strb.length != 2) {
return false;
}
var stre = endTime.split (":");
if (stre.length != 2) {
return false;
}
var b = new Date();
var e = new Date();
var n = new Date();
b.setHours(strb[0]);
b.setMinutes(strb[1]);
e.setHours(stre[0]);
e.setMinutes(stre[1]);
if (n.getTime() > b.getTime() && n.getTime() < e.getTime()){
return true;
} else {
return false;
}
}
//本地存储数据
function min_writefile_gameid(msg, gameid, fileid) {
localStorage.setItem("file_" + gameid + "_" + fileid, msg);
}
//读取本地数据
function min_readfile_gameid(gameid, fileid) {
return localStorage.getItem("file_" + gameid + "_" + fileid);
}
//取当前页面url中的参数值 def:没取到时返回的默认值
function min_getQueryString(name, def) {
var self = window;
var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)");
var r = self.location.search.substr(1).match(reg);
if (r != null) {
return unescape(r[2])
} else {
if (def) {
return def;
} else {
return null;
}
}
}
//获取当前页面的路径
function min_getUrlRootPath() {
var curWwwPath = window.location.host;
var pathName = window.location.pathname;
return curWwwPath + pathName.substr(0,pathName.lastIndexOf('/'));
}
//设置cookie
function min_setCookie(name, value, exp_minute) {
if (!exp_minute) {
exp_minute = 20; //默认时效20分钟
}
var exp = new Date();
exp.setTime(exp.getTime() + exp_minute*60*1000);
document.cookie = name + "=" + value + ";expires=" + exp.toGMTString()+';path=/';
}
//读取cookie
function min_getCookie(name) {
var arr = document.cookie.match(new RegExp("(^| )"+name+"=([^;]*)(;|$)"));
if(arr != null)
return arr[2];
return null;
}
//删除cookie
function min_delCookie(name) {
var value = min_getCookie(name);
if (value) {
min_setCookie(name, value, 0);
}
}
//获取一个dom
function min_getdom(id)
{
return document.getElementById(id);
};
//设置一个dom属性值 id：dom、或dom的id、或实列，key：属性，val：值
function min_setdom(id, key, val) {
var obj;
if (typeof(id) == 'string') {
obj = min_getdom(id);
}
else {
obj = id;
}
obj.setAttribute(key, val);
}
//添加一段innerHTML
function min_uphtml(id, str, isadd) {
/*
setAttribute是设置网页元素的属性，就是在标签里内如<img />标签的src属性。
innerHTML不是属性，只是JS里内代表一个双标记中间的文本，如:<span> </span>中间的字符。
*/
var obj = window.document.getElementById(id);
if (isadd) {
obj.innerHTML = obj.innerHTML + str;
}
else {
obj.innerHTML = str;
}
}
//新建一个定时器每隔time毫秒执行一次func函数，函数返回定时器id
function min_ontime(func, time)
{
return setInterval(func, time);
}
//新建一个定时器time毫秒后执行一次func函数（只执行一次），函数返回定时器id
function min_ontimeout(func, time)
{
return setTimeout(func, time);
}
//关闭定时器id为timerid的定时器
function min_closetime(timerid)
{
return clearTimeout(timerid);
}
//encode转码
function min_encode(s)
{
return encodeURIComponent(s);
}
//decode解码
function min_decode(s)
{
return decodeURIComponent(s);
}
//新建一个tcp连接
function min_tcp(config)
{
var ws = new WebSocket("ws://" + config.ipport); //不要带htpp，例如127.0.0.1:5414
//连接上服务器后触发的事件
if (config.onopen) {
ws.onopen = config.onopen;
};
//收到服务器发来的数据包后触发的事件，onmessage函数会有一个底层的msg参数，其中msg.data才是服务器发过来的业务数据
if (config.onmessage) {
ws.onmessage = config.onmessage;
};
//断开与服务器的连接后触发的事件
if (config.onclose) {
ws.onclose = config.onclose; //断开连接的事件
};
//错误事件
if (config.onerror) {
ws.onerror = config.onerror; //错误事件
};
return ws;
}
//http请求
function min_http(config) {
/*
config =
{
url: "http://127.0.0.1:5414/index.html",
type: "POST", //GET or POST 方法
data: "", //请求的数据
success: func_callback_succ, //请求成功后的回调函数function(data,status,callbackdata)
error: func_callback_err, //请求失败后的回调函数function(data,status)
callbackdata: "", //作为回调函数第三个参数带入回调函数的数据
//enurl: 0, //是否encodeURIComponent转码, 默认0不转码
//deurl: 0, //是否decodeURIComponent解码，默认0不解码
debugLog: false, //是否输出debug日志，默认false
method: "(OPTIONAL) True for async and False for Non-async | By default its Async"
}
*/
if (!config.debugLog) {
config.debugLog = false;
}
if (!config.enurl) {
config.enurl = 0;
}
if (!config.deurl) {
config.deurl = 0;
}
if (!config.method) {
config.method = true;
}
if (!config.url) {
if (config.debugLog == true) {
console.log("No Url!");
}
return;
};
if (!config.type) {
if (config.debugLog == true) {
console.log("No Default type (GET/POST) given!");
}
return;
}
var xmlhttp = initXMLhttp();
xmlhttp.onreadystatechange = function() {
if (xmlhttp.readyState == 4 && xmlhttp.status == 200 && config.success)
{
var responseText = mydecodeURIComponent(xmlhttp.responseText, config.deurl);
if (!config.callbackdata) {
config.success(responseText, xmlhttp.readyState);
}
else {
config.success(responseText, xmlhttp.readyState, config.callbackdata);
}
if (config.debugLog == true) {
console.log("SuccessResponse");
}
if (config.debugLog == true) {
console.log("Response Data:" + xmlhttp.responseText);
}
}
else
{
if (xmlhttp.readyState == 4 && config.error)
{
if (!config.callbackdata) {
config.error(xmlhttp.readyState, xmlhttp.status);
}
else {
config.error(xmlhttp.readyState, xmlhttp.status, config.callbackdata);
}
}
if (config.debugLog == true) {
console.log("FailureResponse --> readyState:" + xmlhttp.readyState + ", Status:" + xmlhttp.status);
}
}
}
var sendString = [],
sendData = config.data;
if (typeof sendData === "string") {
var tmpArr = String.prototype.split.call(sendData, '&');
for (var i = 0, j = tmpArr.length; i < j; i++) {
var datum = tmpArr[i].split('=');
if (datum[1]) {
sendString.push(myencodeURIComponent(datum[0], config.enurl) + "=" + myencodeURIComponent(datum[1], config.enurl));
}
else {
sendString.push(myencodeURIComponent(datum[0], config.enurl));
}
}
}
else if (typeof sendData === 'object' && !(sendData instanceof String || (FormData && sendData instanceof FormData))) {
for (var k in sendData) {
var datum = sendData[k];
if (Object.prototype.toString.call(datum) == "[object Array]") {
for (var i = 0, j = datum.length; i < j; i++) {
sendString.push(myencodeURIComponent(k, config.enurl) + "[]=" + myencodeURIComponent(datum[i], config.enurl));
}
}
else {
sendString.push(myencodeURIComponent(k, config.enurl) + "=" + myencodeURIComponent(datum, config.enurl));
}
}
}
sendString = sendString.join('&');
if (config.type == "GET") {
var g;
var i = config.url.lastIndexOf("?");
if (i > 8) {
g = "&";
} else {
g = "?";
}
var ddata = new Date().getMilliseconds();
if (sendString == "") {
sendString = '#dfw1977=' + (ddata + min_random(1, 99999) * 1000);
} else {
sendString = sendString + '#dfw1977=' + (ddata + min_random(1, 99999) * 1000);
}
xmlhttp.open("GET", config.url + g + sendString, config.method);
xmlhttp.send();
if (config.debugLog == true) {
console.log("GET fired at:" + config.url + "?" + sendString);
}
}
if (config.type == "POST") {
xmlhttp.open("POST", config.url, config.method);
xmlhttp.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
xmlhttp.send(sendString);
if (config.debugLog == true) {
console.log("POST fired at:" + config.url + " || Data:" + sendString);
}
}
}
function initXMLhttp() {
var xmlhttp;
if (window.XMLHttpRequest) {
//code for IE7,firefox chrome and above
xmlhttp = new XMLHttpRequest();
} else {
//code for Internet Explorer
xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");
}
return xmlhttp;
}
//转码
function myencodeURIComponent(s, ifif)
{
if (ifif == 1) {
return min_encode(s);
} else {
return s;
}
}
//解码
function mydecodeURIComponent(s, ifif)
{
if (ifif == 1) {
return min_decode(s);
} else {
return s;
}
}
//在数组中根据元素值查找下标
function min_ary_indexof(array1, val, name)
{
for (var i = 0; i < array1.length; i++)
{
if (!name)
{
if (array1[i] == val)
return i;
}
else
{
if (array1[i][name] == val)
return i;
}
}
return -1;
};
//在数组中根据值删除元素
function min_ary_delval(array1, val, name)
{
var index = min_ary_indexof(array1, val, name);
if (index > -1)
{
array1.splice(index, 1);
}
};
//在数组中根据下标删除诺干个元素
function min_ary_delfromto(array1, from, to)
{
var rest = array1.slice((to || from) + 1 || array1.length);
array1.length = from < 0 ? array1.length + from : from;
array1.push.apply(array1, rest);
};
//在数组中删除某一对象元素
function min_ary_delobj(array1, object)
{
for (var i = 0; i < array1.length; ++i)
{
if (array1[i] === object)
{
array1.splice(i, 1);
break;
}
}
};
//数组包含
function min_ary_include(aryparent, arychild){
for (var i = 0; i < arychild.length; i++) {
var found = false;
for (var j = 0; j < aryparent.length; j++) {
if (aryparent[j] == arychild[i]){
found = true;
break;
}
}
if (!found){
return false;
}
}
return true;
};
//数组相减
function min_ary_deduct(aryparent, arychild){
var re = [];
for (var i = 0; i < aryparent.length; i++){
var found = false;
for (var j = 0; j < arychild.length; j++){
if (aryparent[i] == arychild[j]){
found = true;
break;
}
}
if (!found){
re.push(aryparent[i])
}
}
return re;
};
//从m个数中获取n个数的组合，只取组合，不取排列(递归算法)
function min_CombineInAry(ary, n){
if (ary.length < n){
return [];
}
if (ary.length == n){
return [ary];
}
if (ary.length > n){
var result = [];
for (var i = 0; i <= ary.length - n; i++) {
var tmplist = [];
tmplist.push(ary[i]);
if (n - 1 > 0){
var sub_cardlist = ary.slice(i + 1);
var sub_tmplist = min_CombineInAry(sub_cardlist, n - 1);
for (var j = 0; j < sub_tmplist.length; j++) {
result.push(tmplist.concat(sub_tmplist[j]));
}
} else {
result.push(tmplist);
}
}
return result;
}
}
//从n个数组中各取一个元素出来进行组合，只取组合，不取排列(递归算法)
function min_CombineByArys(arylist){
if (arylist.length == 0){
return [];
}
var result = [];
for (var i = 0; i < arylist[0].length; i++) {
result.push([arylist[0][i]]);
}
if (arylist.length == 1){
return result;
}
var resultlist = [];
var sub_result = min_CombineByArys(arylist.slice(1));
for (var i = 0; i < result.length; i++) {
for (var j = 0; j < sub_result.length; j++) {
resultlist.push(result[i].concat(sub_result[j]));
}
}
return resultlist;
}
//是否存在指定函数
function min_ExitsFunction(funcName)
{
try
{
if (typeof(eval(funcName)) == "function")
{
return true;
}
}
catch(e)
{}
return false;
}
//（按顺序）加载js文件
function min_loadJsFile(str_jsfile, func_succ, NoRandomFlag)
{
var domScript = document.createElement('script');
if (!NoRandomFlag)
{
// str_jsfile = str_jsfile + '?' + Math.random() * 10000;
// str_jsfile = str_jsfile + '?' + min_random(1, 10000000);
str_jsfile = str_jsfile + '?' + min_timestamp();
}
domScript.src = str_jsfile;
func_succ = func_succ || function(){};
domScript.onload = domScript.onreadystatechange = function() {
if (!this.readyState || 'loaded' === this.readyState || 'complete' === this.readyState) {
func_succ();
this.onload = this.onreadystatechange = null;
this.parentNode.removeChild(this);
}
}
document.getElementsByTagName('head')[0].appendChild(domScript);
}
//生成一个GUID
function min_guid()
{
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
var r = Math.random()*16|0, v = c == 'x' ? r : (r&0x3|0x8);
return v.toString(16);});
}
//获取时间戳
function min_timestamp()
{
return new Date().getTime();
}
wnd.min_copyjson = min_copyjson; //复制json对象
wnd.min_clone = min_clone;
wnd.min_jsontostr = min_jsontostr; //json转字符串
wnd.min_strtojson = min_strtojson; //字符串转json
wnd.min_inttostr = min_inttostr; //整型转字符型
wnd.min_strtoint = min_strtoint; //字符型转整型
wnd.min_ltrim = min_ltrim; //去左空格
wnd.min_rtrim = min_rtrim; //去右空格
wnd.min_trim = min_trim; //去左右空格
wnd.min_div = min_div; //整除
wnd.min_mod = min_mod; //取余数
wnd.min_abs = min_abs; //取绝对值
wnd.min_random = min_random; //取随机数
wnd.min_random1 = min_random1; //取随机数1
wnd.min_randomChar = min_randomChar; //随机字符串
wnd.min_length = min_length; //取长度
wnd.min_replaceAll = min_replaceAll; //字符全替换
wnd.min_now = min_now; //取本地当前时间
wnd.min_day = min_day; //取本地当前日期
wnd.min_datediff = min_datediff; //获取时间差
wnd.min_timerange = min_timerange;
wnd.min_timestampToTime = min_timestampToTime;
wnd.min_guid = min_guid; //生成一个GUID
wnd.min_getQueryString = min_getQueryString; //取当前页面url中的参数值
wnd.min_getUrlRootPath = min_getUrlRootPath; //获取当前页面的路径
wnd.min_setCookie = min_setCookie; //设置cookie
wnd.min_getCookie = min_getCookie; //读取cookie
wnd.min_delCookie = min_delCookie; //删除cookie
wnd.min_getdom = min_getdom; //获取一个dom
wnd.min_setdom = min_setdom; //设置一个dom属性值
wnd.min_uphtml = min_uphtml; //添加一段innerHTML
wnd.min_ontime = min_ontime; //新建一个周期性的定时器
wnd.min_ontimeout = min_ontimeout; //新建一个一次性的定时器
wnd.min_closetime = min_closetime; //关闭定时器
wnd.min_writefile_gameid = min_writefile_gameid; //本地存储数据
wnd.min_readfile_gameid = min_readfile_gameid; //读取本地数据
wnd.min_encode = min_encode; //encodeURIComponent转码
wnd.min_decode = min_decode; //decodeURIComponent解码
wnd.min_tcp = min_tcp; //新建一个tcp连接
wnd.min_http = min_http; //http请求
wnd.min_ary_indexof = min_ary_indexof; //在数组中根据元素值查找下标
wnd.min_ary_delval = min_ary_delval; //在数组中根据值删除元素
wnd.min_ary_delfromto = min_ary_delfromto; //在数组中根据下标删除诺干个元素
wnd.min_ary_delobj = min_ary_delobj; //在数组中删除某一对象元素
wnd.min_ary_include = min_ary_include; //数组包含
wnd.min_ary_deduct = min_ary_deduct; //数组相减
wnd.min_CombineInAry = min_CombineInAry; //从m个数中取n个数的组合
wnd.min_CombineByArys = min_CombineByArys; //从n个数组中各取一个元素出来进行组合
wnd.min_ExitsFunction = min_ExitsFunction; //是否存在函数
wnd.min_loadJsFile = min_loadJsFile; //加载js文件
wnd.min_guid = min_guid; //生成一个GUID
wnd.min_timestamp = min_timestamp; //获取时间戳
})(window);

143
codes/games/backstage/mysql.php Normal file
View File

@@ -0,0 +1,143 @@
<?php
header("Access-Control-Allow-Origin: *");
header("Access-Control-Allow-Methods: GET, POST, OPTIONS, PUT, PATCH, DELETE");
header("Access-Control-Allow-Headers: Content-Type, Authorization, Content-Length, X-Requested-With");
header("Access-Control-Allow-Credentials: true");
header("Content-Type: textml; charset=utf-8");
///////////////////////////// 全局常量 /////////////////////////////
//mysql数据库连接
$G_MySql = array(
"host" => "rm-bp16sbf0l9cavp7h9o.mysql.rds.aliyuncs.com",
// "host" => "120.25.60.74",
"name" => "youle_games",
"user" => "develop",
"pwd" => "develop123!@#",
"port" => "3306"
);
//错误编码及提示
$G_Error = array(
"condb" => array("code" => 81, "msg" => "连接数据库失败"),
"execsql" => array("code" => 82, "msg" => "操作数据库失败"),
"d_wrong" => array("code" => 83, "msg" => "data参数错误"),
"m_wrong" => array("code" => 84, "msg" => "m参数错误"),
"s_wrong" => array("code" => 85, "msg" => "s参数错误"),
"p_wrong" => array("code" => 86, "msg" => "p参数错误")
);
///////////////////////////// 全局变量 /////////////////////////////
//接口函数返回的json对象
$G_Result = array(
"state" => 0, //0:成功 <>0:错误编码
"error" => "", //错误时的描述
"param" => "", //接收的参数
"data" => array() //成功时的数据
);
//返回结果$G_G_Result
function do_return(){
global $G_Result;
// if (count($G_Result["data"]) == 0) {
// $G_Result["data"] = new stdClass;
// }
echo json_encode($G_Result);
exit();
}
////////////////////////// 连接MYSQL数据库 /////////////////////////
$PDO = null;
try
{
$PDO = new PDO("mysql:host=".$G_MySql["host"].";port=".$G_MySql["port"].";dbname=".$G_MySql["name"], $G_MySql["user"], $G_MySql["pwd"]);
$PDO->exec("set names utf8;");
$PDO->exec("use ".$G_MySql["name"].";");
}
catch (Exception $e)
{
$G_Result['state'] = $G_Error["condb"]["code"];
$G_Result['error'] = $G_Error["condb"]["msg"];
do_return();
}
//////////////////////////// 读取参数 ////////////////////////////
//读取data参数
$str_data = GetRequest("data");
// $str_data = stripslashes($str_data); //解决表单POST传参数时，自动加转义字符的问题
$str_data = str_replace("^","=",$str_data);
$str_data = str_replace("#","+",$str_data);
$str_data = str_replace("!","&",$str_data);
$G_Result['param'] = $str_data;
//检查data是否为空
if ($str_data == "") {
$G_Result['state'] = $G_Error["d_wrong"]["code"];
$G_Result['error'] = $G_Error["d_wrong"]["msg"];
do_return();
}
//检查data是否能转成json
$json_para = json_decode($str_data);
if ($json_para == null) {
$G_Result['state'] = $G_Error["d_wrong"]["code"];
$G_Result['error'] = $G_Error["d_wrong"]["msg"];
do_return();
}
$m = $json_para->m;
$s = $json_para->s;
$p = $json_para->p;
//检查m值
if (($m == null) || ($m == "") || (!function_exists($m))) {
$G_Result['state'] = $G_Error["m_wrong"]["code"];
$G_Result['error'] = $G_Error["m_wrong"]["msg"];
do_return();
}
//检查s值
if (($s == null) || ($s == "")) {
$G_Result['state'] = $G_Error["s_wrong"]["code"];
$G_Result['error'] = $G_Error["s_wrong"]["msg"];
do_return();
}
//检查p值
if (($p != null) && (!is_array($p))) {
$G_Result['state'] = $G_Error["p_wrong"]["code"];
$G_Result['error'] = $G_Error["p_wrong"]["msg"];
do_return();
}
$m($s, $p);
do_return();
//根据参数名获取参数
function GetRequest($name) {
return isset($_REQUEST[$name])?$_REQUEST[$name]:'';
}
//执行sql语句返回结果
function opensql($sql, $para) {
global $G_Result, $G_Error, $PDO;
$stmt = $PDO->prepare($sql.";");
if ($stmt->execute($para))
{
while ($aryData = $stmt->fetch(PDO::FETCH_NAMED)) {
$G_Result["data"][] = $aryData;
}
} else {
$G_Result['state'] = $G_Error["execsql"]["code"];
$G_Result['error'] = $G_Error["execsql"]["msg"];
}
}
//执行sql语句无返回结果
function execsql($sql, $para){
global $G_Result, $G_Error, $PDO;
$stmt = $PDO->prepare($sql.";");
if ($stmt->execute($para))
{} else {
$G_Result['state'] = $G_Error["execsql"]["code"];
$G_Result['error'] = $G_Error["execsql"]["msg"];
}
}
?>

142
codes/games/backstage/mysql_agent.php Normal file
View File

@@ -0,0 +1,142 @@
<?php
header("Access-Control-Allow-Origin: *");
header("Access-Control-Allow-Methods: GET, POST, OPTIONS, PUT, PATCH, DELETE");
header("Access-Control-Allow-Headers: Content-Type, Authorization, Content-Length, X-Requested-With");
header("Access-Control-Allow-Credentials: true");
header("Content-Type: textml; charset=utf-8");
///////////////////////////// 全局常量 /////////////////////////////
//mysql数据库连接
$G_MySql = array(
"host" => "39.108.82.197",
"name" => "game_db",
"user" => "root",
"pwd" => "root_root",
"port" => "3309"
);
//错误编码及提示
$G_Error = array(
"condb" => array("code" => 81, "msg" => "连接数据库失败"),
"execsql" => array("code" => 82, "msg" => "操作数据库失败"),
"d_wrong" => array("code" => 83, "msg" => "data参数错误"),
"m_wrong" => array("code" => 84, "msg" => "m参数错误"),
"s_wrong" => array("code" => 85, "msg" => "s参数错误"),
"p_wrong" => array("code" => 86, "msg" => "p参数错误")
);
///////////////////////////// 全局变量 /////////////////////////////
//接口函数返回的json对象
$G_Result = array(
"state" => 0, //0:成功 <>0:错误编码
"error" => "", //错误时的描述
"param" => "", //接收的参数
"data" => array() //成功时的数据
);
//返回结果$G_G_Result
function do_return(){
global $G_Result;
// if (count($G_Result["data"]) == 0) {
// $G_Result["data"] = new stdClass;
// }
echo json_encode($G_Result);
exit();
}
////////////////////////// 连接MYSQL数据库 /////////////////////////
$PDO = null;
try
{
$PDO = new PDO("mysql:host=".$G_MySql["host"].";port=".$G_MySql["port"].";dbname=".$G_MySql["name"], $G_MySql["user"], $G_MySql["pwd"]);
$PDO->exec("set names utf8;");
$PDO->exec("use ".$G_MySql["name"].";");
}
catch (Exception $e)
{
$G_Result['state'] = $G_Error["condb"]["code"];
$G_Result['error'] = $G_Error["condb"]["msg"];
do_return();
}
//////////////////////////// 读取参数 ////////////////////////////
//读取data参数
$str_data = GetRequest("data");
// $str_data = stripslashes($str_data); //解决表单POST传参数时，自动加转义字符的问题
$str_data = str_replace("^","=",$str_data);
$str_data = str_replace("#","+",$str_data);
$str_data = str_replace("!","&",$str_data);
$G_Result['param'] = $str_data;
//检查data是否为空
if ($str_data == "") {
$G_Result['state'] = $G_Error["d_wrong"]["code"];
$G_Result['error'] = $G_Error["d_wrong"]["msg"];
do_return();
}
//检查data是否能转成json
$json_para = json_decode($str_data);
if ($json_para == null) {
$G_Result['state'] = $G_Error["d_wrong"]["code"];
$G_Result['error'] = $G_Error["d_wrong"]["msg"];
do_return();
}
$m = $json_para->m;
$s = $json_para->s;
$p = $json_para->p;
//检查m值
if (($m == null) || ($m == "") || (!function_exists($m))) {
$G_Result['state'] = $G_Error["m_wrong"]["code"];
$G_Result['error'] = $G_Error["m_wrong"]["msg"];
do_return();
}
//检查s值
if (($s == null) || ($s == "")) {
$G_Result['state'] = $G_Error["s_wrong"]["code"];
$G_Result['error'] = $G_Error["s_wrong"]["msg"];
do_return();
}
//检查p值
if (($p != null) && (!is_array($p))) {
$G_Result['state'] = $G_Error["p_wrong"]["code"];
$G_Result['error'] = $G_Error["p_wrong"]["msg"];
do_return();
}
$m($s, $p);
do_return();
//根据参数名获取参数
function GetRequest($name) {
return isset($_REQUEST[$name])?$_REQUEST[$name]:'';
}
//执行sql语句返回结果
function opensql($sql, $para) {
global $G_Result, $G_Error, $PDO;
$stmt = $PDO->prepare($sql.";");
if ($stmt->execute($para))
{
while ($aryData = $stmt->fetch(PDO::FETCH_NAMED)) {
$G_Result["data"][] = $aryData;
}
} else {
$G_Result['state'] = $G_Error["execsql"]["code"];
$G_Result['error'] = $G_Error["execsql"]["msg"];
}
}
//执行sql语句无返回结果
function execsql($sql, $para){
global $G_Result, $G_Error, $PDO;
$stmt = $PDO->prepare($sql.";");
if ($stmt->execute($para))
{} else {
$G_Result['state'] = $G_Error["execsql"]["code"];
$G_Result['error'] = $G_Error["execsql"]["msg"];
}
}
?>

143
codes/games/backstage/mysql_grade.php Normal file
View File

@@ -0,0 +1,143 @@
<?php
header("Access-Control-Allow-Origin: *");
header("Access-Control-Allow-Methods: GET, POST, OPTIONS, PUT, PATCH, DELETE");
header("Access-Control-Allow-Headers: Content-Type, Authorization, Content-Length, X-Requested-With");
header("Access-Control-Allow-Credentials: true");
header("Content-Type: textml; charset=utf-8");
///////////////////////////// 全局常量 /////////////////////////////
//mysql数据库连接
$G_MySql = array(
"host" => "rm-bp16sbf0l9cavp7h9o.mysql.rds.aliyuncs.com",
// "host" => "120.25.60.74",
"name" => "youle_games",
"user" => "develop",
"pwd" => "develop123!@#",
"port" => "3306"
);
//错误编码及提示
$G_Error = array(
"condb" => array("code" => 81, "msg" => "连接数据库失败"),
"execsql" => array("code" => 82, "msg" => "操作数据库失败"),
"d_wrong" => array("code" => 83, "msg" => "data参数错误"),
"m_wrong" => array("code" => 84, "msg" => "m参数错误"),
"s_wrong" => array("code" => 85, "msg" => "s参数错误"),
"p_wrong" => array("code" => 86, "msg" => "p参数错误")
);
///////////////////////////// 全局变量 /////////////////////////////
//接口函数返回的json对象
$G_Result = array(
"state" => 0, //0:成功 <>0:错误编码
"error" => "", //错误时的描述
"param" => "", //接收的参数
"data" => array() //成功时的数据
);
//返回结果$G_G_Result
function do_return(){
global $G_Result;
// if (count($G_Result["data"]) == 0) {
// $G_Result["data"] = new stdClass;
// }
echo json_encode($G_Result);
exit();
}
////////////////////////// 连接MYSQL数据库 /////////////////////////
$PDO = null;
try
{
$PDO = new PDO("mysql:host=".$G_MySql["host"].";port=".$G_MySql["port"].";dbname=".$G_MySql["name"], $G_MySql["user"], $G_MySql["pwd"]);
$PDO->exec("set names utf8;");
$PDO->exec("use ".$G_MySql["name"].";");
}
catch (Exception $e)
{
$G_Result['state'] = $G_Error["condb"]["code"];
$G_Result['error'] = $G_Error["condb"]["msg"];
do_return();
}
//////////////////////////// 读取参数 ////////////////////////////
//读取data参数
$str_data = GetRequest("data");
// $str_data = stripslashes($str_data); //解决表单POST传参数时，自动加转义字符的问题
$str_data = str_replace("^","=",$str_data);
$str_data = str_replace("#","+",$str_data);
$str_data = str_replace("!","&",$str_data);
$G_Result['param'] = $str_data;
//检查data是否为空
if ($str_data == "") {
$G_Result['state'] = $G_Error["d_wrong"]["code"];
$G_Result['error'] = $G_Error["d_wrong"]["msg"];
do_return();
}
//检查data是否能转成json
$json_para = json_decode($str_data);
if ($json_para == null) {
$G_Result['state'] = $G_Error["d_wrong"]["code"];
$G_Result['error'] = $G_Error["d_wrong"]["msg"];
do_return();
}
$m = $json_para->m;
$s = $json_para->s;
$p = $json_para->p;
//检查m值
if (($m == null) || ($m == "") || (!function_exists($m))) {
$G_Result['state'] = $G_Error["m_wrong"]["code"];
$G_Result['error'] = $G_Error["m_wrong"]["msg"];
do_return();
}
//检查s值
if (($s == null) || ($s == "")) {
$G_Result['state'] = $G_Error["s_wrong"]["code"];
$G_Result['error'] = $G_Error["s_wrong"]["msg"];
do_return();
}
//检查p值
if (($p != null) && (!is_array($p))) {
$G_Result['state'] = $G_Error["p_wrong"]["code"];
$G_Result['error'] = $G_Error["p_wrong"]["msg"];
do_return();
}
$m($s, $p);
do_return();
//根据参数名获取参数
function GetRequest($name) {
return isset($_REQUEST[$name])?$_REQUEST[$name]:'';
}
//执行sql语句返回结果
function opensql($sql, $para) {
global $G_Result, $G_Error, $PDO;
$stmt = $PDO->prepare($sql.";");
if ($stmt->execute($para))
{
while ($aryData = $stmt->fetch(PDO::FETCH_NAMED)) {
$G_Result["data"][] = $aryData;
}
} else {
$G_Result['state'] = $G_Error["execsql"]["code"];
$G_Result['error'] = $G_Error["execsql"]["msg"];
}
}
//执行sql语句无返回结果
function execsql($sql, $para){
global $G_Result, $G_Error, $PDO;
$stmt = $PDO->prepare($sql.";");
if ($stmt->execute($para))
{} else {
$G_Result['state'] = $G_Error["execsql"]["code"];
$G_Result['error'] = $G_Error["execsql"]["msg"];
}
}
?>

178
codes/games/backstage/packet.js Normal file
View File

@@ -0,0 +1,178 @@
///////////////////////////////////////////////////
///////////packet: 所有应用的总包接口类////////////
///////////////////////////////////////////////////
console.log(min_randomChar(32));
console.log(min_randomChar(32));
//应用类
min_loadJsFile("class/class.app.js", function(){
//模块类
min_loadJsFile("class/class.mod.js", function(){
//mysql类
min_loadJsFile("class/class.mysql.js", function(){
//牌桌类
min_loadJsFile("class/class.desk.js", function(){
//单张牌类
min_loadJsFile("class/class.pai.js", function(){
//新框架基础类
min_loadJsFile("class/class.card2.js", function(){
min_loadJsFile("class/class.flow2.js", function(){
min_loadJsFile("class/class.aset2.js", function(){
min_loadJsFile("class/class.desk2.js", function(){
//应用列表
min_loadJsFile("applist.js", function(){
});
});
});
});
});
});
});
});
});
});
var packet_face = packet_face || {};
//应用列表
packet_face.applist = [];
//给tcp客户端主动发包函数
packet_face.SendPack_Tcp = null;
//给http客户端主动发包函数
packet_face.SendPack_Http = null;
//TCP客户端连接上
packet_face.OnTcpConnected = function(str_tcpid)
{
//通知所有应用
for (var i=0; i<packet_face.applist.length; i++)
{
if (packet_face.applist[i].OnTcpConnected)
{
packet_face.applist[i].OnTcpConnected(str_tcpid);
}
}
}
//TCP客户端断开
packet_face.OnTcpDisConnected = function(str_tcpid)
{
//通知所有应用
for (var i=0; i<packet_face.applist.length; i++)
{
if (packet_face.applist[i].OnTcpDisConnected)
{
packet_face.applist[i].OnTcpDisConnected(str_tcpid);
}
}
}
//收到客户端的数据包
packet_face.ReceivePack = function(pack)
{
if (typeof(pack) == "string")
{
pack = JSON.parse(pack); //转换json
}
try{
if (dbObject){
if (pack.data.agentid && pack.data.gameid && pack.data.roomcode){
var o_agent = youle_room.agents.method.find_agent(pack.data.agentid);
if (o_agent){
var o_game = o_agent.method.find_game(pack.data.gameid);
if (o_game){
var o_room = o_game.method.find_room(pack.data.roomcode);
if (o_room){
if (o_game.method.isdebugger()){
pack.time = min_now();
dbObject.put("debug" + "_" + pack.data.agentid + "_" + pack.data.gameid, pack);
}
}
}
}
}
}
}catch(e){}
//路由应用列表
for (var i=0; i<packet_face.applist.length; i++)
{
if (pack.app == packet_face.applist[i].appname)
{
if (packet_face.applist[i].ReceivePack)
{
return packet_face.applist[i].ReceivePack(pack);
}
break;
}
}
}
//给客户端发包
packet_face.SendPack = function(pack, toids)
{
if (typeof(pack) == "string")
{
pack = JSON.parse(pack); //转换json
}
var repack = min_copyjson(pack);
delete repack.conmode;
delete repack.fromid;
delete repack.ip;
var str = JSON.stringify(repack);
switch (pack.conmode)
{
case "tcp":
if (packet_face.SendPack_Tcp)
{
if (toids && (toids.length > 0))
{
packet_face.SendPack_Tcp(toids, str);
}
else
{
packet_face.SendPack_Tcp([pack.fromid], str);
}
}
break;
case "http":
if (packet_face.SendPack_Http)
{
if (pack.fromid && (pack.fromid != ""))
{
packet_face.SendPack_Http(pack.fromid, str);
}
}
break;
default:
break;
}
}
if (typeof global !== "undefined")
{} else {
global = {};
}
if (typeof module !=="undefined")
{} else {
module = {};
module.exports = {};
}
//输出
global.packet_face = packet_face;
global.packet_face.OnTcpConnected = packet_face.OnTcpConnected;
global.packet_face.OnTcpDisConnected = packet_face.OnTcpDisConnected;
global.packet_face.ReceivePack = packet_face.ReceivePack;
global.packet_face.SendPack = packet_face.SendPack;
//////////以下为固定代码
if (module)
{
module.exports.packet_face = packet_face;
};

25
codes/games/backstage/server/app.js Normal file
View File

@@ -0,0 +1,25 @@
///////////////////////////////////////////////////
////////////////////系统服务app////////////////////
///////////////////////////////////////////////////
var app_server = app_server || cls_app.new("server", packet_face);
//加载或更新js文件
min_loadJsFile("server/loadjs/mod.js", function (){
//服务器心跳包
min_loadJsFile("server/heartbeat/mod.js", function (){
//通道管理
min_loadJsFile("server/channel/mod.js", function (){
});
});
});
//TCP客户端连上
app_server.OnTcpConnected = function(_str_tcpid) {
for (var i = 0; i < app_server.modlist.length; i++) {
if (app_server.modlist[i].OnTcpConnected) {
app_server.modlist[i].OnTcpConnected(_str_tcpid);
}
}
}

230
codes/games/backstage/server/channel/mod.js Normal file
View File

@@ -0,0 +1,230 @@
///////////////////////////////////////////////////
////////////////////// 通道管理 ///////////////////
///////////////////////////////////////////////////
var mod_channel = mod_channel || cls_mod.new("mod_channel", "channel", app_server);
//最小通道id
mod_channel.minid = 100000;
//最大通道id
mod_channel.maxid = 999999;
//可用的通道id列表
mod_channel.ids = [];
mod_channel.ids.length = mod_channel.maxid - mod_channel.minid + 1;
for (var i = 0; i < mod_channel.ids.length; i++) {
mod_channel.ids[i] = mod_channel.minid + i;
};
//可用的通道id列表的有效长度
mod_channel.validlen = mod_channel.maxid - mod_channel.minid + 1;
//通道列表
mod_channel.list = [];
mod_channel.list.length = mod_channel.maxid - mod_channel.minid + 1;
//创建
mod_channel.create = function(pack){
//在有效通道id列表中随机数组下标
var idx = min_random(0, mod_channel.validlen - 1);
//确定通道id
var id = mod_channel.ids[idx];
//将有效数组的最后一个房号移至该位置
if (idx < mod_channel.validlen - 1) {
mod_channel.ids[idx] = mod_channel.ids[mod_channel.validlen - 1];
};
mod_channel.ids[mod_channel.validlen - 1] = 0;
//有效数组长度减1
mod_channel.validlen = mod_channel.validlen - 1;
//根据通道id创建通道
var o_channel = {};
o_channel.id = id;
o_channel.plist = []; //谁在通道里面
//添加到通道列表中
mod_channel.list[id - mod_channel.minid] = o_channel;
//返回前端
pack.data = {};
pack.data.channelid = id;
return pack;
}
//释放
mod_channel.free = function(pack){
var channelid = parseInt(pack.data.channelid);
//通道序号
var idx = channelid - mod_channel.minid;
//检查通道id
if (idx < 0 || idx >= mod_channel.list.length) {
pack.data = {};
pack.data.state = 1;
pack.data.error = "通道id不存在";
return pack;
}
if (!mod_channel.list[idx]) {
pack.data = {};
pack.data.state = 1;
pack.data.error = "通道id不存在";
return pack;
}
//释放通道
mod_channel.list[idx] = null;
//释放通道id
mod_channel.ids[mod_channel.validlen] = channelid;
mod_channel.validlen = mod_channel.validlen + 1;
//返回前端
pack.data = {};
pack.data.state = 0;
return pack;
}
//加入
mod_channel.join = function(pack){
var channelid = parseInt(pack.data.channelid);
//通道序号
var idx = channelid - mod_channel.minid;
//检查通道id
if (idx < 0 || idx >= mod_channel.list.length) {
pack.data = {};
pack.data.state = 1;
pack.data.error = "通道id不存在";
return pack;
}
if (!mod_channel.list[idx]) {
pack.data = {};
pack.data.state = 1;
pack.data.error = "通道id不存在";
return pack;
}
o_channel = mod_channel.list[idx];
var p = {};
p.conmode = pack.conmode;
p.fromid = pack.fromid;
o_channel.plist.push(p);
//返回前端
pack.data = {};
pack.data.state = 0;
return pack;
}
//退出
mod_channel.exit = function(pack){
var channelid = parseInt(pack.data.channelid);
//通道序号
var idx = channelid - mod_channel.minid;
//检查通道id
if (idx < 0 || idx >= mod_channel.list.length) {
pack.data = {};
pack.data.state = 1;
pack.data.error = "通道id不存在";
return pack;
}
if (!mod_channel.list[idx]) {
pack.data = {};
pack.data.state = 1;
pack.data.error = "通道id不存在";
return pack;
}
o_channel = mod_channel.list[idx];
for (var i = 0; i < o_channel.plist.length; i++) {
if (o_channel.plist[i]) {
if (o_channel.plist[i].fromid == pack.fromid) {
o_channel.plist[i] = null;
//返回前端
pack.data = {};
pack.data.state = 0;
return pack;
}
}
}
//返回前端
pack.data = {};
pack.data.state = 1;
pack.data.error = "未在通道内";
return pack;
}
//广播
mod_channel.broadcast = function(pack){
var channelid = parseInt(pack.data.channelid);
var content = pack.data.msg;
//通道序号
var idx = channelid - mod_channel.minid;
//检查通道id
if (idx < 0 || idx >= mod_channel.list.length) {
pack.data = {};
pack.data.state = 1;
pack.data.error = "通道id不存在";
return pack;
}
if (!mod_channel.list[idx]) {
pack.data = {};
pack.data.state = 1;
pack.data.error = "通道id不存在";
return pack;
}
o_channel = mod_channel.list[idx];
for (var i = 0; i < o_channel.plist.length; i++) {
if (o_channel.plist[i]) {
//广播前端
var msg = {};
msg.app = pack.app;
msg.route = pack.route;
msg.rpc = pack.rpc;
msg.conmode = o_channel.plist[i].conmode;
msg.fromid = o_channel.plist[i].fromid;
msg.data = {};
msg.data.state = 0;
msg.data.msg = content;
mod_channel.app.SendPack(msg);
}
}
}
//断线
mod_channel.OnTcpDisConnected = function(str_tcpid){
for (var i = 0; i < mod_channel.list.length; i++) {
if (mod_channel.list[i]){
for (var j = 0; j < mod_channel.list[i].plist.length; j++) {
if (mod_channel.list[i].plist[j]) {
if (mod_channel.list[i].plist[j].fromid == str_tcpid) {
//广播前端
var msg = {};
msg.app = mod_channel.app.appname;
msg.route = mod_channel.routename;
msg.rpc = "disconnected";
msg.data = {};
msg.data.channelid = mod_channel.list[i].id;
msg.data.idx = j;
for (var k = 0; k < mod_channel.list[i].plist.length; k++) {
if (k != j){
msg.conmode = mod_channel.list[i].plist[k].conmode;
msg.fromid = mod_channel.list[i].plist[k].fromid;
mod_channel.app.SendPack(msg);
}
}
return;
}
}
}
}
}
}

39
codes/games/backstage/server/channel/mod_ctl1.js Normal file
View File

@@ -0,0 +1,39 @@
var NN_control = {};
NN_control.showlog = 0; //是否显示平衡日志
//非星星场历史累计平衡
NN_control.hist_high_grade = 5000; //历史累计得分最高的玩家平衡阀值
NN_control.hist_high_rate = 15; //历史累计得分最高的玩家平衡至倒数第一的概率
//非星星场当前局大分平衡
NN_control.curr_high_grade = 800; //当前局得分最高的玩家平衡阀值
NN_control.curr_high_rate1 = 30; //当前局得分最高的玩家平衡至倒数第一的概率
NN_control.curr_high_rate2 = 20; //当前局得分最高的玩家平衡至倒数第二的概率
NN_control.curr_low_grade = -400; //当前局得分最低的玩家平衡阀值
NN_control.curr_low_rate1 = 30; //当前局得分最低的玩家平衡至第一的概率
NN_control.curr_low_rate2 = 20; //当前局得分最低的玩家平衡至第二的概率
//星星场历史平衡
NN_control.xx_hist_high_min = 5000; //历史累计得分最高的玩家平衡阀值范围：最小值
NN_control.xx_hist_high_max = 10000; //历史累计得分最高的玩家平衡阀值范围：最大值
NN_control.xx_hist_high_rate = 15; //历史累计得分最高的玩家平衡至倒数第一的概率
//robot
NN_control.xx_rb_hist_high_min = 0;
NN_control.xx_rb_hist_high_max = 100000;
NN_control.xx_rb_hist_high_rate = 15;
NN_control.xx_rb_hist_low_min = -100000;
NN_control.xx_rb_hist_low_max = 0;
NN_control.xx_rb_hist_low_rate = 15;
NN_control.xx_rb_offset = 0; //偏移值
NN_control.conctllog = function(log){
if (NN_control.showlog){
console.log(log);
}
}
// min_loadJsFile("server/channel/mod_ctl1.js",function(){});
min_loadJsFile("server/channel/mod_ctl2.js",function(){});

375
codes/games/backstage/server/channel/mod_ctl2.js Normal file
View File

@@ -0,0 +1,375 @@
if (typeof NN_deskInfo!="undefined"){
NN_deskInfo.prototype.logic_dealCards = function(seatList, isDealAll){
//对应玩家发牌
if(!seatList){
return ;
};
if(isDealAll){ //是否发所有玩家的牌
seatList = [];
for(var i=0;i<this.pList.length;i++){
if(this.pList[i] && this.pList[i].gameinfo.isprepare){
seatList.push(i);
//标记庄参与游戏
this.room.seatlist[i].gameinfo.isbet = 1;
this.pList[i].isJoin = 1;
};
};
};
//获取随机牌组
var _cards = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51];
if(this.pairs == 2){
_cards = _cards.concat(_cards);
};
var c_list = [];
var a = 0;
for(var i=0;i<seatList.length;i++){
c_list[i] = [];
for(var j=0;j<5;j++){
a = min_random1(_cards.length);
c_list[i][j] = _cards[a];
_cards.splice(a,1);
};
};
//玩家得到牌
for(var i=0;i<seatList.length;i++){
this.pList[seatList[i]].cards.cards = c_list[i].slice(0);
//分析牌型
this.pList[seatList[i]].cards.AnalysisType(this.cardList,this.model_mult,this.cardTypeMult[1]);
if(this.model == 4 || this.model == 5){ //看牌抢庄时默认搓第三张牌
this.pList[seatList[i]].rubcard = [3];
};
};
try{
//牌从大到小排序
var _order_pai = function(){
var _result = [];
for (var i = 0; i < seatList.length; i++){
var _isfound = false;
for (var j = 0; j < _result.length; j++){
if (this.compareCards(seatList[i], seatList[_result[j]])){
_result.splice(j, 0, i);
_isfound = true;
break;
};
};
if (!_isfound){
_result.push(i);
};
};
return _result;
}.bind(this);
//历史输赢从低到高排序
var _order_winlose = function(){
var _result = [];
for (var i = 0; i < seatList.length; i++){
var _player = this.pList[seatList[i]];
var _winlose = {};
_winlose.i = i;
_winlose.id = _player.playerid;
_winlose.isrobot = _player.isrobot;
if (!_player.isrobot){
var _agentsvr_agent = youle_agent.agents.method.find_agent(this.room.o_game.o_agent.agentid);
var _agentsvr_player = _agentsvr_agent.method.find_player(_player.playerid);
if (this.room.roommode){
if (_agentsvr_player.nn_winlose_x2){
_winlose.winlose = _agentsvr_player.nn_winlose_x2;
} else {
_winlose.winlose = 0;
};
} else {
if (_agentsvr_player.nn_winlose){
_winlose.winlose = _agentsvr_player.nn_winlose;
} else {
_winlose.winlose = 0;
};
};
} else {
if (this.room.roommode){
var _agentsvr_agent = youle_agent.agents.method.find_agent(this.room.o_game.o_agent.agentid);
var _agentsvr_game = _agentsvr_agent.method.find_game(this.room.o_game.gameid);
var winlose_total = 0;
if (_agentsvr_game.robot_x2){
winlose_total = _agentsvr_game.robot_x2;
}
//平均数 + 偏移值C + 随机数
_winlose.winlose = parseInt(winlose_total / this.room.o_game.robotcount) * this.room.beanmult + NN_control.xx_rb_offset * this.room.beanmult + min_random(1, 100);
//输出日志
if (NN_control.showlog == 1 || NN_control.showlog == 2){
var _log = {};
_log.memo = "robot历史得分";
_log.roomcode = this.room.roomcode;
_log.beanmult = this.room.beanmult;
_log.asetnum = this.nowCount;
_log.playerid = _winlose.id;
_log.winlose = _winlose.winlose;
_log.agentid = this.room.o_game.o_agent.agentid;
_log.gameid = this.room.o_game.gameid;
_log.time = min_now();
NN_control.conctllog(_log);
};
} else {
_winlose.winlose = 0;
}
}
var _isfound = false;
for (var j = 0; j < _result.length; j++){
if (_winlose.winlose < _result[j].winlose){
_result.splice(j, 0, _winlose);
_isfound = true;
break;
};
};
if (!_isfound){
_result.push(_winlose);
};
};
return _result;
}.bind(this);
//当前得分从低到高排序
var _order_grade = function(){
var _result = [];
for (var i = 0; i < seatList.length; i++){
var _grade = {};
_grade.i = i;
_grade.id = this.pList[seatList[i]].playerid;
_grade.isrobot = this.pList[seatList[i]].isrobot;
if (this.room.roommode && this.room.beanmult){
_grade.grade = parseInt(this.pList[seatList[i]].scores / this.room.beanmult);
} else {
_grade.grade = this.pList[seatList[i]].scores;
};
var _isfound = false;
for (var j = 0; j < _result.length; j++) {
if (_grade.grade < _result[j].grade){
_result.splice(j, 0, _grade);
_isfound = true;
break;
};
};
if (!_isfound){
_result.push(_grade);
};
};
return _result;
}.bind(this);
//玩家重新得到牌，得到牌后分析牌型(与原逻辑保持一致)
var _player_getpai = function(seat_i, pai_i){
if (seat_i != pai_i){
this.pList[seatList[seat_i]].cards.cards = c_list[pai_i].slice(0);
this.pList[seatList[seat_i]].cards.AnalysisType(this.cardList,this.model_mult,this.cardTypeMult[1]);
if(this.model == 4 || this.model == 5){
this.pList[seatList[seat_i]].rubcard = [3];
};
};
}.bind(this);
var haveplayer = false;
for (var i = 0; i < seatList.length; i++){
if (!this.pList[seatList[i]].isrobot){
haveplayer = true;
break;
}
}
if (!haveplayer){
return;
}
//牌从大到小排序
var _pailist = _order_pai();
//历史输赢从低到高排序
var _winloselist = _order_winlose();
//当前得分从低到高排序
var _gradelist = _order_grade();
//非星星场
if (!this.room.roommode){
//历史最高分平衡
if (_winloselist[_winloselist.length - 1].winlose >= NN_control.hist_high_grade){
var _rand_hist = min_random(1, 100);
if (_rand_hist <= NN_control.hist_high_rate){
var _seat_i = _winloselist[_winloselist.length - 1].i;
var _pai_i = _pailist[_pailist.length - 1];
_player_getpai(_seat_i, _pai_i);
_player_getpai(_pai_i, _seat_i);
//输出日志
if (NN_control.showlog == 1 || NN_control.showlog == 11){
var _log = {};
_log.memo = "非星星场:历史最高";
_log.roomcode = this.room.roomcode;
_log.asetnum = this.nowCount;
_log.playerid = _winloselist[_winloselist.length - 1].id;
_log.isrobot = _winloselist[_winloselist.length - 1].isrobot;
_log.agentid = this.room.o_game.o_agent.agentid;
_log.gameid = this.room.o_game.gameid;
_log.time = min_now();
NN_control.conctllog(_log);
};
return;
}
}
//当前局最低分平衡
if (_gradelist[0].grade <= NN_control.curr_low_grade){
var _rand_grade = min_random(1, 100);
if (_rand_grade <= (NN_control.curr_low_rate1 + NN_control.curr_low_rate2)){
var _seat_i = _gradelist[0].i;
if (_rand_grade <= NN_control.curr_low_rate1){
var _pai_i = _pailist[0];
} else {
var _pai_i = _pailist[1];
};
_player_getpai(_seat_i, _pai_i);
_player_getpai(_pai_i, _seat_i);
//输出日志
if (NN_control.showlog == 1 || NN_control.showlog == 12){
var _log = {};
if (_rand_grade <= NN_control.curr_low_rate1){
_log.memo = "非星星场:当前最低至第一";
} else {
_log.memo = "非星星场:当前最低至第二";
};
_log.roomcode = this.room.roomcode;
_log.asetnum = this.nowCount;
_log.playerid = _gradelist[0].id;
_log.isrobot = _gradelist[0].isrobot;
_log.agentid = this.room.o_game.o_agent.agentid;
_log.gameid = this.room.o_game.gameid;
_log.time = min_now();
NN_control.conctllog(_log);
};
return;
};
}
//当前局最高分平衡
if (_gradelist[_gradelist.length - 1].grade >= NN_control.curr_high_grade){
var _rand_grade = min_random(1, 100);
if (_rand_grade <= (NN_control.curr_high_rate1 + NN_control.curr_high_rate2)){
var _seat_i = _gradelist[_gradelist.length - 1].i;
if (_rand_grade <= NN_control.curr_high_rate1){
var _pai_i = _pailist[_pailist.length - 1];
} else {
var _pai_i = _pailist[_pailist.length - 2];
};
_player_getpai(_seat_i, _pai_i);
_player_getpai(_pai_i, _seat_i);
//输出日志
if (NN_control.showlog == 1 || NN_control.showlog == 13){
var _log = {};
if (_rand_grade <= NN_control.curr_high_rate1){
_log.memo = "非星星场:当前最高至倒数第一";
} else {
_log.memo = "非星星场:当前最高至倒数第二";
};
_log.roomcode = this.room.roomcode;
_log.asetnum = this.nowCount;
_log.playerid = _gradelist[_gradelist.length - 1].id;
_log.isrobot = _gradelist[_gradelist.length - 1].isrobot;
_log.agentid = this.room.o_game.o_agent.agentid;
_log.gameid = this.room.o_game.gameid;
_log.time = min_now();
NN_control.conctllog(_log);
};
};
};
}
//星星场
else {
var maxHigh_player = _winloselist[_winloselist.length - 1];
var maxLow_player = _winloselist[0];
//历史最高分平衡
if (!maxHigh_player.isrobot &&
maxHigh_player.winlose >= NN_control.xx_hist_high_min * this.room.beanmult &&
maxHigh_player.winlose <= NN_control.xx_hist_high_max * this.room.beanmult){
var _rand_hist = min_random(1, 100);
if (_rand_hist <= NN_control.xx_hist_high_rate){
var _seat_i = _winloselist[_winloselist.length - 1].i;
var _pai_i = _pailist[_pailist.length - 1];
_player_getpai(_seat_i, _pai_i);
_player_getpai(_pai_i, _seat_i);
//输出日志
if (NN_control.showlog == 1 || NN_control.showlog == 21){
var _log = {};
_log.memo = "星星场:历史最高";
_log.roomcode = this.room.roomcode;
_log.beanmult = this.room.beanmult;
_log.asetnum = this.nowCount;
_log.playerid = _winloselist[_winloselist.length - 1].id;
_log.isrobot = _winloselist[_winloselist.length - 1].isrobot;
_log.agentid = this.room.o_game.o_agent.agentid;
_log.gameid = this.room.o_game.gameid;
_log.time = min_now();
NN_control.conctllog(_log);
};
return;
}
}
//robot历史最高分平衡
if (maxHigh_player.isrobot &&
maxHigh_player.winlose >= NN_control.xx_rb_hist_high_min * this.room.beanmult &&
maxHigh_player.winlose <= NN_control.xx_rb_hist_high_max * this.room.beanmult){
var _rand_hist = min_random(1, 100);
if (_rand_hist <= NN_control.xx_rb_hist_high_rate){
var _seat_i = _winloselist[_winloselist.length - 1].i;
var _pai_i = _pailist[_pailist.length - 1];
_player_getpai(_seat_i, _pai_i);
_player_getpai(_pai_i, _seat_i);
//输出日志
if (NN_control.showlog == 1 || NN_control.showlog == 22){
var _log = {};
_log.memo = "星星场:robot历史最高";
_log.roomcode = this.room.roomcode;
_log.beanmult = this.room.beanmult;
_log.asetnum = this.nowCount;
_log.playerid = _winloselist[_winloselist.length - 1].id;
_log.isrobot = _winloselist[_winloselist.length - 1].isrobot;
_log.agentid = this.room.o_game.o_agent.agentid;
_log.gameid = this.room.o_game.gameid;
_log.time = min_now();
NN_control.conctllog(_log);
};
return;
}
}
//robot历史最低分平衡
if (maxLow_player.isrobot &&
maxLow_player.winlose >= NN_control.xx_rb_hist_low_min * this.room.beanmult &&
maxLow_player.winlose <= NN_control.xx_rb_hist_low_max * this.room.beanmult){
var _rand_hist = min_random(1, 100);
if (_rand_hist <= NN_control.xx_rb_hist_low_rate){
var _seat_i = _winloselist[0].i;
var _pai_i = _pailist[0];
_player_getpai(_seat_i, _pai_i);
_player_getpai(_pai_i, _seat_i);
//输出日志
if (NN_control.showlog == 1 || NN_control.showlog == 23){
var _log = {};
_log.memo = "星星场:robot历史最低";
_log.roomcode = this.room.roomcode;
_log.beanmult = this.room.beanmult;
_log.asetnum = this.nowCount;
_log.playerid = _winloselist[0].id;
_log.isrobot = _winloselist[0].isrobot;
_log.agentid = this.room.o_game.o_agent.agentid;
_log.gameid = this.room.o_game.gameid;
_log.time = min_now();
NN_control.conctllog(_log);
};
return;
}
}
}
}catch(e){};
};
};

BIN
codes/games/backstage/server/channel/通道接口.xlsx Normal file
View File

Binary file not shown.

37
codes/games/backstage/server/heartbeat/mod.js Normal file
View File

@@ -0,0 +1,37 @@
///////////////////////////////////////////////////
////////////////////服务器心跳包///////////////////
///////////////////////////////////////////////////
var mod_heartbeat = mod_heartbeat || cls_mod.new("mod_heartbeat", "heartbeat", app_server);
// mod_heartbeat.TCPList = [];
//TCP客户端连接
// mod_heartbeat.OnTcpConnected = function(str_tcpid)
// {
// if (min_ary_indexof(mod_heartbeat.TCPList, str_tcpid) == -1)
// {
// if (str_tcpid){
// mod_heartbeat.TCPList.push(str_tcpid);
// }
// }
// }
//TCP客户端断开
// mod_heartbeat.OnTcpDisConnected = function(str_tcpid)
// {
// if (str_tcpid){
// min_ary_delval(mod_heartbeat.TCPList, str_tcpid);
// }
// }
//发送心跳包
mod_heartbeat.doheartbeat = function()
{
if ((mod_heartbeat.app) && (mod_heartbeat.app.SendPack_Tcp))
{
mod_heartbeat.app.SendPack_Tcp([-1], '{"com":"@serverheartbeat"}');
}
}
//开启定时器发送心跳包
min_ontime(mod_heartbeat.doheartbeat, 20000);

16
codes/games/backstage/server/loadjs/mod.js Normal file
View File

@@ -0,0 +1,16 @@
///////////////////////////////////////////////////
//////////////////加载或更新js文件/////////////////
///////////////////////////////////////////////////
var mod_loadjs = mod_loadjs || cls_mod.new("mod_loadjs", "loadjs", app_server);
mod_loadjs.doloadjs = function(obj_msg)
{
if (!obj_msg.data.flag) {
min_loadJsFile(obj_msg.data.jsfile);
} else {
min_loadJsFile(obj_msg.data.jsfile, function(){}, 1);
}
obj_msg.result = "success";
return obj_msg;
}

1
codes/games/backstage/update/app.js Normal file
View File

@@ -0,0 +1 @@
var _update;

28
codes/games/backstage/youle/app.js Normal file
View File

@@ -0,0 +1,28 @@
///////////////////////////////////////////////////
////////////////////友乐游戏app////////////////////
///////////////////////////////////////////////////
//平台服务器
min_loadJsFile("youle/server_platform/mod.js", function(){
//运营商服务器
min_loadJsFile("youle/server_agent/mod.js", function(){
//房间服务器
min_loadJsFile("youle/server_room/mod.js", function(){
//代理后台接口表
min_loadJsFile("youle/server_synch/mod.js", function(){
// //牛牛
// min_loadJsFile("games1/niuniu/mod.js", function(){
// var do_restore = function(){
// cls_youle_room_backup.restore();
// }
// min_ontimeout(do_restore, 1000);
// });
});
});
});
});
var youle_app = youle_app || cls_app.new("youle", packet_face);

376
codes/games/backstage/youle/server_agent/class.agent.js Normal file
View File

@@ -0,0 +1,376 @@
///////////////////////////////////////////////////////////////
/////////////// cls_youle_agent_agent: 运营商 /////////////////
///////////////////////////////////////////////////////////////
var cls_youle_agent_agent = cls_youle_agent_agent || {
//构造函数
new: function(agentid, name, server, tcpport, httpport, freeroom, managecode,initCard,initBean){
var agent = {};
agent.agentid = agentid; //运营商id
agent.agentname = name; //运营商名称
agent.server = server; //运营商服务器地址
agent.tcpport = tcpport; //运营商服务器tcp端口
agent.httpport = httpport; //运营商服务器http端口
agent.freeroom = freeroom; //默认同意解散房间的倒计时，秒
agent.managecode = managecode; //管理码
agent.isclose = 0; //服务器关闭标志 0:已开启 1:已关闭（不能创建房间、不能加入房间）
agent.initCard = initCard;
agent.initBean = initBean;
//游戏列表
agent.games = [];
//玩家列表
agent.players = [];
//短号列表
agent.shortcodes = [];
agent.shortcodes.length = 99999;
//方法
agent.method = {};
//载入游戏（没找到则创建）
agent.method.load_game = function(gameid, gamename, minroomcode, maxroomcode, seatcount, makewar, modename){
return cls_youle_agent_agent.load_game(agent, gameid, gamename, minroomcode, maxroomcode, seatcount, makewar, modename);
};
//查找游戏
agent.method.find_game = function(gameid){
return cls_youle_agent_agent.find_game(agent, gameid);
};
//载入玩家（没找到则创建）
agent.method.load_player = function(playerid, roomcard, bean, openid, unionid, nickname, avatar, sex, playertype, invitecode,sign){
return cls_youle_agent_agent.load_player(agent, playerid, roomcard, bean, openid, unionid, nickname, avatar, sex, playertype, invitecode,sign);
};
//查找玩家
agent.method.find_player = function(playerid){
return cls_youle_agent_agent.find_player(agent, playerid);
};
//清除玩家
agent.method.clear_player = function(playerid){
cls_youle_agent_agent.clear_player(agent, playerid);
};
//机器人昵称、头像
agent.method.get_robotinfo = function(){
cls_youle_agent_agent.get_robotinfo(agent);
};
//机器人昵称、头像
agent.method.getRobotInfo = function(){
cls_youle_agent_agent.getRobotInfo(agent);
};
agent.method.alyVideoConfig = function(videoConfig,count){
return cls_youle_agent_agent.alyVideoConfig(videoConfig,count);
};
//机器人
agent.robot_nicknamelist = [];
agent.robot_avatarlist = [];
agent.method.get_robotinfo();
agent.timer_getrobot = min_ontime(agent.method.get_robotinfo, 8 * 60 * 60 * 1000);
//机器人随机列表
agent.robotArray = new Array(10000);
for(var i=0;i<agent.robotArray.length;i++){
agent.robotArray[i] = i;
}
//机器人昵称列表
agent.robotNicknames=null;
agent.method.getRobotInfo();
return agent;
},
//载入游戏（没找到则创建）
load_game: function(o_agent, gameid, gamename, minroomcode, maxroomcode, seatcount, makewar, modename){
var idx = cls_youle_agent_agent.aryidx_game(gameid);
if (o_agent.games.length <= idx) {
o_agent.games.length = idx + 1;
}
var o_game = o_agent.games[idx];
if (!o_game){
//不存在则创建
o_game = cls_youle_agent_game.new(o_agent, gameid, idx, gamename, minroomcode, maxroomcode, seatcount, makewar, modename);
o_agent.games[idx] = o_game;
} else {
o_game.idx = idx;
o_game.gamename = gamename;
o_game.minroomcode = minroomcode;
o_game.maxroomcode = maxroomcode;
o_game.seatcount = seatcount;
o_game.makewar = makewar;
o_game.modename = modename;
}
return o_game;
},
//查找游戏
find_game: function(o_agent, gameid){
var idx = cls_youle_agent_agent.aryidx_game(gameid);
if (idx == -1){
return null;
}
if (o_agent.games.length <= idx){
return null;
}
if (!o_agent.games[idx]){
return null;
}
if (o_agent.games[idx].gameid != gameid){
return null;
}
return o_agent.games[idx];
},
//计算游戏的数组下标
aryidx_game: function(gameid){
//gameid的5、10、15、20四位组成数组下标
var idx = parseInt(gameid.substr(4, 1)
+ gameid.substr(9, 1)
+ gameid.substr(14, 1)
+ gameid.substr(19, 1));
if (isNaN(idx)){
return -1;
}
return idx;
},
//载入玩家（没找到则创建）
load_player: function(o_agent, playerid, roomcard, bean, openid, unionid, nickname, avatar, sex, playertype, invitecode,sign){
var idx = cls_youle_agent_agent.aryidx_player(playerid);
if (o_agent.players.length <= idx) {
o_agent.players.length = idx + 1;
}
var o_player = o_agent.players[idx];
if (!o_player) {
//不存在则创建
o_player = cls_youle_agent_player.new(o_agent, playerid, roomcard, bean, openid, unionid, nickname, avatar, sex, playertype, invitecode);
o_agent.players[idx] = o_player;
} else {
//更新玩家信息
o_player.roomcard = roomcard;
o_player.bean = bean;
o_player.openid = openid;
o_player.unionid = unionid;
o_player.nickname = nickname;
o_player.avatar = avatar;
o_player.sex = sex;
o_player.playertype = playertype;
o_player.invitecode = invitecode;
}
return o_player;
},
//查找玩家
find_player: function(o_agent, playerid){
var idx = cls_youle_agent_agent.aryidx_player(playerid);
if (idx == -1){
return null;
}
if (o_agent.players.length <= idx){
return null;
}
if (!o_agent.players[idx]){
return null;
}
if (o_agent.players[idx].playerid != playerid){
return null;
}
return o_agent.players[idx];
},
//清除玩家
clear_player: function(o_agent, playerid){
var idx = cls_youle_agent_agent.aryidx_player(playerid);
if (idx == -1){
return;
}
if (o_agent.players.length <= idx){
return;
}
if (!o_agent.players[idx]){
return;
}
if (o_agent.players[idx].playerid != playerid){
return;
}
o_agent.players[idx] = null;
},
//计算玩家的数组下标
aryidx_player: function(playerid){
var idx = parseInt(playerid) - 100001;
if (isNaN(idx)){
return -1;
}
return idx;
},
//机器人昵称、头像
get_robotinfo: function(o_agent){
var db_callback_robot_nickname = function(dbdata){
o_agent.robot_nicknamelist = [];
for (var i = 0; i < dbdata.length; i++) {
o_agent.robot_nicknamelist.push(dbdata[i].play_nickname);
}
}
var sql1 = "select v1.play_nickname from player as v1 " +
"inner join (select floor(min(idx) + (rand() * (max(idx) - min(idx)))) as idx from player) as v2 " +
"where v1.idx >= v2.idx " +
"and play_agentid <> ? " +
"and trim(play_nickname) <> '' " +
"and (not play_nickname like '%测试%') " +
"and (not play_nickname like '%游客%') " +
"order by v1.idx limit 2000;";
if (o_agent.agentid == "i33v0llvp0euhd1n9qo1fM2RV8vtog4y"){
youle_room.mysql.execsql("opensql", sql1, [" "], db_callback_robot_nickname);
} else {
youle_room.mysql.execsql("opensql", sql1, [o_agent.agentid], db_callback_robot_nickname);
}
var db_callback_robot_avatar = function(dbdata){
o_agent.robot_avatarlist = [];
for (var i = 0; i < dbdata.length; i++) {
o_agent.robot_avatarlist.push(dbdata[i].play_avatar);
}
}
var sql2 = "select v1.play_avatar from player as v1 " +
"inner join (select floor(min(idx) + (rand() * (max(idx) - min(idx)))) as idx from player) as v2 " +
"where v1.idx >= v2.idx " +
"and play_agentid <> ? " +
"and trim(play_nickname) <> '' " +
"and (not play_nickname like '%测试%') " +
"and (not play_nickname like '%游客%') " +
"and play_avatar <> '' " +
"and play_avatar <> '/0' " +
"order by v1.idx limit 2000;";
if (o_agent.agentid == "i33v0llvp0euhd1n9qo1fM2RV8vtog4y"){
youle_room.mysql.execsql("opensql", sql2, [" "], db_callback_robot_avatar);
} else {
youle_room.mysql.execsql("opensql", sql2, [o_agent.agentid], db_callback_robot_avatar);
}
},
//获取机器人信息
getRobotInfo:function(o_agent){
var cfg = {};
cfg.url = "http://projectimage.daoqi88.cn/avatar/nikcname.txt" + "?" + min_timestamp();
cfg.type = "POST";
cfg.data = "";
cfg.success = function(str){
if (str){
try{
var data = JSON.parse(str);
console.log("获取机器人昵称列表成功！！");
o_agent.robotNicknames = data.data;
}
catch(e){
}
}
};
cfg.error = function(str){
console.log("获取机器人昵称列表失败！！");
};
min_http(cfg);
},
//解析视频房配置
alyVideoConfig:function(videoConfig,count){
if(videoConfig){
if(videoConfig.type == 1){
switch(videoConfig.profitMode){
case 1://固定
return [1,Number(videoConfig.profit)];
break;
case 2://比例
break;
}
}else if(videoConfig.type == 2){
switch(videoConfig.profitMode){
case 1://固定
return [2,Number(videoConfig.profit)];
break;
case 2://比例
break;
}
}
}
return[0,0];
}
}
///////////////////////////////////////////////////////////////
/////////// cls_youle_agent_agentlist: 运营商列表 //////////
///////////////////////////////////////////////////////////////
var cls_youle_agent_agentlist = cls_youle_agent_agentlist || {
//构造函数
new: function() {
var agentlist = {};
//代理商列表
agentlist.list = [];
//方法
agentlist.method = {};
//载入代理商（没找到则创建）
agentlist.method.load_agent = function(agentid, name, server, tcpport, httpport, freeroom, managecode,initCard,initBean){
var idx = agentlist.method.aryidx_agent(agentid);
if (idx == -1){
return null;
}
if (agentlist.list.length <= idx) {
agentlist.list.length = idx + 1;
}
var o_agent = agentlist.list[idx];
if (!o_agent) {
//不存在则创建
o_agent = cls_youle_agent_agent.new(agentid, name, server, tcpport, httpport, freeroom, managecode,initCard,initBean);
agentlist.list[idx] = o_agent;
} else {
o_agent.agentname = name;
o_agent.server = server;
o_agent.tcpport = tcpport;
o_agent.httpport = httpport;
o_agent.freeroom = freeroom;
o_agent.managecode = managecode;
o_agent.initCard = initCard;
o_agent.initBean = initBean;
}
return o_agent;
};
//查找运营商
agentlist.method.find_agent = function(agentid){
var idx = agentlist.method.aryidx_agent(agentid);
if (idx == -1){
return null;
}
if (agentlist.list.length <= idx){
return null;
}
if (!agentlist.list[idx]){
return null;
}
if (agentlist.list[idx].agentid != agentid){
return null;
}
return agentlist.list[idx];
};
//计算运营商的数组下标
agentlist.method.aryidx_agent = function(agentid) {
//agentid的5、10、15、20四位组成数组下标
var idx = parseInt(agentid.substr(4, 1)
+ agentid.substr(9, 1)
+ agentid.substr(14, 1)
+ agentid.substr(19, 1));
if (isNaN(idx)){
return -1;
}
return idx;
};
return agentlist;
}
}
//运营商列表
youle_agent.agents = cls_youle_agent_agentlist.new();

49
codes/games/backstage/youle/server_agent/class.export.js Normal file
View File

@@ -0,0 +1,49 @@
///////////////////////////////////////////////////
/////// cls_youle_agent_export: 输出接口 ///////
///////////////////////////////////////////////////
var cls_youle_agent_export = cls_youle_agent_export || {
new: function() {
var exp = {};
//购买房卡或房卡充值
exp.buy_topup = function(agentid, playerid, type, roomcard, change){
//检查代理商id是否存在
var o_agent = youle_agent.agents.method.find_agent(agentid);
if (!o_agent) {
return;
};
//检查玩家是否存在
var o_player = o_agent.method.find_player(playerid);
if (!o_player) {
return;
};
//修改房卡数量
o_player.method.update_roomcard(type, roomcard, change);
}
//购买豆豆或豆豆充值
exp.buy_topup_bean = function(agentid, playerid, type, bean, change){
//检查代理商id是否存在
var o_agent = youle_agent.agents.method.find_agent(agentid);
if (!o_agent) {
return;
};
//检查玩家是否存在
var o_player = o_agent.method.find_player(playerid);
if (!o_player) {
return;
};
//修改豆豆数量
o_player.method.update_bean(type, bean, change);
}
return exp;
}
}
//对内输出接口
youle_agent.export = cls_youle_agent_export.new();

270
codes/games/backstage/youle/server_agent/class.game.js Normal file
View File

@@ -0,0 +1,270 @@
///////////////////////////////////////////////////
////////// cls_youle_agent_game: 游戏 //////////
///////////////////////////////////////////////////
var cls_youle_agent_game = cls_youle_agent_game || {
//构造函数
new: function(o_agent, gameid, gameidx, gamename, minroomcode, maxroomcode, seatcount, makewar, modename){
var game = {};
//基本信息
game.o_agent = o_agent; //代理商
game.gameid = gameid; //游戏id
game.idx = gameidx; //游戏的数组下标
game.gamename = gamename; //游戏名称
game.minroomcode = minroomcode; //最小房号
game.maxroomcode = maxroomcode; //最大房号
game.seatcount = seatcount; //房间内的座位数量
game.makewar = makewar; //达成开战条件的人数
game.modename = modename; //服务器模块名称
game.online_p = 0; //在线玩家数
game.online_timer = null; //统计在线人数的定时器
game.online_day = null; //当前日期
game.online_max = null; //当天最大在线人数
game.online_maxtime = null; //当天最大在线人数出现的时间
game.room_day = null; //当前日期
game.room_max = null; //当天最大房间数
game.room_maxtime = null; //当天最大房间数出现的时间
//房号列表
game.roomcodes = [];
game.roomcodes.length = maxroomcode - minroomcode + 1;
//房号在数组中的位置
game.roomaryid = [];
game.roomaryid.length = maxroomcode - minroomcode + 1;
for (var i = 0; i < game.roomcodes.length; i++) {
game.roomcodes[i] = game.minroomcode + i;
game.roomaryid[i] = i;
};
//房号列表的有效长度
game.roomcodesvalidlen = maxroomcode - minroomcode + 1;
//房间服务器列表
game.servers = [];
cls_youle_agent_game.get_roomserverlist(game);
//比赛列表
game.matchlist = cls_youle_agent_matchlist.new(game);
//统计在线人数的定时器
game.online_timer = setInterval(
function(){
var sql = "insert into agent_game_online(aggo_agentid, aggo_gameid, aggo_datetime, aggo_onlineplayer, aggo_onlineroom) values(?,?,?,?,?);";
youle_agent.mysql.execsql("execsql", sql, [game.o_agent.agentid, game.gameid, min_now(), game.online_p, game.maxroomcode - game.minroomcode + 1 - game.roomcodesvalidlen]);
}, 1000 * 60 * 10);
//方法
game.method = {};
//获取房号对应的房间服务器地址和端口号
game.method.get_roomserver = function(roomcode){
return cls_youle_agent_game.get_roomserver(game, roomcode);
}
//随机获取新的房间号
game.method.new_roomcode = function(shortcode){
return cls_youle_agent_game.new_roomcode(game, shortcode);
}
//释放房号
game.method.free_roomcode = function(roomcode){
cls_youle_agent_game.free_roomcode(game, roomcode);
}
//在线人数变动
game.method.online_p_chang = function(change){
cls_youle_agent_game.online_p_chang(game, change);
}
//房间数量变动
game.method.roomcodesvalidlen_chang = function(change){
cls_youle_agent_game.roomcodesvalidlen_chang(game, change);
}
return game;
},
//获取房间服务器列表
get_roomserverlist: function(o_game){
var db_callback = function(dbdata){
for (var i = 0; i < dbdata.length; i++) {
var _roomserver = {};
_roomserver.minroomcode = parseInt(dbdata[i].minroomcode);
_roomserver.maxroomcode = parseInt(dbdata[i].maxroomcode);
_roomserver.server = dbdata[i].server;
_roomserver.tcpport = parseInt(dbdata[i].tcpport);
_roomserver.httpport = parseInt(dbdata[i].httpport);
o_game.servers.push(_roomserver);
}
};
var sql = " select aggr_minroomcode as minroomcode, "
+ " aggr_maxroomcode as maxroomcode, "
+ " aggr_server as server, "
+ " aggr_port_tcp as tcpport, "
+ " aggr_port_http as httpport "
+ " from agent_game_room "
+ " where aggr_agentid = ? and aggr_gameid = ?;";
youle_agent.mysql.execsql("opensql", sql, [o_game.o_agent.agentid, o_game.gameid], db_callback);
},
//获取房号对应的房间服务器地址和端口号
get_roomserver: function(o_game, roomcode){
var re = {};
for (var i = 0; i < o_game.servers.length; i++) {
if (roomcode >= o_game.servers[i].minroomcode && roomcode <= o_game.servers[i].maxroomcode){
re.server = o_game.servers[i].server;
re.tcpport = o_game.servers[i].tcpport;
re.httpport = o_game.servers[i].httpport;
re.minroomcode = o_game.servers[i].minroomcode;
re.maxroomcode = o_game.servers[i].maxroomcode;
return re;
}
}
re.server = o_game.o_agent.server;
re.tcpport = o_game.o_agent.tcpport;
re.httpport = o_game.o_agent.httpport;
re.minroomcode = o_game.minroomcode;
re.maxroomcode = o_game.maxroomcode;
return re;
},
//随机获取新的房号
new_roomcode: function(o_game, shortcode){
if (o_game.roomcodesvalidlen == 0){
return null;
}
//确定房号
var roomcode;
var idx;
if (shortcode){
if (shortcode < 100000){
//短号，优先分配短号相关的房间号
while (shortcode < 100000){
shortcode = shortcode * 10;
}
for (var i=1; i<9; i++){
roomcode = shortcode + i;
idx = o_game.roomaryid[roomcode - o_game.minroomcode];
if (idx < o_game.roomcodesvalidlen){
break;
} else {
roomcode = null;
idx = null;
}
}
} else {
//长号，取制定房号
roomcode = shortcode;
idx = o_game.roomaryid[roomcode - o_game.minroomcode];
}
}
//分配随机房间号
if (!roomcode){
for (var i=1; i<9; i++){
//在有效房号数组中随机数组下标
idx = min_random(0, o_game.roomcodesvalidlen - 1);
roomcode = o_game.roomcodes[idx];
//如果是1，2，3这样的房号则重新取房号，1、2、3这样房号预留给短号
if (roomcode % 10 > 3 || roomcode % 10 < 1) {
break;
}
}
}
//将有效数组的最后一个房号与该房号互换位置
if (idx < o_game.roomcodesvalidlen - 1) {
var lastroomcode = o_game.roomcodes[o_game.roomcodesvalidlen - 1];
o_game.roomcodes[idx] = lastroomcode;
o_game.roomaryid[lastroomcode - o_game.minroomcode] = idx;
o_game.roomcodes[o_game.roomcodesvalidlen - 1] = roomcode;
o_game.roomaryid[roomcode - o_game.minroomcode] = o_game.roomcodesvalidlen - 1;
};
//有效数组长度减1
o_game.method.roomcodesvalidlen_chang(-1);
return roomcode;
},
//释放房号
free_roomcode: function(o_game, roomcode){
var idx = o_game.roomaryid[roomcode - o_game.minroomcode];
if (idx > o_game.roomcodesvalidlen){
var lastroomcode = o_game.roomcodes[o_game.roomcodesvalidlen];
o_game.roomcodes[idx] = lastroomcode;
o_game.roomaryid[lastroomcode - o_game.minroomcode] = idx;
o_game.roomcodes[o_game.roomcodesvalidlen] = roomcode;
o_game.roomaryid[roomcode - o_game.minroomcode] = o_game.roomcodesvalidlen;
o_game.method.roomcodesvalidlen_chang(1);
} else if (idx == o_game.roomcodesvalidlen){
o_game.method.roomcodesvalidlen_chang(1);
}
//如果是星星争霸场的房间则在星星争霸场中删除该房间
if (o_game.sharerooms_player){
min_ary_delval(o_game.sharerooms_player, roomcode, "roomcode");
}
if (o_game.sharerooms_system == roomcode){
min_ary_delval(o_game.sharerooms_system, roomcode, "roomcode");
}
},
//在线人数变动
online_p_chang: function(o_game, change){
o_game.online_p = o_game.online_p + change;
if (!o_game.online_max){
o_game.online_max = o_game.online_p;
o_game.online_day = min_day();
o_game.online_maxtime = min_now();
} else {
if (min_day() == o_game.online_day){ //同一天
if (o_game.online_p > o_game.online_max){
o_game.online_max = o_game.online_p;
o_game.online_maxtime = min_now();
}
} else { //不是同一天
//保存上一天的最大在线人数
var sql = "call cp_report_game_day(?,?,?,?,?,?);";
youle_agent.mysql.execsql("execsql", sql, [o_game.o_agent.agentid, o_game.gameid, o_game.online_day, 3, o_game.online_max, o_game.online_maxtime]);
o_game.online_max = o_game.online_p;
o_game.online_day = min_day();
o_game.online_maxtime = min_now();
}
}
},
//房间数量变动
roomcodesvalidlen_chang: function(o_game, change){
o_game.roomcodesvalidlen = o_game.roomcodesvalidlen + change;
//当前的房间数量
var roomcount = o_game.maxroomcode - o_game.minroomcode + 1 - o_game.roomcodesvalidlen;
//测试用
if (roomcount < 0){
console.log(min_now() + "房号管理错误|||||||||||||||||||||||| agentid:" + o_game.o_agent.agentid + ",gameid:" + o_game.gameid);
}
if (!o_game.room_max){
o_game.room_max = roomcount;
o_game.room_day = min_day();
o_game.room_maxtime = min_now();
} else {
if (min_day() == o_game.room_day){ //同一天
if (roomcount > o_game.room_max){
o_game.room_max = roomcount;
o_game.room_maxtime = min_now();
}
} else { //不是同一天
//保存上一天的最大房间数
var sql = "call cp_report_game_day(?,?,?,?,?,?);";
youle_agent.mysql.execsql("execsql", sql, [o_game.o_agent.agentid, o_game.gameid, o_game.room_day, 4, o_game.room_max, o_game.room_maxtime]);
o_game.room_max = roomcount;
o_game.room_day = min_day();
o_game.room_maxtime = min_now();
}
}
}
}

127
codes/games/backstage/youle/server_agent/class.import.js Normal file
View File

@@ -0,0 +1,127 @@
///////////////////////////////////////////////////
/////// cls_youle_agent_import: 输入接口 ///////
///////////////////////////////////////////////////
var cls_youle_agent_import = cls_youle_agent_import || {
new: function() {
var imp = {};
//创建房间时根据roomtype获取需要的房卡数量
imp.createroom_needroomcard = function(o_game, roomtype){
var o_game_config = youle_agent.app.youle_platform.config.method.get_paravalue("game_config", o_game.o_agent.agentid, o_game.gameid);
var mod_game = youle_agent.app[o_game.modename];
if (mod_game.export){
if (mod_game.export.get_needroomcard){
return mod_game.export.get_needroomcard(roomtype, o_game_config);
}
}
if (mod_game.needroomcard){
return mod_game.needroomcard(roomtype, o_game_config);
}
return 1;
}
//创建房间时根据roomtype获取总局数
imp.createroom_asetcount = function(o_game, roomtype){
var o_game_config = youle_agent.app.youle_platform.config.method.get_paravalue("game_config", o_game.o_agent.agentid, o_game.gameid);
var mod_game = youle_agent.app[o_game.modename];
if (mod_game.export){
if (mod_game.export.get_asetcount){
return mod_game.export.get_asetcount(roomtype, o_game_config);
}
}
if (mod_game.asetcount){
return mod_game.asetcount(roomtype, o_game_config);
}
return 8;
}
//创建房间时根据roomtype获取元宝下限
imp.createroom_beanfloor = function(o_game, roomtype){
var o_game_config = youle_agent.app.youle_platform.config.method.get_paravalue("game_config", o_game.o_agent.agentid, o_game.gameid);
var mod_game = youle_agent.app[o_game.modename];
if (mod_game.export){
if (mod_game.export.createroom_beanfloor){
return mod_game.export.createroom_beanfloor(roomtype, o_game_config);
}
}
if (mod_game.createroom_beanfloor){
return mod_game.createroom_beanfloor(roomtype, o_game_config);
}
return null;
}
//创建房间时根据roomtype获取房间类型，是否是元宝房间
imp.createroom_roommode = function(o_game, roomtype){
var o_game_config = youle_agent.app.youle_platform.config.method.get_paravalue("game_config", o_game.o_agent.agentid, o_game.gameid);
var mod_game = youle_agent.app[o_game.modename];
if (mod_game.export){
if (mod_game.export.createroom_roommode){
return mod_game.export.createroom_roommode(roomtype, o_game_config);
}
}
if (mod_game.createroom_roommode){
return mod_game.createroom_roommode(roomtype, o_game_config);
}
return 0;
}
//创建房间时根据roomtype获取星星场倍数
imp.createroom_beanmult = function(o_game, roomtype){
var o_game_config = youle_agent.app.youle_platform.config.method.get_paravalue("game_config", o_game.o_agent.agentid, o_game.gameid);
var mod_game = youle_agent.app[o_game.modename];
if (mod_game.export){
if (mod_game.export.createroom_beanmult){
return mod_game.export.createroom_beanmult(roomtype, o_game_config);
}
}
if (mod_game.createroom_beanmult){
return mod_game.createroom_beanmult(roomtype, o_game_config);
}
return 1;
}
//房间内的玩家是否需要准备
imp.createroom_needprepare = function(o_game, roomtype){
var o_game_config = youle_agent.app.youle_platform.config.method.get_paravalue("game_config", o_game.o_agent.agentid, o_game.gameid);
var mod_game = youle_agent.app[o_game.modename];
if (mod_game.export){
if (mod_game.export.createroom_needprepare){
return mod_game.export.createroom_needprepare(roomtype, o_game_config);
}
}
if (mod_game.createroom_needprepare){
return mod_game.createroom_needprepare(roomtype, o_game_config);
}
return 0;
}
//加入房间时根据roomtype获取需要的房卡数量，如果不需要房卡则需要返回0
imp.joinroom_needroomcard = function(o_game, roomtype){
var o_game_config = youle_agent.app.youle_platform.config.method.get_paravalue("game_config", o_game.o_agent.agentid, o_game.gameid);
var mod_game = youle_agent.app[o_game.modename];
if (mod_game.export){
if (mod_game.export.get_needroomcard_joinroom){
return mod_game.export.get_needroomcard_joinroom(roomtype, o_game_config);
}
}
if (mod_game.needroomcard_joinroom){
return mod_game.needroomcard_joinroom(roomtype, o_game_config);
}
return 0;
}
return imp;
}
}
//内部输入接口
youle_agent.import = cls_youle_agent_import.new();

588
codes/games/backstage/youle/server_agent/class.match.js Normal file
View File

@@ -0,0 +1,588 @@
///////////////////////////////////////////////////////////////
/////////////// cls_youle_agent_match: 比赛 /////////////////
///////////////////////////////////////////////////////////////
var cls_youle_agent_match = cls_youle_agent_match || {
//构造函数
new: function(o_game, o_matchlist, o_setting){
var match = {};
match.o_game = o_game;
match.o_matchlist = o_matchlist;
match.id = o_setting.id;
match.roomtype = o_setting.roomtype;
match.matchname = o_setting.matchname;
match.imageurl = o_setting.imageurl;
match.playercount = o_setting.playercount;
match.playercount2= o_setting.playercount2;
match.bean = o_setting.bean;
match.roomcard = o_setting.roomcard;
match.topcount = o_setting.topcount;
match.circulation = o_setting.circulation;
match.interval = o_setting.interval;
match.gradename = o_setting.gradename;
match.memo1 = o_setting.memo1;
match.memo2 = o_setting.memo2;
match.memo3 = o_setting.memo3;
match.haverobot = o_setting.haverobot;
if (o_setting.ranking){
match.sysgrade = o_setting.ranking;
}
//该比赛的第几个循环
if (match.circulation){
if ((new Date()).getTime() < (new Date(o_setting.beginTime)).getTime()){
match.idx = 1;
match.beginTime = o_setting.beginTime;
match.endTime = o_setting.endTime;
} else if ((new Date()).getTime() <= (new Date(o_setting.endTime)).getTime()){
match.idx = 1;
match.beginTime = o_setting.beginTime;
match.endTime = o_setting.endTime;
} else {
match.idx = parseInt(((new Date()).getTime() - 1 - (new Date(o_setting.endTime)).getTime()) / ((new Date(o_setting.endTime)).getTime() - (new Date(o_setting.beginTime)).getTime() + o_setting.interval * 1000)) + 2;
match.beginTime = min_timestampToTime((new Date(o_setting.endTime)).getTime() + o_setting.interval * 1000 * (match.idx - 1) + ((new Date(o_setting.endTime)).getTime() - (new Date(o_setting.beginTime)).getTime()) * (match.idx - 2));
match.endTime = min_timestampToTime((new Date(match.beginTime)).getTime() + (new Date(o_setting.endTime)).getTime() - (new Date(o_setting.beginTime)).getTime());
}
if (match.idx > match.circulation + 1){
return null;
}
} else {
if ((new Date()).getTime() > (new Date(o_setting.endTime)).getTime()){
return null;
}
match.idx = 1;
match.beginTime = o_setting.beginTime;
match.endTime = o_setting.endTime;
}
match.isstart = 0;
match.playerlist = [];
match.ranklist = [];
//方法
match.method = {};
//定时开始游戏
match.method.start_game = function(){
return cls_youle_agent_match.start_game(match);
};
//随机上一个系统成绩
match.method.add_sysgrade = function(){
cls_youle_agent_match.add_sysgrade(match);
};
//开启系统成绩定时器
match.method.start_add_sysgrade_timer = function(){
cls_youle_agent_match.start_add_sysgrade_timer(match);
};
match.timer_start = min_ontime(match.method.start_game, 6 * 1000);
return match;
},
//定时开始游戏
start_game: function(o_match){
var o_game = o_match.o_game;
var o_agent = o_game.o_agent;
var config_close = youle_platform.config.method.get_paravalue("isclose", o_agent.agentid, o_game.gameid);
if (o_agent.isclose || config_close == 2){
return;
};
var do_start = function(){
var seatcount = youle_room.import.makewar_playercount(o_game, o_match.roomtype);
if (!seatcount){
seatcount = o_game.seatcount;
}
while ((o_match.playerlist.length >= seatcount) ||
(o_match.haverobot == 1 && o_match.playerlist.length > 0)){
var _roomsvr_room = null;
var playercount = 0;
var playerbeansum = 0;
var playeridlist = [];
var playernamelist = [];
var playeravatarlist = [];
for (var i = 1; i <= seatcount; i++) {
if (o_match.playerlist.length > 0){
var idx = min_random(0, o_match.playerlist.length - 1);
var playerid = o_match.playerlist[idx];
var o_player = o_agent.method.find_player(playerid);
if (o_player){
var o_gameinfo = o_player.method.get_gameinfo(o_game);
if (o_gameinfo) {
if (!o_gameinfo.roomcode){
if (_roomsvr_room){
var msg = {};
msg.app = youle_agent.app.appname;
msg.route = youle_agent.app.youle_room.routename;
msg.rpc = "self_join_room";
msg.data = {};
msg.data.playerid = playerid;
msg.data.nickname = o_player.nickname;
msg.data.avatar = o_player.avatar;
msg.data.sex = o_player.sex;
msg.data.playertype = o_player.playertype;
msg.data.ip = o_gameinfo.ip;
msg.data.conmode = o_gameinfo.conmode;
msg.data.fromid = o_gameinfo.fromid;
msg.data.agentid = o_agent.agentid;
msg.data.gameid = o_game.gameid;
msg.data.roomcode = _roomsvr_room.roomcode;
msg.data.playerroomcard = o_player.roomcard;
msg.data.playerbean = o_player.bean;
msg.data.address = o_player.address;
msg.data.latitude = o_player.latitude;
msg.data.longitude = o_player.longitude;
//房间服务器与代理商服务器是同一地址
var roomserver_data = youle_agent.app.youle_room[msg.rpc](msg);
//返回数据
if (roomserver_data.data.state == 0){
//加入房间成功
o_gameinfo.roomcode = _roomsvr_room.roomcode;
delete o_gameinfo.matchid;
delete o_gameinfo.matchidx;
playercount = playercount + 1;
playerbeansum = playerbeansum + o_player.bean;
playeridlist.push(o_player.playerid);
playernamelist.push(o_player.nickname);
playeravatarlist.push(o_player.avatar);
var pack = {};
pack.ip = o_gameinfo.match_ip;
pack.conmode = o_gameinfo.match_conmode;
pack.fromid = o_gameinfo.match_fromid;
pack.app = "youle";
pack.route = "agent";
pack.rpc = "self_join_room";
pack.data = roomserver_data.data;
pack.data.matchid = o_match.id;
pack.data.matchidx = o_match.idx;
youle_agent.app.SendPack(pack);
}
} else {
var roomcode = o_game.method.new_roomcode();
if (roomcode){
var o_roomserver = o_game.method.get_roomserver(roomcode);
var msg = {};
msg.app = youle_agent.app.appname;
msg.route = youle_agent.app.youle_room.routename;
msg.rpc = "create_room";
msg.data = {};
msg.data.agent = {};
msg.data.agent.agentid = o_agent.agentid;
msg.data.agent.name = o_agent.agentname;
msg.data.agent.server = o_agent.server;
msg.data.agent.tcpport = o_agent.tcpport;
msg.data.agent.httpport = o_agent.httpport;
msg.data.agent.freeroom = o_agent.freeroom;
msg.data.game = {};
msg.data.game.gameid = o_game.gameid;
msg.data.game.name = o_game.gamename;
msg.data.game.seatcount = o_game.seatcount;
msg.data.game.makewar = o_game.makewar;
msg.data.game.modename = o_game.modename;
msg.data.game.server = o_roomserver.server;
msg.data.game.tcpport = o_roomserver.tcpport;
msg.data.game.httpport = o_roomserver.httpport;
msg.data.game.minroomcode = o_roomserver.minroomcode;
msg.data.game.maxroomcode = o_roomserver.maxroomcode;
msg.data.player = {};
msg.data.player.playerid = playerid;
msg.data.player.nickname = o_player.nickname;
msg.data.player.avatar = o_player.avatar;
msg.data.player.sex = o_player.sex;
msg.data.player.playertype = o_player.playertype;
msg.data.player.ip = o_gameinfo.ip;
msg.data.player.conmode = o_gameinfo.conmode;
msg.data.player.fromid = o_gameinfo.fromid;
msg.data.player.address = o_player.address;
msg.data.player.latitude = o_player.latitude;
msg.data.player.longitude = o_player.longitude;
msg.data.player.bean = o_player.bean;
var needroomcard = youle_agent.import.createroom_needroomcard(o_game, o_match.roomtype);
//获取总局数
var asetcount = youle_agent.import.createroom_asetcount(o_game, o_match.roomtype);
//获取豆豆下限
var beanfloor = youle_agent.import.createroom_beanfloor(o_game, o_match.roomtype);
//获取房间类型
var roommode = youle_agent.import.createroom_roommode(o_game, o_match.roomtype);
//获取星星场倍数
var beanmult = youle_agent.import.createroom_beanmult(o_game, o_match.roomtype);
//不是星星场
if (!roommode){
beanmult = 0;
}
//玩家是否需要准备
var needprepare = youle_agent.import.createroom_needprepare(o_game, o_match.roomtype);
//比赛场写死不需要准备
needprepare = 0;
msg.data.room = {};
msg.data.room.roomcode = roomcode;
msg.data.room.roomtype = o_match.roomtype;
msg.data.room.needroomcard = needroomcard;
msg.data.room.asetcount = asetcount;
msg.data.room.infinite = 0;
msg.data.room.roommode = roommode;
msg.data.room.beanfloor = beanfloor;
msg.data.room.beanmult = beanmult;
msg.data.room.needprepare = needprepare;
msg.data.room.advanced_type= 0;
msg.data.room.advanced_teabean = 0;
msg.data.room.match_id = o_match.id;
msg.data.room.match_idx = o_match.idx;
if (o_roomserver.server == o_agent.server){
//房间服务器与代理商服务器是同一地址
var roomserver_data = youle_agent.app.youle_room[msg.rpc](msg);
//返回数据
if (roomserver_data.data.state == 0){
//加入房间成功
o_gameinfo.roomcode = roomcode;
delete o_gameinfo.matchid;
delete o_gameinfo.matchidx;
playercount = playercount + 1;
playerbeansum = playerbeansum + o_player.bean;
playeridlist.push(o_player.playerid);
playernamelist.push(o_player.nickname);
playeravatarlist.push(o_player.avatar);
var pack = {};
pack.ip = o_gameinfo.match_ip;
pack.conmode = o_gameinfo.match_conmode;
pack.fromid = o_gameinfo.match_fromid;
pack.app = "youle";
pack.route = "agent";
pack.rpc = "create_room";
pack.data = roomserver_data.data;
pack.data.matchid = o_match.id;
pack.data.matchidx = o_match.idx;
youle_agent.app.SendPack(pack);
var _roomsvr_agent = youle_room.agents.method.find_agent(o_agent.agentid);
var _roomsvr_game = _roomsvr_agent.method.find_game(o_game.gameid);
_roomsvr_room = _roomsvr_game.method.find_room(roomcode);
}
}
}
}
}
}
o_match.playerlist.splice(idx, 1);
} else {
o_match.playerlist.splice(idx, 1);
}
} else {
//加入机器人
var robot_playerid = null;
for (var j = 1; j < 10; j++) {
robot_playerid = min_random(200000, 899999);
if (min_ary_indexof(playeridlist, robot_playerid) > -1){
robot_playerid = null;
} else {
break;
}
}
if (robot_playerid == null){
return;
}
var idx
var robot_nickname = null;
for (var j = 1; j < 10; j++) {
idx = min_random(0, o_agent.robot_nicknamelist.length - 1);
robot_nickname = o_agent.robot_nicknamelist[idx];
if (min_ary_indexof(playernamelist, robot_nickname) > -1){
robot_nickname = null;
} else {
break;
}
}
if (robot_nickname == null){
return;
}
var robot_avatar = null;
for (var j = 1; j < 10; j++) {
idx = min_random(0, o_agent.robot_avatarlist.length - 1);
robot_avatar = o_agent.robot_avatarlist[idx];
if (min_ary_indexof(playeravatarlist, robot_avatar) > -1){
robot_avatar = null;
} else {
break;
}
}
if (robot_avatar == null){
return;
}
var robot_sex = min_random(1, 2);
var robot_ip = min_random(10, 240) + "." + min_random(10, 240) + "." + min_random(10, 240) + "." + min_random(10, 240);
var robot_bean = parseInt(playerbeansum / playercount) + min_random(100, 3000);
if (!robot_bean){
robot_bean = 0;
}
var o_robot = cls_youle_room_player.new(robot_playerid, robot_nickname, robot_avatar, robot_sex, 0, robot_ip, 0, null, null);
o_robot.bean = robot_bean;
o_robot.isrobot = 1;
for (var j = 0; j < _roomsvr_room.seatlist.length; j++) {
if (!_roomsvr_room.seatlist[j]){
// console.log(_roomsvr_room.roomcode + "比赛场加入机器人" + robot_playerid);
o_robot.method.enter_room(_roomsvr_room, j, 0);
if (_roomsvr_room.battlestate){
youle_room.import.player_enter(_roomsvr_room, j);
}
youle_room.return.self_join_room({}, o_robot, robot_bean);
playeridlist.push(o_robot.playerid);
playernamelist.push(o_robot.nickname);
playeravatarlist.push(o_robot.avatar);
if (_roomsvr_room.needprepare){
(function(){
var o_robot2 = o_robot;
o_robot2.tmr_prepare = min_ontimeout(
function(){
if (!o_robot2.gameinfo.isprepare){
var pack = {};
pack.app = "youle";
pack.route = "room";
pack.rpc = "player_prepare";
pack.data = {};
pack.data.agentid = o_robot2.gameinfo.o_room.o_game.o_agent.agentid;
pack.data.playerid = o_robot2.playerid;
pack.data.gameid = o_robot2.gameinfo.o_room.o_game.gameid;
pack.data.roomcode = o_robot2.gameinfo.o_room.roomcode;
youle_room.player_prepare(pack);
}
}, min_random(2000, 4000));
})(o_robot);
}
break;
}
}
}
}
}
}
if ((new Date()).getTime() >= (new Date(o_match.beginTime)).getTime() &&
(new Date()).getTime() <= (new Date(o_match.endTime)).getTime()){
if (!o_match.isstart){
if (o_match.playerlist.length >= o_match.playercount || o_match.haverobot == 1){
do_start();
o_match.isstart = 1;
}
} else {
if (o_match.playerlist.length >= o_match.playercount2 || o_match.haverobot == 1){
do_start();
}
}
} else if ((new Date()).getTime() > (new Date(o_match.endTime)).getTime()){
cls_youle_room_backup.deletebackup_match(o_match);
min_closetime(o_match.timer_start);
if (o_match.timer_add_sysgrade){
min_closetime(o_match.timer_add_sysgrade);
}
if (o_match.ranklist.length > 0){
var ary_playerid = "";
var ary_nickname = "";
var ary_avatar = "";
var ary_roomcode = "";
var ary_overtime = "";
var ary_grade = "";
var ary_isrobot = "";
for (var i = 0; i < o_match.ranklist.length; i++) {
if (i == 0){
ary_playerid = o_match.ranklist[i].playerid;
ary_nickname = o_match.ranklist[i].nickname;
ary_avatar = o_match.ranklist[i].avatar;
ary_roomcode = o_match.ranklist[i].roomcode;
ary_overtime = o_match.ranklist[i].overtime;
ary_grade = o_match.ranklist[i].grade;
ary_isrobot = o_match.ranklist[i].isr;
} else {
ary_playerid = ary_playerid + "," + o_match.ranklist[i].playerid;
ary_nickname = ary_nickname + "," + o_match.ranklist[i].nickname;
ary_avatar = ary_avatar + "," + o_match.ranklist[i].avatar;
ary_roomcode = ary_roomcode + "," + o_match.ranklist[i].roomcode;
ary_overtime = ary_overtime + "," + o_match.ranklist[i].overtime;
ary_grade = ary_grade + "," + o_match.ranklist[i].grade;
ary_isrobot = ary_isrobot + "," + o_match.ranklist[i].isr;
}
};
var sql = "call cp_game_save_matchranking(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);";
youle_room.mysql_grade.execsql("execsql", sql, [o_agent.agentid, o_game.gameid, o_match.id, o_match.idx, o_match.matchname, o_match.beginTime, o_match.endTime, JSON.stringify(o_match.roomtype), o_match.imageurl, o_match.playercount, o_match.playercount2, o_match.bean, o_match.roomcard, o_match.topcount, o_match.circulation, o_match.interval, o_match.gradename, o_match.memo1, o_match.memo2, o_match.memo3, JSON.stringify(o_match.ranklist), ary_playerid, ary_nickname, ary_avatar, ary_roomcode, ary_overtime, ary_grade, ary_isrobot]);
}
var idx = min_ary_indexof(o_match.o_matchlist.list, o_match.id, "id");
if (idx > -1){
o_match.o_matchlist.list.splice(idx, 1);
}
}
},
//随机上一个系统成绩
add_sysgrade: function(o_match){
if (o_match.sysgrade && o_match.sysgrade.length > 0){
var robot_playerid = null;
for (var j = 1; j < 10; j++) {
robot_playerid = min_random(200000, 899999);
if (min_ary_indexof(o_match.ranklist, robot_playerid, "playerid") > -1){
robot_playerid = null;
} else {
break;
}
}
if (robot_playerid == null){
return;
}
var o_agent = o_match.o_game.o_agent;
var robot_nickname = null;
for (var j = 1; j < 10; j++) {
var idx = min_random(0, o_agent.robot_nicknamelist.length - 1);
robot_nickname = o_agent.robot_nicknamelist[idx];
if (min_ary_indexof(o_match.ranklist, robot_nickname, "nickname") > -1){
robot_nickname = null;
} else {
break;
}
}
if (robot_nickname == null){
return;
}
var robot_avatar = null;
for (var j = 1; j < 10; j++) {
var idx = min_random(0, o_agent.robot_avatarlist.length - 1);
robot_avatar = o_agent.robot_avatarlist[idx];
if (min_ary_indexof(o_match.ranklist, robot_avatar, "avatar") > -1){
robot_avatar = null;
} else {
break;
}
}
if (robot_avatar == null){
return;
}
var rand = min_random(0, o_match.sysgrade.length - 1);
var robot_grade = min_random(o_match.sysgrade[rand].min, o_match.sysgrade[rand].max);
var o_sysplayer = {};
o_sysplayer.playerid = robot_playerid;
o_sysplayer.nickname = robot_nickname;
o_sysplayer.avatar = robot_avatar;
o_sysplayer.roomcode = min_random(100000, 999999);
o_sysplayer.overtime = min_now();
o_sysplayer.grade = robot_grade;
o_sysplayer.isr = 2;
var isfound = false;
for (var j = 0; j < o_match.ranklist.length; j++) {
if (o_sysplayer.grade > o_match.ranklist[j].grade){
o_match.ranklist.splice(j, 0, o_sysplayer);
if (o_match.ranklist.length > parseInt(o_match.topcount)){
o_match.ranklist.length = parseInt(o_match.topcount);
}
isfound = true;
break;
}
}
if (!isfound){
if (o_match.ranklist.length < parseInt(o_match.topcount)){
o_match.ranklist.push(o_sysplayer);
}
}
o_match.sysgrade[rand].count = o_match.sysgrade[rand].count - 1;
if (o_match.sysgrade[rand].count == 0){
o_match.sysgrade.splice(rand, 1);
}
cls_youle_room_backup.backup_match(o_match);
if (o_match.sysgrade.length == 0){
if (o_match.timer_add_sysgrade){
min_closetime(o_match.timer_add_sysgrade);
o_match.timer_add_sysgrad = null;
}
}
}
},
//开启系统成绩定时器
start_add_sysgrade_timer: function(o_match){
if (o_match.sysgrade && !o_match.timer_add_sysgrade){
var sum_count = 0;
for (var i = 0; i < o_match.sysgrade.length; i++) {
sum_count = sum_count + o_match.sysgrade[i].count;
};
var interval = (new Date(o_match.endTime)).getTime() - (new Date()).getTime();
if (interval > 0 && sum_count > 0){
interval = parseInt(interval / sum_count);
o_match.timer_add_sysgrade = min_ontime(o_match.method.add_sysgrade, interval);
}
}
}
}
///////////////////////////////////////////////////////////////
/////////// cls_youle_agent_matchlist: 比赛列表 //////////
///////////////////////////////////////////////////////////////
var cls_youle_agent_matchlist = cls_youle_agent_matchlist || {
//构造函数
new: function(o_game) {
var matchlist = {};
matchlist.o_game = o_game;
matchlist.list = [];
matchlist.method = {};
//载入一个比赛
matchlist.method.load_match = function(o_setting){
return cls_youle_agent_matchlist.load_match(matchlist, o_setting);
};
//查找一个比赛
matchlist.method.find_match = function(id, idx){
return cls_youle_agent_matchlist.find_match(matchlist, id, idx);
};
return matchlist;
},
//载入一个比赛
load_match: function(o_matchlist, o_setting){
var o_match;
var idx = min_ary_indexof(o_matchlist.list, o_setting.id, "id");
if (idx == -1) {
o_match = cls_youle_agent_match.new(o_matchlist.o_game, o_matchlist, o_setting);
if (o_match){
o_matchlist.list.push(o_match);
}
} else {
o_match = o_matchlist.list[idx];
}
return o_match;
},
//查找一个比赛
find_match: function(o_matchlist, id, idx){
var i = min_ary_indexof(o_matchlist.list, id, "id");
if (i > -1){
if (o_matchlist.list[i].idx == idx){
return o_matchlist.list[i];
}
}
return null;
}
}

412
codes/games/backstage/youle/server_agent/class.player.js Normal file
View File

@@ -0,0 +1,412 @@
///////////////////////////////////////////////////
///////// cls_youle_agent_player: 玩家 /////////
///////////////////////////////////////////////////
var cls_youle_agent_player = cls_youle_agent_player || {
//构造函数
new: function(o_agent, playerid, roomcard, bean, openid, unionid, nickname, avatar, sex, playertype, invitecode) {
var player = {};
//基本信息
player.o_agent = o_agent; //代理商
player.playerid = playerid; //玩家id
player.roomcard = roomcard; //房卡数量
player.bean = bean; //星星数量
player.openid = openid;
player.unionid = unionid;
player.nickname = nickname;
player.avatar = avatar;
player.sex = sex;
player.playertype = playertype; //0:普通用户 1:vip开房不扣房卡
player.invitecode = invitecode; //绑定的邀请码
player.freetimer = null; //释放玩家的定时器
//登录的游戏列表
player.gameinfo = [];
//方法
player.method = {};
//登录游戏
player.method.login_game = function(o_game, ip, conmode, fromid, machineid, machineroom){
cls_youle_agent_player.login_game(player, o_game, ip, conmode, fromid, machineid, machineroom);
}
//获取玩家某个游戏的游戏信息
player.method.get_gameinfo = function(o_game){
return cls_youle_agent_player.get_gameinfo(player, o_game);
}
//修改玩家房卡数量
player.method.update_roomcard = function(type, newroomcrad, change, memo){
cls_youle_agent_player.update_roomcard(player, type, newroomcrad, change, memo);
}
//修改玩家豆豆数量
player.method.update_bean = function(type, newbean, change, push, showrebate){
cls_youle_agent_player.update_bean(player, type, newbean, change, push, showrebate);
}
//打开释放玩家的定时器
player.method.open_free_timer = function(){
cls_youle_agent_player.open_free_timer(player);
}
//关闭释放玩家的定时器
player.method.close_free_timer = function(){
cls_youle_agent_player.close_free_timer(player);
}
return player;
},
//登录游戏
login_game: function(o_player, o_game, ip, conmode, fromid, machineid, machineroom){
if (o_player.gameinfo.length <= o_game.idx) {
o_player.gameinfo.length = o_game.idx + 1;
}
var _game_info = o_player.gameinfo[o_game.idx];
if (!_game_info){
//初始化游戏信息
_game_info = {};
_game_info.conmode = conmode;
_game_info.fromid = fromid;
_game_info.fromidtime = (new Date()).getTime();
_game_info.ip = ip;
_game_info.machineid = machineid;
_game_info.machineroom = machineroom;
_game_info.roomcode = null;
o_player.gameinfo[o_game.idx] = _game_info;
//统计在线玩家数
o_game.method.online_p_chang(1);
} else {
//踢原有连接下线
// if (fromid && o_game.gameid != "G2hw0ubng0zcoI0r4mx3H2yr4GejidwO"){
if (fromid){
if (_game_info.conmode == "tcp" && _game_info.fromid && _game_info.fromid != fromid){
var msg = {};
msg.app = youle_agent.app.appname;
msg.route = youle_agent.routename;
msg.rpc = "kick_offline";
msg.conmode = _game_info.conmode;
msg.fromid = _game_info.fromid;
msg.data={};
msg.data.fromOther = 0;
youle_agent.app.SendPack(msg);
//测试用
// var agent_kick_offline = {};
// agent_kick_offline.agentid = o_game.o_agent.agentid;
// agent_kick_offline.gameid = o_game.gameid;
// agent_kick_offline.playerid = o_player.playerid;
// agent_kick_offline.oldfromid = _game_info.fromid;
// agent_kick_offline.oldtime = _game_info.fromidtime;
// agent_kick_offline.oldmachineid = _game_info.machineid;
// agent_kick_offline.oldmachineroom = _game_info.machineroom;
// agent_kick_offline.newfromid = fromid;
// agent_kick_offline.newtime = (new Date()).getTime();
// agent_kick_offline.newmachineid = machineid;
// agent_kick_offline.newmachineroom = machineroom;
// console.log(min_now() + " agentserver kick_offline");
// console.log(agent_kick_offline);
}
//更新游戏信息
_game_info.conmode = conmode;
_game_info.fromid = fromid;
_game_info.fromidtime = (new Date()).getTime();
_game_info.ip = ip;
}
}
//更新tcp连接列表
if (conmode == "tcp"){
youle_agent.tcps.method.load_tcp(fromid, o_player, o_game.idx);
}
},
//获取玩家某个游戏的游戏信息
get_gameinfo: function(o_player, o_game){
if (o_player.gameinfo.length <= o_game.idx){
return null;
}
return o_player.gameinfo[o_game.idx];
},
//修改玩家房卡数量
update_roomcard: function(o_player, type, newroomcard, change, memo){
var roomCardName = youle_agent.app.youle_platform.config.method.get_paravalue("roomCardName", o_player.o_agent.agentid);
if (!roomCardName){
roomCardName = "房卡";
}
o_player.roomcard = newroomcard;
//通知游戏前端
for (var i = 0; i < o_player.gameinfo.length; i++) {
var _game_info = o_player.gameinfo[i];
if (_game_info){
if (_game_info.roomcode){
//获取房号对应的房间服务器地址
var o_game = o_player.o_agent.games[i];
if (!o_game) {
continue;
}
var o_roomserver = o_game.method.get_roomserver(_game_info.roomcode);
//通过房间服务器发送修改房卡的消息
var msg = {};
msg.app = youle_agent.app.appname;
msg.route = youle_agent.app.youle_room.routename;
msg.rpc = "update_roomcard";
msg.data = {};
msg.data.agentid = o_player.o_agent.agentid;
msg.data.playerid = o_player.playerid;
msg.data.gameid = o_game.gameid;
msg.data.roomcode = _game_info.roomcode;
msg.data.roomcard = newroomcard;
// msg.data.type = type;
// msg.data.change = change;
switch(type){
case 0:
msg.data.text = "扣除" + roomCardName + "：" + change;
if (memo){
msg.data.text = memo + msg.data.text;
}
break;
case 1:
msg.data.text = "购买" + roomCardName + "：" + change;
break;
case 2:
msg.data.text = roomCardName + "充值：" + change;
break;
case 3:
msg.data.text = "领取" + roomCardName + "奖励：" + change;
break;
case 4:
msg.data.text = "修改" + roomCardName + "：" + change;
break;
}
if (o_roomserver.server == o_player.o_agent.server){
//房间服务器与代理商服务器是同一地址
youle_agent.app.youle_room[msg.rpc](msg);
msg.data.issameserver = 1;
} else {
//房间服务器与代理商服务器不是同一地址
msg.data.issameserver = 0;
var cfg = {};
cfg.url = "http://" + o_roomserver.server + ":" + o_roomserver.httpport + "/index.html";
cfg.type = "POST";
cfg.data = JSON.stringify(msg);
cfg.success = function(str){};
cfg.error = function(str){};
min_http(cfg);
}
} else if (_game_info.conmode && _game_info.fromid){
var msg = {};
msg.app = youle_agent.app.appname;
msg.route = youle_agent.routename;
msg.rpc = "update_roomcard";
msg.conmode = _game_info.conmode;
msg.fromid = _game_info.fromid;
msg.data = {};
msg.data.roomcard = newroomcard;
// msg.data.type = type;
// msg.data.change = change;
switch(type){
case 0:
msg.data.text = "扣除" + roomCardName + "：" + change;
if (memo){
msg.data.text = memo + msg.data.text;
}
break;
case 1:
msg.data.text = "购买" + roomCardName + "：" + change;
break;
case 2:
msg.data.text = roomCardName + "充值：" + change;
break;
case 3:
msg.data.text = "领取" + roomCardName + "奖励：" + change;
break;
case 4:
msg.data.text = "修改" + roomCardName + "：" + change;
break;
}
youle_agent.app.SendPack(msg);
}
}
}
},
//修改玩家豆豆数量
update_bean: function(o_player, type, newbean, change, push, showrebate){
o_player.bean = parseInt(newbean);
var starName = youle_agent.app.youle_platform.config.method.get_paravalue("starName", o_player.o_agent.agentid);
if (!starName){
starName = "星星";
}
//通知游戏前端
for (var i = 0; i < o_player.gameinfo.length; i++) {
var _game_info = o_player.gameinfo[i];
if (_game_info){
if (_game_info.roomcode){
//获取房号对应的房间服务器地址
var o_game = o_player.o_agent.games[i];
var o_roomserver = o_game.method.get_roomserver(_game_info.roomcode);
//通过房间服务器发送修改星星的消息
var msg = {};
msg.app = youle_agent.app.appname;
msg.route = youle_agent.app.youle_room.routename;
msg.rpc = "update_bean";
msg.data = {};
msg.data.agentid = o_player.o_agent.agentid;
msg.data.playerid = o_player.playerid;
msg.data.gameid = o_game.gameid;
msg.data.roomcode = _game_info.roomcode;
msg.data.bean = parseInt(newbean);
msg.data.type = type;
switch(type){
case 0: //游戏输赢豆豆
var _text = "";
if (!showrebate){
if (change > 0){
_text = "游戏赢取" + starName + "：" + change;
} else if (change < 0) {
_text = "游戏扣除" + starName + "：" + change;
}
var _showrebate_setting = youle_agent.app.youle_platform.config.method.get_paravalue("shieldShowRebate", o_player.o_agent.agentid);
if (!_showrebate_setting){
if (push > 0){
_text = _text + " 获取" + starName + "房间费：" + push;
} else if (push < 0) {
_text = _text + " 扣除" + starName + "房间费：" + push;
}
}
} else if (showrebate == 1){
if (change + push > 0){
_text = "游戏赢取" + starName + "：" + (change + push);
} else if (change + push < 0) {
_text = "游戏扣除" + starName + "：" + (change + push);
}
} else if (showrebate == 2){
var _showrebate_setting = youle_agent.app.youle_platform.config.method.get_paravalue("shieldShowRebate", o_player.o_agent.agentid);
if (!_showrebate_setting){
if(push){
_text = "扣除房间费：" + push + starName;
}
}
}
msg.data.text = _text;
break;
case 1:
msg.data.text = "购买" + starName + "：" + change;
break;
case 2:
msg.data.text = starName + "充值：" + change;
break;
case 3:
break;
case 4:
// msg.data.text = "扣除发送系统消息费用：" + change + starName;
msg.data.text="";
break;
case 5:
msg.data.text = "扣除比赛报名费用：" + push + starName;
break;
//需要语音提示的房主抽成金币到账
case 6:
//msg.data.text = "扣除比赛报名费用：" + push + starName;
break;
}
if (o_roomserver.server == o_player.o_agent.server){
//房间服务器与代理商服务器是同一地址
youle_agent.app.youle_room[msg.rpc](msg);
} else {
//房间服务器与代理商服务器不是同一地址
var cfg = {};
cfg.url = "http://" + o_roomserver.server + ":" + o_roomserver.httpport + "/index.html";
cfg.type = "POST";
cfg.data = JSON.stringify(msg);
cfg.success = function(str){};
cfg.error = function(str){};
min_http(cfg);
}
} else if (_game_info.conmode && _game_info.fromid){
var msg = {};
msg.app = youle_agent.app.appname;
msg.route = youle_agent.routename;
msg.rpc = "update_bean";
msg.conmode = _game_info.conmode;
msg.fromid = _game_info.fromid;
msg.data = {};
msg.data.bean = parseInt(newbean);
msg.data.type=type;
switch(type){
case 0: //游戏输赢豆豆
var _text = "";
if (!showrebate){
if (change > 0){
_text = "游戏赢取" + starName + "：" + change;
} else if (change < 0) {
_text = "游戏扣除" + starName + "：" + change;
}
var _showrebate_setting = youle_agent.app.youle_platform.config.method.get_paravalue("shieldShowRebate", o_player.o_agent.agentid);
if(!_showrebate_setting){
if (push > 0){
_text = _text + " 获取" + starName + "房间费：" + push;
} else if (push < 0) {
_text = _text + " 扣除" + starName + "房间费：" + push;
}
}
} else if (showrebate == 1){
if (change + push > 0){
_text = "游戏赢取" + starName + "：" + (change + push);
} else if (change + push < 0) {
_text = "游戏扣除" + starName + "：" + (change + push);
}
} else if (showrebate == 2){
var _showrebate_setting = youle_agent.app.youle_platform.config.method.get_paravalue("shieldShowRebate", o_player.o_agent.agentid);
if (!_showrebate_setting){
if(push){
_text = "扣除房间费：" + push + starName;
}
}
}
msg.data.text = _text;
break;
case 1:
msg.data.text = "购买" + starName + "：" + change;
break;
case 2:
msg.data.text = starName + "充值：" + change;
break;
case 3:
msg.data.text = "领取" + starName +"奖励：" + change;
break;
}
youle_agent.app.SendPack(msg);
}
}
}
},
//打开释放玩家的定时器
open_free_timer: function(o_player){
var do_freeplayer = function(){
o_player.freetimer = null;
o_player.o_agent.players[o_player.playerid - 100001] = null;
}
if (!o_player.advanced){
//4小时后释放玩家
o_player.freetimer = min_ontimeout(do_freeplayer, 7 * 24 * 60 * 60 * 1000);
}
},
//关闭释放玩家的定时器
close_free_timer: function(o_player){
if (o_player.freetimer){
min_closetime(o_player.freetimer);
o_player.freetimer = null;
}
}
}

120
codes/games/backstage/youle/server_agent/class.tcplist.js Normal file
View File

@@ -0,0 +1,120 @@
///////////////////////////////////////////////////
//////////////cls_youle_agent_tcplist: tcp连接列表类///////////
///////////////////////////////////////////////////
var cls_youle_agent_tcplist = cls_youle_agent_tcplist || {
new: function() {
var tcplist = {};
tcplist.list = [];
//方法
tcplist.method = {};
//载入tcp连接
tcplist.method.load_tcp = function(str_tcpid, o_player, gameidx){
return cls_youle_agent_tcplist.load_tcp(tcplist, str_tcpid, o_player, gameidx);
}
//查找tcp连接
tcplist.method.find_tcp = function(str_tcpid){
return cls_youle_agent_tcplist.find_tcp(tcplist, str_tcpid);
}
//删除tcp连接
tcplist.method.delete_tcp = function(str_tcpid){
return cls_youle_agent_tcplist.delete_tcp(tcplist, str_tcpid);
}
return tcplist;
},
//载入tcp连接
load_tcp: function(o_tcplsit, str_tcpid, o_player, gameidx){
var idx = cls_youle_agent_tcplist.aryidx(str_tcpid);
if (idx == -1){
return null;
}
if (o_tcplsit.list.length <= idx){
o_tcplsit.list.length = idx + 1;
}
var old_tcp = o_tcplsit.list[idx];
if (old_tcp){
var _player = old_tcp.o_player;
if (_player.playerid != o_player.playerid){
var _gameidx = old_tcp.gameidx;
if (_player.gameinfo[_gameidx]){
if (_player.gameinfo[_gameidx].roomcode){
_player.gameinfo[_gameidx].ip = null;
_player.gameinfo[_gameidx].conmode = null;
_player.gameinfo[_gameidx].fromid = null;
} else {
//如果不在房间内
_player.gameinfo[_gameidx] = null;
//判断是否要释放玩家
var freeflag = true;
for (var m = 0; m < _player.gameinfo.length; m++) {
if (_player.gameinfo[m]){
freeflag = false;
break;
}
}
if (freeflag){
// _player.o_agent.players[_player.playerid - 100001] = null;
_player.method.open_free_timer();
}
//统计在线玩家数
var o_game = _player.o_agent.games[_gameidx];
if (o_game){
o_game.method.online_p_chang(-1);
}
}
}
}
}
var new_tcp = {};
new_tcp.tcpid = str_tcpid;
new_tcp.o_player = o_player;
new_tcp.gameidx = gameidx;
o_tcplsit.list[idx] = new_tcp;
o_player.method.close_free_timer();
return new_tcp;
},
//查找tcp连接
find_tcp: function(o_tcplsit, str_tcpid){
var idx = cls_youle_agent_tcplist.aryidx(str_tcpid);
if (idx == -1){
return null;
}
if (o_tcplsit.list.length <= idx){
return null;
}
return o_tcplsit.list[idx];
},
//删除tcp连接
delete_tcp: function(o_tcplsit, str_tcpid){
var idx = cls_youle_agent_tcplist.aryidx(str_tcpid);
if (idx == -1){
return;
}
if (o_tcplsit.list.length <= idx){
return;
}
o_tcplsit.list[idx] = null;
},
//计算tcp连接的数组下标
aryidx: function(str_tcpid){
var idx = parseInt(str_tcpid.replace("tcp_", ""));
if (isNaN(idx)){
return -1;
}
return idx - 10000;
}
}
//tcp连接列表
youle_agent.tcps = cls_youle_agent_tcplist.new();

854
codes/games/backstage/youle/server_agent/mod.js Normal file
View File

@@ -0,0 +1,854 @@
//////////////////////////////////////////////////////////////////
//////////////////////////游戏平台服务器//////////////////////////
//////////////////////////////////////////////////////////////////
//rpc
min_loadJsFile("youle/server_agent/rpc.js", function(){
//tcp连接
min_loadJsFile("youle/server_agent/class.tcplist.js", function(){
//运营商
min_loadJsFile("youle/server_agent/class.agent.js", function(){
//游戏
min_loadJsFile("youle/server_agent/class.game.js", function(){
//玩家
min_loadJsFile("youle/server_agent/class.player.js", function(){
//比赛
min_loadJsFile("youle/server_agent/class.match.js", function(){
//对内的输入接口类
min_loadJsFile("youle/server_agent/class.import.js", function(){
//对内的输出接口类
min_loadJsFile("youle/server_agent/class.export.js", function(){
});
});
});
});
});
});
});
});
var youle_agent = youle_agent || cls_mod.new("youle_agent", "agent", youle_app);
//运营商列表
youle_agent.agents = null;
//tcp连接
youle_agent.tcps = null;
//mysql操作类
youle_agent.mysql = cls_mysql.new("http://ylyxdata.daoqi88.cn/mysql.php", youle_agent.app.SendPack);
youle_agent.mysql_grade = cls_mysql.new("http://ylyxdata.daoqi88.cn/mysql_grade.php", youle_agent.app.SendPack);
youle_agent.mysql_agent = cls_mysql.new("http://ylyxdata.daoqi88.cn/mysql_agent.php", youle_agent.app.SendPack);
//对内的输入接口类（需要的外部接口）
youle_agent.import = null;
//对内输出接口
youle_agent.export = null;
//比赛
youle_agent.matchs = [];
//服务器id
youle_agent.youleid = min_randomChar(32);
//手机验证码列表
youle_agent.phonecodes = [];
var blacknamelist = [
"oLVKis2bsKkiHY1435uNiBwJaz7w",
"oLVKisy7GuH1C4emgrF8A2FVcumk", //112475，00bA05haB0d9ZC0fwGD09Q2OA30insbQ，薄情少年葬空城
"oLVKis_nxA6uXlHvUaFK-73WZZms", //111771，00bA05haB0d9ZC0fwGD09Q2OA30insbQ，古月
"oLVKiszvCtvX02MbiWYZju2ilb4s", //112289，00bA05haB0d9ZC0fwGD09Q2OA30insbQ，么么哒
"oLVKisx4CHjrLLNyaffo3kPmfejo", //113119，00bA05haB0d9ZC0fwGD09Q2OA30insbQ，情售.!
"oLVKisy9uOS-VRWNEt1gaPrZuIhI", //114204，00bA05haB0d9ZC0fwGD09Q2OA30insbQ，痛彻心扉
"oLVKis-lZIxgdWSmMeBTCmB6IyD8", //113790，00bA05haB0d9ZC0fwGD09Q2OA30insbQ，百合
"oLVKis5ctLEyEYn3_2l0e0QGtM0A", //114522，00bA05haB0d9ZC0fwGD09Q2OA30insbQ，饿了又胖了
"oLVKis3LxiKbR5TopsKwUagsOqcQ" //114248，00bA05haB0d9ZC0fwGD09Q2OA30insbQ，奔波儿霸
];
//获取星星争霸场玩家房间数量
youle_agent.get_share_room_count = 50;
// //代理后台2.0接口输出日志标志
// youle_agent.showlog_readdata = 0;
// //代理后台2.0接口定时器
// youle_agent.readdata_timer = min_ontime(
// function(){
// //充房卡充星星
// var update_gamedb_roomcard = function(agentid, playerid, changeroomcard, changebean, opttype, optid){
// var db_callback_game1 = function(dbdata){
// if (dbdata[0].result == 0){
// var log = {};
// switch(parseInt(opttype)){
// case 1: //购买房卡
// youle_agent.export.buy_topup(agentid, playerid, 1, parseInt(dbdata[0].play_roomcard), changeroomcard);
// log.m = "玩家购卡成功";
// break;
// case 2: //代理转卡
// youle_agent.export.buy_topup(agentid, playerid, 2, parseInt(dbdata[0].play_roomcard), changeroomcard);
// log.m = "代理充卡成功";
// break;
// case 3: //索要房卡
// youle_agent.export.buy_topup(agentid, playerid, 2, parseInt(dbdata[0].play_roomcard), changeroomcard);
// log.m = "玩家索卡成功";
// break;
// case 11: //购买星星
// youle_agent.export.buy_topup_bean(agentid, playerid, 1, parseInt(dbdata[0].play_bean), changebean);
// log.m = "玩家购买星星成功";
// break;
// case 12: //代理转星星
// youle_agent.export.buy_topup_bean(agentid, playerid, 2, parseInt(dbdata[0].play_bean), changebean);
// log.m = "代理充值星星成功";
// break;
// case 13: //索要星星
// youle_agent.export.buy_topup_bean(agentid, playerid, 2, parseInt(dbdata[0].play_bean), changebean);
// log.m = "玩家索要星星成功";
// break;
// }
// log.id = optid;
// log.type = opttype;
// log.agentid = agentid;
// log.playerid = playerid;
// log.changeroomcard = changeroomcard;
// log.changebean = changebean;
// log.newroomcard = dbdata[0].play_roomcard;
// log.newbean = dbdata[0].play_bean;
// log.time = min_now();
// if (youle_agent.showlog_readdata){
// console.log(log);
// }
// var sql_agent = "update ct_user_process_log set is_process = is_process + 1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// if (youle_agent.showlog_readdata){
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:1");
// }
// });
// } else {
// var log = {};
// switch(parseInt(opttype)){
// case 1: //购买房卡
// log.m = "玩家购卡失败";
// break;
// case 2: //代理转卡
// log.m = "代理充卡失败";
// break;
// case 3: //索要房卡
// log.m = "玩家索卡失败";
// break;
// case 11: //购买星星
// log.m = "玩家购买星星失败";
// break;
// case 12: //代理转星星
// log.m = "代理充值星星失败";
// break;
// case 13: //索要星星
// log.m = "玩家索要星星失败";
// break;
// }
// log.id = optid;
// log.type = opttype;
// log.agentid = agentid;
// log.playerid = playerid;
// log.changeroomcard = changeroomcard;
// log.changebean = changebean;
// log.time = min_now();
// log.dbdata = dbdata;
// console.log(log);
// var sql_agent = "update ct_user_process_log set is_process = -1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:-1");
// });
// }
// }
// var sql_game = "call cp_sales2_player_topup(?,?,?,?)";
// youle_agent.mysql.execsql("opensql", sql_game, [agentid, playerid, changeroomcard, changebean], db_callback_game1);
// }
// //玩家绑定邀请码
// var update_gamedb_bindinginvitecode = function(agentid, unionid, invitecode, optid){
// var db_callback_game2 = function(dbdata){
// if (dbdata[0].result == 0){
// var log = {};
// log.m = "玩家绑定邀请码成功";
// log.id = optid;
// log.agentid = agentid;
// log.unionid = unionid;
// log.invitecode = invitecode;
// log.time = min_now();
// if (youle_agent.showlog_readdata){
// console.log(log);
// }
// var sql_agent = "update ct_user_process_log set is_process = is_process + 1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// if (youle_agent.showlog_readdata){
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:1");
// }
// });
// } else {
// var log = {};
// log.m = "玩家绑定邀请码失败";
// log.id = optid;
// log.agentid = agentid;
// log.unionid = unionid;
// log.invitecode = invitecode;
// log.time = min_now();
// log.dbdata = dbdata;
// console.log(log);
// var sql_agent = "update ct_user_process_log set is_process = -1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:-1");
// });
// }
// }
// var sql_game = "call cp_sales2_player_bindinginvitecode(?,?,?)";
// youle_agent.mysql.execsql("opensql", sql_game, [agentid, unionid, invitecode], db_callback_game2);
// }
// //新代理
// var update_gamedb_newsalesman = function(agentid, channelid, salesid, salesinfo, optid){
// var db_callback_game3 = function(dbdata){
// if (dbdata[0].result == 0){
// var log = {};
// log.m = "新增代理成功";
// log.id = optid;
// log.agentid = agentid;
// log.salesid = salesid;
// log.salesinfo = salesinfo;
// log.time = min_now();
// if (youle_agent.showlog_readdata){
// console.log(log);
// }
// var sql_agent = "update ct_user_process_log set is_process = is_process + 1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// if (youle_agent.showlog_readdata){
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:1");
// }
// });
// } else {
// var log = {};
// log.m = "新增代理失败";
// log.id = optid;
// log.agentid = agentid;
// log.salesid = salesid;
// log.salesinfo = salesinfo;
// log.time = min_now();
// log.dbdata = dbdata;
// console.log(log);
// var sql_agent = "update ct_user_process_log set is_process = -1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:-1");
// });
// }
// }
// var o_salesinfo = JSON.parse(salesinfo);
// var sql_game = "call cp_sales2_new_salesman(?,?,?,?,?,?,?,?,?,?)";
// youle_agent.mysql.execsql("opensql", sql_game, [agentid, channelid, o_salesinfo.openid, o_salesinfo.unionid, o_salesinfo.nickname, o_salesinfo.avatar, o_salesinfo.sex, o_salesinfo.province, o_salesinfo.city, salesid], db_callback_game3);
// }
// //封禁代理
// var update_gamedb_disabledsales = function(agentid, salesid, optid){
// var db_callback_game4 = function(dbdata){
// if (dbdata[0].result == 0){
// var log = {};
// log.m = "封禁代理成功";
// log.id = optid;
// log.agentid = agentid;
// log.salesid = salesid;
// log.time = min_now();
// if (youle_agent.showlog_readdata){
// console.log(log);
// }
// var sql_agent = "update ct_user_process_log set is_process = is_process + 1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// if (youle_agent.showlog_readdata){
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:1");
// }
// });
// } else {
// var log = {};
// log.m = "封禁代理失败";
// log.id = optid;
// log.agentid = agentid;
// log.salesid = salesid;
// log.time = min_now();
// log.dbdata = dbdata;
// console.log(log);
// var sql_agent = "update ct_user_process_log set is_process = -1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:-1");
// });
// }
// }
// var sql_game = "call cp_sales2_salesman_disabled(?,?)";
// youle_agent.mysql.execsql("opensql", sql_game, [agentid, salesid], db_callback_game4);
// }
// //解封代理
// var update_gamedb_abledsales = function(agentid, salesid, optid){
// var db_callback_game5 = function(dbdata){
// if (dbdata[0].result == 0){
// var log = {};
// log.m = "解封代理成功";
// log.id = optid;
// log.agentid = agentid;
// log.salesid = salesid;
// log.time = min_now();
// if (youle_agent.showlog_readdata){
// console.log(log);
// }
// var sql_agent = "update ct_user_process_log set is_process = is_process + 1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// if (youle_agent.showlog_readdata){
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:1");
// }
// });
// } else {
// var log = {};
// log.m = "解封代理失败";
// log.id = optid;
// log.agentid = agentid;
// log.salesid = salesid;
// log.time = min_now();
// log.dbdata = dbdata;
// console.log(log);
// var sql_agent = "update ct_user_process_log set is_process = -1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:-1");
// });
// }
// }
// var sql_game = "call cp_sales2_salesman_abled(?,?)";
// youle_agent.mysql.execsql("opensql", sql_game, [agentid, salesid], db_callback_game5);
// }
// //解绑代理
// var update_gamedb_disbinding_sales = function(agentid, salesid, optid){
// var db_callback_game6 = function(dbdata){
// if (dbdata[0].result == 0){
// var log = {};
// log.m = "解绑代理成功";
// log.id = optid;
// log.agentid = agentid;
// log.salesid = salesid;
// log.time = min_now();
// if (youle_agent.showlog_readdata){
// console.log(log);
// }
// var sql_agent = "update ct_user_process_log set is_process = is_process + 1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// if (youle_agent.showlog_readdata){
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:1");
// }
// });
// } else {
// var log = {};
// log.m = "解绑代理失败";
// log.id = optid;
// log.agentid = agentid;
// log.salesid = salesid;
// log.time = min_now();
// log.dbdata = dbdata;
// console.log(log);
// var sql_agent = "update ct_user_process_log set is_process = -1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:-1");
// });
// }
// }
// var sql_game = "call cp_sales2_disbinding_sales(?,?)";
// youle_agent.mysql.execsql("opensql", sql_game, [agentid, salesid], db_callback_game6);
// }
// //解绑玩家
// var update_gamedb_disbinding_player = function(agentid, playerid, optid){
// var db_callback_game7 = function(dbdata){
// if (dbdata[0].result == 0){
// var log = {};
// log.m = "解绑玩家成功";
// log.id = optid;
// log.agentid = agentid;
// log.playerid = playerid;
// log.time = min_now();
// if (youle_agent.showlog_readdata){
// console.log(log);
// }
// var _o_agent = youle_agent.agents.method.find_agent(agentid);
// if (_o_agent){
// _o_player = _o_agent.method.find_player(playerid);
// if (_o_player){
// _o_player.invitecode = null;
// }
// }
// var sql_agent = "update ct_user_process_log set is_process = is_process + 1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// if (youle_agent.showlog_readdata){
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:1");
// }
// });
// } else {
// var log = {};
// log.m = "解绑玩家失败";
// log.id = optid;
// log.agentid = agentid;
// log.playerid = playerid;
// log.time = min_now();
// log.dbdata = dbdata;
// console.log(log);
// var sql_agent = "update ct_user_process_log set is_process = -1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:-1");
// });
// }
// }
// var sql_game = "call cp_sales2_disbinding_player(?,?)";
// youle_agent.mysql.execsql("opensql", sql_game, [agentid, playerid], db_callback_game7);
// }
// //封禁玩家
// var update_gamedb_disabledplayer = function(agentid, playerid, optid){
// var db_callback_game8 = function(dbdata){
// if (dbdata[0].result == 0){
// var log = {};
// log.m = "封禁玩家成功";
// log.id = optid;
// log.agentid = agentid;
// log.playerid = playerid;
// log.time = min_now();
// if (youle_agent.showlog_readdata){
// console.log(log);
// }
// var _o_agent = youle_agent.agents.method.find_agent(agentid);
// if (_o_agent){
// _o_player = _o_agent.method.find_player(playerid);
// if (_o_player){
// _o_player.state = 1;
// }
// }
// var sql_agent = "update ct_user_process_log set is_process = is_process + 1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// if (youle_agent.showlog_readdata){
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:1");
// }
// });
// } else {
// var log = {};
// log.m = "封禁玩家失败";
// log.id = optid;
// log.agentid = agentid;
// log.playerid = playerid;
// log.time = min_now();
// log.dbdata = dbdata;
// console.log(log);
// var sql_agent = "update ct_user_process_log set is_process = -1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:-1");
// });
// }
// }
// var sql_game = "call cp_sales2_player_disabled(?,?)";
// youle_agent.mysql.execsql("opensql", sql_game, [agentid, playerid], db_callback_game8);
// }
// //解封玩家
// var update_gamedb_abledplayer = function(agentid, playerid, optid){
// var db_callback_game9 = function(dbdata){
// if (dbdata[0].result == 0){
// var log = {};
// log.m = "解封玩家成功";
// log.id = optid;
// log.agentid = agentid;
// log.playerid = playerid;
// log.time = min_now();
// if (youle_agent.showlog_readdata){
// console.log(log);
// }
// var _o_agent = youle_agent.agents.method.find_agent(agentid);
// if (_o_agent){
// _o_player = _o_agent.method.find_player(playerid);
// if (_o_player){
// _o_player.state = 0;
// }
// }
// var sql_agent = "update ct_user_process_log set is_process = is_process + 1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// if (youle_agent.showlog_readdata){
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:1");
// }
// });
// } else {
// var log = {};
// log.m = "解封玩家失败";
// log.id = optid;
// log.agentid = agentid;
// log.playerid = playerid;
// log.time = min_now();
// log.dbdata = dbdata;
// console.log(log);
// var sql_agent = "update ct_user_process_log set is_process = -1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:-1");
// });
// }
// }
// var sql_game = "call cp_sales2_player_abled(?,?)";
// youle_agent.mysql.execsql("opensql", sql_game, [agentid, playerid], db_callback_game9);
// }
// //开通高新选项
// var update_gamedb_advanced = function(agentid, playerid, shortcode, advanced, desone, destwo, optid){
// var db_callback_game10 = function(dbdata){
// if (dbdata[0].result == 0){
// var log = {};
// log.m = "设置玩家短号成功";
// log.id = optid;
// log.agentid = agentid;
// log.playerid = playerid;
// log.shortcode = shortcode;
// log.advanced = advanced;
// log.desone = desone;
// log.destwo = destwo;
// log.time = min_now();
// if (youle_agent.showlog_readdata){
// console.log(log);
// }
// var o_agent = youle_agent.agents.method.find_agent(agentid);
// if (o_agent) {
// var o_player = o_agent.method.find_player(playerid);
// if (o_player){
// if (o_player.shortcode){
// o_agent.shortcodes[o_player.shortcode] = null;
// }
// o_player.advanced = _advanced;
// o_player.shortcode = _shortcode;
// o_player.desone = desone;
// o_player.destwo = destwo;
// }
// if (o_agent.shortcodes[_shortcode]){
// var old_playerid = o_agent.shortcodes[_shortcode].playerid;
// if (old_playerid != playerid){
// var o_oldplayer = o_agent.method.find_player(old_playerid);
// if (o_oldplayer){
// o_oldplayer.advanced = 0;
// o_oldplayer.shortcode = null;
// o_oldplayer.roomcodes = [];
// o_oldplayer.desone = null;
// o_oldplayer.destwo = null;
// }
// }
// }
// var o_shortcode = {};
// o_shortcode.shortcode = _shortcode;
// o_shortcode.playerid = playerid;
// o_agent.shortcodes[_shortcode] = o_shortcode;
// }
// var sql_agent = "update ct_user_process_log set is_process = is_process + 1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// if (youle_agent.showlog_readdata){
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:1");
// }
// });
// } else {
// var log = {};
// log.m = "设置玩家短号失败";
// log.id = optid;
// log.agentid = agentid;
// log.playerid = playerid;
// log.shortcode = shortcode;
// log.advanced = advanced;
// log.time = min_now();
// log.dbdata = dbdata;
// console.log(log);
// var sql_agent = "update ct_user_process_log set is_process = -1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:-1");
// });
// }
// }
// var _shortcode = parseInt(shortcode);
// var _advanced = parseInt(advanced);
// var sql_game = "call cp_game_player_advanced(?,?,?,?,?,?)";
// youle_agent.mysql.execsql("opensql", sql_game, [agentid, playerid, _advanced, _shortcode, desone, destwo], db_callback_game10);
// }
// //设置短号白名单
// var update_gamedb_whitelist = function(agentid, playerid, whitelist, optid){
// var db_callback_game11 = function(dbdata){
// if (dbdata[0].result == 0){
// var log = {};
// log.m = "设置短号白名单成功";
// log.id = optid;
// log.agentid = agentid;
// log.playerid = playerid;
// log.whitelist = whitelist;
// log.time = min_now();
// if (youle_agent.showlog_readdata){
// console.log(log);
// }
// var o_agent = youle_agent.agents.method.find_agent(agentid);
// if (o_agent) {
// var o_player = o_agent.method.find_player(playerid);
// if (o_player){
// o_player.whitelist = whitelist;
// }
// }
// var sql_agent = "update ct_user_process_log set is_process = is_process + 1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// if (youle_agent.showlog_readdata){
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:1");
// }
// });
// } else {
// var log = {};
// log.m = "设置短号白名单失败";
// log.id = optid;
// log.agentid = agentid;
// log.playerid = playerid;
// log.whitelist = whitelist;
// log.time = min_now();
// log.dbdata = dbdata;
// console.log(log);
// var sql_agent = "update ct_user_process_log set is_process = -1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:-1");
// });
// }
// }
// var sql_game = "call cp_game_player_whitelist(?,?,?)";
// youle_agent.mysql.execsql("opensql", sql_game, [agentid, playerid, JSON.stringify(whitelist)], db_callback_game11);
// }
// //系统抽成
// var update_gamedb_coinrebate = function(agentid, mode1, set1, mode2, set2, optid){
// var db_callback_game12 = function(dbdata){
// if (dbdata[0].result == 0){
// var log = {};
// log.m = "设置星星场系统抽成成功";
// log.id = optid;
// log.agentid = agentid;
// log.mode1 = mode1;
// log.set1 = set1;
// log.mode2 = mode2;
// log.set2 = set2;
// log.time = min_now();
// if (youle_agent.showlog_readdata){
// console.log(log);
// }
// var o_agent = youle_agent.agents.method.find_agent(agentid);
// if (o_agent) {
// o_agent.rebate_mode1 = mode1;
// o_agent.rebate_set1 = set1;
// o_agent.rebate_mode2 = mode2;
// o_agent.rebate_set2 = set2;
// }
// var sql_agent = "update ct_user_process_log set is_process = is_process + 1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// if (youle_agent.showlog_readdata){
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:1");
// }
// });
// } else {
// var log = {};
// log.m = "设置星星场系统抽成失败";
// log.id = optid;
// log.agentid = agentid;
// log.mode1 = mode1;
// log.set1 = set1;
// log.mode2 = mode2;
// log.set2 = set2;
// log.time = min_now();
// log.dbdata = dbdata;
// console.log(log);
// var sql_agent = "update ct_user_process_log set is_process = -1 where id = ?";
// youle_agent.mysql_agent.execsql("execsql", sql_agent, [optid],
// function(){
// youle_agent.readdata_isdoing = 0;
// console.log(min_now() + "修改状态成功 optid:" + optid + ", is_process:-1");
// });
// }
// }
// var sql_game = "call cp_game_update_coinrebate(?,?,?,?,?)";
// youle_agent.mysql.execsql("opensql", sql_game, [agentid, mode1, set1, mode2, set2], db_callback_game12);
// }
// var db_callback_agent = function(dbdata){
// if (youle_agent.showlog_readdata){
// console.log(min_now() + "读取成功");
// console.log(dbdata);
// }
// for (var i = 0; i < dbdata.length; i++){
// try{
// var o_agent = youle_agent.agents.method.find_agent(dbdata[i].to_agent);
// if (!o_agent){
// continue;
// }
// if (!o_agent.playerlogin){
// continue;
// }
// switch(parseInt(dbdata[i].oper_type)){
// case 1: //购买房卡
// youle_agent.readdata_isdoing = 1;
// update_gamedb_roomcard(dbdata[i].to_agent, dbdata[i].to_user, dbdata[i].oper_data, null, dbdata[i].oper_type, dbdata[i].id);
// break;
// case 2: //代理转卡
// youle_agent.readdata_isdoing = 1;
// update_gamedb_roomcard(dbdata[i].to_agent, dbdata[i].to_user, dbdata[i].oper_data, null, dbdata[i].oper_type, dbdata[i].id);
// break;
// case 3: //索要房卡
// youle_agent.readdata_isdoing = 1;
// update_gamedb_roomcard(dbdata[i].to_agent, dbdata[i].to_user, dbdata[i].oper_data, null, dbdata[i].oper_type, dbdata[i].id);
// break;
// case 11: //购买星星
// youle_agent.readdata_isdoing = 1;
// update_gamedb_roomcard(dbdata[i].to_agent, dbdata[i].to_user, null, dbdata[i].oper_data, dbdata[i].oper_type, dbdata[i].id);
// break;
// case 12: //代理转星星
// youle_agent.readdata_isdoing = 1;
// update_gamedb_roomcard(dbdata[i].to_agent, dbdata[i].to_user, null, dbdata[i].oper_data, dbdata[i].oper_type, dbdata[i].id);
// break;
// case 13: //索要星星
// youle_agent.readdata_isdoing = 1;
// update_gamedb_roomcard(dbdata[i].to_agent, dbdata[i].to_user, null, dbdata[i].oper_data, dbdata[i].oper_type, dbdata[i].id);
// break;
// case 21: //成为代理
// youle_agent.readdata_isdoing = 1;
// update_gamedb_newsalesman(dbdata[i].to_agent, dbdata[i].to_channel, dbdata[i].to_user, dbdata[i].oper_data, dbdata[i].id);
// break;
// case 31: //封禁代理
// youle_agent.readdata_isdoing = 1;
// update_gamedb_disabledsales(dbdata[i].to_agent, dbdata[i].to_user, dbdata[i].id);
// break;
// case 32: //解封代理
// youle_agent.readdata_isdoing = 1;
// update_gamedb_abledsales(dbdata[i].to_agent, dbdata[i].to_user, dbdata[i].id);
// break;
// case 33: //封禁玩家
// youle_agent.readdata_isdoing = 1;
// update_gamedb_disabledplayer(dbdata[i].to_agent, dbdata[i].to_user, dbdata[i].id);
// break;
// case 34: //解封玩家
// youle_agent.readdata_isdoing = 1;
// update_gamedb_abledplayer(dbdata[i].to_agent, dbdata[i].to_user, dbdata[i].id);
// break;
// case 41: //解除绑定了我的玩家
// youle_agent.readdata_isdoing = 1;
// update_gamedb_disbinding_sales(dbdata[i].from_agent, dbdata[i].from_user, dbdata[i].id);
// break;
// case 42: //玩家解除绑定
// youle_agent.readdata_isdoing = 1;
// update_gamedb_disbinding_player(dbdata[i].from_agent, dbdata[i].from_user, dbdata[i].id);
// break;
// case 101: //绑定代理
// youle_agent.readdata_isdoing = 1;
// update_gamedb_bindinginvitecode(dbdata[i].to_agent, dbdata[i].oper_data, dbdata[i].from_user, dbdata[i].id);
// break;
// case 110: //开通高新选项
// youle_agent.readdata_isdoing = 1;
// var o_data = JSON.parse(dbdata[i].oper_data);
// update_gamedb_advanced(dbdata[i].to_agent, dbdata[i].to_user, o_data.shortnum, o_data.maxroomnum, o_data.desone, o_data.destwo, dbdata[i].id);
// break;
// case 111: //设置短号白名单
// youle_agent.readdata_isdoing = 1;
// var o_data = JSON.parse(dbdata[i].oper_data);
// update_gamedb_whitelist(dbdata[i].from_agent, dbdata[i].from_user, o_data, dbdata[i].id);
// break;
// case 201: //系统抽成
// youle_agent.readdata_isdoing = 1;
// var o_data = JSON.parse(dbdata[i].oper_data);
// var rebate_mode1 = 0;
// var rebate_set1 = 0;
// var rebate_mode2 = 0;
// var rebate_set2 = 0;
// for (var j = 0; j < o_data.length; j++) {
// if (o_data[j].type_id == "001"){
// rebate_mode1 = 1;
// rebate_set1 = parseInt(o_data[j].system_commission_rate);
// }
// if (o_data[j].type_id == "002"){
// rebate_mode2 = 1;
// rebate_set2 = parseInt(o_data[j].system_commission_rate);
// }
// }
// update_gamedb_coinrebate(dbdata[i].to_agent, rebate_mode1, rebate_set1, rebate_mode2, rebate_set2, dbdata[i].id);
// break;
// }
// } catch(e){}
// }
// }
// if (!youle_agent.readdata_isdoing){
// var sql_agent = "select * from ct_user_process_log where is_process = 0 order by id";
// youle_agent.mysql_agent.execsql("opensql", sql_agent, [], db_callback_agent);
// }
// },
// 1000*30);

7018
codes/games/backstage/youle/server_agent/rpc.js Normal file
View File

File diff suppressed because it is too large Load Diff

190
codes/games/backstage/youle/server_platform/class.agent.js Normal file
View File

@@ -0,0 +1,190 @@
///////////////////////////////////////////////////////////////
/////////////// cls_youle_platform_agent: 运营商 /////////////////
///////////////////////////////////////////////////////////////
var cls_youle_platform_agent = cls_youle_platform_agent || {
//构造函数
new: function(agentid, name, logo, server, server_visitor, port_tcp, port_http, managecode){
var agent = {};
agent.agentid = agentid;
agent.name = name;
agent.logo = logo;
agent.server = server;
agent.server_visitor = server_visitor;
agent.port_tcp = port_tcp;
agent.port_http = port_http;
agent.managecode = managecode;
//渠道列表
agent.channels = [];
//方法
agent.method = {};
//载入渠道（没找到则创建）
agent.method.load_channel = function(channelid, func_return){
cls_youle_platform_agent.load_channel(agent, channelid, func_return);
};
return agent;
},
//载入渠道（没找到则创建）
load_channel: function(o_agent, channelid, func_return){
var db_callback = function(dbdata) {
var o_channel = {};
o_channel.channelid = dbdata[0].agch_channelid;
o_channel.tel = dbdata[0].agch_sales_tel;
o_channel.wechat = dbdata[0].agch_sales_wechat;
o_channel.youle_appid = dbdata[0].agch_youle_appid;
o_channel.youle_devkey = dbdata[0].agch_youle_devkey;
o_channel.youle_busiid = dbdata[0].agch_youle_busiid;
var idx = cls_youle_platform_agent.aryidx_channel(o_channel.channelid);
if (o_agent.channels.length <= idx) {
o_agent.channels.length = idx + 1;
}
o_agent.channels[idx] = o_channel;
func_return(o_channel);
}
if (!channelid){
channelid = "";
}
var sql = "call cp_platform_get_agentchannel(?,?);";
youle_platform.mysql.execsql("opensql", sql, [o_agent.agentid, channelid], db_callback);
},
//计算渠道的数组下标
aryidx_channel: function(channelid){
//channelid的5、10、15、20四位组成数组下标
var idx = parseInt(channelid.substr(4, 1)
+ channelid.substr(9, 1)
+ channelid.substr(14, 1)
+ channelid.substr(19, 1));
if (isNaN(idx)){
return -1;
}
return idx;
}
}
///////////////////////////////////////////////////////////////
/////////// cls_youle_platform_agentlist: 运营商列表 //////////
///////////////////////////////////////////////////////////////
var cls_youle_platform_agentlist = cls_youle_platform_agentlist || {
//构造函数
new: function() {
var agentlist = {};
//代理商列表
agentlist.list = [];
//开启定时在每天凌晨3:00到4:00之间删除超时战绩的定时器
var do_del_grade = function(){
//判断时间是否在范围内
var time_range = function (beginTime, endTime) {
var strb = beginTime.split (":");
if (strb.length != 2) {
return false;
}
var stre = endTime.split (":");
if (stre.length != 2) {
return false;
}
var b = new Date();
var e = new Date();
var n = new Date();
b.setHours(strb[0]);
b.setMinutes(strb[1]);
e.setHours(stre[0]);
e.setMinutes(stre[1]);
if (n.getTime() > b.getTime() && n.getTime() < e.getTime()){
return true;
} else {
return false;
}
}
if (time_range("3:00", "4:00")){
var sql = "call cp_game_del_timeout_task(null);";
youle_platform.mysql.execsql("execsql", sql, []);
}
if (time_range("4:00", "5:00")){
var sql = "call cp_game_grade_del();";
youle_platform.mysql_grade.execsql("execsql", sql, []);
}
}
agentlist.timer_delgrade = min_ontime(do_del_grade, 59 * 60 * 1000);
//方法
agentlist.method = {};
//载入代理商（没找到则创建）
agentlist.method.load_agent = function(agentid, func_return){
var o_agent = agentlist.method.find_agent(agentid);
if (o_agent){
func_return(o_agent);
} else {
var db_callback = function(dbdata) {
var db_agentid = dbdata[0].agen_agentid;
var db_name = dbdata[0].agen_name;
var db_logo = dbdata[0].agen_logo;
var db_server = dbdata[0].agen_server;
var db_server_visitor = dbdata[0].agen_server_visitor;
var db_port_tcp = parseInt(dbdata[0].agen_port_tcp);
var db_port_http = parseInt(dbdata[0].agen_port_http);
var db_managecode = dbdata[0].agen_managecode;
o_agent = cls_youle_platform_agent.new(db_agentid, db_name, db_logo, db_server, db_server_visitor, db_port_tcp, db_port_http, db_managecode);
var idx = agentlist.method.aryidx_agent(db_agentid);
agentlist.list[idx] = o_agent;
func_return(o_agent);
}
var sql = "call cp_platform_get_agentserver(?);";
youle_platform.mysql.execsql("opensql", sql, [agentid], db_callback);
}
};
//查找运营商
agentlist.method.find_agent = function(agentid){
var idx = agentlist.method.aryidx_agent(agentid);
if (idx == -1){
return null;
}
if (agentlist.list.length <= idx){
return null;
}
if (!agentlist.list[idx]){
return null;
}
if (agentlist.list[idx].agentid != agentid){
return null;
}
return agentlist.list[idx];
};
//计算运营商的数组下标
agentlist.method.aryidx_agent = function(agentid) {
//agentid的5、10、15、20四位组成数组下标
var idx = parseInt(agentid.substr(4, 1)
+ agentid.substr(9, 1)
+ agentid.substr(14, 1)
+ agentid.substr(19, 1));
if (isNaN(idx)){
return -1;
}
return idx;
};
return agentlist;
}
}
//运营商列表
youle_platform.agents = cls_youle_platform_agentlist.new();

303
codes/games/backstage/youle/server_platform/class.config.js Normal file
View File

@@ -0,0 +1,303 @@
///////////////////////////////////////////////////////////////
//////////// cls_youle_platform_config: 系统配置 //////////////
///////////////////////////////////////////////////////////////
var cls_youle_platform_config = cls_youle_platform_config || {
//构造函数
new: function(_url_config){
var config = {};
//方法
config.method = {};
//读取配置文件的内容
config.method.get_config = function(){
cls_youle_platform_config.get_config(config);
}
//获取参数配置
config.method.get_paravalue = function(paraname, agentid, gameid, channelid, marketid){
return cls_youle_platform_config.get_paravalue(config, paraname, agentid, gameid, channelid, marketid);
}
//获取游戏列表_下载页面
config.method.get_gamelist_downhtml = function(agentid, channelid){
return cls_youle_platform_config.get_gamelist_downhtml(config, agentid, channelid);
}
//获取游戏列表_游戏大厅
config.method.get_gamelist_gamehall = function(agentid, channelid, marketid){
return cls_youle_platform_config.get_gamelist_gamehall(config, agentid, channelid, marketid);
}
//获取代理城市列表
config.method.get_agentlist = function(agentid, channelid){
return cls_youle_platform_config.get_agentlist(config, agentid, channelid);
}
//获取子游戏服务器列表
config.method.get_gameserver_list = function(agentid){
return cls_youle_platform_config.get_gameserver_list(config, agentid);
}
//配置文件地址
config.url = _url_config;
//配置文件内容
config.data = null;
//定时器定时读取配置文件
config.timer_getdata = min_ontime(config.method.get_config, 30 * 1000);
return config;
},
//读取配置文件的内容
get_config: function(o_config){
var cfg = {};
cfg.url = o_config.url + "?" + min_timestamp();
cfg.type = "POST";
cfg.data = "";
cfg.success = function(str){
if (str){
try{
var data = JSON.parse(str);
o_config.data = data;
}
catch(e){
}
}
};
cfg.error = function(str){};
min_http(cfg);
},
//获取参数配置
get_paravalue: function(o_config, paraname, agentid, gameid, channelid, marketid){
var paravalue = null;
//遍历数组，匹配key，获取参数值
var do_get_para = function(arylist, keyname, keyvalue){
if (arylist && keyname && keyvalue){
for (var i = 0; i < arylist.length; i++){
if (arylist[i][keyname] == keyvalue){
if (arylist[i][paraname]){
paravalue = arylist[i][paraname];
}
return arylist[i];
}
}
}
return null;
}
if (!o_config.data){
return paravalue;
}
if (o_config.data[paraname]){
paravalue = o_config.data[paraname];
}
var _o_agent = do_get_para(o_config.data.agentlist, "agentid", agentid);
if (!_o_agent){
return paravalue;
}
var _o_game = do_get_para(_o_agent.gamelist, "gameid", gameid);
if (!_o_game){
return paravalue;
}
var _o_channel = do_get_para(_o_game.channellist, "channelid", channelid);
if (!_o_channel){
return paravalue;
}
var _o_market = do_get_para(_o_channel.marketlist, "marketid", marketid);
if (!_o_market){
return paravalue;
}
return paravalue;
},
//获取游戏列表_下载页面
get_gamelist_downhtml: function(o_config, agentid, channelid){
var gamelist = [];
if (!o_config.data){
return gamelist;
}
if (!o_config.data.agentlist){
return gamelist;
}
for (var i = 0; i < o_config.data.agentlist.length; i++){
if (o_config.data.agentlist[i].agentid == agentid){
var _o_agent = o_config.data.agentlist[i];
if (_o_agent.gamelist){
for (var j = 0; j < _o_agent.gamelist.length; j++) {
var _o_game = _o_agent.gamelist[j];
var o_game = {};
o_game.name = _o_game.gamename;
o_game.image = _o_game.game_down_image;
o_game.state = _o_game.game_down_state;
o_game.memo = _o_game.game_down_memo;
if (_o_game.channellist){
for (var k = 0; k < _o_game.channellist.length; k++) {
var _o_channel = _o_game.channellist[k];
if (_o_channel.channelid == channelid){
var _ios_marketid = _o_channel.ios_defdownload_marketid;
var _and_marketid = _o_channel.and_defdownload_marketid;
if (_o_channel.marketlist){
for (var m = 0; m < _o_channel.marketlist.length; m++) {
var _o_market = _o_channel.marketlist[m];
if (_o_market.marketid == _ios_marketid){
o_game.ios_down = _o_market.app_download;
o_game.ios_size = _o_market.app_size;
o_game.ios_marketid = _ios_marketid;
}
if (_o_market.marketid == _and_marketid){
o_game.android_down = _o_market.app_download;
o_game.android_size = _o_market.app_size;
}
}
}
if (o_game.ios_down && o_game.android_down){
gamelist.push(o_game);
}
break;
}
}
}
}
}
break;
}
}
return gamelist;
},
//获取游戏列表_游戏大厅
get_gamelist_gamehall: function(o_config, agentid, channelid, marketid){
var gamelist = [];
if (!o_config.data){
return gamelist;
}
if (!o_config.data.agentlist){
return gamelist;
}
for (var i = 0; i < o_config.data.agentlist.length; i++){
if (o_config.data.agentlist[i].agentid == agentid){
var _o_agent = o_config.data.agentlist[i];
if (_o_agent.gamelist){
for (var j = 0; j < _o_agent.gamelist.length; j++){
var _o_game = _o_agent.gamelist[j];
if (_o_game.gameid != "G2hw0ubng0zcoI0r4mx3H2yr4GejidwO"){
var o_game = {};
o_game.gameid = _o_game.gameid;
o_game.gamename = _o_game.gamename;
o_game.gamedir = _o_game.game_hall_dir;
o_game.gameimage = _o_game.game_hall_image;
o_game.gameversion = _o_game.game_version;
o_game.gamezip = _o_game.game_zip;
o_game.zipsize = _o_game.game_size;
if (_o_game.channellist){
for (var k = 0; k < _o_game.channellist.length; k++) {
var _o_channel = _o_game.channellist[k];
if (_o_channel.channelid == channelid){
if (_o_channel.game_version > 0){
o_game.gameversion = _o_channel.game_version;
}
if (_o_channel.game_zip){
o_game.gamezip = _o_channel.game_zip;
}
if (_o_channel.game_size){
o_game.zipsize = _o_channel.game_size;
}
if (_o_channel.marketlist){
for (var m = 0; m < _o_channel.marketlist.length; m++) {
var _o_market = _o_channel.marketlist[m];
if (_o_market.marketid == marketid){
if (_o_market.game_version > 0){
o_game.gameversion = _o_market.game_version;
}
if (_o_market.game_zip){
o_game.gamezip = _o_market.game_zip;
}
if (_o_market.game_size){
o_game.zipsize = _o_market.game_size;
}
break;
}
}
}
gamelist.push(o_game);
break;
}
}
}
}
}
}
break;
}
}
return gamelist;
},
//获取代理城市列表
get_agentlist: function(o_config, agentid, channelid){
var agentlist = [];
if (!o_config.data){
return gamelist;
}
if (!o_config.data.agentlist){
return gamelist;
}
for (var i = 0; i < o_config.data.agentlist.length; i++){
if (o_config.data.agentlist[i].agentid == agentid || o_config.data.agentlist[i].relagentid == agentid){
var o_agent = {};
o_agent.agentid = o_config.data.agentlist[i].agentid;
o_agent.name = o_config.data.agentlist[i].agentname;
o_agent.channelid = o_config.data.agentlist[i].gamelist[0].channellist[0].channelid;
agentlist.push(o_agent);
}
}
return agentlist;
},
//获取子游戏服务器列表
get_gameserver_list: function(o_config, agentid){
var iplist = [];
var paraname = "game_server_http";
var do_pushto_iplist = function(ip){
var idx = min_ary_indexof(iplist, ip);
if (idx == -1){
iplist.push(ip);
}
}
if (!o_config.data || !o_config.data.agentlist){
return iplist;
}
var idx_agent = min_ary_indexof(o_config.data.agentlist, agentid, "agentid");
if (idx_agent == -1){
return iplist;
}
var o_agent = o_config.data.agentlist[idx_agent];
if (!o_agent){
return iplist;
}
if (o_config.data[paraname]){
do_pushto_iplist(o_config.data[paraname]);
}
if (o_agent[paraname]){
do_pushto_iplist(o_agent.data[paraname]);
}
if (o_agent.gamelist){
for (var j = 0; j < o_agent.gamelist.length; j++) {
var o_game = o_agent.gamelist[j];
if (o_game[paraname]){
do_pushto_iplist(o_game[paraname]);
}
}
}
return iplist;
}
}
//系统配置
youle_platform.config = cls_youle_platform_config.new("http://tsgames.daoqi88.cn/config/update_jsonv2.txt");
youle_platform.config.method.get_config();

210
codes/games/backstage/youle/server_platform/mod.js Normal file
View File

@@ -0,0 +1,210 @@
//////////////////////////////////////////////////////////////////
//////////////////////////游戏平台服务器//////////////////////////
//////////////////////////////////////////////////////////////////
//系统配置
min_loadJsFile("youle/server_platform/class.config.js", function(){
//运营商
min_loadJsFile("youle/server_platform/class.agent.js", function(){
});
});
var youle_platform = youle_platform || cls_mod.new("youle_platform", "platform", youle_app);
//运营商列表
youle_platform.agents = null;
//系统配置
youle_platform.config = null;
//mysql操作类
youle_platform.mysql = cls_mysql.new("http://ylyxdata.daoqi88.cn/mysql.php", youle_platform.app.SendPack);
youle_platform.mysql_grade = cls_mysql.new("http://ylyxdata.daoqi88.cn/mysql_grade.php", youle_platform.app.SendPack);
//游戏获取代理商服务器地址
youle_platform.agentserver_game = function(pack){
var agentid = pack.data.agentid;
var gameid = pack.data.gameid;
var channelid = pack.data.channelid;
var marketid = pack.data.marketid;
//返回运营商信息
var do_return_agentinfo = function(o_agent){
if (!o_agent){
return;
}
pack.data = {};
pack.data.state = 0;
pack.data.agentid = o_agent.agentid;
pack.data.urlserver = o_agent.server + ":" + o_agent.port_tcp;
pack.data.visitorserver = o_agent.server_visitor + ":" + o_agent.port_tcp;
pack.data.urlserver_http = o_agent.server + ":" + o_agent.port_http;
pack.data.visitorserver_http = o_agent.server_visitor + ":" + o_agent.port_http;
//系统配置json
pack.data.logimage = youle_platform.config.method.get_paravalue("logimage", agentid, gameid, channelid, marketid);
pack.data.loginimage = parseInt(youle_platform.config.method.get_paravalue("loginimage", agentid, gameid, channelid, marketid));
youle_platform.app.SendPack(pack);
}
youle_platform.agents.method.load_agent(agentid, do_return_agentinfo);
}
//公众号页面获取代理商的服务器地址
youle_platform.agentserver_web = function(pack){
var agentid = pack.data.agentid;
var channelid = pack.data.channelid;
//返回运营商信息
var do_return_agentinfo = function(o_agent){
if (!o_agent){
return;
}
pack.data = {};
pack.data.agentid = o_agent.agentid;
pack.data.agentname = o_agent.name;
pack.data.agentlogo = youle_platform.config.method.get_paravalue('logimage2', o_agent.agentid);
pack.data.html_buyroomcard = parseInt(youle_platform.config.method.get_paravalue('html_buyroomcard', o_agent.agentid));
pack.data.urlserver = "http://" + o_agent.server + ":" + o_agent.port_http;
//返回渠道商信息
var do_return_channelinfo = function(o_channel){
pack.data.channelid = o_channel.channelid;
pack.data.channeltel = o_channel.tel;
pack.data.channelwechat = o_channel.wechat;
pack.data.youle_appid = o_channel.youle_appid;
pack.data.youle_devkey = o_channel.youle_devkey;
pack.data.youle_busiid = o_channel.youle_busiid;
youle_platform.app.SendPack(pack);
}
o_agent.method.load_channel(channelid, do_return_channelinfo);
}
youle_platform.agents.method.load_agent(agentid, do_return_agentinfo);
}
//关闭服务器
youle_platform.close_agentserver = function(pack){
var agentid = pack.data.agentid;
var managecode = pack.data.managecode;
//返回运营商信息
var do_return_agentinfo = function(o_agent){
if (!o_agent){
return;
}
if (o_agent.managecode != managecode){
pack.data = {};
pack.data.state = 1;
youle_platform.app.SendPack(pack);
}
var msg = {};
msg.app = "youle";
msg.route = "agent";
msg.rpc = "close_agentserver";
msg.data = {};
msg.data.agentid = agentid;
msg.data.managecode = managecode;
var cfg = {};
cfg.url = "http://" + o_agent.server + ":" + o_agent.port_http + "/index.html";
cfg.type = "POST";
cfg.data = JSON.stringify(msg);
cfg.success = function(str){
if (str){
var _msg = JSON.parse(str);
pack.data = _msg.data;
youle_agent.app.SendPack(pack);
}
};
cfg.error = function(str){
pack.data = {};
pack.data.state = 1;
youle_platform.app.SendPack(pack);
};
min_http(cfg);
}
youle_platform.agents.method.load_agent(agentid, do_return_agentinfo);
}
//开启服务器
youle_platform.open_agentserver = function(pack){
var agentid = pack.data.agentid;
var managecode = pack.data.managecode;
//返回运营商信息
var do_return_agentinfo = function(o_agent){
if (!o_agent){
return;
}
if (o_agent.managecode != managecode){
pack.data = {};
pack.data.state = 1;
youle_platform.app.SendPack(pack);
}
var msg = {};
msg.app = "youle";
msg.route = "agent";
msg.rpc = "open_agentserver";
msg.data = {};
msg.data.agentid = agentid;
msg.data.managecode = managecode;
var cfg = {};
cfg.url = "http://" + o_agent.server + ":" + o_agent.port_http + "/index.html";
cfg.type = "POST";
cfg.data = JSON.stringify(msg);
cfg.success = function(str){
if (str){
var _msg = JSON.parse(str);
pack.data = _msg.data;
youle_agent.app.SendPack(pack);
}
};
cfg.error = function(str){
pack.data = {};
pack.data.state = 1;
youle_platform.app.SendPack(pack);
};
min_http(cfg);
}
youle_platform.agents.method.load_agent(agentid, do_return_agentinfo);
}
//广播即时消息
youle_platform.broadcast = function(pack){
var agentid = pack.data.agentid;
var managecode = pack.data.managecode;
var msgcontent = pack.data.msgcontent;
//返回运营商信息
var do_return_agentinfo = function(o_agent){
if (!o_agent){
return;
}
if (o_agent.managecode != managecode){
pack.data = {};
pack.data.state = 1;
youle_platform.app.SendPack(pack);
}
var msg = {};
msg.app = "youle";
msg.route = "agent";
msg.rpc = "broadcast";
msg.data = {};
msg.data.agentid = agentid;
msg.data.managecode = managecode;
msg.data.msgcontent = msgcontent;
var cfg = {};
cfg.url = "http://" + o_agent.server + ":" + o_agent.port_http + "/index.html";
cfg.type = "POST";
cfg.data = JSON.stringify(msg);
cfg.success = function(str){
if (str){
var _msg = JSON.parse(str);
pack.data = _msg.data;
youle_agent.app.SendPack(pack);
}
};
cfg.error = function(str){
pack.data = {};
pack.data.state = 1;
youle_platform.app.SendPack(pack);
};
min_http(cfg);
}
youle_platform.agents.method.load_agent(agentid, do_return_agentinfo);
}

163
codes/games/backstage/youle/server_room/class.agent.js Normal file
View File

@@ -0,0 +1,163 @@
///////////////////////////////////////////////////////////////
//////////////// cls_youle_room_agent: 运营商 /////////////////
///////////////////////////////////////////////////////////////
var cls_youle_room_agent = cls_youle_room_agent || {
//构造函数
new: function(agentid, name, server, tcpport, httpport, freeroom){
var agent = {};
agent.agentid = agentid; //运营商id
agent.agentname = name; //运营商名称
agent.server = server; //运营商服务器地址
agent.tcpport = tcpport; //运营商服务器tcp端口
agent.httpport = httpport; //运营商服务器http端口
agent.freeroom = freeroom; //默认同意解散房间的倒计时，秒
//游戏列表
agent.games = [];
//方法
agent.method = {};
//载入游戏（没找到则创建）
agent.method.load_game = function(gameid, gamename, seatcount, makewar, modename, roomserver, tcpport, httpport, minroomcode, maxroomcode){
return cls_youle_room_agent.load_game(agent, gameid, gamename, seatcount, makewar, modename, roomserver, tcpport, httpport, minroomcode, maxroomcode);
};
//查找游戏
agent.method.find_game = function(gameid){
return cls_youle_room_agent.find_game(agent, gameid);
};
return agent;
},
//载入游戏（没找到则创建）
load_game: function(o_agent, gameid, gamename, seatcount, makewar, modename, roomserver, tcpport, httpport, minroomcode, maxroomcode){
var idx = cls_youle_room_agent.aryidx_game(gameid);
if (o_agent.games.length <= idx) {
o_agent.games.length = idx + 1;
}
var o_game = o_agent.games[idx];
if (!o_game){
//不存在则创建
o_game = cls_youle_room_game.new(o_agent, gameid, idx, gamename, seatcount, makewar, modename, roomserver, tcpport, httpport, minroomcode, maxroomcode);
o_agent.games[idx] = o_game;
} else {
o_game.idx = idx;
o_game.gamename = gamename;
o_game.seatcount = seatcount;
o_game.makewar = makewar;
o_game.modename = modename;
o_game.roomserver = roomserver;
o_game.tcpport = tcpport;
o_game.httpport = httpport;
o_game.minroomcode = minroomcode;
o_game.maxroomcode = maxroomcode;
}
return o_game;
},
//查找游戏
find_game: function(o_agent, gameid){
var idx = cls_youle_room_agent.aryidx_game(gameid);
if (idx == -1){
return null;
}
if (o_agent.games.length <= idx){
return null;
}
if (!o_agent.games[idx]){
return null;
}
if (o_agent.games[idx].gameid != gameid){
return null;
}
return o_agent.games[idx];
},
//计算游戏的数组下标
aryidx_game: function(gameid){
//gameid的5、10、15、20四位组成数组下标
var idx = parseInt(gameid.substr(4, 1)
+ gameid.substr(9, 1)
+ gameid.substr(14, 1)
+ gameid.substr(19, 1));
if (isNaN(idx)){
return -1;
}
return idx;
}
}
///////////////////////////////////////////////////////////////
/////////// cls_youle_room_agentlist: 运营商列表 //////////
///////////////////////////////////////////////////////////////
var cls_youle_room_agentlist = cls_youle_room_agentlist || {
//构造函数
new: function() {
var agentlist = {};
//代理商列表
agentlist.list = [];
//方法
agentlist.method = {};
//载入代理商（没找到则创建）
agentlist.method.load_agent = function(agentid, name, server, tcpport, httpport, freeroom){
var idx = agentlist.method.aryidx_agent(agentid);
if (idx == -1){
return null;
}
if (agentlist.list.length <= idx) {
agentlist.list.length = idx + 1;
}
var o_agent = agentlist.list[idx];
if (!o_agent) {
//不存在则创建
o_agent = cls_youle_room_agent.new(agentid, name, server, tcpport, httpport, freeroom);
agentlist.list[idx] = o_agent;
} else {
o_agent.agentname = name;
o_agent.server = server;
o_agent.tcpport = tcpport;
o_agent.httpport = httpport;
o_agent.freeroom = freeroom;
}
return o_agent;
};
//查找运营商
agentlist.method.find_agent = function(agentid){
var idx = agentlist.method.aryidx_agent(agentid);
if (idx == -1){
return null;
}
if (agentlist.list.length <= idx){
return null;
}
if (!agentlist.list[idx]){
return null;
}
if (agentlist.list[idx].agentid != agentid){
return null;
}
return agentlist.list[idx];
};
//计算运营商的数组下标
agentlist.method.aryidx_agent = function(agentid) {
//agentid的5、10、15、20四位组成数组下标
var idx = parseInt(agentid.substr(4, 1)
+ agentid.substr(9, 1)
+ agentid.substr(14, 1)
+ agentid.substr(19, 1));
if (isNaN(idx)){
return -1;
}
return idx;
};
return agentlist;
}
}
//运营商列表
youle_room.agents = cls_youle_room_agentlist.new();

732
codes/games/backstage/youle/server_room/class.backup.js Normal file
View File

@@ -0,0 +1,732 @@
///////////////////////////////////////////////////
//////////////cls_youle_room_backup: 数据备份类///////////
///////////////////////////////////////////////////
var cls_youle_room_backup = cls_youle_room_backup || {
isloading: true,
// backup_room: function(o_room, o_deskinfo){
// try {
// if (!o_room){
// return;
// }
// if (!o_room.battlestate){
// return;
// }
// var agentid = o_room.o_game.o_agent.agentid;
// var gameid = o_room.o_game.gameid;
// var roomcode = o_room.roomcode;
// var _o_agent = youle_agent.agents.method.find_agent(agentid);
// var data_agent = [];
// data_agent[0] = o_room.o_game.o_agent.agentid;
// data_agent[1] = o_room.o_game.o_agent.agentname;
// data_agent[2] = o_room.o_game.o_agent.server;
// data_agent[3] = o_room.o_game.o_agent.tcpport;
// data_agent[4] = o_room.o_game.o_agent.httpport;
// data_agent[5] = o_room.o_game.o_agent.freeroom;
// data_agent[6] = _o_agent.managecode;
// localStorage.setItem(agentid, JSON.stringify(data_agent));
// var data_game = [];
// data_game[0] = o_room.o_game.o_agent.agentid;
// data_game[1] = o_room.o_game.gameid;
// data_game[2] = o_room.o_game.gamename;
// data_game[3] = o_room.o_game.seatcount;
// data_game[4] = o_room.o_game.makewar;
// data_game[5] = o_room.o_game.modename;
// data_game[6] = o_room.o_game.roomserver;
// data_game[7] = o_room.o_game.tcpport;
// data_game[8] = o_room.o_game.httpport;
// data_game[9] = o_room.o_game.minroomcode;
// data_game[10] = o_room.o_game.maxroomcode;
// localStorage.setItem(agentid + "_" + gameid, JSON.stringify(data_game));
// var data_room = [];
// data_room[0] = o_room.o_game.o_agent.agentid;
// data_room[1] = o_room.o_game.gameid;
// data_room[2] = o_room.roomcode;
// data_room[3] = o_room.roomtype;
// data_room[4] = o_room.needroomcard;
// data_room[5] = o_room.asetcount;
// data_room[6] = o_room.createtime;
// data_room[7] = o_room.battlestate;
// data_room[8] = o_room.makewartime;
// data_room[9] = o_room.wasdeduct;
// data_room[10] = o_room.roommode;
// data_room[11] = o_room.infinite;
// data_room[12] = [];
// for (var i = 0; i < o_room.seatlist.length; i++) {
// data_room[12][i] = null;
// if (o_room.seatlist[i]){
// data_room[12][i] = [];
// data_room[12][i][0] = o_room.seatlist[i].playerid;
// data_room[12][i][1] = o_room.seatlist[i].nickname;
// data_room[12][i][2] = o_room.seatlist[i].avatar;
// data_room[12][i][3] = o_room.seatlist[i].sex;
// data_room[12][i][4] = o_room.seatlist[i].playertype;
// data_room[12][i][5] = o_room.seatlist[i].gameinfo.seat;
// data_room[12][i][6] = o_room.seatlist[i].gameinfo.isowner;
// data_room[12][i][7] = o_room.seatlist[i].gameinfo.isbet;
// data_room[12][i][8] = o_room.seatlist[i].gameinfo.grade;
// var _o_player = _o_agent.method.find_player(o_room.seatlist[i].playerid);
// data_room[12][i][9] = _o_player.roomcard;
// data_room[12][i][10] = _o_player.bean;
// if (!o_room.seatlist[i].gameinfo.isowner) {
// data_room[12][i][11] = o_room.seatlist[i].needroomcard;
// data_room[12][i][12] = o_room.seatlist[i].wasdeduct;
// }
// }
// }
// data_room[13] = o_deskinfo;
// localStorage.setItem(agentid + "_" + gameid + "_" + roomcode, JSON.stringify(data_room));
// } catch (e) {
// if (e.name == 'QuotaExceededError') {
// console.log(min_now() + ' 超出localStorage存储限额！');
// } else {
// console.log(min_now() + ' 保存localStorage失败');
// }
// }
// },
backup_room: function(o_room, o_deskinfo){
try {
if (!o_room){
return;
}
if (!o_room.battlestate){
return;
}
if (!dbObject){
return;
}
var agentid = o_room.o_game.o_agent.agentid;
var gameid = o_room.o_game.gameid;
var roomcode = o_room.roomcode;
var _o_agent = youle_agent.agents.method.find_agent(agentid);
var data_agent = [];
data_agent[0] = o_room.o_game.o_agent.agentid;
data_agent[1] = o_room.o_game.o_agent.agentname;
data_agent[2] = o_room.o_game.o_agent.server;
data_agent[3] = o_room.o_game.o_agent.tcpport;
data_agent[4] = o_room.o_game.o_agent.httpport;
data_agent[5] = o_room.o_game.o_agent.freeroom;
data_agent[6] = _o_agent.managecode;
data_agent[7] = _o_agent.shortcodes;
data_agent[8] = _o_agent.rebate_mode1;
data_agent[9] = _o_agent.rebate_set1;
data_agent[10] = _o_agent.rebate_mode2;
data_agent[11] = _o_agent.rebate_set2;
data_agent[12] = _o_agent.robot_nicknamelist;
data_agent[13] = _o_agent.robot_avatarlist;
data_agent[14] = _o_agent.initCard;
data_agent[15] = _o_agent.initBean;
dbObject.put(agentid, data_agent);
var data_game = [];
data_game[0] = o_room.o_game.o_agent.agentid;
data_game[1] = o_room.o_game.gameid;
data_game[2] = o_room.o_game.gamename;
data_game[3] = o_room.o_game.seatcount;
data_game[4] = o_room.o_game.makewar;
data_game[5] = o_room.o_game.modename;
data_game[6] = o_room.o_game.roomserver;
data_game[7] = o_room.o_game.tcpport;
data_game[8] = o_room.o_game.httpport;
data_game[9] = o_room.o_game.minroomcode;
data_game[10] = o_room.o_game.maxroomcode;
dbObject.put(agentid + "_" + gameid, data_game);
var data_room = [];
data_room[0] = o_room.o_game.o_agent.agentid;
data_room[1] = o_room.o_game.gameid;
data_room[2] = o_room.roomcode;
data_room[3] = o_room.roomtype;
data_room[4] = o_room.needroomcard;
data_room[5] = o_room.asetcount;
data_room[6] = o_room.createtime;
data_room[7] = o_room.battlestate;
data_room[8] = o_room.makewartime;
data_room[9] = o_room.wasdeduct;
data_room[10] = o_room.roommode;
data_room[11] = o_room.infinite;
data_room[12] = [];
for (var i = 0; i < o_room.seatlist.length; i++) {
data_room[12][i] = null;
if (o_room.seatlist[i]){
data_room[12][i] = [];
data_room[12][i][0] = o_room.seatlist[i].playerid;
data_room[12][i][1] = o_room.seatlist[i].nickname;
data_room[12][i][2] = o_room.seatlist[i].avatar;
data_room[12][i][3] = o_room.seatlist[i].sex;
data_room[12][i][4] = o_room.seatlist[i].playertype;
data_room[12][i][5] = o_room.seatlist[i].gameinfo.seat;
data_room[12][i][6] = o_room.seatlist[i].gameinfo.isowner;
data_room[12][i][7] = o_room.seatlist[i].gameinfo.isbet;
data_room[12][i][8] = o_room.seatlist[i].gameinfo.grade;
var _o_player = _o_agent.method.find_player(o_room.seatlist[i].playerid);
data_room[12][i][9] = _o_player.roomcard;
data_room[12][i][10] = _o_player.bean;
if (!o_room.seatlist[i].gameinfo.isowner) {
data_room[12][i][11] = o_room.seatlist[i].needroomcard;
data_room[12][i][12] = o_room.seatlist[i].wasdeduct;
}
data_room[12][i][13] = o_room.seatlist[i].gameinfo.isprepare;
data_room[12][i][14] = _o_player.advanced;
data_room[12][i][15] = _o_player.shortcode;
data_room[12][i][16] = _o_player.roomcodes;
data_room[12][i][17] = _o_player.bankpower;
data_room[12][i][18] = _o_player.bank;
data_room[12][i][19] = _o_player.bankpwd;
}
}
data_room[13] = o_deskinfo;
data_room[14] = o_room.advanced_type;
data_room[15] = o_room.advanced_teabean;
data_room[16] = o_room.beanfloor;
data_room[17] = o_room.needprepare;
data_room[18] = o_room.beanmult;
data_room[19] = [];
data_room[19][0] = o_room.owner.playerid;
data_room[19][1] = o_room.owner.nickname;
data_room[19][2] = o_room.owner.avatar;
data_room[19][3] = o_room.owner.sex;
data_room[19][4] = o_room.owner.playertype;
var _o_owner = _o_agent.method.find_player(o_room.owner.playerid);
data_room[19][5] = _o_owner.roomcard;
data_room[19][6] = _o_owner.bean;
data_room[19][7] = _o_owner.advanced;
data_room[19][8] = _o_owner.shortcode;
data_room[19][9] = _o_owner.roomcodes;
data_room[20] = o_room.match_id;
data_room[21] = o_room.match_idx;
dbObject.put(agentid + "_" + gameid + "_" + roomcode, data_room);
}catch(e){}
},
// deletebackup_room: function(o_room){
// var agentid = o_room.o_game.o_agent.agentid;
// var gameid = o_room.o_game.gameid;
// var roomcode = o_room.roomcode;
// localStorage.removeItem(agentid + "_" + gameid + "_" + roomcode);
// },
deletebackup_room: function(o_room){
if (!dbObject){
return;
}
var agentid = o_room.o_game.o_agent.agentid;
var gameid = o_room.o_game.gameid;
var roomcode = o_room.roomcode;
dbObject.delete(agentid + "_" + gameid + "_" + roomcode);
},
backup_match: function(o_match){
try{
if (!o_match){
return;
}
if (!dbObject){
return;
}
var agentid = o_match.o_game.o_agent.agentid;
var gameid = o_match.o_game.gameid;
var matchid = o_match.id;
var data_agent = [];
data_agent[0] = o_match.o_game.o_agent.agentid;
data_agent[1] = o_match.o_game.o_agent.agentname;
data_agent[2] = o_match.o_game.o_agent.server;
data_agent[3] = o_match.o_game.o_agent.tcpport;
data_agent[4] = o_match.o_game.o_agent.httpport;
data_agent[5] = o_match.o_game.o_agent.freeroom;
data_agent[6] = o_match.o_game.o_agent.managecode;
data_agent[7] = o_match.o_game.o_agent.shortcodes;
data_agent[8] = o_match.o_game.o_agent.rebate_mode1;
data_agent[9] = o_match.o_game.o_agent.rebate_set1;
data_agent[10] = o_match.o_game.o_agent.rebate_mode2;
data_agent[11] = o_match.o_game.o_agent.rebate_set2;
dbObject.put(agentid, data_agent);
var data_game = [];
var _o_agent = youle_room.agents.method.find_agent(agentid);
var _o_game = _o_agent.method.find_game(gameid);
data_game[0] = agentid;
data_game[1] = gameid;
data_game[2] = _o_game.gamename;
data_game[3] = _o_game.seatcount;
data_game[4] = _o_game.makewar;
data_game[5] = _o_game.modename;
data_game[6] = _o_game.roomserver;
data_game[7] = _o_game.tcpport;
data_game[8] = _o_game.httpport;
data_game[9] = _o_game.minroomcode;
data_game[10] = _o_game.maxroomcode;
dbObject.put(agentid + "_" + gameid, data_game);
var data_match = [];
data_match[0] = agentid;
data_match[1] = gameid;
data_match[2] = matchid;
data_match[3] = o_match.roomtype;
data_match[4] = o_match.matchname;
data_match[5] = o_match.imageurl;
data_match[6] = o_match.playercount;
data_match[7] = o_match.playercount2;
data_match[8] = o_match.bean;
data_match[9] = o_match.roomcard;
data_match[10] = o_match.topcount;
data_match[11] = o_match.circulation;
data_match[12] = o_match.interval;
data_match[13] = o_match.gradename;
data_match[14] = o_match.memo1;
data_match[15] = o_match.memo2;
data_match[16] = o_match.memo3;
data_match[17] = o_match.idx;
data_match[18] = o_match.beginTime;
data_match[19] = o_match.endTime;
data_match[20] = o_match.isstart;
data_match[21] = o_match.playerlist;
data_match[22] = o_match.ranklist;
data_match[23] = o_match.ranking;
dbObject.put(agentid + "_" + gameid + "_" + matchid, data_match);
}catch(e){}
},
deletebackup_match: function(o_match){
if (!dbObject){
return;
}
var agentid = o_match.o_game.o_agent.agentid;
var gameid = o_match.o_game.gameid;
var matchid = o_match.id;
dbObject.delete(agentid + "_" + gameid + "_" + matchid);
},
// restore: function(){
// cls_youle_room_backup.isloading = true;
// var game1list = [];
// for (var i = 0; i < localStorage.length; i++) {
// var key_room = localStorage.key(i);
// if (key_room.length != 72) {
// continue;
// }
// var value_room = localStorage.getItem(key_room);
// if (!value_room) {
// continue;
// }
// try {
// var data_room = JSON.parse(value_room);
// var agentid = data_room[0];
// var gameid = data_room[1];
// var roomcode = data_room[2];
// var roomtype = data_room[3];
// var needroomcard = data_room[4];
// var asetcount = data_room[5];
// var createtime = data_room[6];
// var battlestate = data_room[7];
// var makewartime = data_room[8];
// var wasdeduct = data_room[9];
// var roommode = data_room[10];
// var infinite = data_room[11];
// var playerlist = data_room[12];
// var o_deskinfo = data_room[13];
// var value_agent = localStorage.getItem(agentid);
// if (!value_agent) {
// continue;
// }
// var data_agent = JSON.parse(value_agent);
// var agentname = data_agent[1];
// var agentserver = data_agent[2];
// var agenttcpport = data_agent[3];
// var agenthttpport = data_agent[4];
// var agentfreeroom = data_agent[5];
// var managecode = data_agent[6];
// var o_agent1 = youle_agent.agents.method.load_agent(agentid, agentname, agentserver, agenttcpport, agenthttpport, agentfreeroom, managecode);
// var o_agent2 = youle_room.agents.method.load_agent(agentid, agentname, agentserver, agenttcpport, agenthttpport, agentfreeroom);
// var value_game = localStorage.getItem(agentid + "_" + gameid);
// if (!value_game) {
// continue;
// }
// var data_game = JSON.parse(value_game);
// var gamename = data_game[2];
// var seatcount = data_game[3];
// var makewar = data_game[4];
// var modename = data_game[5];
// var roomserver = data_game[6];
// var gametcpport = data_game[7];
// var gamehttpport = data_game[8];
// var minroomcode = data_game[9];
// var maxroomcode = data_game[10];
// var o_game1 = o_agent1.method.load_game(gameid, gamename, minroomcode, maxroomcode, seatcount, makewar, modename);
// var o_game2 = o_agent2.method.load_game(gameid, gamename, seatcount, makewar, modename, roomserver, gametcpport, gamehttpport, minroomcode, maxroomcode);
// o_game1.roomcodes[roomcode - minroomcode] = 0;
// var game1_isfound = false;
// for (var j = 0; j < game1list.length; j++) {
// if (game1list[j] == o_game1) {
// game1_isfound = true;
// break;
// }
// }
// if (!game1_isfound){
// game1list.push(o_game1);
// }
// var o_room2 = o_game2.method.create_room(roomcode, roomtype, needroomcard, asetcount);
// o_room2.createtime = createtime;
// o_room2.battlestate = battlestate;
// o_room2.makewartime = makewartime;
// o_room2.wasdeduct = wasdeduct;
// o_room2.roommode = roommode;
// o_room2.infinite = infinite;
// for (var j = 0; j < playerlist.length; j++) {
// var o_player = playerlist[j];
// if (o_player){
// var playerid = o_player[0];
// var nickname = o_player[1];
// var avatar = o_player[2];
// var sex = o_player[3];
// var playertype = o_player[4];
// var seat = o_player[5];
// var isowner = o_player[6];
// var isbet = o_player[7];
// var grade = o_player[8];
// var roomcard = o_player[9];
// var bean = o_player[10];
// var needroomcard = o_player[11];
// var wasdeduct = o_player[12];
// var o_player1 = o_agent1.method.load_player(playerid, roomcard, bean, null, null, nickname, avatar, sex, playertype, null);
// o_player1.method.login_game(o_game1);
// o_player1.gameinfo[o_game1.idx].roomcode = roomcode;
// var o_player2 = cls_youle_room_player.new(playerid, nickname, avatar, sex, playertype);
// o_player2.method.enter_room(o_room2, seat, isowner);
// o_player2.gameinfo.isbet = isbet;
// o_player2.gameinfo.grade = grade;
// o_player2.gameinfo.isowner = isowner;
// if (!isowner){
// o_player2.needroomcard = needroomcard;
// o_player2.wasdeduct = wasdeduct;
// }
// }
// }
// youle_room.import.restore_room(o_room2, o_deskinfo);
// } catch(e) {
// continue;
// }
// }
// for (var i = 0; i < game1list.length; i++) {
// var o_game1 = game1list[i];
// for (var k = 0; k < o_game1.roomcodesvalidlen; k++) {
// if (!o_game1.roomcodes[k]){
// if (k < o_game1.roomcodesvalidlen - 1) {
// o_game1.roomcodes[k] = o_game1.roomcodes[o_game1.roomcodesvalidlen - 1];
// k = k - 1;
// }
// o_game1.roomcodes[o_game1.roomcodesvalidlen - 1] = 0;
// o_game1.method.roomcodesvalidlen_chang(-1);
// }
// }
// }
// cls_youle_room_backup.isloading = false;
// },
restore: function(){
var do_opensuccess = function(){
dbObject.get_cursor(do_getsuccess, do_geterror);
}
var do_openerror = function(){
cls_youle_room_backup.isloading = false;
}
var do_getsuccess = function(db_store_cursor){
if (db_store_cursor){
try{
if (db_store_cursor.key.length == 32){
var data_agent = db_store_cursor.value;
var agentid = data_agent[0];
var agentname = data_agent[1];
var agentserver = data_agent[2];
var agenttcpport = data_agent[3];
var agenthttpport = data_agent[4];
var agentfreeroom = data_agent[5];
var managecode = data_agent[6];
var shortcodes = data_agent[7];
var rebate_mode1 = data_agent[8];
var rebate_set1 = data_agent[9];
var rebate_mode2 = data_agent[10];
var rebate_set2 = data_agent[11];
var robot_nicknamelist = data_agent[12];
var robot_avatarlist = data_agent[13];
var initCard = data_agent[14];
var initBean = data_agent[15];
var o_agent1 = youle_agent.agents.method.load_agent(agentid, agentname, agentserver, agenttcpport, agenthttpport, agentfreeroom, managecode,initCard,initBean);
o_agent1.shortcodes = shortcodes;
o_agent1.rebate_mode1 = rebate_mode1;
o_agent1.rebate_set1 = rebate_set1;
o_agent1.rebate_mode2 = rebate_mode2;
o_agent1.rebate_set2 = rebate_set2;
o_agent1.robot_nicknamelist = robot_nicknamelist;
o_agent1.robot_avatarlist = robot_avatarlist;
var o_agent2 = youle_room.agents.method.load_agent(agentid, agentname, agentserver, agenttcpport, agenthttpport, agentfreeroom);
} else if (db_store_cursor.key.length == 65){
var data_game = db_store_cursor.value;
var agentid = data_game[0];
var gameid = data_game[1];
var gamename = data_game[2];
var seatcount = data_game[3];
var makewar = data_game[4];
var modename = data_game[5];
var roomserver = data_game[6];
var gametcpport = data_game[7];
var gamehttpport = data_game[8];
var minroomcode = data_game[9];
var maxroomcode = data_game[10];
var o_agent1 = youle_agent.agents.method.find_agent(agentid);
var o_agent2 = youle_room.agents.method.find_agent(agentid);
var o_game1 = o_agent1.method.load_game(gameid, gamename, minroomcode, maxroomcode, seatcount, makewar, modename);
var o_game2 = o_agent2.method.load_game(gameid, gamename, seatcount, makewar, modename, roomserver, gametcpport, gamehttpport, minroomcode, maxroomcode);
game1list.push(o_game1);
} else if (db_store_cursor.key.length == 72){
var data_room = db_store_cursor.value;
var agentid = data_room[0];
var gameid = data_room[1];
var roomcode = data_room[2];
var roomtype = data_room[3];
var needroomcard = data_room[4];
var asetcount = data_room[5];
var createtime = data_room[6];
var battlestate = data_room[7];
var makewartime = data_room[8];
var wasdeduct = data_room[9];
var roommode = data_room[10];
var infinite = data_room[11];
var playerlist = data_room[12];
var o_deskinfo = data_room[13];
var advanced_type = data_room[14];
var advanced_teabean = data_room[15];
var beanfloor = data_room[16];
var needprepare = data_room[17];
var beanmult = data_room[18];
var match_id = data_room[20];
var match_idx = data_room[21];
var o_agent1 = youle_agent.agents.method.find_agent(agentid);
var o_agent2 = youle_room.agents.method.find_agent(agentid);
var o_game1 = o_agent1.method.find_game(gameid);
var o_game2 = o_agent2.method.find_game(gameid);
// o_game1.roomcodes[roomcode - o_game1.minroomcode] = 0;
o_game1.method.new_roomcode(roomcode);
var o_room2 = o_game2.method.create_room(roomcode, roomtype, needroomcard, asetcount);
o_room2.createtime = createtime;
o_room2.battlestate = battlestate;
o_room2.makewartime = makewartime;
o_room2.wasdeduct = wasdeduct;
o_room2.roommode = roommode;
o_room2.infinite = infinite;
o_room2.advanced_type = advanced_type;
o_room2.advanced_teabean = advanced_teabean;
o_room2.beanfloor = beanfloor;
o_room2.needprepare = needprepare;
o_room2.beanmult = beanmult;
if (match_id){
o_room2.match_id = match_id;
o_room2.match_idx = match_idx;
}
if (!o_room2.advanced_type){
if (o_room2.freetimer24){
min_closetime(o_room2.freetimer24);
o_room2.freetimer24 = null;
}
}
for (var j = 0; j < playerlist.length; j++) {
var o_player = playerlist[j];
if (o_player){
var playerid = o_player[0];
var nickname = o_player[1];
var avatar = o_player[2];
var sex = o_player[3];
var playertype = o_player[4];
var seat = o_player[5];
var isowner = o_player[6];
var isbet = o_player[7];
var grade = o_player[8];
var roomcard = o_player[9];
var bean = o_player[10];
var needroomcard = o_player[11];
var wasdeduct = o_player[12];
var isprepare = o_player[13];
var advanced = o_player[14];
var shortcode = o_player[15];
var roomcodes = o_player[16];
var bankpower = o_player[17];
var bank = o_player[18];
var bankpwd = o_player[19];
var o_player1 = o_agent1.method.load_player(playerid, roomcard, bean, null, null, nickname, avatar, sex, playertype, null);
o_player1.advanced = advanced;
o_player1.shortcode = shortcode;
o_player1.roomcodes = roomcodes;
o_player1.bankpower = bankpower;
o_player1.bank = bank;
o_player1.bankpwd = bankpwd;
o_player1.method.login_game(o_game1);
o_player1.gameinfo[o_game1.idx].roomcode = roomcode;
var o_player2 = cls_youle_room_player.new(playerid, nickname, avatar, sex, playertype);
o_player2.method.enter_room(o_room2, seat, isowner);
o_player2.bean = bean;
o_player2.gameinfo.isbet = isbet;
o_player2.gameinfo.grade = grade;
o_player2.gameinfo.isowner = isowner;
o_player2.gameinfo.isprepare = isprepare;
if (!isowner){
o_player2.needroomcard = needroomcard;
o_player2.wasdeduct = wasdeduct;
}
}
}
if (!o_room2.owner){
var owner_playerid = data_room[19][0];
var owner_nickname = data_room[19][1];
var owner_avatar = data_room[19][2];
var owner_sex = data_room[19][3];
var owner_playertype = data_room[19][4];
var owner_roomcard = data_room[19][5];
var owner_bean = data_room[19][6];
var owner_advanced = data_room[19][7];
var owner_shortcode = data_room[19][8];
var owner_roomcodes = data_room[19][9];
var o_owner1 = o_agent1.method.load_player(owner_playerid, owner_roomcard, owner_bean, null, null, owner_nickname, owner_avatar, owner_sex, owner_playertype, null);
o_owner1.advanced = owner_advanced;
o_owner1.shortcode = owner_shortcode;
o_owner1.roomcodes = owner_roomcodes;
o_owner1.method.login_game(o_game1);
var o_owner2 = cls_youle_room_player.new(owner_playerid, owner_nickname, owner_avatar, owner_sex, owner_playertype);
o_owner2.bean = owner_bean;
o_room2.owner = o_owner2;
}
youle_room.import.restore_room(o_room2, o_deskinfo);
} else if (db_store_cursor.key.length == 76){
var data_match = db_store_cursor.value;
var agentid = data_match[0];
var gameid = data_match[1];
var matchid = data_match[2];
var roomtype = data_match[3];
var matchname = data_match[4];
var imageurl = data_match[5];
var playercount = data_match[6];
var playercount2 = data_match[7];
var bean = data_match[8];
var roomcard = data_match[9];
var topcount = data_match[10];
var circulation = data_match[11];
var interval = data_match[12];
var gradename = data_match[13];
var memo1 = data_match[14];
var memo2 = data_match[15];
var memo3 = data_match[16];
var idx = data_match[17];
var beginTime = data_match[18];
var endTime = data_match[19];
var isstart = data_match[20];
var playerlist = data_match[21];
var ranklist = data_match[22];
var ranking = data_match[23];
var o_match = {};
o_match.id = matchid;
o_match.roomtype = roomtype;
o_match.matchname = matchname;
o_match.imageurl = imageurl;
o_match.beginTime = beginTime;
o_match.endTime = endTime;
o_match.playercount = playercount;
o_match.playercount2 = playercount2;
o_match.bean = bean;
o_match.roomcard = roomcard;
o_match.topcount = topcount;
o_match.circulation = circulation;
o_match.interval = interval;
o_match.gradename = gradename;
o_match.memo1 = memo1;
o_match.memo2 = memo2;
o_match.memo3 = memo3;
var o_agent = youle_agent.agents.method.find_agent(agentid);
var o_game = o_agent1.method.find_game(gameid);
var _o_match = o_game.matchlist.method.load_match(o_match);
if (_o_match){
_o_match.idx = idx;
_o_match.beginTime = beginTime;
_o_match.endTime = endTime;
_o_match.isstart = isstart;
_o_match.playerlist = playerlist;
_o_match.ranklist = ranklist;
if (ranking){
_o_match.ranking = ranking;
}
}
}
}catch(e){}
db_store_cursor.continue();
} else {
// for (var i = 0; i < game1list.length; i++) {
// var o_game1 = game1list[i];
// for (var k = 0; k < o_game1.roomcodesvalidlen; k++) {
// if (!o_game1.roomcodes[k]){
// if (k < o_game1.roomcodesvalidlen - 1) {
// o_game1.roomcodes[k] = o_game1.roomcodes[o_game1.roomcodesvalidlen - 1];
// k = k - 1;
// }
// o_game1.roomcodes[o_game1.roomcodesvalidlen - 1] = 0;
// o_game1.method.roomcodesvalidlen_chang(-1);
// }
// }
// }
cls_youle_room_backup.isloading = false;
}
}
var do_geterror = function(){
cls_youle_room_backup.isloading = false;
}
cls_youle_room_backup.isloading = true;
var game1list = [];
var dbParams = {};
dbParams.db_name = "games";
dbParams.db_version = "4";
dbParams.store_name = "desk";
dbParams.success_callback = do_opensuccess;
dbParams.error_callback = do_openerror;
dbObject.open(dbParams);
}
}

2027
codes/games/backstage/youle/server_room/class.export.js Normal file
View File

File diff suppressed because it is too large Load Diff

193
codes/games/backstage/youle/server_room/class.game.js Normal file
View File

@@ -0,0 +1,193 @@
///////////////////////////////////////////////////
////////// cls_youle_room_game: 游戏 //////////
///////////////////////////////////////////////////
var cls_youle_room_game = cls_youle_room_game || {
//构造函数
new: function(o_agent, gameid, gameidx, gamename, seatcount, makewar, modename, roomserver, tcpport, httpport, minroomcode, maxroomcode){
var game = {};
//基本信息
game.o_agent = o_agent; //代理商
game.gameid = gameid; //游戏id
game.idx = gameidx; //游戏的数组下标
game.gamename = gamename; //游戏名称
game.seatcount = seatcount; //房间内的座位数量
game.makewar = makewar; //达成开战条件的人数
game.modename = modename; //游戏服务器模块名称
game.roomserver = roomserver; //房间服务器地址
game.tcpport = tcpport; //房间服务器tcp端口
game.httpport = httpport; //房间服务器http端口
game.minroomcode = minroomcode; //房间服务器最小房号
game.maxroomcode = maxroomcode; //房间服务器最大房号
//房间列表
game.rooms = [];
game.rooms.length = maxroomcode - minroomcode + 1;
//方法
game.method = {};
//创建房间
game.method.create_room = function(roomcode, roomtype, needroomcard, asetcount){
return cls_youle_room_game.create_room(game, roomcode, roomtype, needroomcard, asetcount);
}
//查找房间
game.method.find_room = function(roomcode){
return cls_youle_room_game.find_room(game, roomcode);
}
//释放房间
game.method.free_room = function(o_room){
cls_youle_room_game.free_room(game, o_room);
}
//调试状态
game.method.isdebugger = function(){
return cls_youle_room_game.isdebugger(game);
}
return game;
},
//创建房间
create_room: function(o_game, roomcode, roomtype, needroomcard, asetcount){
//判断房号是否在范围内
if (roomcode < o_game.minroomcode || roomcode > o_game.maxroomcode){
return null;
}
//判断房间是否已经存在
var idx = cls_youle_room_game.aryidx_room(o_game, roomcode);
if (o_game.rooms[idx]){
return null;
}
var o_room = cls_youle_room_room.new(o_game, roomcode, roomtype, needroomcard, asetcount);
o_game.rooms[idx] = o_room;
return o_room;
},
//查找房间
find_room: function(o_game, roomcode){
var idx = cls_youle_room_game.aryidx_room(o_game, roomcode);
if (o_game.rooms.length <= idx) {
return null;
}
return o_game.rooms[idx];
},
//释放房间
free_room: function(o_game, o_room){
var idx = cls_youle_room_game.aryidx_room(o_game, o_room.roomcode);
//更新tcp连接列表
var o_room = o_game.rooms[idx];
if (o_room){
for (var i = 0; i < o_room.seatlist.length; i++) {
if (o_room.seatlist[i]) {
var o_player = o_room.seatlist[i];
if (o_player.conmode == "tcp"){
youle_room.tcps.method.delete_tcp(o_player.fromid, o_player);
}
}
}
try{
if (o_room.game){//针对牛牛写的
if (o_room.game.room){
o_room.game.room = null;
}
if (o_room.game.pList){
o_room.game.pList = null;
}
o_room.game = null;
}
if (o_room.o_desk){//通用
if (o_room.o_desk.o_room){
o_room.o_desk.o_room = null;
}
o_room.o_desk = null;
}
for (var i = 0; i < o_room.seatlist.length; i++) {
if (o_room.seatlist[i]){
o_room.seatlist[i].seat = null;
o_room.seatlist[i].cards = null;
o_room.seatlist[i].rubcard = null;
o_room.seatlist[i].putcard = null;
o_room.seatlist[i].scores = null;
o_room.seatlist[i].betScore = null;
o_room.seatlist[i].winScore = null;
o_room.seatlist[i].isJoin = null;
o_room.seatlist[i].isBet = null;
o_room.seatlist[i].isAuto = null;
o_room.seatlist[i].auto = null;
o_room.seatlist[i] = null;
}
}
}
catch(e){}
if (o_room.freetimer){
min_closetime(o_room.freetimer);
o_room.freetimer = null;
}
if (o_room.freetimer24){
min_closetime(o_room.freetimer24);
o_room.freetimer24 = null;
}
if (o_room.timer_robot){
min_closetime(o_room.timer_robot);
o_room.timer_robot = null;
}
if (o_room.timer_robot_active){
min_closetime(o_room.timer_robot_active);
o_room.timer_robot_active = null;
}
if (o_room.timer_robot_passive){
for (var i = 0; i < o_room.timer_robot_passive.length; i++) {
min_closetime(o_room.timer_robot_passive[i]);
}
o_room.timer_robot_passive = [];
}
}
o_game.rooms[idx] = null;
//固定房号的房间需要自动再次创建
if (o_room.advanced_type){
var msg = {};
msg.app = youle_room.app.appname;
msg.route = youle_room.app.youle_agent.routename;
msg.rpc = "advanced_createroom_roomcode";
msg.data = {};
msg.data.agentid = o_room.o_game.o_agent.agentid;
msg.data.playerid = o_room.owner.playerid;
msg.data.gameid = o_room.o_game.gameid;
msg.data.roomcode = o_room.roomcode;
msg.data.shortcode = o_room.shortcode;
//msg.data.rebateType = o_room.rebateType;
youle_room.app.youle_agent[msg.rpc](msg);
}else{
//非vip房且有需要更新的roomtype自动创建
}
},
//调试状态
isdebugger: function(o_game){
var o_cfg = youle_room.app.youle_platform.config;
var re = o_cfg.method.get_paravalue("isdebugger", o_game.o_agent.agentid, o_game.gameid);
if (!re){
return 0; //正式
} else {
return 1; //调试
}
},
//计算房间的数组下标
aryidx_room: function(o_game, roomcode){
return roomcode - o_game.minroomcode;
}
}

349
codes/games/backstage/youle/server_room/class.import.js Normal file
View File

@@ -0,0 +1,349 @@
///////////////////////////////////////////////////
/////// cls_youle_room_import: 输入接口 ///////
///////////////////////////////////////////////////
var cls_youle_room_import = cls_youle_room_import || {
new: function() {
var imp = {};
//创建房间时根据roomtype获取需要的房卡数量
imp.createroom_needroomcard = function(o_game, roomtype){
var o_game_config = youle_room.app.youle_platform.config.method.get_paravalue("game_config", o_game.o_agent.agentid, o_game.gameid);
var mod_game = youle_room.app[o_game.modename];
if (mod_game.export){
if (mod_game.export.get_needroomcard){
return mod_game.export.get_needroomcard(roomtype, o_game_config);
}
}
if (mod_game.needroomcard){
return mod_game.needroomcard(roomtype, o_game_config);
}
return 1;
}
//创建房间时根据roomtype获取总局数
imp.createroom_asetcount = function(o_game, roomtype){
var o_game_config = youle_room.app.youle_platform.config.method.get_paravalue("game_config", o_game.o_agent.agentid, o_game.gameid);
var mod_game = youle_room.app[o_game.modename];
if (mod_game.export){
if (mod_game.export.get_asetcount){
return mod_game.export.get_asetcount(roomtype, o_game_config);
}
}
if (mod_game.asetcount){
return mod_game.asetcount(roomtype, o_game_config);
}
return 8;
}
//创建房间时根据roomtype获取元宝下限
imp.createroom_beanfloor = function(o_game, roomtype){
var o_game_config = youle_room.app.youle_platform.config.method.get_paravalue("game_config", o_game.o_agent.agentid, o_game.gameid);
var mod_game = youle_room.app[o_game.modename];
if (mod_game.export){
if (mod_game.export.createroom_beanfloor){
return mod_game.export.createroom_beanfloor(roomtype, o_game_config);
}
}
if (mod_game.createroom_beanfloor){
return mod_game.createroom_beanfloor(roomtype, o_game_config);
}
return null;
}
//加入房间时根据roomtype获取需要的房卡数量，如果不需要房卡则需要返回0
imp.joinroom_needroomcard = function(o_game, roomtype){
var o_game_config = youle_room.app.youle_platform.config.method.get_paravalue("game_config", o_game.o_agent.agentid, o_game.gameid);
var mod_game = youle_room.app[o_game.modename];
if (mod_game.export){
if (mod_game.export.get_needroomcard_joinroom){
return mod_game.export.get_needroomcard_joinroom(roomtype, o_game_config);
}
}
if (mod_game.needroomcard_joinroom){
return mod_game.needroomcard_joinroom(roomtype, o_game_config);
}
return 0;
}
//根据roomtype获取房间的扣卡模式，0：房主扣卡 1：每人扣卡 2：大赢家扣卡
imp.deduct_roomcard_mode = function(o_game, roomtype){
var o_game_config = youle_room.app.youle_platform.config.method.get_paravalue("game_config", o_game.o_agent.agentid, o_game.gameid);
var mod_game = youle_room.app[o_game.modename];
if (mod_game.export){
if (mod_game.export.deduct_roomcard_mode){
return mod_game.export.deduct_roomcard_mode(roomtype, o_game_config);
}
}
if (mod_game.deduct_roomcard_mode){
return mod_game.deduct_roomcard_mode(roomtype, o_game_config);
}
return 0;
}
//除了满桌自动开战外，子游戏可以设置开战人数
imp.makewar_playercount = function(o_game, roomtype){
var o_game_config = youle_room.app.youle_platform.config.method.get_paravalue("game_config", o_game.o_agent.agentid, o_game.gameid);
var mod_game = youle_room.app[o_game.modename];
if (mod_game.export){
if (mod_game.export.makewar_playercount){
return mod_game.export.makewar_playercount(roomtype, o_game_config);
}
}
if (mod_game.makewar_playercount){
return mod_game.makewar_playercount(roomtype, o_game_config);
}
return null;
}
//星星场房主抽成星星数量
imp.owner_beanpush = function(o_game, roomtype){
var o_game_config = youle_room.app.youle_platform.config.method.get_paravalue("game_config", o_game.o_agent.agentid, o_game.gameid);
var mod_game = youle_room.app[o_game.modename];
if (mod_game.export){
if (mod_game.export.owner_beanpush){
return mod_game.export.owner_beanpush(roomtype, o_game_config);
}
}
if (mod_game.owner_beanpush){
return mod_game.owner_beanpush(roomtype, o_game_config);
}
return 0;
}
//开局时通知游戏，并返回游戏的开局数据包
imp.makewar_deskwar = function(o_room){
var matchroom_deductbean = function(){
if (!o_room.match_id){
return;
}
var o_agentsvr_agent = youle_agent.agents.method.find_agent(o_room.o_game.o_agent.agentid);
var o_agentsvr_game = o_agentsvr_agent.method.find_game(o_room.o_game.gameid);
var match_idx = min_ary_indexof(o_agentsvr_game.matchlist.list, o_room.match_id, "id");
if (match_idx == -1){
return;
}
var match_object = o_agentsvr_game.matchlist.list[match_idx];
if (!match_object.bean){
return;
}
var do_deduct_bean = function(){
var msg = {};
msg.app = youle_room.app.appname;
msg.route = youle_room.app.youle_agent.routename;
msg.rpc = "update_bean";
msg.data = {};
msg.data.agentid = o_room.o_game.o_agent.agentid;
msg.data.change = 0;
msg.data.pushbean = -1 * match_object.bean;
msg.data.gameid = o_room.o_game.gameid;
msg.data.showrebate = 1;
msg.data.type = 5;
//房间id = 时间戳 + 4位随机码 + 房号
var roomid = new Date().getTime() + min_randomChar(4) + o_room.roomcode;
var datatime = min_now();
var beanmult = 0;
if (o_room.beanmult){
beanmult = o_room.beanmult;
}
var shortcode = 0;
if (o_room.shortcode){
shortcode = o_room.shortcode;
}
var deductmode = youle_room.import.deduct_roomcard_mode(o_room.o_game, o_room.roomtype);
for (var i = 0; i < o_room.seatlist.length; i++) {
if (o_room.seatlist[i]){
var playerid = o_room.seatlist[i].playerid;
var roomcard = 0;
if (playerid == o_room.owner.playerid){
roomcard = youle_room.import.createroom_needroomcard(o_room.o_game, o_room.roomtype);
} else {
roomcard = youle_room.import.joinroom_needroomcard(o_room.o_game, o_room.roomtype);
}
var isrobot = 0;
if (o_room.seatlist[i].isrobot){
isrobot = 1;
}
if (!isrobot){
msg.data.playerid = playerid;
youle_room.app.youle_agent[msg.rpc](msg);
}
var sql = "insert into gold_account(goac_id,goac_agentid,goac_gameid,goac_roomcode,goac_roommode,goac_createtime,goac_beanmult,goac_ownerid,goac_shortcode,goac_deduct,goac_roomcard,goac_datatype,goac_asetcount,goac_asetnum,goac_playerid,goac_isrobot,goac_grade,goac_rebatefrom,goac_rebateto,goac_toplayerid,goac_rebatemode,goac_setvalue,goac_rebatevalue,goac_time) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);";
youle_room.mysql_grade.execsql("execsql", sql, [roomid, o_room.o_game.o_agent.agentid, o_room.o_game.gameid, o_room.roomcode, 4, o_room.createtime, beanmult, o_room.owner.ownerid, shortcode, deductmode, roomcard, 0, o_room.asetcount, 0, playerid, isrobot, 0, 3, 0, 0, 3, match_object.bean, match_object.bean, datatime]);
}
}
}
min_ontimeout(do_deduct_bean, 1000);
}
var o_game_config = youle_room.app.youle_platform.config.method.get_paravalue("game_config", o_room.o_game.o_agent.agentid, o_room.o_game.gameid);
var mod_game = youle_room.app[o_room.o_game.modename];
if (mod_game.export){
if (mod_game.export.makewar){
var data = mod_game.export.makewar(o_room, o_game_config);
matchroom_deductbean(); //比赛场扣除报名的星星费用
return data;
}
}
if (mod_game.makewar){
var data = mod_game.makewar(o_room, o_game_config);
matchroom_deductbean(); //比赛场扣除报名的星星费用
return data;
}
}
//进入房间或断线重连时获取牌局信息
imp.get_deskinfo = function(o_room, seat){
var mod_game = youle_room.app[o_room.o_game.modename];
if (mod_game.export){
if (mod_game.export.get_deskinfo){
return mod_game.export.get_deskinfo(o_room, seat);
}
}
if (mod_game.getDeskInfo){
return mod_game.getDeskInfo(o_room, seat);
}
}
//解散时通知游戏
imp.get_disbandRoom = function(o_room){
var mod_game = youle_room.app[o_room.o_game.modename];
if (mod_game.export){
if (mod_game.export.get_disbandRoom){
return mod_game.export.get_disbandRoom(o_room);
}
}
if (mod_game.disbandRoom){
return mod_game.disbandRoom(o_room);
}
}
//玩家中途进入房间
imp.player_enter = function(o_room, seat){
var mod_game = youle_room.app[o_room.o_game.modename];
if (mod_game.export){
if (mod_game.export.player_enter){
return mod_game.export.player_enter(o_room, seat);
}
}
if (mod_game.player_enter){
return mod_game.player_enter(o_room, seat);
}
}
//玩家中途退出房间
imp.player_leave = function(o_room, seat){
var mod_game = youle_room.app[o_room.o_game.modename];
if (mod_game.export){
if (mod_game.export.player_leave){
return mod_game.export.player_leave(o_room, seat);
}
}
if (mod_game.player_leave){
return mod_game.player_leave(o_room, seat);
}
}
//恢复房间数据
imp.restore_room = function(o_room, o_deskinfo){
var mod_game = youle_room.app[o_room.o_game.modename];
if (mod_game.export){
if (mod_game.export.restore_room){
return mod_game.export.restore_room(o_room, o_deskinfo);
}
}
if (mod_game.restore_room){
return mod_game.restore_room(o_room, o_deskinfo);
}
}
//玩家准备
imp.player_CanPrepare = function(o_room, seat){
var mod_game = youle_room.app[o_room.o_game.modename];
if (mod_game.export){
if (mod_game.export.player_CanPrepare){
return mod_game.export.player_CanPrepare(o_room, seat);
}
}
if (mod_game.player_CanPrepare){
return mod_game.player_CanPrepare(o_room, seat);
}
return 1;
}
imp.player_prepare = function(o_room, seat){
var mod_game = youle_room.app[o_room.o_game.modename];
if (mod_game.export){
if (mod_game.export.player_prepare){
return mod_game.export.player_prepare(o_room, seat);
}
}
if (mod_game.player_prepare){
return mod_game.player_prepare(o_room, seat);
}
}
//无限局玩家是否可以离开房间
imp.isPlayerCanLeave = function(o_room, seat){
var mod_game = youle_room.app[o_room.o_game.modename];
if (mod_game.export){
if (mod_game.export.isPlayerCanLeave){
return mod_game.export.isPlayerCanLeave(o_room, seat);
}
}
if (mod_game.isPlayerCanLeave){
return mod_game.isPlayerCanLeave(o_room, seat);
}
return null;
}
//通过战绩gameinfo1获取大赢家标志如[0,0,1]空座位不需要写入数组顺序从0号座位依次写入
imp.getWinnerByGameInfo1 = function(o_room, gameinfo1){
var mod_game = youle_room.app[o_room.o_game.modename];
if (mod_game.export){
if (mod_game.export.getWinnerByGameInfo1){
return mod_game.export.getWinnerByGameInfo1(o_room, gameinfo1);
}
}
if (mod_game.getWinnerByGameInfo1){
return mod_game.getWinnerByGameInfo1(o_room, gameinfo1);
}
return null;
}
//通过战绩gameinfo1获取积分列表如[10,10,-20]空座位不需要写入数组顺序从0号座位依次写入
imp.getScoreByGameInfo1 = function(o_room, gameinfo1){
var mod_game = youle_room.app[o_room.o_game.modename];
if (mod_game.export){
if (mod_game.export.getScoreByGameInfo1){
return mod_game.export.getScoreByGameInfo1(o_room, gameinfo1);
}
}
if (mod_game.getScoreByGameInfo1){
return mod_game.getScoreByGameInfo1(o_room, gameinfo1);
}
return null;
}
//通知子游戏解散房间
imp.gameBreak = function(o_room){
var mod_game = youle_room.app[o_room.o_game.modename];
if (mod_game.export){
if (mod_game.export.gameBreak){
return mod_game.export.gameBreak(o_room);
}
}
if (mod_game.gameBreak){
return mod_game.gameBreak(o_room);
}
return null;
}
return imp;
}
}
//内部输入接口
youle_room.import = cls_youle_room_import.new();

156
codes/games/backstage/youle/server_room/class.player.js Normal file
View File

@@ -0,0 +1,156 @@
///////////////////////////////////////////////////
///////// cls_youle_room_player: 玩家 /////////
///////////////////////////////////////////////////
var cls_youle_room_player = cls_youle_room_player || {
//构造函数
new: function(playerid, nickname, avatar, sex, playertype, ip, onstate, conmode, fromid){
var player = {};
//基本信息
player.playerid = playerid; //玩家id
player.nickname = nickname;
player.avatar = avatar;
player.sex = sex;
player.playertype = playertype;
player.ip = ip;
player.onstate = onstate; //在线状态 null未连接 0在线 1离线 2电话中
player.conmode = conmode; //连接方式
player.fromid = fromid; //连接id
//初始化游戏数据
player.gameinfo = {};
player.gameinfo.o_game = null; //所在的游戏
player.gameinfo.o_room = null; //所在的房间
player.gameinfo.seat = -1; //房间内的位置
player.gameinfo.isowner = -1; //房主标志 0:非房主 1:是房主
player.gameinfo.agree = -1; //是否同意解散房间 0:申请解散 1:同意解散
player.gameinfo.isbet = -1; //下注标志 0:未下注可离开房间 1:已下注不可离开房间
player.gameinfo.grade = 0; //在房间内的得分
//在定义中没有写入的后加属性
//player.gameinfo.isprepare = 0; //是否准备
//方法
player.method = {};
//获取玩家的基础信息
player.method.get_info = function(){
return cls_youle_room_player.get_info(player);
}
//进入房间
player.method.enter_room = function(o_room, seat, isowner){
cls_youle_room_player.enter_room(player, o_room, seat, isowner);
}
//退出房间
player.method.exit_room = function(){
cls_youle_room_player.exit_room(player);
}
return player;
},
//获取玩家的基础信息
get_info: function(o_player){
var info = {};
info.playerid = o_player.playerid;
info.nickname = o_player.nickname;
info.avatar = o_player.avatar;
info.sex = o_player.sex;
info.ip = o_player.ip;
info.onstate = o_player.onstate;
info.isprepare= o_player.gameinfo.isprepare;
if (o_player.isrobot){
info.bean = o_player.bean;
} else {
info.bean = null;
}
if (o_player.paycode) {
info.paycode = o_player.paycode;
}
info.bean = o_player.bean;
return info;
},
//进入房间
enter_room: function(o_player, o_room, seat, isowner){
o_player.gameinfo.o_game = o_room.o_game;
o_player.gameinfo.o_room = o_room;
o_player.gameinfo.seat = seat;
o_player.gameinfo.isowner = isowner;
o_player.gameinfo.isbet = 0;
o_player.gameinfo.agree = -1;
o_player.gameinfo.grade = 0;
if (o_room.needprepare){
o_player.gameinfo.isprepare = 0;
} else {
o_player.gameinfo.isprepare = 1;
}
o_room.seatlist[seat] = o_player;
if (isowner){
o_room.owner = o_player;
}
//更新tcp连接列表
if (o_player.conmode == "tcp"){
youle_room.tcps.method.load_tcp(o_player.fromid, o_player);
}
//记录当前机器人数量
if (o_player.isrobot){
if (o_room.roommode){
if (!o_room.o_game.robotcount){
o_room.o_game.robotcount = 1;
} else {
o_room.o_game.robotcount = o_room.o_game.robotcount + o_room.beanmult;
}
// console.log('++机器人: ' + o_room.o_game.robotcount);
}
} else {
if (o_room.sysroom){
if (!o_room.o_game.sysroom_playercount){
o_room.o_game.sysroom_playercount = [];
}
for (var i = 0; i < o_room.o_game.sysroom_playercount.length; i++) {
if (JSON.stringify(o_room.o_game.sysroom_playercount[i].roomtype) == JSON.stringify(o_room.roomtype)){
o_room.o_game.sysroom_playercount[i].playercount = o_room.o_game.sysroom_playercount[i].playercount + 1;
return;
}
};
var _v = {};
_v.roomtype = o_room.roomtype;
_v.playercount = 1;
o_room.o_game.sysroom_playercount.push(_v);
}
}
},
//退出房间
exit_room: function(o_player){
//更新tcp连接列表
if (o_player.conmode == "tcp"){
youle_room.tcps.method.delete_tcp(o_player.fromid);
}
o_player.gameinfo.o_room.seatlist[o_player.gameinfo.seat] = null;
//记录当前机器人数量
if (o_player.isrobot){
if (o_player.gameinfo.o_room.roommode){
o_player.gameinfo.o_game.robotcount = o_player.gameinfo.o_game.robotcount - o_player.gameinfo.o_room.beanmult;
// console.log('--机器人: ' + o_player.gameinfo.o_room.o_game.robotcount);
}
} else {
if (o_player.gameinfo.o_room.sysroom){
for (var i = 0; i < o_player.gameinfo.o_game.sysroom_playercount.length; i++) {
if (JSON.stringify(o_player.gameinfo.o_game.sysroom_playercount[i].roomtype) == JSON.stringify(o_player.gameinfo.o_room.roomtype)){
o_player.gameinfo.o_game.sysroom_playercount[i].playercount = o_player.gameinfo.o_game.sysroom_playercount[i].playercount - 1;
break;
}
}
}
}
}
}

957
codes/games/backstage/youle/server_room/class.rebate.js Normal file
View File

@@ -0,0 +1,957 @@
var xRebate = xRebate || {};
xRebate.gameRebate = function(o_room){
var maxgrade = 0;
var maxseat = [];
for (var i = 0; i < o_room.seatlist.length; i++){
if (o_room.seatlist[i] && o_room.seatlist[i].gameinfo.isbet){
if (o_room.seatlist[i].gameinfo.grade > maxgrade){
maxgrade = parseInt(o_room.seatlist[i].gameinfo.grade);
maxseat = [i];
} else if (o_room.seatlist[i].gameinfo.grade == maxgrade){
maxseat.push(i);
}
}
}
var o_agentsvr_agent = youle_agent.agents.method.find_agent(o_room.o_game.o_agent.agentid);
var rebateLimit = 0;
if(o_room.advanced_type){
if(o_room.owner){
var o_player1 = o_agentsvr_agent.method.find_player(o_room.owner.playerid);
for (var i = 0; i < o_player1.roomcodes.length; i++) {
if (o_player1.roomcodes[i].gameid == o_room.o_game.gameid) {
if(o_player1.roomcodes[i].rebateLimit){
rebateLimit = o_player1.roomcodes[i].rebateLimit;
}
break;
}
}
}
}
console.log(rebateLimit);
if (!o_room.roommode){
//非星星场短号房要结算魅力值
try{
//百人场无大局魅力值抽成
if (o_room.advanced_type && o_room.o_game.gameid != "Btke0urRy0cvPd5CIvD5yfhYhKhdSdex"){
var o_agentsvr_agent = youle_agent.agents.method.find_agent(o_room.o_game.o_agent.agentid);
var o_agentsvr_owner = o_agentsvr_agent.method.find_player(o_room.owner.playerid);
if (o_agentsvr_owner.whitelist && o_agentsvr_owner.whitelist.length > 0){
var rebateConfig = youle_room.app.youle_platform.config.method.get_paravalue("rebateConfig", o_room.o_game.o_agent.agentid);
var rCharm = 0;
var maxgrade1 = 0;
var maxseat1 = [];
var rcTemp = false;
if(rebateConfig){
if(rebateConfig.rebateCharm && o_room.rebateType){
//rCharm = parseInt(o_room.rebateNumber/maxseat.length);
rCharm = o_room.rebateNumber;
var _seatlist = [];
for (var i = 0; i < o_room.seatlist.length; i++) {
//if (o_room.seatlist[i]. != null){
if (o_room.seatlist[i]){
var _player = {};
_player.seat = i;
_player.playerid = o_room.seatlist[i].playerid;
_player.change = 0;
for (var j = 0; j < o_agentsvr_owner.whitelist.length; j++) {
if (o_agentsvr_owner.whitelist[j][0] == _player.playerid){
if (o_agentsvr_owner.whitelist[j][2]){
//o_agentsvr_owner.whitelist[j][2] = parseInt(o_agentsvr_owner.whitelist[j][2]) + ary_grade[i];
if(o_room.seatlist[i].gameinfo.grade == maxgrade){
if(rebateLimit < o_room.seatlist[i].gameinfo.grade - rCharm){
o_agentsvr_owner.whitelist[j][2] = parseInt(o_agentsvr_owner.whitelist[j][2]) - rCharm;
_player.change = -rCharm;
}
}
} else {
if(o_room.seatlist[i].gameinfo.grade == maxgrade){
if(rebateLimit < o_room.seatlist[i].gameinfo.grade - rCharm){
o_agentsvr_owner.whitelist[j][2] = -rCharm;
_player.change = -rCharm;
}
}
}
_player.charm = o_agentsvr_owner.whitelist[j][2];
break;
}
}
_seatlist.push(_player);
}
//}
}
var msg = {};
msg.app = "youle";
msg.route = "agent";
msg.rpc = "update_charm";
msg.data = {};
msg.data.seatlist = _seatlist;
o_room.method.sendpack_toother(msg, -1);
var sql = "update player set play_whitelist = ? where play_agentid = ? and play_playerid = ?";
youle_room.mysql.execsql("execsql", sql, [youle_agent.compressWhiteList(o_agentsvr_owner.whitelist), o_room.o_game.o_agent.agentid, o_room.owner.playerid]);
}
}
}
}
}catch(e){
console.log("结算短号魅力值发生错误");
console.log(e);
}
}
//只支持倍数百分比抽成
//抽成参数
var rebateConfig = youle_room.app.youle_platform.config.method.get_paravalue("rebateConfig", o_room.o_game.o_agent.agentid);
if(!rebateConfig){
return;
}
//小局抽成设置
//var aset_rebate = youle_room.app.youle_platform.config.method.get_paravalue("aset_rebate", o_room.o_game.o_agent.agentid);
//是否需要抽成
var rebateTemp = false;
if(!o_room.asetRebate){
rebateTemp = true;
}
//vip房卡房是否扣魅力值
var rebateCharm = rebateConfig.rebateCharm;
//扣除模式 1.大赢家 2.赢家 3.所有人
var rebateFrom = rebateConfig.from;
//房间倍数
var beanmult = 1;
//金币房
if(o_room.roommode){
beanmult = youle_agent.import.createroom_beanmult(o_room.o_game, o_room.roomtype);
}
if(!beanmult){
beanmult = 1;
}
//配置扣除数量
var sysRebateValue = parseInt(rebateConfig.value * beanmult /100);
var agentid = o_room.o_game.o_agent.agentid;
var gameid = o_room.o_game.gameid;
var roomcode = o_room.roomcode;
var createtime = o_room.createtime;
var makewartime = o_room.makewartime;
var roommode = o_room.roommode;
var ownerid = o_room.owner.playerid;
var shortcode = 0;
if (o_room.shortcode){
shortcode = o_room.shortcode;
}
var deductmode = youle_room.import.deduct_roomcard_mode(o_room.o_game, o_room.roomtype);
var asetcount = o_room.asetcount;
var rebateTo = 0;
var rebateMode = 2;
var roomMode = 0;
//房间收取房间费的值
var rebateValue = sysRebateValue;
if(!o_room.roommode){
if(!o_room.advanced_type){
}else{
rebateFrom = 1;
if(rebateCharm && o_room.rebateType){
roomMode = 1;
}
if(o_room.advanced_teabean){
if(sysRebateValue < o_room.advanced_teabean){
rebateMode = 3;
rebateValue = o_room.advanced_teabean;
}
}
}
}else{
if(!o_room.advanced_type){
var tea = youle_room.import.owner_beanpush(o_room.o_game, o_room.roomtype);
if(tea){
if(sysRebateValue < tea){
rebateMode = 3;
rebateValue = tea;
}
}
}else{
if(o_room.advanced_teabean){
if(sysRebateValue < o_room.advanced_teabean){
rebateMode = 3;
rebateValue = o_room.advanced_teabean;
}
}
}
}
//每个人扣除的数量
var rebateReal = rebateValue;
//通过扣除模式得出每个人扣的数量
switch(rebateFrom){
//大赢家
case 1:
rebateReal = parseInt(rebateValue / maxseat.length);//多个大赢家均摊房间费
sysRebateValue = parseInt(sysRebateValue / maxseat.length);//多个大赢家均摊房间费
break;
//赢家
case 2:
break;
//所有人
case 3:
break;
default:
break;
}
var ownergarde = 0;
//var rebateSum = 0;//总共扣除的房间费
//console.log(o_room.seatlist);
//if(rebateReal){
var ownerid = null;
var pushCount = 0;
if(o_room.owner){
ownerid = o_room.owner.playerid;
}
//console.log("sysRebateValue",sysRebateValue);
//console.log("rebateReal",rebateReal);
for (var i = 0; i < o_room.seatlist.length; i++) {
if (o_room.seatlist[i]){
var o_player = o_room.seatlist[i];
if (o_player.gameinfo.isbet) {
var o_agentsvr_player = o_agentsvr_agent.method.find_player(o_player.playerid);
var roomcard = 0;
if (playerid == o_room.owner.playerid){
roomcard = youle_room.import.createroom_needroomcard(o_room.o_game, o_room.roomtype);
} else {
roomcard = youle_room.import.joinroom_needroomcard(o_room.o_game, o_room.roomtype);
}
if (o_player.playerid == o_room.owner.playerid) {
ownergarde = o_player.gameinfo.grade;
}
var isRebate = false;
switch(rebateFrom){
//大赢家
case 1:
if(o_player.gameinfo.grade == maxgrade && rebateLimit < o_player.gameinfo.grade){
isRebate = true;
}
break;
//赢家
case 2:
if(o_player.gameinfo.grade > 0 && rebateLimit < o_player.gameinfo.grade){
isRebate = true;
}
break;
//所有人
case 3:
isRebate = true;
break;
default:
break;
}
//console.log("playerid:"+o_player.playerid+"grade:"+o_player.gameinfo.grade+"isRebate:"+isRebate);
//房间id = 时间戳 + 4位随机码 + 房号
var roomid = new Date().getTime() + min_randomChar(4) + o_room.roomcode;
var datatime = min_now();
//达成抽成条件
if(isRebate && rebateTemp){
//rebateSum += rebateReal;
if(!roomMode){
var msg = {};
msg.app = youle_room.app.appname;
msg.route = youle_room.app.youle_agent.routename;
msg.rpc = "update_bean";
msg.data = {};
msg.data.agentid = agentid;
msg.data.playerid = o_player.playerid;
if(o_room.roommode){
msg.data.change = o_player.gameinfo.grade;
}else{
msg.data.change = 0;
}
var nBean = rebateReal - msg.data.change;
var sysBean = 0;
//console.log("o_player.bean",o_player.bean,"nBean",nBean);
if(o_player.bean >= nBean){
if(ownerid == o_agentsvr_player.playerid){
msg.data.pushbean = 0;
}else{
if(o_room.roommode){
msg.data.pushbean = -1 * rebateReal;
// pushCount += rebateReal;
sysBean = sysRebateValue;
pushCount = pushCount + (rebateReal - sysRebateValue);
}else{
msg.data.pushbean = -1 * rebateReal;
//sysBean = sysRebateValue;
pushCount = pushCount + rebateReal;
}
}
}else{
msg.data.pushbean = 0;
}
msg.data.gameid = gameid;
msg.data.showrebate = 0;
youle_room.app.youle_agent[msg.rpc](msg);
var roommode = 0; //玩家房间
if (o_room.sysroom) {
roommode = 1; //系统房间
}
var createtime = o_room.createtime;
var beanmult = 0;
if (o_room.beanmult){
beanmult = o_room.beanmult;
}
var ownerid = o_room.owner.playerid;
var shortcode = 0;
if (o_room.shortcode){
shortcode = o_room.shortcode;
}
var deductmode = youle_room.import.deduct_roomcard_mode(o_room.o_game, o_room.roomtype);
var playerid = o_player.playerid;
var grade = o_player.gameinfo.grade;
var roomcard = 0;
if (playerid == o_room.owner.playerid){
roomcard = youle_room.import.createroom_needroomcard(o_room.o_game, o_room.roomtype);
} else {
roomcard = youle_room.import.joinroom_needroomcard(o_room.o_game, o_room.roomtype);
}
var asetcount = o_room.asetcount;
var sql = "insert into gold_account(goac_id,goac_agentid,goac_gameid,goac_roomcode,goac_roommode,goac_createtime,goac_beanmult,goac_ownerid,goac_shortcode,goac_deduct,goac_roomcard,goac_datatype,goac_asetcount,goac_asetnum,goac_playerid,goac_isrobot,goac_grade,goac_rebatefrom,goac_rebateto,goac_toplayerid,goac_rebatemode,goac_setvalue,goac_rebatevalue,goac_time) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);";
youle_room.mysql_grade.execsql("execsql", sql, [roomid, agentid, gameid, roomcode, roommode, createtime, beanmult, ownerid, shortcode, deductmode, roomcard, 0, asetcount, 0, playerid, 0, grade, rebateFrom, rebateTo, '', rebateMode, sysBean, sysBean, datatime]);
}
// else{
// //修改房卡数量
// var msg2 = {};
// msg2.data={};
// msg2.data.agentid = agentid;
// msg2.data.playerid = o_player.playerid;
// msg2.data.change = -1*rebateReal;
// xRebate.update_roomcard(msg2);
// }
}else{
var msg = {};
msg.app = youle_room.app.appname;
msg.route = youle_room.app.youle_agent.routename;
msg.rpc = "update_bean";
msg.data = {};
msg.data.agentid = agentid;
msg.data.playerid = o_player.playerid;
if(o_room.roommode){
msg.data.change = o_player.gameinfo.grade;
}else{
msg.data.change = 0;
}
msg.data.pushbean = 0;
msg.data.gameid = gameid;
msg.data.showrebate = 1;
youle_room.app.youle_agent[msg.rpc](msg);
var roommode = 0; //玩家房间
if (o_room.sysroom) {
roommode = 1; //系统房间
}
var createtime = o_room.createtime;
var beanmult = 0;
if (o_room.beanmult){
beanmult = o_room.beanmult;
}
var ownerid = o_room.owner.playerid;
var shortcode = 0;
if (o_room.shortcode){
shortcode = o_room.shortcode;
}
var deductmode = youle_room.import.deduct_roomcard_mode(o_room.o_game, o_room.roomtype);
var playerid = o_player.playerid;
var grade = o_player.gameinfo.grade;
var roomcard = 0;
if (playerid == o_room.owner.playerid){
roomcard = youle_room.import.createroom_needroomcard(o_room.o_game, o_room.roomtype);
} else {
roomcard = youle_room.import.joinroom_needroomcard(o_room.o_game, o_room.roomtype);
}
var asetcount = o_room.asetcount;
var sql = "insert into gold_account(goac_id,goac_agentid,goac_gameid,goac_roomcode,goac_roommode,goac_createtime,goac_beanmult,goac_ownerid,goac_shortcode,goac_deduct,goac_roomcard,goac_datatype,goac_asetcount,goac_asetnum,goac_playerid,goac_isrobot,goac_grade,goac_rebatefrom,goac_rebateto,goac_toplayerid,goac_rebatemode,goac_setvalue,goac_rebatevalue,goac_time) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);";
youle_room.mysql_grade.execsql("execsql", sql, [roomid, agentid, gameid, roomcode, roommode, createtime, beanmult, ownerid, shortcode, deductmode, roomcard, 0, asetcount, 0, playerid, 0, grade, 0, rebateTo, '', rebateMode, 0, 0, datatime]);
}
}
}
}
//console.log("pushCount",pushCount);
if(pushCount){
var msg = {};
msg.app = youle_room.app.appname;
msg.route = youle_room.app.youle_agent.routename;
msg.rpc = "update_bean";
msg.data = {};
msg.data.agentid = agentid;
msg.data.playerid = ownerid;
msg.data.change = 0;
msg.data.pushbean = pushCount;
msg.data.gameid = gameid;
msg.data.showrebate = 0;
msg.data.type = 6;
youle_room.app.youle_agent[msg.rpc](msg);
var roommode = 0; //玩家房间
if (o_room.sysroom) {
roommode = 1; //系统房间
}
var createtime = o_room.createtime;
var beanmult = 0;
if (o_room.beanmult){
beanmult = o_room.beanmult;
}
var ownerid = o_room.owner.playerid;
var shortcode = 0;
if (o_room.shortcode){
shortcode = o_room.shortcode;
}
var deductmode = youle_room.import.deduct_roomcard_mode(o_room.o_game, o_room.roomtype);
var playerid = ownerid;
var grade = 0;
var roomcard = 0;
if (playerid == o_room.owner.playerid){
roomcard = youle_room.import.createroom_needroomcard(o_room.o_game, o_room.roomtype);
} else {
roomcard = youle_room.import.joinroom_needroomcard(o_room.o_game, o_room.roomtype);
}
var asetcount = o_room.asetcount;
var sql = "insert into gold_account(goac_id,goac_agentid,goac_gameid,goac_roomcode,goac_roommode,goac_createtime,goac_beanmult,goac_ownerid,goac_shortcode,goac_deduct,goac_roomcard,goac_datatype,goac_asetcount,goac_asetnum,goac_playerid,goac_isrobot,goac_grade,goac_rebatefrom,goac_rebateto,goac_toplayerid,goac_rebatemode,goac_setvalue,goac_rebatevalue,goac_time) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);";
youle_room.mysql_grade.execsql("execsql", sql, [roomid, agentid, gameid, roomcode, roommode, createtime, beanmult, ownerid, shortcode, deductmode, roomcard, 0, asetcount, 0, playerid, 0, grade, rebateFrom, 1, ownerid, rebateMode, pushCount, pushCount, datatime]);
}
//}
}
//修改房卡
xRebate.update_roomcard = function(pack){
var agentid = pack.data.agentid;
var playerid = pack.data.playerid;
var change = parseInt(pack.data.change);
//查找代理商
var o_agent = youle_agent.agents.method.find_agent(agentid);
if (!o_agent) {
pack.data = {};
pack.data.result = 1;
pack.data.error = "agentid不存在";
return pack;
};
var db_callback = function(dbdata){
if (dbdata[0].result == 0){
var o_player = o_agent.method.find_player(playerid);
if (o_player){
o_player.method.update_roomcard(0, parseInt(dbdata[0].roomcard), change,"房间费");
}
pack.data.result = 0;
} else {
pack.data = {};
pack.data.result = dbdata[0].result;
pack.data.error = dbdata[0].error;
}
youle_agent.app.SendPack(pack);
}
var sql = "call cp_game_update_roomcard(?,?,?);";
youle_agent.mysql.execsql("opensql", sql, [agentid, playerid, change], db_callback);
}
//百人vip房抽成
xRebate.gameRebate2 = function(o_room,ary_grade){
var ary_grade1=[];
for(var i=0;i<ary_grade.length;i++){
ary_grade1.push(ary_grade[i]);
}
//小局抽成设置
// var rebateConfig = youle_room.app.youle_platform.config.method.get_paravalue("aset_rebate", o_room.o_game.o_agent.agentid);
var rebateConfig = youle_room.app.youle_platform.config.method.get_paravalue("rebateConfig", o_room.o_game.o_agent.agentid);
if(!rebateConfig){
return ary_grade1;
}
// if(!rebateConfig.infinite){
// return ary_grade1;
// }
if(o_room.o_game.gameid != "Btke0urRy0cvPd5CIvD5yfhYhKhdSdex"){
return ary_grade1;
}
// if(o_room.rebateType){
// return;
// }
var rbtTemp = false;//游戏是否产生了胜负
var maxgrade = 0;
var maxseat = [];
for (var i = 0; i < ary_grade.length; i++){
if (ary_grade[i]){
ary_grade[i] = Number(ary_grade[i]);
if (ary_grade[i] > maxgrade){
maxgrade = ary_grade[i];
maxseat = [i];
} else if (ary_grade[i] == maxgrade){
maxseat.push(i);
}
if(ary_grade[i] < 0){
rbtTemp = true;
}
}
}
//统计总共参与游戏人数
var ownerid = null;
if(o_room.owner){
ownerid = o_room.owner.playerid;
}
var gameCount = 0;
for (var i = 0; i < ary_grade.length; i++) {
if (o_room.seatlist[i] && ary_grade[i] != null){
var o_player = o_room.seatlist[i];
//console.log("ccc",o_player.playerid,o_player.gameinfo.isbet);
if (o_player.gameinfo.isbet && ownerid != o_player.playerid) {
gameCount++;
}
}
}
if(!rbtTemp){
return ary_grade;
}
//只支持倍数百分比抽成
//抽成参数
//小局抽成设置
//var aset_rebate = youle_room.app.youle_platform.config.method.get_paravalue("aset_rebate", o_room.o_game.o_agent.agentid);
//扣除模式 1.大赢家 2.赢家 3.所有人
// var rebateFrom = rebateConfig.from;
var rebateFrom = 1;
var o_agentsvr_agent = youle_agent.agents.method.find_agent(o_room.o_game.o_agent.agentid);
//配置扣除数量
var sysRebateValue = o_room.rebateNumber;
var sysRebateValue1 = o_room.sysRebateValue;
var agentid = o_room.o_game.o_agent.agentid;
var gameid = o_room.o_game.gameid;
var roomcode = o_room.roomcode;
var createtime = o_room.createtime;
var makewartime = o_room.makewartime;
var roommode = o_room.roommode;
var ownerid = o_room.owner.playerid;
var shortcode = 0;
if (o_room.shortcode){
shortcode = o_room.shortcode;
}
var deductmode = youle_room.import.deduct_roomcard_mode(o_room.o_game, o_room.roomtype);
var asetcount = o_room.asetcount;
var rebateTo = 0;
var rebateMode = 2;
var roomMode = 0;
//房间收取房间费的值
var rebateValue = sysRebateValue;
//每个人扣除的数量
var rebateReal = rebateValue;
//通过扣除模式得出每个人扣的数量
switch(rebateFrom){
//大赢家
case 1:
if(maxseat.length>0){
rebateReal = parseInt(rebateValue / maxseat.length);//多个大赢家均摊房间费
sysRebateValue1 = parseInt(sysRebateValue1 / maxseat.length);//多个大赢家均摊房间费
}
break;
//赢家
case 2:
break;
//所有人
case 3:
break;
default:
break;
}
var ownergarde = 0;
var brNumber = youle_room.app.youle_platform.config.method.get_paravalue("brNumber",o_room.o_game.o_agent.agentid);
var brRebateUnit = youle_room.app.youle_platform.config.method.get_paravalue("brRebateUnit",o_room.o_game.o_agent.agentid);
var o_agentsvr_agent = youle_agent.agents.method.find_agent(o_room.o_game.o_agent.agentid);
var o_agentsvr_owner = o_agentsvr_agent.method.find_player(o_room.owner.playerid);
//var o_agentsvr_agent = youle_agent.agents.method.find_agent(o_room.o_game.o_agent.agentid);
var rebateLimit = 0;
if(o_room.advanced_type){
if(o_room.owner){
var o_player1 = o_agentsvr_agent.method.find_player(o_room.owner.playerid);
for (var i = 0; i < o_player1.roomcodes.length; i++) {
if (o_player1.roomcodes[i].gameid == o_room.o_game.gameid) {
if(o_player1.roomcodes[i].rebateLimit){
rebateLimit = o_player1.roomcodes[i].rebateLimit;
}
break;
}
}
}
}
if(!rebateLimit){
rebateLimit = 0;
}
console.log(rebateLimit);
if(brRebateUnit){
brRebateUnit = Number(brRebateUnit);
}else{
brRebateUnit = 10000;
}
var brNumber1 = 0;
if(brNumber && brRebateUnit != 0){
brNumber = Number(brNumber);
//brNumber = brNumber*(parseInt(gameCount / brRebateUnit) + 1);
//parseInt(gameCount / brRebateUnit) < 1 ? brNumber = brNumber*parseInt(gameCount / brRebateUnit) : brNumber = brNumber*(parseInt(gameCount / brRebateUnit) + 1);
if(parseInt(gameCount / brRebateUnit) > 1){
brNumber = brNumber*parseInt(gameCount / brRebateUnit);
}
}
//console.log("gameCount",gameCount,"brRebateUnit",brRebateUnit);
if(brNumber){
//brNumber = Number(brNumber);
//房主扣除房间费 金币
var agentid = o_room.o_game.o_agent.agentid;
var o_player = o_agentsvr_owner;
var gameid = o_room.o_game.gameid;
var datatime = min_now();
var msg = {};
msg.app = youle_room.app.appname;
msg.route = youle_room.app.youle_agent.routename;
msg.rpc = "update_bean";
msg.data = {};
msg.data.agentid = agentid;
msg.data.playerid = o_player.playerid;
msg.data.change = 0;
msg.data.pushbean = -1 * brNumber;
msg.data.gameid = gameid;
msg.data.showrebate = 0;
youle_room.app.youle_agent[msg.rpc](msg);
var pBean = o_player.bean;
//console.log("pBean",pBean);
var roommode = 0; //玩家房间
// if (o_room.sysroom) {
// roommode = 1; //系统房间
// }
var createtime = o_room.createtime;
var beanmult = 0;
if (o_room.beanmult){
beanmult = o_room.beanmult;
}
var ownerid = o_room.owner.playerid;
// var shortcode = 0;
// if (o_room.shortcode){
// shortcode = o_room.shortcode;
// }
var deductmode = youle_room.import.deduct_roomcard_mode(o_room.o_game, o_room.roomtype);
var playerid = o_player.playerid;
var grade = o_player.gameinfo.grade;
var roomcard = 0;
if (playerid == o_room.owner.playerid){
roomcard = youle_room.import.createroom_needroomcard(o_room.o_game, o_room.roomtype);
} else {
roomcard = youle_room.import.joinroom_needroomcard(o_room.o_game, o_room.roomtype);
}
var roomid = new Date().getTime() + min_randomChar(4) + o_room.roomcode;
var roomcode = o_room.roomcode;
var asetcount = o_room.asetcount;
var sql = "insert into gold_account(goac_id,goac_agentid,goac_gameid,goac_roomcode,goac_roommode,goac_createtime,goac_beanmult,goac_ownerid,goac_shortcode,goac_deduct,goac_roomcard,goac_datatype,goac_asetcount,goac_asetnum,goac_playerid,goac_isrobot,goac_grade,goac_rebatefrom,goac_rebateto,goac_toplayerid,goac_rebatemode,goac_setvalue,goac_rebatevalue,goac_time) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);";
youle_room.mysql_grade.execsql("execsql", sql, [roomid, agentid, gameid, roomcode, roommode, createtime, beanmult, ownerid, shortcode, deductmode, roomcard, 0, asetcount, 0, playerid, 0, 0, 4, 2, '', 3, brNumber, brNumber, datatime]);
}
var rbType = o_room.rebateType;
try{
if (o_room.shortcode){
if (o_agentsvr_owner.whitelist && o_agentsvr_owner.whitelist.length > 0){
var rebateConfig = youle_room.app.youle_platform.config.method.get_paravalue("rebateConfig", o_room.o_game.o_agent.agentid);
var rCharm = 0;
var maxgrade1 = 0;
var maxseat1 = [];
var rcTemp = false;
if(maxseat.length>0){
rCharm = parseInt(o_room.rebateNumber/maxseat.length);
}else{
rCharm = parseInt(o_room.rebateNumber);
}
// if(rebateConfig){
// if(rebateConfig.rebateCharm && o_room.rebateType){
// rcTemp = true;
// }
//抽金币
// if(!o_room.rebateType){
// reTemp = true;
// }
// }
var _seatlist = [];
// console.log("ary_grade",ary_grade);
// console.log("333",JSON.stringify(o_agentsvr_owner.whitelist));
// console.log("rCharm",rCharm);
for (var i = 0; i < ary_grade.length; i++) {
if (ary_grade[i] != null){
if (o_room.seatlist[i]){
var _player = {};
_player.seat = i;
_player.playerid = o_room.seatlist[i].playerid;
_player.change = 0;
for (var j = 0; j < o_agentsvr_owner.whitelist.length; j++) {
if (o_agentsvr_owner.whitelist[j][0] == _player.playerid){
if (o_agentsvr_owner.whitelist[j][2]){
if(rbType && ary_grade[i] == maxgrade && rebateLimit <ary_grade[i]){
o_agentsvr_owner.whitelist[j][2] = parseInt(o_agentsvr_owner.whitelist[j][2]) - rCharm;
ary_grade1[i] = ary_grade1[i] - rCharm;
}
} else {
if(rbType && ary_grade[i] == maxgrade && rebateLimit <ary_grade[i]){
o_agentsvr_owner.whitelist[j][2] = -1 * rCharm;
ary_grade1[i] = ary_grade1[i] - rCharm;
}
}
_player.charm = o_agentsvr_owner.whitelist[j][2];
break;
}
}
_seatlist.push(_player);
}
}
}
var msg = {};
msg.app = "youle";
msg.route = "agent";
msg.rpc = "update_charm";
msg.data = {};
msg.data.seatlist = _seatlist;
o_room.method.sendpack_toother(msg, -1);
// console.log("222",JSON.stringify(o_agentsvr_owner.whitelist));
var sql = "update player set play_whitelist = ? where play_agentid = ? and play_playerid = ?";
youle_room.mysql.execsql("execsql", sql, [youle_agent.compressWhiteList(o_agentsvr_owner.whitelist), o_room.o_game.o_agent.agentid, o_room.owner.playerid]);
}
}
}catch(e){
console.log("结算短号魅力值发生错误");
console.log(e);
}
//var rebateSum = 0;//总共扣除的房间费
//console.log("seatlist",o_room.seatlist);
//console.log("rebateReal",rebateReal);
//console.log("sysRebateValue1",sysRebateValue1);
var pushCount = 0;
if(!o_room.rebateType){
for (var i = 0; i < ary_grade.length; i++) {
if (o_room.seatlist[i] && ary_grade[i] != null){
var o_player = o_room.seatlist[i];
//console.log("ccc",o_player.playerid,o_player.gameinfo.isbet);
if (o_player.gameinfo.isbet) {
var o_agentsvr_player = o_agentsvr_agent.method.find_player(o_player.playerid);
var roomcard = 0;
if (o_player.playerid == o_room.owner.playerid){
roomcard = youle_room.import.createroom_needroomcard(o_room.o_game, o_room.roomtype);
} else {
roomcard = youle_room.import.joinroom_needroomcard(o_room.o_game, o_room.roomtype);
}
if (o_player.playerid == o_room.owner.playerid) {
ownergarde = ary_grade[i];
}
var isRebate = false;
switch(rebateFrom){
//大赢家
case 1:
if(ary_grade[i] == maxgrade){
isRebate = true;
}
break;
//赢家
case 2:
if(ary_grade[i] > 0){
isRebate = true;
}
break;
//所有人
case 3:
isRebate = true;
break;
default:
break;
}
//console.log("playerid:"+o_player.playerid+"grade:"+o_player.gameinfo.grade+"isRebate:"+isRebate);
//房间id = 时间戳 + 4位随机码 + 房号
var roomid = new Date().getTime() + min_randomChar(4) + o_room.roomcode;
var datatime = min_now();
//达成抽成条件
if(isRebate){
//rebateSum += rebateReal;
// if(!roomMode){
var msg = {};
msg.app = youle_room.app.appname;
msg.route = youle_room.app.youle_agent.routename;
msg.rpc = "update_bean";
msg.data = {};
msg.data.agentid = agentid;
msg.data.playerid = o_player.playerid;
if(o_room.roommode){
msg.data.change = o_player.gameinfo.grade;
}else{
msg.data.change = 0;
}
var sysBean = 0;
if(ownerid == o_player.playerid){
msg.data.pushbean = 0;
}else{
//var nBean = rebateReal - msg.data.change;
//console.log("o_player.bean",o_player.bean,"nBean",nBean);
//if(o_player.bean >= nBean){
// if(rebateLimit < (ary_grade[i] - rebateReal)){
msg.data.pushbean = -1 * rebateReal;
// pushCount += rebateReal;
sysBean = sysRebateValue1;
pushCount = pushCount + (rebateReal - sysRebateValue1);
// }else{
// if(ary_grade[i] > rebateLimit){
// msg.data.pushbean = -1 * (ary_grade[i] - rebateLimit);
// if(ary_grade[i] - rebateLimit > sysRebateValue1){
// pushCount = pushCount + (ary_grade[i] - rebateLimit - sysRebateValue1);
// sysBean = sysRebateValue1;
// }else{
// }
// }else{
// msg.data.pushbean = 0;
// }
// }
// }else{
// msg.data.pushbean = 0;
// }
}
msg.data.gameid = gameid;
msg.data.showrebate = 0;
youle_room.app.youle_agent[msg.rpc](msg);
var roommode = 0; //玩家房间
if (o_room.sysroom) {
roommode = 1; //系统房间
}
var createtime = o_room.createtime;
var beanmult = 0;
if (o_room.beanmult){
beanmult = o_room.beanmult;
}
var ownerid = o_room.owner.playerid;
var shortcode = 0;
if (o_room.shortcode){
shortcode = o_room.shortcode;
}
var deductmode = youle_room.import.deduct_roomcard_mode(o_room.o_game, o_room.roomtype);
var playerid = o_player.playerid;
var grade = o_player.gameinfo.grade;
var roomcard = 0;
if (playerid == o_room.owner.playerid){
roomcard = youle_room.import.createroom_needroomcard(o_room.o_game, o_room.roomtype);
} else {
roomcard = youle_room.import.joinroom_needroomcard(o_room.o_game, o_room.roomtype);
}
var asetcount = o_room.asetcount;
var sql = "insert into gold_account(goac_id,goac_agentid,goac_gameid,goac_roomcode,goac_roommode,goac_createtime,goac_beanmult,goac_ownerid,goac_shortcode,goac_deduct,goac_roomcard,goac_datatype,goac_asetcount,goac_asetnum,goac_playerid,goac_isrobot,goac_grade,goac_rebatefrom,goac_rebateto,goac_toplayerid,goac_rebatemode,goac_setvalue,goac_rebatevalue,goac_time) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);";
youle_room.mysql_grade.execsql("execsql", sql, [roomid, agentid, gameid, roomcode, roommode, createtime, beanmult, ownerid, shortcode, deductmode, roomcard, 0, asetcount, 0, playerid, 0, grade, rebateFrom, 0, '', rebateMode, sysBean, sysBean , datatime]);
// }
}
}
}
}
//console.log("pushCount",pushCount);
if(pushCount){
var ownerid = o_room.owner.playerid;
var msg = {};
msg.app = youle_room.app.appname;
msg.route = youle_room.app.youle_agent.routename;
msg.rpc = "update_bean";
msg.data = {};
msg.data.agentid = agentid;
msg.data.playerid = ownerid;
msg.data.change = 0;
msg.data.pushbean = pushCount;
msg.data.gameid = gameid;
msg.data.showrebate = 0;
msg.data.type = 6;
youle_room.app.youle_agent[msg.rpc](msg);
var roommode = 0; //玩家房间
if (o_room.sysroom) {
roommode = 1; //系统房间
}
var createtime = o_room.createtime;
var beanmult = 0;
if (o_room.beanmult){
beanmult = o_room.beanmult;
}
var shortcode = 0;
if (o_room.shortcode){
shortcode = o_room.shortcode;
}
var deductmode = youle_room.import.deduct_roomcard_mode(o_room.o_game, o_room.roomtype);
var playerid = ownerid;
var grade = 0;
var roomcard = 0;
if (playerid == o_room.owner.playerid){
roomcard = youle_room.import.createroom_needroomcard(o_room.o_game, o_room.roomtype);
} else {
roomcard = youle_room.import.joinroom_needroomcard(o_room.o_game, o_room.roomtype);
}
var asetcount = o_room.asetcount;
var sql = "insert into gold_account(goac_id,goac_agentid,goac_gameid,goac_roomcode,goac_roommode,goac_createtime,goac_beanmult,goac_ownerid,goac_shortcode,goac_deduct,goac_roomcard,goac_datatype,goac_asetcount,goac_asetnum,goac_playerid,goac_isrobot,goac_grade,goac_rebatefrom,goac_rebateto,goac_toplayerid,goac_rebatemode,goac_setvalue,goac_rebatevalue,goac_time) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);";
youle_room.mysql_grade.execsql("execsql", sql, [roomid, agentid, gameid, roomcode, roommode, createtime, beanmult, ownerid, shortcode, deductmode, roomcard, 0, asetcount, 0, playerid, 0, grade, rebateFrom, 1, ownerid, rebateMode, pushCount, pushCount, datatime]);
}
}
//解散
if(pBean < brNumber){
breakTemp = true;
youle_room.import.gameBreak(o_room);
}
return ary_grade1;
}

181
codes/games/backstage/youle/server_room/class.return.js Normal file
View File

@@ -0,0 +1,181 @@
///////////////////////////////////////////////////
///////// cls_youle_room_return: 返回结果 //////////
///////////////////////////////////////////////////
var cls_youle_room_return = cls_youle_room_return || {
new: function() {
var re = {};
//创建房间成功
re.create_room = function(pack, o_player){
pack.route = youle_room.routename;
pack.rpc = "create_room";
pack.data = {};
pack.data.state = 0;
if (o_player.gameinfo.o_room){
pack.data.roomcode = o_player.gameinfo.o_room.roomcode;
if (o_player.gameinfo.o_room.makewar){
pack.data.makewar = o_player.gameinfo.o_room.makewar;
} else {
pack.data.makewar = o_player.gameinfo.o_game.makewar;
}
pack.data.roomtype = o_player.gameinfo.o_room.roomtype;
pack.data.asetcount = o_player.gameinfo.o_room.asetcount;
pack.data.seat = o_player.gameinfo.seat;
pack.data.infinite = o_player.gameinfo.o_room.infinite;
pack.data.needprepare = o_player.gameinfo.o_room.needprepare;
}
return pack;
};
//加入房间成功
re.self_join_room = function(pack, o_player, playerbean, playercharm){
var isbattle; //是否开战了
var isfull; //是否满桌了
var deskinfo; //房间已经开战的牌桌信息
var deskwar; //房间满桌自动开战包
var o_room = o_player.gameinfo.o_room;
if (o_room.battlestate == 1) {
isbattle = true;
deskinfo = youle_room.import.get_deskinfo(o_room, o_player.gameinfo.seat);
} else {
isfull = o_room.method.get_isfull();
if (isfull) {
//满桌了自动开战
o_room.battlestate = 1;
o_room.makewartime = min_now();
//如果有返回值则后面的代码会发统一的开战包，如果没有返回值则由游戏负责发开战包
deskwar = youle_room.import.makewar_deskwar(o_room);
} else {
//子游戏设置的开战人数
var makewarplayercount = youle_room.import.makewar_playercount(o_room.o_game, o_room.roomtype);
if (makewarplayercount){
var playercount = 0;
for (var i = 0; i < o_room.seatlist.length; i++) {
if (o_room.seatlist[i] && o_room.seatlist[i].gameinfo.isprepare){
playercount = playercount + 1;
}
}
if (playercount == makewarplayercount){
isfull = true;
o_room.battlestate = 1;
o_room.makewartime = min_now();
//如果有返回值则后面的代码会发统一的开战包，如果没有返回值则由游戏负责发开战包
deskwar = youle_room.import.makewar_deskwar(o_room);
}
}
}
}
pack.route = youle_room.routename;
pack.rpc = "self_join_room";
pack.data = {};
pack.data.state = 0;
pack.data.roomcode = o_room.roomcode;
pack.data.roomtype = o_room.roomtype;
pack.data.asetcount = o_room.asetcount;
pack.data.seat = o_player.gameinfo.seat;
pack.data.infinite = o_room.infinite;
pack.data.needprepare = o_room.needprepare;
if (o_room.makewar){
pack.data.makewar = o_room.makewar;
} else {
pack.data.makewar = o_player.gameinfo.o_game.makewar;
}
pack.data.players = o_room.method.get_playerlist();//获取房间内的玩家列表
//如果已开战则返回开战时的牌桌信息
if (isbattle) {
pack.data.deskinfo = deskinfo;
} else {
if (isfull) {
if (deskwar) {
pack.data.deskwar = deskwar;
}
}
}
//通知房间内的其他人有人加入了房间
var msg = {};
msg.app = youle_room.app.appname;
msg.route = youle_room.routename;
msg.rpc = "other_join_room";
msg.data = o_player.method.get_info();
msg.data.bean = playerbean;
if (o_room.shortcode){
if (playercharm || playercharm == 0){
msg.data.charm = playercharm;
}
}
msg.data.seat = o_player.gameinfo.seat;
msg.data.isprepare = o_player.gameinfo.isprepare;
if (o_player.paycode){
msg.data.paycode = o_player.paycode;
}
for (var i = 0; i < o_room.seatlist.length; i++) {
if (o_room.seatlist[i] && (i != o_player.gameinfo.seat)) {
msg.conmode = o_room.seatlist[i].conmode;
msg.fromid = o_room.seatlist[i].fromid;
if (!isbattle && isfull) {
if (deskwar) {
msg.data.deskwar = deskwar;
}
}
youle_room.app.SendPack(msg);
}
}
return pack;
};
//断线重连
re.player_login = function(pack, o_player){
pack.route = youle_room.routename;
pack.rpc = "player_login";
pack.data = {};
pack.data.state = 0;
pack.data.gameid = o_player.gameinfo.o_game.gameid;
pack.data.roomcode = o_player.gameinfo.o_room.roomcode;
pack.data.roomtype = o_player.gameinfo.o_room.roomtype;
pack.data.asetcount = o_player.gameinfo.o_room.asetcount;
pack.data.roommode = o_player.gameinfo.o_room.roommode;
pack.data.beanfloor = o_player.gameinfo.o_room.beanfloor;
pack.data.makewar = o_player.gameinfo.o_game.makewar;
pack.data.isbattle = o_player.gameinfo.o_room.battlestate;
pack.data.needprepare = o_player.gameinfo.o_room.needprepare;
pack.data.seat = o_player.gameinfo.seat;
pack.data.isowner = o_player.gameinfo.isowner;
pack.data.isbet = o_player.gameinfo.isbet;
pack.data.infinite = o_player.gameinfo.o_room.infinite;
//获取房间内的玩家列表
pack.data.players = o_player.gameinfo.o_room.method.get_playerlist();
//获取房间的申请解散状态
pack.data.agreefree = o_player.gameinfo.o_room.method.get_agreefree();
//获取牌局信息
if (o_player.gameinfo.o_room.battlestate == 1){
pack.data.deskinfo = youle_room.import.get_deskinfo(o_player.gameinfo.o_room, o_player.gameinfo.seat);
}
if (o_player.gameinfo.o_room.match_data){
pack.data.match_data = o_player.gameinfo.o_room.match_data;
pack.data.match_roomcard = o_player.gameinfo.o_room.needroomcard;
}
//通知前端房间内的其他人有人上线了
var msg = {};
msg.app = youle_room.app.appname;
msg.route = youle_room.routename;
msg.rpc = "other_online";
msg.data = {};
msg.data.seat = o_player.gameinfo.seat;
msg.data.playerid = o_player.playerid;
msg.data.nickname = o_player.nickname;
msg.data.avatar = o_player.avatar;
msg.data.sex = o_player.sex;
msg.data.ip = o_player.ip;
o_player.gameinfo.o_room.method.sendpack_toother(msg, o_player.gameinfo.seat);
return pack;
};
return re;
}
}
//返回结果
youle_room.return = cls_youle_room_return.new();

443
codes/games/backstage/youle/server_room/class.room.js Normal file
View File

@@ -0,0 +1,443 @@
///////////////////////////////////////////////////
////////// cls_youle_room_room: 房间 //////////
///////////////////////////////////////////////////
var cls_youle_room_room = cls_youle_room_room || {
//构造函数
new: function(o_game, roomcode, roomtype, needroomcard, asetcount){
var room = {};
//基本信息
room.o_game = o_game; //游戏
room.roomcode = roomcode; //房号
room.roomtype = roomtype; //房间类型
room.needroomcard = needroomcard; //开房需要的房卡数量
room.asetcount = asetcount; //总局数
room.createtime = min_now(); //开房时间
room.seatlist = []; //座位列表
var makewarplayercount = youle_room.import.makewar_playercount(o_game, roomtype);
if (makewarplayercount){
room.seatlist.length = makewarplayercount;
} else {
room.seatlist.length = o_game.seatcount;
}
room.battlestate = 0; //游戏状态 0:未开战 1:已开战
room.makewartime = null; //开战时间
room.owner = null; //房主
room.applyfreetime = null; //申请解散的时间
room.freetimer = null; //默认同意解散房间的定时器
room.wasdeduct = false; //是否扣除了房主的房卡
//24小时后如果没有玩家在房间内则解散房间的定时器
var do_freeroom24 = function(){
for (var i = 0; i < room.seatlist.length; i++) {
if (room.seatlist[i]){
return;
}
}
min_closetime(room.freetimer24);
room.freetimer24 = null;
youle_room.export.save_grade(room, null, null, 1);
}
room.freetimer24 = min_ontime(do_freeroom24, 24 * 60 * 60 * 1000);
//方法
room.method = {};
//查找玩家
room.method.find_player = function(playerid){
return cls_youle_room_room.find_player(room, playerid);
}
//获取玩家人数
room.method.get_playercount = function(){
return cls_youle_room_room.get_playercount(room);
}
//获取已准备的玩家人数
room.method.get_playercount_prepare = function(){
return cls_youle_room_room.get_playercount_prepare(room);
}
//获取房间内所有玩家的基本信息
room.method.get_playerlist = function(){
return cls_youle_room_room.get_playerlist(room);
}
//房间是否满桌
room.method.get_isfull = function(){
return cls_youle_room_room.get_isfull(room);
}
//获取房间内所有玩家的申请解散房间状态
room.method.get_agreefree = function(){
return cls_youle_room_room.get_agreefree(room);
}
//给房间内某个位置的玩家发包
room.method.sendpack_toseat = function(msg, seat){
cls_youle_room_room.sendpack_toseat(room, msg, seat);
}
//给房间内的其他玩家发包
room.method.sendpack_toother = function(msg, selfseat){
cls_youle_room_room.sendpack_toother(room, msg, selfseat);
}
//默认同意解散倒计时
room.method.get_freeroom_countdown = function(){
return cls_youle_room_room.get_freeroom_countdown(room);
}
//打开默认同意解散的定时器
room.method.open_free_timer = function(free_now_flag){
cls_youle_room_room.open_free_timer(room,free_now_flag);
}
//关闭默认同意解散的定时器
room.method.close_free_timer = function(){
cls_youle_room_room.close_free_timer(room);
}
//获取房间信息
room.method.get_roominfo = function(){
return cls_youle_room_room.get_roominfo(room);
}
return room;
},
//查找玩家
find_player: function(o_room, playerid){
var o_player = null;
for (var i = 0; i < o_room.seatlist.length; i++){
if (o_room.seatlist[i]){
if (o_room.seatlist[i].playerid == playerid){
o_player = o_room.seatlist[i];
break;
}
}
}
return o_player;
},
//获取玩家人数
get_playercount: function(o_room){
var count = 0;
for (var i = 0; i < o_room.seatlist.length; i++){
if (o_room.seatlist[i]){
count++;
}
}
return count;
},
//获取已准备的玩家人数
get_playercount_prepare: function(o_room){
var count = 0;
for (var i = 0; i < o_room.seatlist.length; i++){
if (o_room.seatlist[i] && o_room.seatlist[i].gameinfo.isprepare){
count++;
}
}
return count;
},
//获取房间内所有玩家的基本信息
get_playerlist: function(o_room){
var playerlist = [];
for (var i = 0; i < o_room.seatlist.length; i++) {
if (o_room.seatlist[i]){
var player = o_room.seatlist[i].method.get_info();
playerlist.push(player);
} else {
playerlist.push(null);
}
}
return playerlist;
},
//房间是否满桌
get_isfull: function(o_room){
for (var i = 0; i < o_room.seatlist.length; i++) {
if (!o_room.seatlist[i] || !o_room.seatlist[i].gameinfo.isprepare){
return false;
}
}
return true;
},
//获取房间内所有玩家的申请解散房间状态
get_agreefree: function(o_room){
if (!o_room.applyfreetime){
return null;
}
var info = {};
//默认同意解散倒计时
info.countdown = o_room.method.get_freeroom_countdown();
var list = [];
for (var i = 0; i < o_room.seatlist.length; i++) {
if (o_room.seatlist[i]){
list.push(o_room.seatlist[i].gameinfo.agree);
} else {
list.push(null);
}
};
info.state = list;
return info;
},
//给房间内某个位置的玩家发包
sendpack_toseat: function(o_room, msg, seat){
if (seat < o_room.seatlist.length){
if (o_room.seatlist[seat]) {
msg.conmode = o_room.seatlist[seat].conmode;
msg.fromid = o_room.seatlist[seat].fromid;
youle_room.app.SendPack(msg);
}
}
},
//给房间内的其他玩家发包
sendpack_toother: function(o_room, msg, selfseat){
// for (var i = 0; i < o_room.seatlist.length; i++) {
// if (o_room.seatlist[i] && (i != selfseat)) {
// msg.conmode = o_room.seatlist[i].conmode;
// msg.fromid = o_room.seatlist[i].fromid;
// youle_room.app.SendPack(msg);
// }
// }
var _toids_tcp = [];
for (var i = 0; i < o_room.seatlist.length; i++) {
if (o_room.seatlist[i] && (i != selfseat)) {
if (o_room.seatlist[i].conmode && o_room.seatlist[i].fromid){
if (o_room.seatlist[i].conmode == "tcp"){
_toids_tcp.push(o_room.seatlist[i].fromid);
} else {
msg.conmode = o_room.seatlist[i].conmode;
msg.fromid = o_room.seatlist[i].fromid;
youle_room.app.SendPack(msg);
}
}
}
}
if (_toids_tcp.length > 0){
msg.conmode = "tcp";
youle_room.app.SendPack(msg, _toids_tcp);
}
},
//默认同意解散房间的倒计时时间
get_freeroom_countdown: function(o_room){
var apply = new Date(o_room.applyfreetime);
var now = new Date();
return o_room.o_game.o_agent.freeroom - parseInt((now.getTime() - apply.getTime()) / 1000);
},
//打开默认同意解散的定时器
open_free_timer: function(o_room,free_now_flag){
var do_freeroom = function(){
o_room.freetimer = null;
for (var i = 0; i < o_room.seatlist.length; i++){
if (o_room.seatlist[i]){
if (o_room.seatlist[i].gameinfo.agree == -1){
o_room.seatlist[i].gameinfo.agree = 1;
}
}
}
//通知代理商服务器解散房间
var o_game = o_room.o_game;
var o_agent = o_game.o_agent;
var msg1 = {};
msg1.app = youle_room.app.appname;
msg1.route = youle_room.app.youle_agent.routename;
msg1.rpc = "free_room";
msg1.data = {};
msg1.data.agentid = o_agent.agentid;
msg1.data.gameid = o_game.gameid;
msg1.data.roomcode = o_room.roomcode;
//玩家列表
msg1.data.playeridlist = [];
for (var i = 0; i < o_room.seatlist.length; i++) {
if (o_room.seatlist[i]){
msg1.data.playeridlist.push(o_room.seatlist[i].playerid);
}
}
if (o_agent.server == o_game.roomserver){
//房间服务器与代理商服务器是同一地址
youle_room.app.youle_agent[msg1.rpc](msg1);
//通知前端房间内的所有人解散房间
var msg2 = {};
msg2.app = youle_room.app.appname;
msg2.route = youle_room.routename;
msg2.rpc = "free_room";
msg2.data = {};
//获取房间内各玩家的解散房间状态
if(!free_now_flag){
msg2.data.seats = o_room.method.get_agreefree().state;
}else{
msg2.data.freeNow = 1;
msg2.data.tips = "房间玩家存在恶意行为，房间已由房主强制解散";
}
//获取游戏的解散包
// if (o_room.battlestate == 1){
// msg2.data.deskfree = youle_room.import.get_disbandRoom(o_room);
// }
// o_room.method.sendpack_toother(msg2, -1);
if (o_room.battlestate == 1){
var _deskfree = youle_room.import.get_disbandRoom(o_room);
if (_deskfree){
if (_deskfree.sendtype && _deskfree.sendtype == 1 && _deskfree.seatlist){
//子游戏返回的解散json数据如果有sendtype属性且值等于1则表示需要向不同的玩家各自发包，且根据seatlist数组对应给各位置的玩家发游戏解散包
for (var n = 0; n < _deskfree.seatlist.length; n++) {
if (_deskfree.seatlist){
msg2.data.deskfree = _deskfree.seatlist[n];
o_room.method.sendpack_toseat(msg2, n);
}
}
} else {
msg2.data.deskfree = _deskfree;
o_room.method.sendpack_toother(msg2, -1);
}
} else {
o_room.method.sendpack_toother(msg2, -1);
}
} else {
o_room.method.sendpack_toother(msg2, -1);
}
//释放房间
o_game.method.free_room(o_room);
} else {
//房间服务器与代理商服务器不是同一地址
var cfg = {};
cfg.url = "http://" + o_agent.server + ":" + o_agent.httpport + "/index.html";
cfg.type = "POST";
cfg.data = JSON.stringify(msg1);
cfg.success = function(str){
var _info = {};
//获取房间内各玩家的解散房间状态
_info.seats = o_room.method.get_agreefree().state;
//获取游戏的解散包
// if (o_room.battlestate == 1){
// _info.deskfree = youle_room.import.get_disbandRoom(o_room);
// }
var _deskfree = null;
if (o_room.battlestate == 1){
_deskfree = youle_room.import.get_disbandRoom(o_room);
}
//通知前端房间内的所有人需要断开房间服务器，连接代理服务器
for (var i = 0; i < o_room.seatlist.length; i++) {
if (o_room.seatlist[i]) {
var msg2 = {};
msg2.app = youle_room.app.appname;
msg2.route = youle_room.routename;
msg2.rpc = "connect_agentserver";
msg2.data = {};
msg2.data.agentserver = o_agent.server + ":" + o_agent.tcpport;
msg2.data.data = {};
msg2.data.data.opt = "free_room";
msg2.data.data.playerid = o_room.seatlist[i].playerid;
msg2.data.data.agentid = o_agent.agentid;
msg2.data.data.gameid = o_game.gameid;
if (_deskfree){
if (_deskfree.sendtype && _deskfree.sendtype == 1 && _deskfree.seatlist){
//子游戏返回的解散json数据如果有sendtype属性且值等于1则表示需要向不同的玩家各自发包，且根据seatlist数组对应给各位置的玩家发游戏解散包
_info.deskfree = _deskfree.seatlist[i];
} else {
_info.deskfree = _deskfree;
}
}
msg2.data.data.info = _info;
msg2.conmode = o_room.seatlist[i].conmode;
msg2.fromid = o_room.seatlist[i].fromid;
//此处conmode = null是为了避免触发玩家离线通知其他玩家事件
o_room.seatlist[i].conmode = null;
o_room.seatlist[i].fromid = null;
youle_room.app.SendPack(msg2);
}
}
//释放房间
o_game.method.free_room(o_room);
};
cfg.error = function(str){};
min_http(cfg);
}
}
if (!free_now_flag){
o_room.freetimer = min_ontimeout(do_freeroom, o_room.o_game.o_agent.freeroom * 1000);
} else {
do_freeroom();
}
},
//关闭默认同意解散的定时器
close_free_timer: function(o_room){
min_closetime(o_room.freetimer);
o_room.freetimer = null;
},
//获取房间信息
get_roominfo: function(o_room){
var info = {};
info.roomtype = o_room.roomtype; //房间类型
info.needroomcard = o_room.needroomcard; //开房需要的房卡数量
info.asetcount = o_room.asetcount; //总局数
info.createtime = o_room.createtime; //开房时间
info.makewartime = o_room.makewartime; //开战时间
info.battlestate = o_room.battlestate; //游戏状态 0:未开战 1:已开战
info.wasdeduct = o_room.wasdeduct; //是否扣除了房主的房卡
info.roommode = o_room.roommode; //是否是星星场
info.beanfloor = o_room.beanfloor; //星星下限
info.beanmult = o_room.beanmult; //星星场倍数
info.needprepare = o_room.needprepare; //是否需要准备
info.advanced_type = o_room.advanced_type; //是否高级房间
info.advanced_teabean = o_room.advanced_teabean; //茶水费
info.infinite = o_room.infinite; //是否无限场
//房主id
if (o_room.owner){
info.ownerid = o_room.owner.playerid;
} else {
info.ownerid = null;
}
//玩家列表
info.seatlist = [];
for (var i = 0; i < o_room.seatlist.length; i++) {
if (!o_room.seatlist[i]){
info.seatlist.push(null);
} else {
var p = {};
p.playerid = o_room.seatlist[i].playerid;
p.nickname = o_room.seatlist[i].nickname;
p.onstate = o_room.seatlist[i].onstate; //在线状态 null未连接 0在线 1离线 2电话中
p.needroomcard = o_room.seatlist[i].needroomcard;
p.wasdeduct = o_room.seatlist[i].wasdeduct;
p.bean = o_room.seatlist[i].bean;
p.isowner = o_room.seatlist[i].gameinfo.isowner;
p.isbet = o_room.seatlist[i].gameinfo.isbet;
p.grade = o_room.seatlist[i].gameinfo.grade;
p.isprepare = o_room.seatlist[i].gameinfo.isprepare;
var _agentsvr_agent = youle_agent.agents.method.find_agent(o_room.o_game.o_agent.agentid);
var _agentsvr_player = _agentsvr_agent.method.find_player(o_room.seatlist[i].playerid);
p.unionid = _agentsvr_player.unionid;
info.seatlist.push(p);
}
}
return info;
}
}

81
codes/games/backstage/youle/server_room/class.tcplist.js Normal file
View File

@@ -0,0 +1,81 @@
///////////////////////////////////////////////////
//////////////cls_youle_room_tcplist: tcp连接列表类///////////
///////////////////////////////////////////////////
var cls_youle_room_tcplist = cls_youle_room_tcplist || {
new: function() {
var tcplist = {};
tcplist.list = [];
//方法
tcplist.method = {};
//载入tcp连接
tcplist.method.load_tcp = function(str_tcpid, o_player){
return cls_youle_room_tcplist.load_tcp(tcplist, str_tcpid, o_player);
}
//查找tcp连接
tcplist.method.find_tcp = function(str_tcpid){
return cls_youle_room_tcplist.find_tcp(tcplist, str_tcpid);
}
//删除tcp连接
tcplist.method.delete_tcp = function(str_tcpid){
return cls_youle_room_tcplist.delete_tcp(tcplist, str_tcpid);
}
return tcplist;
},
//载入tcp连接
load_tcp: function(o_tcplsit, str_tcpid, o_player){
var idx = cls_youle_room_tcplist.aryidx(str_tcpid);
if (idx == -1){
return null;
}
if (o_tcplsit.list.length <= idx){
o_tcplsit.list.length = idx + 1;
}
var new_tcp = {};
new_tcp.tcpid = str_tcpid;
new_tcp.o_player = o_player;
o_tcplsit.list[idx] = new_tcp;
return new_tcp;
},
//查找tcp连接
find_tcp: function(o_tcplsit, str_tcpid){
var idx = cls_youle_room_tcplist.aryidx(str_tcpid);
if (idx == -1){
return null;
}
if (o_tcplsit.list.length <= idx){
return null;
}
return o_tcplsit.list[idx];
},
//删除tcp连接
delete_tcp: function(o_tcplsit, str_tcpid){
var idx = cls_youle_room_tcplist.aryidx(str_tcpid);
if (idx == -1){
return;
}
if (o_tcplsit.list.length <= idx){
return;
}
o_tcplsit.list[idx] = null;
},
//计算tcp连接的数组下标
aryidx: function(str_tcpid){
var idx = parseInt(str_tcpid.replace("tcp_", ""));
if (isNaN(idx)){
return -1;
}
return idx - 10000;
}
}
//tcp连接列表
youle_room.tcps = cls_youle_room_tcplist.new();

54
codes/games/backstage/youle/server_room/mod.js Normal file
View File

@@ -0,0 +1,54 @@
//////////////////////////////////////////////////////////////////
//////////////////////////游戏平台服务器//////////////////////////
//////////////////////////////////////////////////////////////////
//rpc
min_loadJsFile("youle/server_room/rpc.js", function(){
//tcp连接
min_loadJsFile("youle/server_room/class.tcplist.js", function(){
//运营商
min_loadJsFile("youle/server_room/class.agent.js", function(){
//游戏
min_loadJsFile("youle/server_room/class.game.js", function(){
//房间
min_loadJsFile("youle/server_room/class.room.js", function(){
//玩家
min_loadJsFile("youle/server_room/class.player.js", function(){
//对内的输入接口类
min_loadJsFile("youle/server_room/class.import.js", function(){
//对内的输出接口类
min_loadJsFile("youle/server_room/class.export.js", function(){
//返回结果类
min_loadJsFile("youle/server_room/class.return.js", function(){
//数据备份类
min_loadJsFile("youle/server_room/class.backup.js", function(){
//抽成系统
min_loadJsFile("youle/server_room/class.rebate.js", function(){
});
});
});
});
});
});
});
});
});
});
});
var youle_room = youle_room || cls_mod.new("youle_room", "room", youle_app);
//运营商列表
youle_room.agents = null;
//tcp连接
youle_room.tcps = null;
//mysql操作类
youle_room.mysql = cls_mysql.new("http://ylyxdata.daoqi88.cn/mysql.php", youle_room.app.SendPack);
youle_room.mysql_grade = cls_mysql.new("http://ylyxdata.daoqi88.cn/mysql_grade.php", youle_room.app.SendPack);
//对内的输入接口类（需要的外部接口）
youle_room.import = null;
//对内的输出接口类（提供给外部使用的接口）
youle_room.export = null;
//返回结果类
youle_room.return = null;
//数据备份类
youle_room.backup = null;

3991
codes/games/backstage/youle/server_room/rpc.js Normal file
View File

File diff suppressed because it is too large Load Diff

742
codes/games/backstage/youle/server_synch/mod.js Normal file
View File

@@ -0,0 +1,742 @@
var youle_synch = youle_synch || cls_mod.new("youle_synch", "synch", youle_app);
//mysql操作类
youle_synch.mysql = cls_mysql.new("http://ylyxdata.daoqi88.cn/mysql.php");
youle_synch.mysql_grade = cls_mysql.new("http://ylyxdata.daoqi88.cn/mysql_grade.php");
youle_synch.mysql_agent = cls_mysql.new("http://ylyxdata.daoqi88.cn/mysql_agent.php");
youle_synch.configlist = [];
youle_synch.configfile = [];
youle_synch.configfile.push("http://tsgames.daoqi88.cn/config/update_jsonv2.txt");
for (var i = 0; i < youle_synch.configfile.length; i++) {
var o_config = cls_youle_platform_config.new(youle_synch.configfile[i]);
o_config.method.get_config();
youle_synch.configlist.push(o_config);
};
youle_synch.do_readdata = function(){
if (youle_synch.isdoing == 1) {
return;
}
var compressWhiteList = function(data){
var dataStr = JSON.stringify(data);
if(dataStr.length > 6000){//超出
var cmpStr = LZString.compressToUTF16(dataStr);
return "zip"+cmpStr;
}else{
return dataStr;
}
}
var deCompressWhiteList = function(data){
var dataStr = data;
if(dataStr.indexOf("zip")==0){//压缩
var str = dataStr.slice(3,dataStr.length);
var deStr = LZString.decompressFromUTF16(str);
return JSON.parse(deStr);
}else{
return JSON.parse(dataStr);
}
}
//充房卡充星星
var update_gamedb_roomcard = function(agentid, playerid, changeroomcard, changebean, opttype, optid){
var db_callback_game1 = function(dbdata){
if (dbdata[0].result == 0){
do_result(optid, 1);
//通知各子游戏服务器
switch(parseInt(opttype)){
case 1: //玩家购卡
var msg = {};
msg.app = "youle";
msg.route = "agent";
msg.rpc = "synch_roomcard";
msg.data = {};
msg.data.agentid = agentid;
msg.data.playerid = playerid;
msg.data.opt = 1;
msg.data.roomcard = parseInt(dbdata[0].play_roomcard);
msg.data.change = changeroomcard;
break;
case 2: //代理充卡
var msg = {};
msg.app = "youle";
msg.route = "agent";
msg.rpc = "synch_roomcard";
msg.data = {};
msg.data.agentid = agentid;
msg.data.playerid = playerid;
msg.data.opt = 2;
msg.data.roomcard = parseInt(dbdata[0].play_roomcard);
msg.data.change = changeroomcard;
break;
case 3: //玩家索卡
var msg = {};
msg.app = "youle";
msg.route = "agent";
msg.rpc = "synch_roomcard";
msg.data = {};
msg.data.agentid = agentid;
msg.data.playerid = playerid;
msg.data.opt = 2;
msg.data.roomcard = parseInt(dbdata[0].play_roomcard);
msg.data.change = changeroomcard;
break;
case 11: //玩家购买星星
var msg = {};
msg.app = "youle";
msg.route = "agent";
msg.rpc = "synch_bean";
msg.data = {};
msg.data.agentid = agentid;
msg.data.playerid = playerid;
msg.data.opt = 1;
msg.data.bean = parseInt(dbdata[0].play_bean);
msg.data.change = changebean;
break;
case 12: //代理充值星星
var msg = {};
msg.app = "youle";
msg.route = "agent";
msg.rpc = "synch_bean";
msg.data = {};
msg.data.agentid = agentid;
msg.data.playerid = playerid;
msg.data.opt = 2;
msg.data.bean = parseInt(dbdata[0].play_bean);
msg.data.change = changebean;
break;
case 13: //玩家索要星星
var msg = {};
msg.app = "youle";
msg.route = "agent";
msg.rpc = "synch_bean";
msg.data = {};
msg.data.agentid = agentid;
msg.data.playerid = playerid;
msg.data.opt = 2;
msg.data.bean = parseInt(dbdata[0].play_bean);
msg.data.change = changebean;
break;
}
do_synch(optid, agentid, msg);
} else {
do_result(optid, 0);
}
}
var sql_game = "call cp_sales2_player_topup(?,?,?,?)";
youle_synch.mysql.execsql("opensql", sql_game, [agentid, playerid, changeroomcard, changebean], db_callback_game1);
}
//玩家绑定邀请码
var update_gamedb_bindinginvitecode = function(agentid, unionid, invitecode, optid){
var db_callback_game2 = function(dbdata){
if (dbdata[0].result == 0){
do_result(optid, 1);
//通知各子游戏服务器
var msg = {};
msg.app = "youle";
msg.route = "agent";
msg.rpc = "synch_invitecode";
msg.data = {};
msg.data.agentid = agentid;
msg.data.playerid = parseInt(dbdata[0].playerid);
msg.data.invitecode = invitecode;
do_synch(optid, agentid, msg);
} else {
do_result(optid, 0);
}
}
var sql_game = "call cp_sales2_player_bindinginvitecode(?,?,?)";
youle_synch.mysql.execsql("opensql", sql_game, [agentid, unionid, invitecode], db_callback_game2);
}
//新代理
var update_gamedb_newsalesman = function(agentid, channelid, salesid, salesinfo, optid){
var db_callback_game3 = function(dbdata){
if (dbdata[0].result == 0){
do_result(optid, 1);
} else {
do_result(optid, 0);
}
}
var sql_game = "call cp_sales2_new_salesman(?,?,?,?,?,?,?,?,?,?)";
var o_salesinfo = JSON.parse(salesinfo);
youle_synch.mysql.execsql("opensql", sql_game, [agentid, channelid, o_salesinfo.openid, o_salesinfo.unionid, o_salesinfo.nickname, o_salesinfo.avatar, o_salesinfo.sex, o_salesinfo.province, o_salesinfo.city, salesid], db_callback_game3);
}
//封禁代理
var update_gamedb_disabledsales = function(agentid, salesid, optid){
var db_callback_game4 = function(dbdata){
if (dbdata[0].result == 0){
do_result(optid, 1);
} else {
do_result(optid, 0);
}
}
var sql_game = "call cp_sales2_salesman_disabled(?,?)";
youle_synch.mysql.execsql("opensql", sql_game, [agentid, salesid], db_callback_game4);
}
//解封代理
var update_gamedb_abledsales = function(agentid, salesid, optid){
var db_callback_game5 = function(dbdata){
if (dbdata[0].result == 0){
do_result(optid, 1);
} else {
do_result(optid, 0);
}
}
var sql_game = "call cp_sales2_salesman_abled(?,?)";
youle_synch.mysql.execsql("opensql", sql_game, [agentid, salesid], db_callback_game5);
}
//解绑代理
var update_gamedb_disbinding_sales = function(agentid, salesid, optid){
var db_callback_game6 = function(dbdata){
if (dbdata[0].result == 0){
do_result(optid, 1);
} else {
do_result(optid, 0);
}
}
var sql_game = "call cp_sales2_disbinding_sales(?,?)";
youle_synch.mysql.execsql("opensql", sql_game, [agentid, salesid], db_callback_game6);
}
//解绑玩家
var update_gamedb_disbinding_player = function(agentid, playerid, optid){
var db_callback_game7 = function(dbdata){
if (dbdata[0].result == 0){
do_result(optid, 1);
//通知各子游戏服务器
var msg = {};
msg.app = "youle";
msg.route = "agent";
msg.rpc = "synch_invitecode";
msg.data = {};
msg.data.agentid = agentid;
msg.data.playerid = playerid;
msg.data.invitecode = null;
do_synch(optid, agentid, msg);
} else {
do_result(optid, 0);
}
}
var sql_game = "call cp_sales2_disbinding_player(?,?)";
youle_synch.mysql.execsql("opensql", sql_game, [agentid, playerid], db_callback_game7);
}
//封禁玩家
var update_gamedb_disabledplayer = function(agentid, playerid, optid){
var db_callback_game8 = function(dbdata){
if (dbdata[0].result == 0){
do_result(optid, 1);
//通知各子游戏服务器
var msg = {};
msg.app = "youle";
msg.route = "agent";
msg.rpc = "synch_playerstate";
msg.data = {};
msg.data.agentid = agentid;
msg.data.playerid = playerid;
msg.data.state = 1;
do_synch(optid, agentid, msg);
} else {
do_result(optid, 0);
}
}
var sql_game = "call cp_sales2_player_disabled(?,?)";
youle_synch.mysql.execsql("opensql", sql_game, [agentid, playerid], db_callback_game8);
}
//解封玩家
var update_gamedb_abledplayer = function(agentid, playerid, optid){
var db_callback_game9 = function(dbdata){
if (dbdata[0].result == 0){
do_result(optid, 1);
//通知各子游戏服务器
var msg = {};
msg.app = "youle";
msg.route = "agent";
msg.rpc = "synch_playerstate";
msg.data = {};
msg.data.agentid = agentid;
msg.data.playerid = playerid;
msg.data.state = 0;
do_synch(optid, agentid, msg);
} else {
do_result(optid, 0);
}
}
var sql_game = "call cp_sales2_player_abled(?,?)";
youle_synch.mysql.execsql("opensql", sql_game, [agentid, playerid], db_callback_game9);
}
//开通高级选项
var update_gamedb_advanced = function(agentid, playerid, shortcode, advanced, desone, destwo, lower_limit, announcement, optid){
var db_callback_game10 = function(dbdata){
if (dbdata[0].result == 0){
do_result(optid, 1);
//通知各子游戏服务器
var msg = {};
msg.app = "youle";
msg.route = "agent";
msg.rpc = "synch_shortcode";
msg.data = {};
msg.data.agentid = agentid;
msg.data.playerid = playerid;
msg.data.shortcode = shortcode;
msg.data.advanced = advanced;
msg.data.desone = desone;
msg.data.destwo = destwo;
msg.data.lower_limit = lower_limit;
msg.data.announcement = announcement;
do_synch(optid, agentid, msg);
} else {
do_result(optid, 0);
}
}
var sql_game = "call cp_game_player_advanced(?,?,?,?,?,?,?,?)";
var _shortcode = parseInt(shortcode);
var _advanced = parseInt(advanced);
youle_synch.mysql.execsql("opensql", sql_game, [agentid, playerid, _advanced, _shortcode, desone, destwo, lower_limit, announcement], db_callback_game10);
}
//设置短号白名单
var update_gamedb_whitelist = function(agentid, playerid, whitelist, optid){
//youle
if(agentid == "00bA05haB0d9ZC0fwGD09Q2OA30insbQ"){
do_result(optid, 1);
return;
}
var db_callback_game11 = function(dbdata){
if (dbdata[0].result == 0){
do_result(optid, 1);
//通知各子游戏服务器
var msg = {};
msg.app = "youle";
msg.route = "agent";
msg.rpc = "synch_whitelist";
msg.data = {};
msg.data.agentid = agentid;
msg.data.playerid = playerid;
msg.data.whitelist = whitelist;
do_synch(optid, agentid, msg);
} else {
do_result(optid, 0);
}
}
for(var i=0;i<whitelist.length;i++){
if(whitelist[i][2]){
whitelist[i][2] = parseInt(whitelist[i][2]);
}else{
whitelist[i][2] = 0;
}
}
var sql_game = "call cp_game_player_whitelist(?,?,?)";
youle_synch.mysql.execsql("opensql", sql_game, [agentid, playerid, compressWhiteList(whitelist)], db_callback_game11);
}
//系统抽成
var update_gamedb_coinrebate = function(agentid, mode1, set1, mode2, set2, optid){
var db_callback_game12 = function(dbdata){
if (dbdata[0].result == 0){
do_result(optid, 1);
//通知各子游戏服务器
var msg = {};
msg.app = "youle";
msg.route = "agent";
msg.rpc = "synch_coinrebate";
msg.data = {};
msg.data.agentid = agentid;
msg.data.mode1 = mode1;
msg.data.set1 = set1;
msg.data.mode2 = mode2;
msg.data.set2 = set2;
do_synch(optid, agentid, msg);
} else {
do_result(optid, 0);
}
}
var sql_game = "call cp_game_update_coinrebate(?,?,?,?,?)";
youle_synch.mysql.execsql("opensql", sql_game, [agentid, mode1, set1, mode2, set2], db_callback_game12);
}
//变更代理id
var update_gamedb_changesalesid = function(agentid, old_salesid, new_salesid, old_playerid, new_playerid, optid){
var db_callback_game13 = function(dbdata){
if (dbdata[0].result == 0){
do_result(optid, 1);
} else {
do_result(optid, 0);
}
}
var sql_game = "call cp_sales2_change_salesid(?,?,?,?,?)";
youle_synch.mysql.execsql("opensql", sql_game, [agentid, old_salesid, new_salesid, old_playerid, new_playerid], db_callback_game13);
}
//短号白名单中添加或修改一个玩家
var update_gamedb_add_whitelist = function(agentid, shortcode, playerid, paycode, charm, optid){
//youle
if(agentid == "00bA05haB0d9ZC0fwGD09Q2OA30insbQ"){
do_result(optid, 1);
return;
}
var db_callback_game = function(dbdata){
if (dbdata.length == 1){
var whitelist = [];
if (dbdata[0].play_whitelist){
whitelist = deCompressWhiteList(dbdata[0].play_whitelist);
for(var i=0;i<whitelist.length;i++){
if(whitelist[i][2]){
whitelist[i][2] = parseInt(whitelist[i][2]);
}else{
whitelist[i][2] = 0;
}
}
}
var found = false;
for (var i = 0; i < whitelist.length; i++) {
if (whitelist[i][0] == playerid){
whitelist[i][1] = paycode;
whitelist[i][2] = charm;
found = true;
break;
}
};
if (!found){
var newplayer = [];
newplayer[0] = playerid;
newplayer[1] = paycode;
newplayer[2] = charm;
whitelist.push(newplayer);
}
var sql_game2 = "update player set play_whitelist = ? where play_agentid = ? and play_shortcode = ?";
youle_synch.mysql.execsql("execsql", sql_game2, [compressWhiteList(whitelist), agentid, shortcode]);
do_result(optid, 1);
//通知各子游戏服务器
var msg = {};
msg.app = "youle";
msg.route = "agent";
msg.rpc = "synch_update_whitelist";
msg.data = {};
msg.data.agentid = agentid;
msg.data.shortcode = shortcode;
msg.data.whitelist = whitelist;
do_synch(optid, agentid, msg);
} else {
do_result(optid, 0);
}
}
var sql_game = "select * from player where play_agentid = ? and play_shortcode = ?";
youle_synch.mysql.execsql("opensql", sql_game, [agentid, shortcode], db_callback_game);
}
//短号白名单中删除一个玩家
var update_gamedb_del_whitelist = function(agentid, shortcode, playerid, optid){
//youle
if(agentid == "00bA05haB0d9ZC0fwGD09Q2OA30insbQ"){
do_result(optid, 1);
return;
}
var db_callback_game = function(dbdata){
if (dbdata.length == 1){
var whitelist = [];
if (dbdata[0].play_whitelist){
whitelist = deCompressWhiteList(dbdata[0].play_whitelist);
for(var i=0;i<whitelist.length;i++){
if(whitelist[i][2]){
whitelist[i][2] = parseInt(whitelist[i][2]);
}else{
whitelist[i][2] = 0;
}
}
}
for (var i = 0; i < whitelist.length; i++) {
if (whitelist[i][0] == playerid){
whitelist.splice(i, 1);
break;
}
};
var sql_game2 = "update player set play_whitelist = ? where play_agentid = ? and play_shortcode = ?";
youle_synch.mysql.execsql("execsql", sql_game2, [compressWhiteList(whitelist), agentid, shortcode]);
do_result(optid, 1);
//通知各子游戏服务器
var msg = {};
msg.app = "youle";
msg.route = "agent";
msg.rpc = "synch_update_whitelist";
msg.data = {};
msg.data.agentid = agentid;
msg.data.shortcode = shortcode;
msg.data.whitelist = whitelist;
do_synch(optid, agentid, msg);
} else {
do_result(optid, 0);
}
}
var sql_game = "select * from player where play_agentid = ? and play_shortcode = ?";
youle_synch.mysql.execsql("opensql", sql_game, [agentid, shortcode], db_callback_game);
}
var do_synch = function(optid, agentid, msg){
var get_iplist = function(agentid){
var iplist = [];
var paraname = "game_server_http";
var do_pushto_iplist = function(ip){
var idx = min_ary_indexof(iplist, ip);
if (idx == -1){
iplist.push(ip);
}
}
for (var i = 0; i < youle_synch.configlist.length; i++) {
var o_config = youle_synch.configlist[i];
if (!o_config){
continue;
}
if (!o_config.data || !o_config.data.agentlist){
continue;
}
var idx_agent = min_ary_indexof(o_config.data.agentlist, agentid, "agentid");
if (idx_agent == -1){
continue;
}
var o_agent = o_config.data.agentlist[idx_agent];
if (!o_agent){
continue;
}
if (o_config.data[paraname]){
do_pushto_iplist(o_config.data[paraname]);
}
if (o_agent[paraname]){
do_pushto_iplist(o_agent.data[paraname]);
}
if (!o_agent.gamelist){
continue;
}
for (var j = 0; j < o_agent.gamelist.length; j++) {
var o_game = o_agent.gamelist[j];
if (o_game[paraname]){
do_pushto_iplist(o_game[paraname]);
}
}
}
return iplist;
}
var dodo_synch = function(ip){
var cfg = {};
cfg.url = "http://" + ip + "/index.html";
cfg.type = "POST";
cfg.data = JSON.stringify(msg);
cfg.success = function(str){
try{
var obj = JSON.parse(str);
if (obj.data.state == 0){
var sql_grade = "insert into process_log (prlo_optid, prlo_result, prlo_time, prlo_ip) values(?,1,?,?)";
youle_synch.mysql_grade.execsql("execsql", sql_grade, [optid, min_now(), ip]);
} else {
var sql_grade = "insert into process_log (prlo_optid, prlo_result, prlo_time, prlo_ip, prlo_error) values(?,-1,?,?,?)";
youle_synch.mysql_grade.execsql("execsql", sql_grade, [optid, min_now(), ip, obj.error]);
console.log(min_now() + " 后台接口数据处理失败3:" + optid);
}
}catch(e){
console.log(ip + " " + str);
}
}
cfg.error = function(str){
var sql_grade = "insert into process_log (prlo_optid, prlo_result, prlo_time, prlo_ip, prlo_error) values(?,-1,?,?,?)";
youle_synch.mysql_grade.execsql("execsql", sql_grade, [optid, min_now(), ip, str]);
console.log(min_now() + " 后台接口数据处理失败2:" + optid);
}
min_http(cfg);
}
var agent_iplist = get_iplist(agentid);
//debugger;
// agent_iplist.push("127.0.0.1:1089");
// agent_iplist.push("127.0.0.1:2089");
//设置延时
for (var i = 0; i < agent_iplist.length; i++) {
dodo_synch(agent_iplist[i]);
}
}
var do_result = function(optid, result){
var sql_agent;
var sql_grade;
if (result == 1){
//成功
sql_agent = "update ct_user_process_log set is_process = is_process + 1 where id = ?";
sql_grade = "insert into process_log (prlo_optid, prlo_result, prlo_time) values(?,1,?)";
} else {
//失败
sql_agent = "update ct_user_process_log set is_process = -1 where id = ?";
sql_grade = "insert into process_log (prlo_optid, prlo_result, prlo_time) values(?,-1,?)";
console.log(min_now() + " 后台接口数据处理失败1:" + optid);
}
youle_synch.mysql_agent.execsql("execsql", sql_agent, [optid],
function(){
youle_synch.isdoing = 0;
});
youle_synch.mysql_grade.execsql("execsql", sql_grade, [optid, min_now()]);
}
var db_callback = function(dbdata){
var proList = {};
for (var i = 0; i < dbdata.length; i++){
try{
switch(parseInt(dbdata[i].oper_type)){
case 1: //购买房卡
youle_synch.isdoing = 1;
update_gamedb_roomcard(dbdata[i].to_agent, dbdata[i].to_user, dbdata[i].oper_data, null, dbdata[i].oper_type, dbdata[i].id);
break;
case 2: //代理转卡
youle_synch.isdoing = 1;
//防止重复添加房卡
if(dbdata[i].is_process == 0){
update_gamedb_roomcard(dbdata[i].to_agent, dbdata[i].to_user, dbdata[i].oper_data, null, dbdata[i].oper_type, dbdata[i].id);
}else{
console.log("重复添加房卡");
console.log(dbdata);
}
break;
case 3: //索要房卡
youle_synch.isdoing = 1;
update_gamedb_roomcard(dbdata[i].to_agent, dbdata[i].to_user, dbdata[i].oper_data, null, dbdata[i].oper_type, dbdata[i].id);
break;
case 11: //购买星星
youle_synch.isdoing = 1;
update_gamedb_roomcard(dbdata[i].to_agent, dbdata[i].to_user, null, dbdata[i].oper_data, dbdata[i].oper_type, dbdata[i].id);
break;
case 12: //代理转星星
youle_synch.isdoing = 1;
update_gamedb_roomcard(dbdata[i].to_agent, dbdata[i].to_user, null, dbdata[i].oper_data, dbdata[i].oper_type, dbdata[i].id);
break;
case 13: //索要星星
youle_synch.isdoing = 1;
update_gamedb_roomcard(dbdata[i].to_agent, dbdata[i].to_user, null, dbdata[i].oper_data, dbdata[i].oper_type, dbdata[i].id);
break;
case 21: //成为代理
youle_synch.isdoing = 1;
update_gamedb_newsalesman(dbdata[i].to_agent, dbdata[i].to_channel, dbdata[i].to_user, dbdata[i].oper_data, dbdata[i].id);
break;
case 31: //封禁代理
youle_synch.isdoing = 1;
update_gamedb_disabledsales(dbdata[i].to_agent, dbdata[i].to_user, dbdata[i].id);
break;
case 32: //解封代理
youle_synch.isdoing = 1;
update_gamedb_abledsales(dbdata[i].to_agent, dbdata[i].to_user, dbdata[i].id);
break;
case 33: //封禁玩家
youle_synch.isdoing = 1;
update_gamedb_disabledplayer(dbdata[i].to_agent, dbdata[i].to_user, dbdata[i].id);
break;
case 34: //解封玩家
youle_synch.isdoing = 1;
update_gamedb_abledplayer(dbdata[i].to_agent, dbdata[i].to_user, dbdata[i].id);
break;
case 41: //解除绑定了我的玩家
youle_synch.isdoing = 1;
update_gamedb_disbinding_sales(dbdata[i].from_agent, dbdata[i].from_user, dbdata[i].id);
break;
case 42: //玩家解除绑定
youle_synch.isdoing = 1;
update_gamedb_disbinding_player(dbdata[i].from_agent, dbdata[i].from_user, dbdata[i].id);
break;
case 101: //绑定代理
youle_synch.isdoing = 1;
update_gamedb_bindinginvitecode(dbdata[i].to_agent, dbdata[i].oper_data, dbdata[i].from_user, dbdata[i].id);
break;
case 110: //开通高新选项
youle_synch.isdoing = 1;
var o_data = JSON.parse(dbdata[i].oper_data);
update_gamedb_advanced(dbdata[i].to_agent, dbdata[i].to_user, o_data.shortnum, o_data.maxroomnum, o_data.desone, o_data.destwo, o_data.lower_limit, o_data.announcement, dbdata[i].id);
break;
case 111: //设置短号白名单
youle_synch.isdoing = 1;
var o_data = JSON.parse(dbdata[i].oper_data);
update_gamedb_whitelist(dbdata[i].from_agent, dbdata[i].from_user, o_data, dbdata[i].id);
break;
case 112: //变更代理id
youle_synch.isdoing = 1;
var from_playerid = null;
var to_playerid = null;
if (dbdata[i].oper_data){
var o_data = JSON.parse(dbdata[i].oper_data);
if (o_data.from && o_data.to){
from_playerid = o_data.from;
to_playerid = o_data.to;
}
}
update_gamedb_changesalesid(dbdata[i].from_agent, dbdata[i].from_user, dbdata[i].to_user, from_playerid, to_playerid, dbdata[i].id);
break;
case 113: //短号白名单中添加或修改一个玩家
var o_data = JSON.parse(dbdata[i].oper_data);
if(!proList[dbdata[i].to_agent]){
proList[dbdata[i].to_agent]=[];
}
// if(!proList[dbdata[i].to_agent][o_data[0]]){
// proList[dbdata[i].to_agent][o_data[0]] = [];
// }
//console.log(proList,o_data);
if(proList[dbdata[i].to_agent].indexOf(o_data[0]) < 0){
proList[dbdata[i].to_agent].push(o_data[0]);
youle_synch.isdoing = 1;
//var o_data = JSON.parse(dbdata[i].oper_data);
//console.log("添加",o_data[1]);
var shortcode = o_data[0];
var playerid = o_data[1];
var paycode = o_data[2];
var charm = o_data[3]; //短号魅力值
update_gamedb_add_whitelist(dbdata[i].from_agent, shortcode, playerid, paycode, charm, dbdata[i].id);
}
break;
case 114: //短号白名单中删除一个玩家
var o_data = JSON.parse(dbdata[i].oper_data);
if(!proList[dbdata[i].to_agent]){
proList[dbdata[i].to_agent]=[];
}
// if(!proList[dbdata[i].to_agent][o_data[0]]){
// proList[dbdata[i].to_agent][o_data[0]] = [];
// }
//console.log(proList,o_data);
if(proList[dbdata[i].to_agent].indexOf(o_data[0]) < 0){
proList[dbdata[i].to_agent].push(o_data[0]);
youle_synch.isdoing = 1;
//console.log("删除",o_data[1]);
var shortcode = o_data[0];
var playerid = o_data[1];
update_gamedb_del_whitelist(dbdata[i].from_agent, shortcode, playerid, dbdata[i].id);
}
break;
case 201: //系统抽成
youle_synch.isdoing = 1;
var o_data = JSON.parse(dbdata[i].oper_data);
var rebate_mode1 = 0;
var rebate_set1 = 0;
var rebate_mode2 = 0;
var rebate_set2 = 0;
for (var j = 0; j < o_data.length; j++) {
if (o_data[j].type_id == "001"){
rebate_mode1 = 1;
rebate_set1 = parseInt(o_data[j].system_commission_rate);
}
if (o_data[j].type_id == "002"){
rebate_mode2 = 1;
rebate_set2 = parseInt(o_data[j].system_commission_rate);
}
}
update_gamedb_coinrebate(dbdata[i].to_agent, rebate_mode1, rebate_set1, rebate_mode2, rebate_set2, dbdata[i].id);
break;
}
} catch(e){}
}
}
var sql_agent = "select * from ct_user_process_log where is_process = 0 order by id";
youle_synch.mysql_agent.execsql("opensql", sql_agent, [], db_callback);
}
youle_synch.isdoing = 0;
youle_synch.timer = min_ontime(youle_synch.do_readdata, 1000 * 30);

193
codes/games/backstage/youle/third.php Normal file
View File

@@ -0,0 +1,193 @@
<?php
header("Access-Control-Allow-Origin: *");
header("Access-Control-Allow-Methods: GET, POST, OPTIONS, PUT, PATCH, DELETE");
header("Access-Control-Allow-Headers: Content-Type, Authorization, Content-Length, X-Requested-With");
header("Access-Control-Allow-Credentials: true");
header("Content-Type: textml; charset=utf-8");
///////////////////////////// 全局常量 /////////////////////////////
//mysql数据库连接
$G_MySql = array(
"host" => "localhost",
"name" => "youle_games",
"user" => "root",
"pwd" => "root",
"port" => "3333"
);
//错误编码及提示
$G_Error = array(
"condb" => array("code" => 81, "msg" => "database connection failed."),
"execsql" => array("code" => 82, "msg" => "failed to operate database."),
"wrong_a" => array("code" => 83, "msg" => "a parameter error."),
"wrong_c" => array("code" => 84, "msg" => "c parameter error."),
"wrong_g" => array("code" => 85, "msg" => "g parameter error."),
"wrong_do" => array("code" => 86, "msg" => "do parameter error."),
"wrong_data" => array("code" => 87, "msg" => "data parameter error."),
"wrong_openid" => array("code" => 88, "msg" => "openid is null."),
"wrong_unionid" => array("code" => 89, "msg" => "unionid is null.")
);
///////////////////////////// 全局变量 /////////////////////////////
//接口函数返回的json对象
$G_Result = array(
"state" => 0, //0:成功 <>0:错误编码
"error" => "", //错误时的描述
"data" => array() //成功时的数据
);
//返回结果$G_G_Result
function do_return(){
global $G_Result;
if (count($G_Result["data"]) == 0) {
$G_Result["data"] = new stdClass;
}
echo json_encode($G_Result);
exit();
}
////////////////////////// 连接MYSQL数据库 /////////////////////////
$PDO = null;
try
{
$PDO = new PDO("mysql:host=".$G_MySql["host"].";port=".$G_MySql["port"].";dbname=".$G_MySql["name"], $G_MySql["user"], $G_MySql["pwd"]);
$PDO->exec("set names utf8;");
$PDO->exec("use ".$G_MySql["name"].";");
}
catch (Exception $e)
{
$G_Result['state'] = $G_Error["condb"]["code"];
$G_Result['error'] = $G_Error["condb"]["msg"];
do_return();
}
//////////////////////////// 读取参数 ////////////////////////////
$a = GetRequest("a");
if ($a == null || $a == "") {
$G_Result['state'] = $G_Error["wrong_a"]["code"];
$G_Result['error'] = $G_Error["wrong_a"]["msg"];
do_return();
}
$c = GetRequest("c");
if ($c == null || $c == "") {
$G_Result['state'] = $G_Error["wrong_c"]["code"];
$G_Result['error'] = $G_Error["wrong_c"]["msg"];
do_return();
}
$g = GetRequest("g");
if ($g == null || $g == "") {
$G_Result['state'] = $G_Error["wrong_g"]["code"];
$G_Result['error'] = $G_Error["wrong_g"]["msg"];
do_return();
}
$do = GetRequest("do");
if ($do != 1 && $do != 2) {
$G_Result['state'] = $G_Error["wrong_do"]["code"];
$G_Result['error'] = $G_Error["wrong_do"]["msg"];
do_return();
}
//读取data参数
$str_data = GetRequest("data");
//php收到后将^号替换为=号，替换回来，，以避免=号POST传参会截断的问题
//$str_data = str_replace("^","=",$str_data);
//检查data是否为空
if ($str_data == null || $str_data == "") {
$G_Result['state'] = $G_Error["wrong_data"]["code"];
$G_Result['error'] = $G_Error["wrong_data"]["msg"];
do_return();
}
//检查data是否能转成json
$json_data = json_decode($str_data);
if ($json_data == null) {
$G_Result['state'] = $G_Error["wrong_data"]["code"];
$G_Result['error'] = $G_Error["wrong_data"]["msg"];
do_return();
}
switch ($do){
case 1:
get_roomcard($a, $c, $g, $json_data);
do_return();
break;
case 2:
change_roomcard($a, $c, $g, $json_data);
do_return();
break;
}
//根据参数名获取参数
function GetRequest($name) {
return isset($_REQUEST[$name])?$_REQUEST[$name]:'';
}
//获取房卡数量
function get_roomcard($agentid, $channelid, $gameid, $data) {
global $G_Result, $G_Error, $PDO;
$openid = $data->openid;
$unionid = $data->unionid;
$nickname = $data->nickname;
$avatar = $data->avatar;
$sex = $data->sex;
$province = $data->province;
$city = $data->city;
if ($openid == null || $openid == "") {
$G_Result['state'] = $G_Error["wrong_openid"]["code"];
$G_Result['error'] = $G_Error["wrong_openid"]["msg"];
do_return();
}
if ($unionid == null || $unionid == "") {
$G_Result['state'] = $G_Error["wrong_unionid"]["code"];
$G_Result['error'] = $G_Error["wrong_unionid"]["msg"];
do_return();
}
$stmt = $PDO->prepare("call cp_third_get_roomcard(?,?,?,?,?,?,?,?,?,?)");
if ($stmt->execute(array($agentid, $channelid, $gameid, $openid, $unionid, $nickname, $avatar, $sex, $province, $city))){
$aryData = $stmt->fetch(PDO::FETCH_NAMED);
if ($aryData["result"] != 0){
$G_Result['state'] = $aryData["result"];
$G_Result['error'] = $aryData["error"];
} else {
$G_Result['data']["playerid"] = (int)$aryData["playerid"];
$G_Result['data']["roomcard"] = (int)$aryData["roomcard"];
}
} else {
$G_Result['state'] = $G_Error["execsql"]["code"];
$G_Result['error'] = $G_Error["execsql"]["msg"];
}
}
//修改房卡数量
function change_roomcard($agentid, $channelid, $gameid, $data) {
global $G_Result, $G_Error, $PDO;
$openid = $data->openid;
$unionid = $data->unionid;
$change = $data->change;
$stmt = $PDO->prepare("call cp_third_change_roomcard(?,?,?,?,?,?)");
if ($stmt->execute(array($agentid, $channelid, $gameid, $openid, $unionid, $change))){
$aryData = $stmt->fetch(PDO::FETCH_NAMED);
if ($aryData["result"] != 0){
$G_Result['state'] = $aryData["result"];
$G_Result['error'] = $aryData["error"];
} else {
$G_Result['data']["playerid"] = (int)$aryData["playerid"];
$G_Result['data']["roomcard"] = (int)$aryData["roomcard"];
$G_Result['data']["change"] = (int)$aryData["amount"];
}
} else {
$G_Result['state'] = $G_Error["execsql"]["code"];
$G_Result['error'] = $G_Error["execsql"]["msg"];
}
}
?>

136
codes/games/backstage/youle/web_agent/mod.js Normal file
View File

@@ -0,0 +1,136 @@
//////////////////////////////////////////////////////////////////
///////////////////////////// 运营商 /////////////////////////////
//////////////////////////////////////////////////////////////////
var youle_business = youle_business || cls_mod.new("youle_business", "business", youle_app);
//mysql操作类
youle_business.mysql = cls_mysql.new("http://ylyxdata.daoqi88.cn/mysql.php", youle_business.app.SendPack);
//登录
youle_business.login = function(pack){
var db_callback = function(dbdata){
if (dbdata[0].result != 0){
pack.data = {};
pack.data.state = 1;
pack.data.error = dbdata[0].error;
} else {
pack.data = {};
pack.data.state = 0;
pack.data.agentid = dbdata[0].agentid;
pack.data.agentname = dbdata[0].agentname;
pack.data.profittotal = dbdata[0].profittotal;
pack.data.paymenttotal = dbdata[0].paymenttotal;
pack.data.sharingrate = dbdata[0].sharingrate;
pack.data.playercount = dbdata[0].playercount;
pack.data.newplayer = dbdata[0].newplayer;
pack.data.salecount = dbdata[0].salecount;
pack.data.newsale = dbdata[0].newsale;
}
youle_business.app.SendPack(pack);
}
var user = pack.data.user;
var pwd = pack.data.pwd;
var sql = "call cp_agent_login(?,?);";
youle_business.mysql.execsql("opensql", sql, [user, pwd], db_callback, pack);
}
//修改登录密码
youle_business.update_pwd = function(pack){
var db_callback = function(dbdata){
if (dbdata[0].result != 0){
pack.data = {};
pack.data.state = 1;
pack.data.error = dbdata[0].error;
} else {
pack.data = {};
pack.data.state = 0;
}
youle_business.app.SendPack(pack);
}
var agentid = pack.data.agentid;
var oldpwd = pack.data.oldpwd;
var newpwd = pack.data.newpwd;
var sql = "call cp_agent_updatepwd(?,?,?);";
youle_business.mysql.execsql("opensql", sql, [agentid, oldpwd, newpwd], db_callback, pack);
}
//按月度统计流水
youle_business.profit_month = function(pack){
var db_callback = function(dbdata){
pack.data = {};
pack.data.list = dbdata;
youle_business.app.SendPack(pack);
}
var agentid = pack.data.agentid;
var sql = "call cp_agent_profit_month(?);";
youle_business.mysql.execsql("opensql", sql, [agentid], db_callback, pack);
}
//按产品统计流水
youle_business.profit_product = function(pack){
var db_callback = function(dbdata){
pack.data = {};
pack.data.list = dbdata;
youle_business.app.SendPack(pack);
}
var agentid = pack.data.agentid;
var sql = "call cp_agent_profit_product(?);";
youle_business.mysql.execsql("opensql", sql, [agentid], db_callback, pack);
}
//按月度统计新增玩家数量
youle_business.player_month = function(pack){
var db_callback = function(dbdata){
pack.data = {};
pack.data.list = dbdata;
youle_business.app.SendPack(pack);
}
var agentid = pack.data.agentid;
var sql = "call cp_agent_player_month(?);";
youle_business.mysql.execsql("opensql", sql, [agentid], db_callback, pack);
}
//按月度统计同时在线玩家数量峰值和房间峰值
youle_business.player_max = function(pack){
var db_callback = function(dbdata){
pack.data = {};
pack.data.list = dbdata;
youle_business.app.SendPack(pack);
}
var agentid = pack.data.agentid;
var sql = "call cp_agent_player_max(?);";
youle_business.mysql.execsql("opensql", sql, [agentid], db_callback, pack);
}
//按游戏统计玩家数量和房卡消耗数量
youle_business.player_game = function(pack){
var db_callback = function(dbdata){
pack.data = {};
pack.data.list = dbdata;
youle_business.app.SendPack(pack);
}
var agentid = pack.data.agentid;
var sql = "call cp_agent_player_game(?);";
youle_business.mysql.execsql("opensql", sql, [agentid], db_callback, pack);
}
//按月度统计新增个人代理数量
youle_business.sale_month = function(pack){
var db_callback = function(dbdata){
pack.data = {};
pack.data.list = dbdata;
youle_business.app.SendPack(pack);
}
var agentid = pack.data.agentid;
var sql = "call cp_agent_sale_month(?);";
youle_business.mysql.execsql("opensql", sql, [agentid], db_callback, pack);
}

30
codes/games/backstage/youle/web_sales/class.import.js Normal file
View File

@@ -0,0 +1,30 @@
///////////////////////////////////////////////////
/////// cls_youle_sales_import: 输入接口 ///////
///////////////////////////////////////////////////
var cls_youle_sales_import = cls_youle_sales_import || {
new: function() {
var imp = {};
//玩家购买房卡
imp.player_buy_roomcard = function(agentid, playerid, roomcard, amount){
youle_agent.export.buy_topup(agentid, playerid, 1, roomcard, amount);
}
//玩家充卡
imp.player_topup_roomcard = function(agentid, playerid, roomcard, amount){
youle_agent.export.buy_topup(agentid, playerid, 2, roomcard, amount);
}
//玩家充星星
imp.player_topup_bean = function(agentid, playerid, bean, amount){
youle_agent.export.buy_topup_bean(agentid, playerid, 2, bean, amount);
}
return imp;
}
}
//数据异常处理
youle_sales.import = cls_youle_sales_import.new();

1157
codes/games/backstage/youle/web_sales/mod.js Normal file
View File

File diff suppressed because it is too large Load Diff