// 양 클라이언트에서 동일한 타이밍으로 게임 시작을 위한, 게임시작 패킷 수신 함수
public void OnReceiveGameStartPacket(PacketId id, byte[] data)
{
GameStartPacket packet = new GameStartPacket(data);
GameStartData startData = packet.GetPacket();
enterGameScene[startData.campNumber - 1] = true;
bool check = false;
for (int i = 0; i < 2; i++)
{
if (enterGameScene[i] == false)
{
Debug.Log((i + 1).ToString() + " 진영에서 아직 데이터 안보냄.");
check = true;
}
}
if (check == false)
{
// 양 단말 모두 준비가 되었으므로 게임 시작
Debug.Log("양 단말의 게임 시작 패킷 수신을 완료했으므로, 일시중지 해제하고 게임 시작");
readyToStart = true;
}
}
public static GameDefinition GetGameDefinition(GameStartData startData)
{
var gamePack = Current.GamePacks.FirstOrDefault(gp => gp.Name == startData.PackName);
var gameSet = gamePack.GameSets.FirstOrDefault(gs => gs.Name == startData.SetName);
var gameDefinition = gameSet.Games[startData.Index];
return(gameDefinition);
}
// 게임 씬으로 진입했을 때, 즉 게임 시작을 위한 준비가 모두 끝났을 때 서버에 준비 되었다는 정보를 송신
public void SendReadyToStartGamePacket()
{
GameStartData data = new GameStartData();
data.campNumber = MyCampNum;
networkManager.SendReliable <GameStartData>(new GameStartPacket(data));
Debug.Log(myCampNum.ToString() + " 게임씬 입장 데이터 전송 완료");
}
void OnGameJoinAccept(GameStartData gameStartData)
{
LastReceivedServerTick = gameStartData.OnJoinServerTick;
ClientTick = gameStartData.OnJoinServerTick;
foreach (PlayerSpawnData playerSpawnData in gameStartData.Players)
{
SpawnPlayer(playerSpawnData);
}
}
void OnGameJoinAccept(GameStartData data)
{
LastRecievedServerTick = data.OnJoinServerTick;
ClientTick = data.OnJoinServerTick;
foreach (PlayerSpawnData ppd in data.Players)
{
SpawnPlayer(ppd);
}
}
void Handle(GameStartData data)
{
gameState = new GameState
{
GameStart = data,
};
currentRoundState = new RoundState();
}
public void OnLoadGameSubmit(Guid saveId, SaveData summary)
{
var data = GameStartData.Create();
data.saveId = saveId;
data.saveName = summary.saveName;
data.seed = summary.seed;
data.isLoadedGame = true;
this.LoadInGame();
}
public void OnNewGameSubmit()
{
if (this.newGameName.text.Length <= 0)
{
return;
}
var data = GameStartData.Create();
data.saveId = Guid.NewGuid();
data.saveName = this.newGameName.text;
this.LoadInGame();
}
public bool Serialize(GameStartData packet)
{
bool ret = true;
ret &= Serialize(packet.campNumber);
ret &= Serialize(packet.trash0);
ret &= Serialize(packet.trash1);
ret &= Serialize(packet.trash2);
ret &= Serialize(packet.trash3);
ret &= Serialize(packet.trash4);
ret &= Serialize(packet.trash5);
ret &= Serialize(packet.trash6);
ret &= Serialize(packet.trash7);
return(ret);
}
public void CreateNewGame(GameStartData gameStartData)
{
// Prepare data for writing
Console.WriteLine("Preparing new game data...");
Game newGame = new Game();
newGame.ThreadTimeStamp = gameStartData.ThreadTs;
newGame.IsActive = true;
newGame.StartingUrl = gameStartData.StartingUrl;
newGame.EndingUrl = gameStartData.EndingUrl;
// Write changes to database
Console.WriteLine("Saving data...");
_context.Games.Add(newGame);
_context.SaveChanges();
Console.WriteLine("Game Written and started.");
}
public bool Deserialize(ref GameStartData element)
{
// 데이터가 정의되어있지 않다면
if (GetDataSize() == 0)
{
return(false);
}
bool ret = true;
ret &= Deserialize(ref element.campNumber);
ret &= Deserialize(ref element.trash0);
ret &= Deserialize(ref element.trash1);
ret &= Deserialize(ref element.trash2);
ret &= Deserialize(ref element.trash3);
ret &= Deserialize(ref element.trash4);
ret &= Deserialize(ref element.trash5);
ret &= Deserialize(ref element.trash6);
ret &= Deserialize(ref element.trash7);
return(ret);
}
private void OnGameStart(GameStartData startData)
{
LastServerTick = startData.ServerTick;
ClientTick = startData.ServerTick;
// Mapreihenfolge festlegen
Random.InitState(startData.Seed);
mapOrder = new int[rounds];
currentMapIndex = 0;
for (int i = 0; i < rounds; i++)
{
mapOrder[i] = Mathf.RoundToInt((mapPrefabs.Length - 1) * Random.value);
}
currentMap = Instantiate(mapPrefabs[mapOrder[currentMapIndex]]);
foreach (var spawnData in startData.Players)
{
SpawnPlayer(spawnData);
}
}
public void CreateNewGame(GameStartData gameStartData)
{
Console.WriteLine($"New Game Create: Ts={gameStartData.ThreadTs}");
gameEntries.Clear();
_mockGameThreadTs = gameStartData.ThreadTs;
}
/*private void SendAndCreateToServer()
* {
* switch (sendOptions)
* {
* case SendOptions.AI_VS_AI:
* SendAI_VS_AI_Data();
* break;
*
* case SendOptions.AckAI_VS_AI:
* SendAck();
* break;
*
* case SendOptions.Ack:
* SendAck();
* break;
*
* default:
* break;
* }
* }*/
private IEnumerator RecieveAndParseServerReply()
{
recievingInCorutine = true;
while (!s.DataAvailable)
{
yield return(null);
}
string ServerReply = sr.ReadLine();
Debug.Log("Recvd " + ServerReply);
loggerText.text = "Recvd " + ServerReply + "\n";
Dictionary <string, object> ServerReplyDict = JsonConvert.DeserializeObject <Dictionary <string, object> >(ServerReply);
MsgsEnum ServerReplytype = (MsgsEnum)int.Parse(ServerReplyDict["type"].ToString());
string serverMsg = ServerReplyDict["msg"].ToString();
switch (ServerReplytype)
{
case MsgsEnum.AI_VS_AI:
break;
case MsgsEnum.AckAI_VS_AI:
AckAI_VS_AI_Data ackAI_VS_AI = JsonConvert.DeserializeObject <AckAI_VS_AI_Data>(serverMsg);
manager.SetMyTurn(ackAI_VS_AI.myTurn);
if (ackAI_VS_AI.ourRemainingTime > 0)
{
manager.SetOurTimer(ackAI_VS_AI.ourRemainingTime / 1000.0f);
}
if (ackAI_VS_AI.theirRemainingTime > 0)
{
manager.SetTheirTimer(ackAI_VS_AI.theirRemainingTime / 1000.0f);
}
SendAck();
break;
case MsgsEnum.moveConfigrations:
MoveData moveConfigData = JsonConvert.DeserializeObject <MoveData>(serverMsg);
boardObject.PlaceStone(moveConfigData.y, moveConfigData.x, moveConfigData.color != 'b');
if (moveConfigData.ourScore > 0 || moveConfigData.theirScore > 0)
{
manager.SetScore(moveConfigData.ourScore, moveConfigData.theirScore);
}
if (moveConfigData.ourTimer > 0)
{
manager.SetOurTimer(moveConfigData.ourTimer / 1000.0f);
}
if (moveConfigData.theirTimer > 0)
{
manager.SetTheirTimer(moveConfigData.theirTimer / 1000.0f);
}
manager.GamePlayedAvA();
//sendOptions = SendOptions.Ack;
SendAck();
break;
case MsgsEnum.gameEnd:
GameEndData gameEndData = JsonConvert.DeserializeObject <GameEndData>(serverMsg);
manager.GameEnd(gameEndData.ourScore, gameEndData.theirScore, gameEndData.win);
SendAck();
break;
case MsgsEnum.gamePaused:
manager.PauseGame();
SendAck();
break;
case MsgsEnum.exit:
break;
case MsgsEnum.ack:
AckData ackData = JsonConvert.DeserializeObject <AckData>(serverMsg);
Debug.Log("Ack data " + ackData.reason + " " + ackData.valid + " " + ackData.valid);
if (ackData.valid)
{
manager.PlayerMoveAccepted();
if (ackData.ourScore > 0 || ackData.theirScore > 0)
{
manager.SetScore(ackData.ourScore, ackData.theirScore);
}
}
else
{
manager.PlayerMoveNotAccepted();
}
manager.ShowWarning(ackData.reason);
SendAck();
break;
case MsgsEnum.gameStart:
GameStartData gameStartData = JsonConvert.DeserializeObject <GameStartData>(serverMsg);
manager.SetMyTurn(gameStartData.myTurn);
if (gameStartData.ourRemainingTime > 0)
{
manager.SetOurTimer(gameStartData.ourRemainingTime / 1000.0f);
}
if (gameStartData.theirRemainingTime > 0)
{
manager.SetTheirTimer(gameStartData.theirRemainingTime / 1000.0f);
}
manager.ResumeGame();
SendAck();
break;
case MsgsEnum.AI_VSHuman:
break;
case MsgsEnum.move:
MoveData moveData = new MoveData();
moveData.countCaptured = 0;
moveData = JsonConvert.DeserializeObject <MoveData>(serverMsg);
boardObject.PlaceStone(moveData.y, moveData.x, moveData.color != 'b');
manager.AiPlayed();
if (moveData.ourScore > 0 || moveData.theirScore > 0)
{
manager.SetScore(moveData.ourScore, moveData.theirScore);
}
//sendOptions = SendOptions.Ack;
SendAck();
break;
case MsgsEnum.forfeit:
break;
case MsgsEnum.remove:
RemoveData removeData = JsonConvert.DeserializeObject <RemoveData>(serverMsg);
boardObject.RemoveStone(removeData.y, removeData.x);
//sendOptions = SendOptions.Ack;
SendAck();
break;
default:
break;
}
recievingInCorutine = false;
}
