public void QueueAttack(int attackId, Vector2Int targetTile)
{
AttackRequestMessage attackMessage = new AttackRequestMessage();
attackMessage.attackId = attackId;
attackMessage.targetTileX = targetTile.x;
attackMessage.targetTileY = targetTile.y;
client.Send(CustomNetMsg.AttackRequest, attackMessage);
}
//The attack request ignores action queue stuff and auto accepts, so I dont have to rewrite the queue system that seems to only work for movement
void GotAttackRequest(NetworkMessage netMsg)
{
AttackRequestMessage attackRequest = netMsg.ReadMessage <AttackRequestMessage>();
AttackMessage attackMessage = new AttackMessage();
attackMessage.id = netMsg.conn.connectionId;
attackMessage.attackId = attackRequest.attackId;
attackMessage.targetTileX = attackRequest.targetTileX;
attackMessage.targetTileY = attackRequest.targetTileY;
//FOr now we will do random damage
attackMessage.result = Random.Range(5, 9);
NetworkServer.SendToAll(CustomNetMsg.Attack, attackMessage);
handleAttack(attackMessage.id, attackMessage.attackId, attackMessage.targetTileX, attackMessage.targetTileY, attackMessage.result);
}
public void HandleAttackRequest(AttackRequestMessage message, int connectID)
{
PlayerData playerData = serverDataHolder.players.Find(x => x.playerIndex == connectID);
RoomData currentRoom = serverDataHolder.rooms[playerData.roomID[0], playerData.roomID[1]];
//monster adds player to target list
Monster monster = serverDataHolder.activeMonsters.Find(x => x.roomID == playerData.roomID);
if (!monster.targetPlayers.Contains(playerData.playerIndex))
{
monster.targetPlayers.Add(playerData.playerIndex);
}
//check treasure even has ammount
if (currentRoom.containsMonster == false)
{
//if not then send request denied
RequestDenied(message, connectID);
return;
}
//then update data in room
currentRoom.monsterHP -= 6;
if (currentRoom.monsterHP <= 0)
{
currentRoom.containsMonster = false;
serverDataHolder.activeMonsters.Remove(serverDataHolder.activeMonsters.Find(x => x.roomID == playerData.roomID));
}
//send hit message back to all players in room
List <int> ids = serverDataHolder.GetOtherPlayerIDsInSameRoom(playerData);
ids.Add(connectID);
HitMonsterMessage hitMessage = new HitMonsterMessage()
{
PlayerID = connectID,
damageDealt = 6
};
foreach (int id in ids)
{
SendMessage(hitMessage, connections[serverDataHolder.players.Find(x => x.playerIndex == id).playerIndex]);
}
NextPlayerTurn();
}
public void OnProcessAttackAction(NetworkMessage msg)
{
AttackRequestMessage message = msg.ReadMessage <AttackRequestMessage>();
if (_gameState.SubActionNumber != message.SubActionNumber || _gameState.ActionNumber != message.ActionNumber)
{
SendToAll(CustomMessageTypes.GameStateSync, new GameStateSyncMessage
{
ActionNumber = _gameState.ActionNumber,
SubActionNumber = _gameState.SubActionNumber,
Message = "Game State Sync",
HostMonsterState = JsonConvert.SerializeObject(_gameState.HostMonsters.Select(m => new { m.MonsterTypeId, m.CurrentNode.Id }).ToDictionary(k => k.MonsterTypeId, v => v.Id)),
GuestMonsterState = JsonConvert.SerializeObject(_gameState.GuestMonsters.Select(m => new { m.MonsterTypeId, m.CurrentNode.Id }).ToDictionary(k => k.MonsterTypeId, v => v.Id)),
SelectedMonsterTypeId = _gameState.SelectedMonster != null ? _gameState.SelectedMonster.MonsterTypeId : 0,
MovementPathIds = _gameState.SelectedMovementPath != null ? JsonConvert.SerializeObject(_gameState.SelectedMovementPath.PathToDestination.Select(n => n.Id).ToArray()) : null,
DestinationNodeId = _gameState.SelectedMovementPath != null ? _gameState.SelectedMovementPath.DestinationNode.Id : 0,
SelectedAttackNodeId = _gameState.SelectedAttackNode != null ? _gameState.SelectedAttackNode.Id : 0,
AvailablePushDestinationIds = JsonConvert.SerializeObject(_gameState.AvailablePushDestinations.Select(n => n.Id))
});
return;
}
_gameState.ProcessAttackAction(message.AttackingMonsterTypeId, message.DefendingMonsterTypeId);
}
void Update()
{
networkJobHandle.Complete();
for (int i = 0; i < connections.Length; ++i)
{
if (!connections[i].IsCreated)
{
connections.RemoveAtSwapBack(i);
--i;
}
}
NetworkConnection newConnection;
while ((newConnection = networkDriver.Accept()) != default)
{
if (connections.Length >= 4)
{
return;
}
connections.Add(newConnection);
//Debug.Log("Accepted new connection");
//new player data is set
//Color col = Random.ColorHSV();
Color col = ColorExtensions.colors[(ColorExtensions.RandomStartIndex + newConnection.InternalId) % ColorExtensions.colors.Length];
col.a = 1;
var colour = (Color32)col;
var playerID = newConnection.InternalId;
var welcomeMessage = new WelcomeMessage
{
PlayerID = playerID,
Colour = ((uint)colour.r << 24) | ((uint)colour.g << 16) | ((uint)colour.b << 8) | colour.a
};
SendMessage(welcomeMessage, newConnection);
//save it to list
PlayerData newData = new PlayerData();
newData.color = colour;
newData.playerIndex = playerID;
if (serverDataHolder.players == null)
{
serverDataHolder.players = new List <PlayerData>();
}
serverDataHolder.players.Add(newData);
//Debug.Log("server data holder players count: " + serverDataHolder.players.Count);
}
DataStreamReader reader;
for (int i = 0; i < connections.Length; ++i)
{
if (!connections[i].IsCreated)
{
continue;
}
NetworkEvent.Type cmd;
while ((cmd = networkDriver.PopEventForConnection(connections[i], out reader)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Data)
{
var messageType = (MessageHeader.MessageType)reader.ReadUShort();
switch (messageType)
{
case MessageHeader.MessageType.none:
StayAlive(i);
break;
case MessageHeader.MessageType.newPlayer:
break;
case MessageHeader.MessageType.welcome:
break;
case MessageHeader.MessageType.setName:
var message = new SetNameMessage();
message.DeserializeObject(ref reader);
messagesQueue.Enqueue(message);
PlayerData newPlayerData = GetPlayerData(connections[i]);
newPlayerData.name = message.Name;
NewPlayerJoined(connections[i]);
break;
case MessageHeader.MessageType.playerLeft:
break;
case MessageHeader.MessageType.moveRequest:
var moveRequest = new MoverequestMessage();
moveRequest.DeserializeObject(ref reader);
//messagesQueue.Enqueue(moveRequest);
bool canmove = HandleMoveRequest(moveRequest, i);
if (canmove)
{
NextPlayerTurn();
}
break;
case MessageHeader.MessageType.claimTreasureRequest:
var treasureRquest = new ClaimTreasureRequestMessage();
treasureRquest.DeserializeObject(ref reader);
HandleTreasureClaim(treasureRquest, i);
break;
case MessageHeader.MessageType.leaveDungeonRequest:
var leaveDungeonRequest = new LeavesDungeonRequestMessage();
leaveDungeonRequest.DeserializeObject(ref reader);
HandleLeaveDungeonRequest(leaveDungeonRequest, i);
break;
case MessageHeader.MessageType.defendRequest:
var defendRequest = new DefendRequestMessage();
defendRequest.DeserializeObject(ref reader);
HandleDefendRequest(defendRequest, i);
break;
case MessageHeader.MessageType.attackRequest:
var attackRequest = new AttackRequestMessage();
attackRequest.DeserializeObject(ref reader);
HandleAttackRequest(attackRequest, i);
break;
default:
break;
}
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
PlayerLeftMessage playerLeftMessage = new PlayerLeftMessage
{
PlayerLeftID = i
};
SendMessageToAll(playerLeftMessage);
Debug.Log("Client disconnected");
connections[i] = default;
}
}
}
networkJobHandle = networkDriver.ScheduleUpdate();
ProcessMessagesQueue();
}
/// <summary>
/// Attackig the player
/// </summary>
public void SendAttackRequest()
{
AttackRequestMessage attackRequest = new AttackRequestMessage();
clientBehaviour.SendRequest(attackRequest);
}
public void RequestAttackMonster()
{
AttackRequestMessage message = new AttackRequestMessage();
dataHolder.client.SendMessage(message);
}
public void Update()
{
networkJobHandle.Complete();
for (int i = 0; i < connections.Length; ++i)
{
if (!connections[i].IsCreated)
{
connections.RemoveAtSwapBack(i);
--i;
}
}
NetworkConnection c;
while (!serverManager.game.started && serverManager.lobby.players.Count < ServerManager.maxPlayers && (c = networkDriver.Accept()) != default)
{
connections.Add(c);
Debug.Log("Accepted connection");
serverManager.HandleNewConnection(c.InternalId);
}
DataStreamReader reader;
for (int i = 0; i < connections.Length; ++i)
{
if (!connections[i].IsCreated)
{
continue;
}
NetworkEvent.Type cmd;
while ((cmd = networkDriver.PopEventForConnection(connections[i], out reader)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Data)
{
var messageType = (Message.MessageType)reader.ReadUShort();
Debug.Log("Host Received: " + messageType + " from " + connections[i].InternalId);
Message message = null;
switch (messageType)
{
case Message.MessageType.None: break; //stay alive
case Message.MessageType.SetName: message = new SetNameMessage(); break;
case Message.MessageType.MoveRequest: message = new MoveRequestMessage(); break;
case Message.MessageType.AttackRequest: message = new AttackRequestMessage(); break;
case Message.MessageType.DefendRequest: message = new DefendRequestMessage(); break;
case Message.MessageType.ClaimTreasureRequest: message = new ClaimTreasureRequestMessage(); break;
case Message.MessageType.LeaveDungeonRequest: message = new LeaveDungeonRequestMessage(); break;
default: break;
}
if (message != null)
{
message.DeserializeObject(ref reader);
receivedMessagesQueue.Enqueue(new AdressedMessage(message, connections[i].InternalId));
}
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
Debug.Log("Client disconnected");
serverManager.HandleDisconnect(connections[i].InternalId);
connections[i] = default;
}
}
}
ProcessMessagesQueue();
//order slightly wrong but will be sent next cycle
foreach (KeyValuePair <int, float> lastSendTime in lastSendTimes)
{
if (Time.time - lastSendTime.Value > STAY_ALIVE_AFTER_SECONDS)
{
QeueMessage(new AdressedMessage(new NoneMessage(), lastSendTime.Key));
}
}
networkJobHandle = networkDriver.ScheduleUpdate();
}
