774 lines
22 KiB
Java
774 lines
22 KiB
Java
package com.game;
|
||
|
||
import java.util.List;
|
||
import java.util.Map;
|
||
|
||
import com.data.bean.AccountBean;
|
||
import com.data.cache.AccountCache;
|
||
import com.data.cache.BaseCache;
|
||
import com.data.cache.GroupMemberCache;
|
||
import com.data.util.ErrorCode;
|
||
import com.data.util.EventType;
|
||
import com.data.util.Utility;
|
||
import com.game.data.JoinRoomData;
|
||
import com.game.data.Player;
|
||
import com.game.data.Room;
|
||
import com.game.player.state.PlayerInitState;
|
||
import com.game.player.state.PlayerReadyState;
|
||
import com.game.room.state.RoomDestoryGameState;
|
||
import com.taurus.core.entity.ITArray;
|
||
import com.taurus.core.entity.ITObject;
|
||
import com.taurus.core.entity.TArray;
|
||
import com.taurus.core.entity.TObject;
|
||
import com.taurus.core.plugin.redis.Redis;
|
||
import com.taurus.core.plugin.redis.RedisLock;
|
||
import com.taurus.core.routes.ActionKey;
|
||
import com.taurus.core.routes.IController;
|
||
import com.taurus.core.util.StringUtil;
|
||
import com.taurus.permanent.data.Session;
|
||
|
||
import redis.clients.jedis.Jedis;
|
||
|
||
/**
|
||
* 基本游戏控制器
|
||
*
|
||
*/
|
||
public class GameController implements IController {
|
||
|
||
/**
|
||
* 聊天
|
||
*/
|
||
@ActionKey(Router.GAME_INTERACTION)
|
||
public void routerChat(Session sender, ITObject params, int gid, Player owner) {
|
||
owner.room.broadCastToClient(0, Router.GAME_EVT_INTERACTION, params);
|
||
}
|
||
|
||
/**
|
||
* 请求准备
|
||
*
|
||
*/
|
||
@ActionKey(Router.GAME_READY)
|
||
public void routerReady(Session sender, ITObject params, int gid, Player owner) {
|
||
owner.stateMachine.execute(ActionEvent.EVENT_READY, gid, params);
|
||
}
|
||
|
||
/**
|
||
* 请求准备
|
||
*
|
||
*/
|
||
@ActionKey(Router.GAME_READY_AND_XIPAI)
|
||
public void routerReadyAndXiPai(Session sender, ITObject params, int gid, Player owner) {
|
||
owner.stateMachine.execute(ActionEvent.EVENT_READY_AND_XIPAI, gid, params);
|
||
}
|
||
|
||
/**
|
||
* 请求开始游戏
|
||
*/
|
||
@ActionKey(Router.GAME_START)
|
||
public void routerStartGame(Session sender, ITObject params, int gid, Player owner) {
|
||
owner.room.stateMachine.execute(ActionEvent.EVENT_START_GAME, gid, params);
|
||
}
|
||
|
||
@ActionKey(Router.GAME_XIPAI)
|
||
public void RouterXiPai(Session sender, ITObject params, int gid, Player owner) {
|
||
owner.stateMachine.execute(ActionEvent.EVENT_XIPAI, 0, params);
|
||
owner.room.stateMachine.execute(ActionEvent.EVENT_XIPAI, 0, params);
|
||
}
|
||
|
||
/**
|
||
* 托管
|
||
*
|
||
*/
|
||
@ActionKey(Router.GAME_ENTRUST)
|
||
@SuppressWarnings("unchecked")
|
||
public void routerEntrust(Session sender, ITObject params, int gid, Player owner) {
|
||
if (owner.room.status == Constant.ROOM_STATUS_PLAYING && owner.room.isEntrust()) {
|
||
owner.entrust = params.getBoolean("ok");
|
||
Global.gameCtr.updatePlayerEntrust(owner);
|
||
Global.logger.info(owner + " manual " + (owner.entrust ? "entrust" : "quitEntrust"));
|
||
if (owner.entrust) {
|
||
owner.setEntrustData(params);
|
||
owner.stateMachine.curState.execute(owner, ActionEvent.EVENT_ENTRUST, gid, params);
|
||
} else {
|
||
owner.exitEntrust();
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 请求进入房间
|
||
*/
|
||
@ActionKey(value = Router.GAME_JOIN_ROOM, validate = GameInterceptor.NOT_PLAYER)
|
||
public void routerJoinRoom(Session sender, ITObject params, int gid) {
|
||
String session_id = params.getUtfString("session");
|
||
// String sessionToken = Utils.getUniqueSessionToken(sender);
|
||
String token = null;
|
||
if (StringUtil.isEmpty(session_id)) {
|
||
Global.logger.info("---------------参数session为null，参数params：{}", params);
|
||
session_id = "";
|
||
} else {
|
||
String[] sourceStrArray = session_id.split(",");
|
||
if (sourceStrArray.length == 2) {
|
||
session_id = sourceStrArray[0];
|
||
token = sourceStrArray[1];
|
||
}
|
||
|
||
if (StringUtil.isNotEmpty(token) && StringUtil.isNotEmpty(session_id)) {
|
||
String token_session = Redis.use("group1_db0").hget(token, "user");
|
||
if (StringUtil.isEmpty(token_session)) {
|
||
MainServer.instance.sendResponse(gid, ErrorCode._NO_SESSION, null, sender);
|
||
return;
|
||
} else {
|
||
if (!token_session.equals(session_id)) {
|
||
MainServer.instance.sendResponse(gid, ErrorCode._NO_SESSION, null, sender);
|
||
return;
|
||
}
|
||
}
|
||
} else {
|
||
MainServer.instance.sendResponse(gid, ErrorCode._NO_SESSION, null, sender);
|
||
return;
|
||
}
|
||
}
|
||
sender.setHashId(session_id);
|
||
String pos = params.getUtfString("pos");
|
||
Global.roomMgr.joinRoom(sender, session_id, gid, pos);
|
||
}
|
||
|
||
/**
|
||
* 自动出牌
|
||
*/
|
||
@ActionKey(Router.GAME_AUTO_CARD)
|
||
public void routerAutoCard(Session sender, ITObject params, int gid, Player owner) {
|
||
owner.manualAutoCard = params.getBoolean("autoCard");
|
||
|
||
if (owner.manualAutoCard) {
|
||
if (!owner.room.openEntrust) {
|
||
owner.manualAutoCard = false;
|
||
return;
|
||
}
|
||
}
|
||
|
||
owner.entrust = owner.manualAutoCard;
|
||
|
||
Global.gameCtr.updatePlayerEntrust(owner);
|
||
Global.logger.info(owner + " manualAutoCard " + (owner.entrust ? "entrust" : "quitEntrust"));
|
||
|
||
if (owner.manualAutoCard) {
|
||
owner.stateMachine.curState.execute(owner, ActionEvent.EVENT_ENTRUST, gid, params);
|
||
} else {
|
||
owner.exitEntrust();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 请求删除解散房间（外部)
|
||
*
|
||
*/
|
||
@ActionKey(value = Router.GAME_REMOVE_ROOM, validate = GameInterceptor.NOT_PLAYER)
|
||
public void routerRemoveRoom(Session sender, ITObject params, int gid) {
|
||
try {
|
||
String roomid = params.getUtfString("room");
|
||
// Global.logger.info(" ower del room : " + roomid);
|
||
// if (Global.roomMgr.removeRoom(roomid)) {
|
||
Global.logger.info(roomid + " is destroy!");
|
||
MainServer.instance.sendResponse(gid, 0, null, sender);
|
||
// } else {
|
||
// MainServer.instance.sendResponse(gid, 1, null, sender);
|
||
// }
|
||
} catch (Exception e) {
|
||
Global.logger.error(e);
|
||
MainServer.instance.sendResponse(gid, 1, null, sender);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 请求退出房间
|
||
*/
|
||
@ActionKey(Router.GAME_EXIT_ROOM)
|
||
public void routerExitRoom(Session sender, ITObject params, int gid, Player owner) {
|
||
owner.stateMachine.execute(ActionEvent.EVENT_EXIT_ROOM, gid, params);
|
||
}
|
||
|
||
/**
|
||
* 请求解散房间
|
||
*/
|
||
@ActionKey(Router.GAME_ASK_DISMISS_ROOM)
|
||
public void routerAskDismiss(Session sender, ITObject params, int gid, Player owner) {
|
||
owner.room.dismissRunable.askDismiss(owner, gid);
|
||
}
|
||
|
||
/**
|
||
* 房间解散投票请求
|
||
*/
|
||
@ActionKey(Router.GAME_DISMISS_ROOM_VOTE)
|
||
public void routerDismissRoomVote(Session sender, ITObject params, int gid, Player owner) {
|
||
boolean agree = params.getBoolean("result");
|
||
owner.room.dismissRunable.responseDismiss(owner, agree);
|
||
}
|
||
|
||
/**
|
||
* 请求更新GPS位置
|
||
*
|
||
*/
|
||
@ActionKey(Router.GAME_UPDATE_POS)
|
||
public void routerUpdatePos(Session sender, ITObject params, int gid, Player owner) {
|
||
owner.gps_pos = params.getUtfString("pos");
|
||
updatePlayerPos(owner);
|
||
}
|
||
|
||
/**
|
||
* 入座
|
||
*/
|
||
@ActionKey(Router.GAME_JOIN_SEAT)
|
||
public void routerJoinSeat(Session sender, ITObject params, int gid, Player owner) {
|
||
Global.gameCtr.joinSeat(owner, gid);
|
||
}
|
||
|
||
/**
|
||
* 进入房间
|
||
*
|
||
* @param parm
|
||
* @param gid
|
||
* @return
|
||
*/
|
||
@SuppressWarnings("unchecked")
|
||
public int joinRoom(JoinRoomData parm, int gid) {
|
||
Room owner = parm.room;
|
||
String session_key = parm.session_key;
|
||
Session sender = parm.sender;
|
||
String gps_pos = parm.gps_pos;
|
||
AccountBean acc = AccountCache.getAccount(session_key);
|
||
int playerid = acc.id;
|
||
|
||
boolean full = owner.playerMapBySeat.size() >= owner.maxPlayers;
|
||
Global.logger.info("owner.status:" + owner.status);
|
||
|
||
boolean reload = owner.status == Constant.ROOM_STATUS_PLAYING;
|
||
|
||
String ip = acc.ip;
|
||
if (StringUtil.isEmpty(ip)) {
|
||
ip = sender.getAddress();
|
||
}
|
||
|
||
Player player = null;
|
||
boolean new_player = false;
|
||
if (owner.playerMapById.containsKey(playerid)) {
|
||
player = owner.playerMapById.get(playerid);
|
||
if (player.isReload) {
|
||
player.isReload = false;
|
||
player.stateMachine.changeState(Global.getState(PlayerInitState.class));
|
||
}
|
||
player.setSender(sender);
|
||
Global.gameCtr.playerNetState(player);
|
||
Global.gameCtr.updatePlayerPos(player);
|
||
} else {
|
||
if (full) {
|
||
sender.setHashId(null);
|
||
delRoomSeat(session_key, owner.room_key);
|
||
return ErrorCode.ROOM_CLOSE;
|
||
}
|
||
// 检测是否打开GPS 、IP检测
|
||
boolean openGps = owner.isOpenGPSCheck(), openIP = owner.isOpenIPCheck();
|
||
if (openGps || openIP) {
|
||
int errResult = 0;
|
||
if (openGps) {
|
||
Global.warn("room:{},playid:{},gps:{}", owner.room_key, playerid, gps_pos);
|
||
// 开了检测GPS 但是未获取到位置、或未打开
|
||
if (!GPSUtil.isOpenGPS(gps_pos)) {
|
||
errResult = 55;
|
||
}
|
||
// 距离过近
|
||
if (errResult == 0 && owner.checkGps(gps_pos)) {
|
||
errResult = 54;
|
||
}
|
||
}
|
||
if (openIP) {
|
||
// 相同IP
|
||
|
||
if (errResult == 0 && owner.checkIp(ip)) {
|
||
errResult = 53;
|
||
}
|
||
}
|
||
if (errResult != 0) {
|
||
delRoomSeat(session_key, owner.room_key);
|
||
return errResult;
|
||
}
|
||
}
|
||
boolean onseat = true;
|
||
long cur_hp = 0;
|
||
if (onseat && owner.hpData != null) {
|
||
cur_hp = Util.readRedisHp(owner.groupId, playerid);
|
||
if (!checkHplimitInRoom(owner, cur_hp)) {
|
||
return ErrorCode.GROUP_LIMIT_NO_HP;
|
||
}
|
||
}
|
||
player = MainServer.instance.newPlayer(playerid, owner, session_key);
|
||
if (player.room.upper_limit_hp == 0 || player.room.upper_limit_hp > cur_hp) {
|
||
player.room.upper_limit_hp = cur_hp;
|
||
}
|
||
|
||
// Playez firstPlayer = player.room.playerMapBySeat.get(player.seat);
|
||
// for (Map.Entry<Integer, Player> entry : player.room.playerMapBySeat.entrySet()) {
|
||
// Player other = entry.getValue();
|
||
// if (other.hp.upper_limit_hp > firstPlayer.hp.upper_limit_hp) {
|
||
// other.hp.upper_limit_hp = cur_hp;
|
||
// }else {
|
||
// player.hp.upper_limit_hp = cur_hp;
|
||
// }
|
||
// Global.logger.info(other.playerid + "当局赢分上限：" + other.hp.upper_limit_hp);
|
||
// }
|
||
|
||
player.hp.cur_hp = cur_hp;
|
||
// Global.logger.info("当局赢分上限：" + player.room.upper_limit_hp);
|
||
owner.addPlayer(player, false, onseat);
|
||
player.setSender(sender);
|
||
player.stateMachine.changeState(Global.getState(PlayerInitState.class));
|
||
new_player = true;
|
||
}
|
||
|
||
player.nick = acc.nick;
|
||
player.portrait = acc.portrait;
|
||
player.sex = acc.sex;
|
||
player.ip = ip;
|
||
if (StringUtil.isNotEmpty(gps_pos))
|
||
player.gps_pos = gps_pos;
|
||
|
||
ITObject data = new TObject();
|
||
if (reload) {
|
||
data.putTObject("reloadInfo", owner.getReloadInfo(player));
|
||
}
|
||
data.putBoolean("reload", reload);
|
||
data.putInt("owner", owner.owner_id);
|
||
data.putInt("agent", owner.agent ? 1 : 0);
|
||
data.putInt("createTime", Integer.parseInt(owner.redis_room_map.get("create_time")));
|
||
data.putTObject("tableInfo", owner.getRoomInfo(player));
|
||
player.response(data, gid, 0);
|
||
|
||
if (new_player && player.seat != 0) {
|
||
owner.broadCastToClient(player.playerid, Router.GAME_EVT_PLAYER_JOIN, player.getInfo());
|
||
}
|
||
Global.logger.info("reload:" + reload);
|
||
player.stateMachine.curState.reload(player);
|
||
|
||
if (reload) {
|
||
owner.join_player = player;
|
||
owner.dismissRunable.reload(player);
|
||
owner.stateMachine.curState.reload(owner);
|
||
|
||
owner.join_player = null;
|
||
}
|
||
return 0;
|
||
|
||
}
|
||
|
||
/**
|
||
* 玩家不能进入房间，删除redis 玩家身上room、seat
|
||
*
|
||
* @param session_key
|
||
* @param owner
|
||
*/
|
||
public void delRoomSeat(String session_key, String room_key) {
|
||
Jedis jedis0 = Redis.use("group1_db0").getJedis();
|
||
RedisLock lock = new RedisLock(session_key, jedis0);
|
||
try {
|
||
lock.lock();
|
||
String cur_room = jedis0.hget(session_key, "room");
|
||
if (StringUtil.isNotEmpty(cur_room)) {
|
||
if (cur_room.equals(room_key)) {
|
||
jedis0.hdel(session_key, "room", "seat");
|
||
}
|
||
}
|
||
} finally {
|
||
lock.unlock();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 检测加人房间限制
|
||
*
|
||
* @param owner
|
||
* @return
|
||
*/
|
||
public boolean checkHplimitInRoom(Room room, long cur_hp) {
|
||
if (room.hpData != null) {
|
||
int limitInRoom = room.hpData.getInt("limitInRoom");
|
||
if (cur_hp < (long) limitInRoom) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 检测加人房间限制
|
||
*
|
||
* @param owner
|
||
* @return
|
||
*/
|
||
public boolean checkHplimitPlay(Room room, int cur_hp) {
|
||
if (room.hpData != null) {
|
||
int limitInRoom = room.hpData.getInt("limitInRoom");
|
||
if (cur_hp < limitInRoom) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 坐下
|
||
*
|
||
* @param owner
|
||
* @param gid
|
||
*/
|
||
public void joinSeat(Player owner, int gid) {
|
||
|
||
}
|
||
|
||
/**
|
||
* 聊天转发
|
||
*
|
||
* @param owner
|
||
* @param params
|
||
*/
|
||
public void chat(Player owner, ITObject params) {
|
||
owner.room.broadCastToClient(0, Router.GAME_EVT_INTERACTION, params);
|
||
}
|
||
|
||
/**
|
||
* 托管事件
|
||
*
|
||
* @param owner
|
||
*/
|
||
public void entrust(Player owner, int time) {
|
||
ITObject broadParam = new TObject();
|
||
broadParam.putInt("aid", owner.playerid);
|
||
broadParam.putInt("time", time);
|
||
owner.room.broadCastToClient(0, Router.GAME_EVT_READY_ENTRUST, broadParam);
|
||
Global.info("{} Ready Entrust, left time:{}", owner.playerid, time);
|
||
}
|
||
|
||
/**
|
||
* 取消托管事件
|
||
*
|
||
* @param owner
|
||
*/
|
||
public void cancelEntrust(Player owner) {
|
||
ITObject broadParam = new TObject();
|
||
broadParam.putInt("aid", owner.playerid);
|
||
owner.room.broadCastToClient(0, Router.GAME_EVT_CANCEL_READY_ENTRUST, broadParam);
|
||
// Global.info("{} Cancel Ready Entrust", owner.playerid);
|
||
}
|
||
|
||
/**
|
||
* 准备事件
|
||
*
|
||
* @param owner
|
||
*/
|
||
public void ready(Player owner) {
|
||
ITObject broadParam = new TObject();
|
||
broadParam.putInt("aid", owner.playerid);
|
||
long cur_hp = Util.readRedisHp(owner.room.groupId, owner.playerid);
|
||
if (cur_hp < owner.hp.cur_hp) {
|
||
Global.logger.error("cur hp:" + cur_hp + " < hp.cur_hp:" + owner.hp.cur_hp + " playerId:" + owner.playerid);
|
||
if (owner.room.round == 0 && (!checkHplimitInRoom(owner.room, cur_hp) || cur_hp == 0)) {
|
||
owner.room.saveMilitaryTotal(true);
|
||
owner.room.stateMachine.changeState(Global.getState(RoomDestoryGameState.class));
|
||
String gm_key = GroupMemberCache.genKey(owner.room.groupId, owner.playerid);
|
||
Redis.use("group1_db10").hset(gm_key, "ban", "1");
|
||
Redis.use("group1_db10").hset(gm_key, "group_ban", "1");
|
||
return;
|
||
}
|
||
}
|
||
owner.hp.cur_hp = cur_hp;
|
||
|
||
boolean flag = true;
|
||
if (owner.room.maxPlayers == owner.room.playerMapById.size()) {
|
||
for (Map.Entry<Integer, Player> entry : owner.room.playerMapById.entrySet()) {
|
||
if (entry.getValue().playerid != owner.playerid
|
||
&& !(entry.getValue().stateMachine.curState instanceof PlayerReadyState)) {
|
||
flag = false;
|
||
break;
|
||
}
|
||
}
|
||
} else {
|
||
flag = false;
|
||
}
|
||
|
||
if (flag) {
|
||
broadParam.putInt("start", 1);
|
||
} else {
|
||
broadParam.putInt("start", 0);
|
||
}
|
||
owner.room.broadCastToClient(0, Router.GAME_EVT_READY, broadParam);
|
||
owner.stateMachine.changeState(Global.getState(PlayerReadyState.class));
|
||
}
|
||
|
||
/**
|
||
* 准备和洗牌事件
|
||
*
|
||
* @param owner
|
||
*/
|
||
public void readyAndXipai(Player owner) {
|
||
if (owner.xi_pai == false) {
|
||
owner.xi_pai = true;
|
||
// owner.room.redisUpdateXiPaiPlayer(owner);
|
||
|
||
}
|
||
long cur_hp = Util.readRedisHp(owner.room.groupId, owner.playerid);
|
||
|
||
if (cur_hp < owner.hp.cur_hp || cur_hp == 0) {
|
||
Global.logger.error(
|
||
"cur hp:" + cur_hp + " < >>>>> hp.cur_hp:" + owner.hp.cur_hp + " playerId:" + owner.playerid);
|
||
if (owner.room.round == 0 && (!checkHplimitInRoom(owner.room, cur_hp) || cur_hp == 0)) {
|
||
owner.room.saveMilitaryTotal(true);
|
||
owner.room.stateMachine.changeState(Global.getState(RoomDestoryGameState.class));
|
||
String gm_key = GroupMemberCache.genKey(owner.room.groupId, owner.playerid);
|
||
Redis.use("group1_db10").hset(gm_key, "ban", "1");
|
||
Redis.use("group1_db10").hset(gm_key, "group_ban", "1");
|
||
return;
|
||
}
|
||
}
|
||
owner.hp.cur_hp = cur_hp;
|
||
ITObject broadParam = new TObject();
|
||
broadParam.putInt("aid", owner.playerid);
|
||
|
||
boolean flag = true;
|
||
if (owner.room.maxPlayers == owner.room.playerMapById.size()) {
|
||
for (Map.Entry<Integer, Player> entry : owner.room.playerMapById.entrySet()) {
|
||
if (entry.getValue().playerid != owner.playerid
|
||
&& !(entry.getValue().stateMachine.curState instanceof PlayerReadyState)) {
|
||
flag = false;
|
||
break;
|
||
}
|
||
}
|
||
} else {
|
||
flag = false;
|
||
}
|
||
|
||
if (flag) {
|
||
broadParam.putInt("start", 1);
|
||
} else {
|
||
broadParam.putInt("start", 0);
|
||
}
|
||
owner.room.broadCastToClient(0, Router.GAME_EVT_READY_AND_XIPAI, broadParam);
|
||
owner.stateMachine.changeState(Global.getState(PlayerReadyState.class));
|
||
}
|
||
|
||
/**
|
||
* 解散房间通知
|
||
*
|
||
* @param askPlayer
|
||
* @param sender
|
||
* @param time
|
||
*/
|
||
public void dismissRoom(Player askPlayer, Player sender, List<Player> playerList, int time) {
|
||
ITObject parm = TObject.newInstance();
|
||
parm.putInt("req_aid", askPlayer.playerid);
|
||
parm.putInt("time", time);
|
||
ITArray list = TArray.newInstance();
|
||
parm.putTArray("list", list);
|
||
for (Player player : playerList) {
|
||
ITObject tem = TObject.newInstance();
|
||
tem.putInt("aid", player.playerid);
|
||
tem.putInt("result", player.dismissState);
|
||
list.addTObject(tem);
|
||
}
|
||
if (sender != null) {
|
||
sender.sendEvent(Router.GAME_EVT_DISMISS_ROOM, parm);
|
||
} else {
|
||
askPlayer.room.broadCastToClient(0, Router.GAME_EVT_DISMISS_ROOM, parm);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 观众席
|
||
*
|
||
* @param owner
|
||
*/
|
||
public void joinSpectator(Player owner) {
|
||
if (owner.room.exitSeat(owner)) {
|
||
if (Global.loggerDebug) {
|
||
Global.logger.info(owner + " exit seat!");
|
||
}
|
||
owner.seat = 0;
|
||
ITObject data = new TObject();
|
||
data.putInt("aid", owner.playerid);
|
||
owner.room.broadCastToClient(0, Router.GAME_EVT_JOIN_SPECTATOR, data);
|
||
owner.room.stateMachine.execute(ActionEvent.EVENT_READY, 0, null);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 解散失败
|
||
*
|
||
* @param owner
|
||
*/
|
||
public void dismisRoomFail(Room owner) {
|
||
owner.broadCastToClient(0, Router.GAME_EVT_DISMISS_ROOM_FAIL, null);
|
||
}
|
||
|
||
/**
|
||
* 退出房间
|
||
*
|
||
* @param owner
|
||
* @param gid
|
||
*/
|
||
public void exitRoom(Player owner, int gid, boolean kick) {
|
||
if (kick) {
|
||
owner.sendEvent(Router.GAME_EVT_KICK_PLAYER, null);
|
||
} else {
|
||
owner.response(null, gid, 0);
|
||
}
|
||
if (owner.room.status == Constant.ROOM_STATUS_NOBEGIN || owner.spectator) {
|
||
int owner_id = owner.room.owner_id;
|
||
if (!owner.room.agent && owner.playerid == owner_id) {
|
||
owner.room.stateMachine.changeState(Global.getState(RoomDestoryGameState.class));
|
||
} else {
|
||
// 在座位上
|
||
if (owner.room.playerMapBySeat.containsKey(owner.seat) && owner.room.playerMapBySeat.size() == 1) {
|
||
ITObject data = new TObject();
|
||
data.putInt("aid", owner.playerid);
|
||
owner.room.broadCastToClient(owner.playerid, Router.GAME_EVT_PLAYER_EXIT, data);
|
||
int groupId = owner.room.groupId;
|
||
String roomid = owner.room.roomid;
|
||
try {
|
||
delRoom(groupId, roomid);
|
||
} catch (Exception e) {
|
||
e.printStackTrace();
|
||
}
|
||
owner.destroy(true);
|
||
|
||
GroupPublisherService.delRoomEvt(groupId, roomid);
|
||
Jedis jedis0 =Redis.use("group1_db0").getJedis();
|
||
jedis0.del("room:"+roomid);
|
||
jedis0.close();
|
||
} else if (owner.room.playerMapBySeat.containsKey(owner.seat)) {
|
||
ITObject data = new TObject();
|
||
data.putInt("aid", owner.playerid);
|
||
owner.room.broadCastToClient(owner.playerid, Router.GAME_EVT_PLAYER_EXIT, data);
|
||
owner.destroy(true);
|
||
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 玩家网络状态通知
|
||
*
|
||
* @param owner
|
||
*/
|
||
public void playerNetState(Player owner) {
|
||
ITObject param = new TObject();
|
||
param.putInt("aid", owner.playerid);
|
||
param.putInt("online", owner.isConnect ? 1 : 0);
|
||
owner.room.updatePlayerOffline(owner);
|
||
owner.room.broadCastToClient(owner.playerid, Router.GAME_EVT_PLAYER_NET_STATE, param);
|
||
}
|
||
|
||
/**
|
||
* 更新玩家GPS位置
|
||
*
|
||
* @param owner
|
||
*/
|
||
public void updatePlayerPos(Player owner) {
|
||
ITObject param = new TObject();
|
||
param.putInt("seat", owner.seat);
|
||
param.putUtfString("pos", owner.gps_pos);
|
||
owner.room.broadCastToClient(owner.playerid, Router.GAME_EVT_UPDATE_POS, param);
|
||
}
|
||
|
||
/**
|
||
* 更新玩家托管
|
||
*
|
||
* @param owner
|
||
*/
|
||
public void updatePlayerEntrust(Player owner) {
|
||
ITObject param = new TObject();
|
||
param.putInt("aid", owner.playerid);
|
||
param.putInt("type", 5);
|
||
param.putBoolean("entrust", owner.entrust);
|
||
owner.room.broadCastToClient(0, Router.GAME_EVT_UPDATE_PLAYERINFO, param);
|
||
}
|
||
|
||
/**
|
||
* 删除房间
|
||
*
|
||
* @param groupId
|
||
* @param roomId
|
||
* @return
|
||
* @throws Exception
|
||
*/
|
||
public static final ITObject delRoom(int groupId, String roomId) throws Exception {
|
||
String tag_key = "room:" + roomId;
|
||
Jedis jedis0 = Redis.use("group1_db0").getJedis();
|
||
// String svr = StringUtil.Empty;
|
||
|
||
RedisLock lock = new RedisLock(tag_key, jedis0);
|
||
try {
|
||
lock.lock();
|
||
List<String> list = jedis0.hmget(tag_key, "AA", "payer", "pay", "group", "game", "status", "gpid", "fake",
|
||
"players");
|
||
String status = list.get(5);
|
||
int _status = Integer.parseInt(status);
|
||
|
||
String group = list.get(3);
|
||
int _gid = 0;
|
||
if (StringUtil.isNotEmpty(group)) {
|
||
_gid = Integer.parseInt(group);
|
||
}
|
||
|
||
String strGpid = list.get(6);
|
||
int _gpid = 0;
|
||
if (StringUtil.isNotEmpty(strGpid)) {
|
||
_gpid = Integer.parseInt(strGpid);
|
||
}
|
||
|
||
String strFake = list.get(7);
|
||
if (_status == 0) {
|
||
if (strFake == null) {
|
||
int gameId = Integer.parseInt(list.get(4));
|
||
boolean pay_AA = Integer.parseInt(list.get(0)) == 1;
|
||
if (!pay_AA) {
|
||
int payer = Integer.parseInt(list.get(1));
|
||
int pay = Integer.parseInt(list.get(2));
|
||
Utility.payDiamo(EventType.REDIS_EVENT_BACK_PAY, payer, gameId, pay, groupId, _gpid);
|
||
}
|
||
}
|
||
}
|
||
if (strFake != null) {
|
||
try {
|
||
ITArray players = TArray.newFromJsonData(list.get(8));
|
||
for (int i = 0; i < players.size(); i++) {
|
||
int player_id = players.getInt(i);
|
||
Redis.use("group1_db1").srem("used_robot", Integer.toString(player_id));
|
||
// Redis.use("group1_db1").sadd("free_robot", Integer.toString(player_id));
|
||
|
||
}
|
||
} catch (Exception e) {
|
||
|
||
}
|
||
}
|
||
jedis0.hset(tag_key, "status", "2");
|
||
BaseCache.updateCacheVer(jedis0, tag_key);
|
||
GroupPublisherService.delRoomEvt(groupId, roomId);
|
||
// svr = jedis0.hget(tag_key, "svr");
|
||
//
|
||
// List<String> server_ip = Redis.use("group1_db0").hmget(svr, "ip", "port");
|
||
// String ip = server_ip.get(0);
|
||
// if(StringUtil.isEmpty(ip)) {
|
||
// throw new WebException(ErrorCode.NO_SERVICE);
|
||
// }
|
||
// String port =server_ip.get(1);
|
||
ITObject obj = TObject.newInstance();
|
||
// obj.putString("ip", ip);
|
||
// obj.putInt("port", Integer.parseInt(port));
|
||
return obj;
|
||
} finally {
|
||
lock.unlock();
|
||
}
|
||
|
||
}
|
||
}
|