private void cleverPlayMove()
{
while (isPlaying)
{
Thread.Sleep(100);
if (hasNewInput == false)
{
continue;
}
hasNewInput = false;
bool dropBomb = false;
int moveDir = -1;
//Obvious quick fix, we should not have to try catch the DLL....
try{
//moveDir = BombermanBot.MainClass.getCurrentAction (lastInput, ref dropBomb);
PlayerCommand outMsg = new PlayerCommand(botColor, moveDir, dropBomb);
theClientController.onOutgoingLocalMsgObj(outMsg, (short)BombermanProtocol.MsgType.playerCommands);
}catch {}
RealtimeTCPController.requestBoard(BombermanOverlord.convertColorToTeam(botColor));
}
}
public void handleGameUpdate(NetworkMessage updateMsg)
{
GameUpdate msg = Deserialize <GameUpdate> (updateMsg.reader.ReadBytesAndSize());
clientRenderer.movePlayer(msg.blueCoords, msg.redCoords);
RealtimeTCPController.gotNewBoard(colorToTeam(msg.myColor), formatBoard(msg));
}
protected override void initHandlers()
{
base.initHandlers();
StartCoroutine(findAndInitRenderer <SpeedRunnerRenderer>((x) => localRenderer = x));
StartCoroutine(handleNetworkMsgQueue());
RealtimeTCPController.resetController();
localPlayer = FindObjectOfType <Player>();
TCPMessageQueue.readMsgInstant = instantReadTCPMsg;
}
public override void onOutgoingLocalMsg(string msg, PlayerColor color)
{
int dir = -1;
if (parseCommandMsg(msg, out dir))
{
sendServerMsg(new GameCommand(color, dir), (short)SnakeProtocol.MsgType.playerCommands);
}
RealtimeTCPController.requestBoard(convertColorToTeam(color));
}
public void addNewUpdate(List <Position2D> blocked, int dir, int enemyDir, Position2D playerPos, Position2D enemyPos, BoardState state)
{
foreach (Position2D c in blocked)
{
if (oldCoords.Any((p) => GameUtils.comparePos(c, p)))
{
continue;
}
oldCoords.Add(c);
}
RealtimeTCPController.gotNewBoard(team, formatBoard(dir, enemyDir, playerPos, enemyPos, state));
}
protected override void initHandlers()
{
connectionToServer.RegisterHandler((short)ServerCommProtocl.PlayerJoinedGameRoom, handlePlayerJoinedRoom);
connectionToServer.RegisterHandler((short)ServerCommProtocl.PlayerLeftGameRoom, handlePlayerLeftRoom);
connectionToServer.RegisterHandler((short)BombermanProtocol.MsgType.playerInit, handleInitSettings);
connectionToServer.RegisterHandler((short)BombermanProtocol.MsgType.gameInfo, handleGameInfoMsg);
connectionToServer.RegisterHandler((short)BombermanProtocol.MsgType.boardInit, handleBoardInit);
connectionToServer.RegisterHandler((short)BombermanProtocol.MsgType.boardUpdate, handleBoardUpdate);
StartCoroutine(findAndInitRenderer <BombermanRenderer>((x) => localRenderer = x));
StartCoroutine(handleNetworkMsgQueue());
RealtimeTCPController.resetController();
}
public void handleInitSettings(NetworkMessage initMsg)
{
GameInfo msg = Deserialize <GameInfo> (initMsg.reader.ReadBytesAndSize());
ClientPlayersHandler.initPlayerColor(msg.username, msg.myColor);
LocalPlayer p = ClientPlayersHandler.getPlayerFromColor(msg.myColor);
RealtimeTCPController.registerLocalPlayer(colorToTeam(msg.myColor), p.takeInput, p.isMainPlayer());
if (p.isMainPlayer())
{
isListeningForTCP = true;
}
}
protected override void initHandlers()
{
base.initHandlers();
connectionToServer.RegisterHandler((short)SnakeProtocol.MsgType.playerInit, handleInitSettings);
connectionToServer.RegisterHandler((short)SnakeProtocol.MsgType.boardUpdate, handleBoardUpdate);
connectionToServer.RegisterHandler((short)SnakeProtocol.MsgType.gameInfo, handleGameInfo);
StartCoroutine(findAndInitRenderer <SnakeRenderer>((x) => localRenderer = x));
StartCoroutine(handleNetworkMsgQueue());
RealtimeTCPController.resetController();
TCPMessageQueue.readMsgInstant = readTCPMsg;
localRenderer.init(localGameUI);
}
protected override void initHandlers()
{
connectionToServer.RegisterHandler((short)SoldiersProtocol.MsgType.playerInit, handleInitSettings);
connectionToServer.RegisterHandler((short)ServerCommProtocl.PlayerJoinedGameRoom, handlePlayerJoinedRoom);
connectionToServer.RegisterHandler((short)ServerCommProtocl.PlayerLeftGameRoom, handlePlayerLeftRoom);
connectionToServer.RegisterHandler((short)SoldiersProtocol.MsgType.boardUpdate, handleBoardUpdate);
connectionToServer.RegisterHandler((short)SoldiersProtocol.MsgType.boardStart, handleBoardStart);
connectionToServer.RegisterHandler((short)SoldiersProtocol.MsgType.gameInfo, handleGameInfo);
StartCoroutine(findAndInitRenderer <SoldiersRenderer>((x) => localRenderer = x));
StartCoroutine(handleNetworkMsgQueue());
RealtimeTCPController.resetController();
TCPMessageQueue.readMsgInstant = readTCPMsg;
}
protected override void playMove(string input)
{
while (isPlaying)
{
Thread.Sleep(200);
if (hasNewInput == false)
{
continue;
}
hasNewInput = false;
makeDecision();
RealtimeTCPController.requestBoard(BombermanOverlord.convertColorToTeam(botColor));
}
}
public void handleInitSettings(NetworkMessage initMsg)
{
byte[] bytes = initMsg.reader.ReadBytesAndSize();
GameInfo msg = ClientController.Deserialize <GameInfo> (bytes);
ClientPlayersHandler.initPlayerColor(msg.username, msg.myColor);
LocalPlayer p = ClientPlayersHandler.getPlayerFromColor(msg.myColor);
RealtimeTCPController.registerLocalPlayer(convertColorToTeam(p.info.color), p.getTakeInputFunc(), !p.isNPC());
if (p.isNPC() == false)
{
localPlayerColor = p.info.color;
}
isListeningForTCP = true;
}
//Since we assume that there is only one bot from the local player we override
protected override void readTCPMsg(ReceivedLocalMessage msg)
{
if (isGameOver)
{
return;
}
List <TCPCommand> playerCommands = SoldiersTCPProtocol.convertMsgToCommands(msg.message);
if (playerCommands.Count == 0)
{
RealtimeTCPController.requestBoard(convertColorToTeam(localPlayerColor), true);
return;
}
PlayerCommands outMsg = new PlayerCommands(localPlayerColor, playerCommands);
sendServerMsg(outMsg, (short)SoldiersProtocol.MsgType.playerCommands);
RealtimeTCPController.requestBoard(0, true);
}
public void handleBoardUpdate(NetworkMessage boardMsg)
{
byte[] bytes = boardMsg.reader.ReadBytesAndSize();
BoardUpdate msg = Deserialize <BoardUpdate> (bytes);
if (msg.updateID < lastUpdateID)
{
return;
}
if (msg.updateID > lastUpdateID)
{
lastUpdateID = msg.updateID;
localRenderer.renderNewBoard(msg);
}
//print ("Update : " + msg.color);
RealtimeTCPController.gotNewBoard(BombermanOverlord.convertColorToTeam(msg.color), BombermanBoardParser.parseBoard(msg));
}
public void handleInitSettings(NetworkMessage initMsg)
{
GameInfo msg = Deserialize <GameInfo> (initMsg.reader.ReadBytesAndSize());
ClientPlayersHandler.initPlayerColor(msg.username, msg.myColor);
LocalPlayer p = ClientPlayersHandler.getPlayerFromColor(msg.myColor);
int playerIndex = convertColorToTeam(msg.myColor);
TCPFormater [playerIndex] = new SnakeTCPFormater(playerIndex);
Action <string> sendBoardFunc = p.getTakeInputFunc();
RealtimeTCPController.registerLocalPlayer(playerIndex,
(string s) => {
sendBoardFunc(s);
}
, !p.isNPC() && !p.Human);
if (p.isMainPlayer())
{
localPlayerColor = p.info.color;
}
if (p.Human)
{
localHumanColor = p.info.color;
}
if (p.info.color == PlayerColor.Blue)
{
hasLocalBluePlayer = true;
}
else
{
hasLocalRedPlayer = true;
}
isListeningForTCP = true;
}
public void handleInitSettings(NetworkMessage initMsg)
{
GameInfo msg = Deserialize <GameInfo> (initMsg.reader.ReadBytesAndSize());
ClientPlayersHandler.initPlayerColor(msg.username, msg.myColor);
LocalPlayer p = ClientPlayersHandler.getPlayerFromColor(msg.myColor);
RealtimeTCPController.registerLocalPlayer(BombermanOverlord.convertColorToTeam(p.info.color), p.getTakeInputFunc(), !p.isNPC());
if (p.isMainPlayer())
{
localPlayerColor = p.info.color;
}
if (p.Human)
{
localHumanColor = p.info.color;
}
print(localPlayerColor);
isListeningForTCP = true;
}
protected override void readTCPMsg(ReceivedLocalMessage msg)
{
if (msg.message.Length == 0)
{
RealtimeTCPController.requestBoard(convertColorToTeam(localPlayerColor), true);
return;
}
APIMsgConclusion conclusion = APIRouter.handleIncomingMsg(msg.message);
if (conclusion.target == MsgTarget.Server)
{
int dir = -1;
if (parseCommandMsg(msg.message, out dir))
{
sendServerMsg(new GameCommand(localPlayerColor, dir), (short)SnakeProtocol.MsgType.playerCommands);
}
RealtimeTCPController.requestBoard(convertColorToTeam(localPlayerColor), true);
}
else if (conclusion.status == ResponseStatus.Success && conclusion.target == MsgTarget.Player)
{
ClientPlayersHandler.getPlayerFromColor(localPlayerColor).takeInput(conclusion.msg);
}
}
protected override void readTCPMsg(ReceivedLocalMessage msg)
{
if (isGameOver)
{
return;
}
if (msg.message.Length == 0)
{
RealtimeTCPController.requestBoard(BombermanOverlord.convertColorToTeam(localPlayerColor), true);
return;
}
PlayerCommand outMsg = new PlayerCommand(localPlayerColor, -1);
parseInputMoveDir(msg.message, ref outMsg);
parseDropBomb(msg.message, ref outMsg);
if (outMsg.moveDir >= 0 || outMsg.dropBomb)
{
sendServerMsg(outMsg, (short)BombermanProtocol.MsgType.playerCommands);
}
RealtimeTCPController.requestBoard(BombermanOverlord.convertColorToTeam(localPlayerColor), true);
}