void RelayMovement()
{
PositionPacket posPacket = new PositionPacket(gameObject.transform.position.x, gameObject.transform.position.y, true, Data.CHARACTER_ID);
SubPacket sp = new SubPacket(GamePacketOpCode.PositionPacket, Data.CHARACTER_ID, 0, posPacket.GetBytes(), SubPacketTypes.GamePacket);
connection.Send(BasePacket.CreatePacket(sp, true, false));
}
private void HandleNearbyActorsQuery(SubPacket subPacket)
{
PositionsInBoundsPacket posInBoundsPacket = new PositionsInBoundsPacket(subPacket.data);
client.Character.SetCharacterCameraBounds(posInBoundsPacket.XMin, posInBoundsPacket.XMax, posInBoundsPacket.YMin, posInBoundsPacket.YMax);
bool foundNearby = false;
List <SubPacket> nearbyCharacters = new List <SubPacket>();
var connectedPlayers = WorldServer.mConnectedPlayerList.Values.ToList();
foreach (var connectedPlayer in connectedPlayers)
{
if ((connectedPlayer.CharacterId != client.Character.CharacterId) && connectedPlayer.XPos > client.Character.BoundsXMin &&
connectedPlayer.XPos < client.Character.BoundsXMax && connectedPlayer.YPos > client.Character.BoundsYMin &&
connectedPlayer.YPos < client.Character.BoundsYMax)
{
foundNearby = true;
PositionPacket packet = new PositionPacket(connectedPlayer.XPos, connectedPlayer.YPos, true, connectedPlayer.CharacterId);
SubPacket sp = new SubPacket(GamePacketOpCode.NearbyActorsQuery, 0, connectedPlayer.CharacterId, packet.GetBytes(), SubPacketTypes.GamePacket);
nearbyCharacters.Add(sp);
}
}
if (foundNearby)
{
client.QueuePacket(BasePacket.CreatePacket(nearbyCharacters, true, false));
client.FlushQueuedSendPackets();
}
}
//processes server responce
private void UDPProcessServerResponse()
{
try
{
IPEndPoint endPoint = new IPEndPoint(IPAddress.Any, 0);
//receive data while connected to server
while (true)
{
//receive packet
byte[] buffer = udpClient.Receive(ref endPoint);
MemoryStream _stream = new MemoryStream(buffer);
Packet recievedPackage = formatter.Deserialize(_stream) as Packet;
//if packet type is...
switch (recievedPackage.mPacketType)
{
//position data is set to player object
case PacketType.positionData:
PositionPacket positionDataPacket = (PositionPacket)recievedPackage;
player[1].position.X = positionDataPacket.mPosX;
player[1].position.Y = positionDataPacket.mPosY;
break;
}
}
}
catch (SocketException e)
{
Console.WriteLine("Client UDP Read Method exception: " + e.Message);
}
//close UDP
udpClient.Close();
}
void OnReceivePacket(ushort type, Stream stream)
{
switch (type)
{
case (ushort)UserPacketType.Message:
MessagePacket messagePacket = new MessagePacket();
messagePacket.Deserialize(stream);
if (ConnectionManager.Instance.isServer)
{
MessageManager.Instance.SendString(messagePacket.payload, 0);
}
messages.text += messagePacket.payload + System.Environment.NewLine;
break;
case (ushort)UserPacketType.Position:
PositionPacket positionPacket = new PositionPacket();
positionPacket.Deserialize(stream);
if (ConnectionManager.Instance.isServer)
{
MessageManager.Instance.SendPosition(positionPacket.payload, 0);
}
// Aca enviaria el payload a donde sea necesario
break;
}
}
public void Position(PositionPacket positionPacket)
{
Session.SendPacket(Session.Character.GenerateSay(
$"Map:{Session.Character.MapInstance.Map.MapId} - X:{Session.Character.PositionX} - Y:{Session.Character.PositionY} - " +
$"Dir:{Session.Character.Direction} - Cell:{Session.Character.MapInstance.Map[Session.Character.PositionX, Session.Character.PositionY]}",
SayColorType.Green));
}
private void PosPacketReceived(GameEventArgs eventArgs)
{
if (eventArgs.PollerPositionPacket.ActorId == character.Id)
{
posPacket = eventArgs.PollerPositionPacket;
}
}
protected void RecvCallback(IAsyncResult ar)
{
PositionPacket packet = PositionPacket.Create(recvBuffer);
sensor.SetPacket(packet);
readyToRequest = true;
}
protected override void OnReceiveDataEvent(uint packetID, ushort packetTypeID, Stream stream)
{
//Debug.Log("Applying velocity received to " + gameObject.name);
switch (packetTypeID)
{
case (ushort)UserPacketType.Velocity:
VelocityPacket velocityPacket = new VelocityPacket();
velocityPacket.Deserialize(stream);
//Debug.Log("Applying velocity received to " + gameObject.name);
Vector3 velocityReceived = new Vector3(
velocityPacket.payload.velocity.x,
velocityPacket.payload.velocity.y,
velocityPacket.payload.velocity.z
);
//rb.position += velocityReceived;
transform.Translate(velocityReceived, Space.Self);
if (NetworkManager.Instance.isServer)
{
NetworkMessageManager.Instance.SendPosition(transform.position, (uint)objectID);
}
break;
case (ushort)UserPacketType.Position:
PositionPacket positionPacket = new PositionPacket();
positionPacket.Deserialize(stream);
Vector3 position = new Vector3(
positionPacket.payload.position.x,
positionPacket.payload.position.y,
positionPacket.payload.position.z
);
//rb.position = position;
transform.position = position;
break;
case (ushort)UserPacketType.Shoot:
Shoot();
break;
case (ushort)UserPacketType.Damage:
DamagePacket damagePacket = new DamagePacket();
damagePacket.Deserialize(stream);
TakeDamage((int)damagePacket.payload.damage);
break;
case (ushort)UserPacketType.ShipDestroyed:
Instantiate(explosionEffect, transform.position, Quaternion.identity);
Destroy(gameObject);
break;
}
}
public void SendPosition(Vector3 position, uint senderId, uint objectId)
{
PositionPacket packet = new PositionPacket();
PositionData positionData = new PositionData();
packet.payload = positionData;
PacketsManager.Instance.SendPacket(packet, null, senderId, objectId);
}
//serialize position data and send to server
public void UDPSendPosition()
{
PositionPacket positionDataPacket = new PositionPacket(player[0].position.X, player[0].position.Y);
MemoryStream messageStream = new MemoryStream();
formatter.Serialize(messageStream, positionDataPacket);
byte[] buffer = messageStream.GetBuffer();
udpClient.Send(buffer, buffer.Length);
}
public void SendEntityInfo(Vector3 position, Quaternion rotation, uint objectId, uint senderId)
{
PositionPacket packet = new PositionPacket(senderId);
packet.payload.pos = position;
packet.payload.rot = rotation;
PacketManager.Instance.SendGamePacket(packet, objectId, senderId);
}
private void ProcessPositionPacket(uint senderId, Stream stream)
{
if (!NetworkManager.Instance.isServer)
{
PositionPacket packet = new PositionPacket();
packet.Deserialize(stream);
transform.position = new Vector3(packet.payload.position.x, packet.payload.position.y, packet.payload.position.z);
}
}
public void SendPosition(Vector3 position, uint objectId)
{
PositionPacket packet = new PositionPacket();
packet.payload = position;
PacketManager.Instance.SendPacket(packet, objectId, packet.reliable);
}
public void SendPositionPacket(PositionPacket p)
{
NetOutgoingMessage posMessage;
posMessage = client.CreateMessage();
posMessage.Write(p.PacketType);
posMessage.Write(p.playerID);
posMessage.Write(p.x);
posMessage.Write(p.y);
client.SendMessage(posMessage, NetDeliveryMethod.Unreliable);
}
public void SendPosition(Vector3 position, uint objectID, uint sequence = 0, bool sendAsReliable = false)
{
PositionPacket positionPacket = new PositionPacket();
positionPacket.payload.sequence = sequence;
positionPacket.payload.position.x = position.x;
positionPacket.payload.position.y = position.y;
positionPacket.payload.position.z = position.z;
SendPacket(positionPacket, objectID);
}
// Start is called before the first frame update
void Start()
{
Debug.Assert(input != null);
Debug.Assert(serverURL != null);
Debug.Assert(btnPost != null);
Debug.Assert(btnGet != null);
Debug.Assert(btnPostToDB != null);
Debug.Assert(Player != null);
// サーバーURLの表示
serverURL.text = ServerURL;
// 各ボタンの処理
btnPost.onClick.AddListener(() =>
{
string text = input.text;
if (string.IsNullOrEmpty(text))
{
text = "-"; //<- なにか入れる
}
StartCoroutine(SendFormPOST(ServerURL + "/log", text,
() =>
{
// 成功時
Debug.Log("OK");
}, (code, err) =>
{
// エラー時
Debug.LogWarning($"WARN : {code.ToString()} : {err}");
}));
});
btnGet.onClick.AddListener(() => {
StartCoroutine(SendGET(ServerURL + "/log?data=" + input.text));
});
btnPostToDB.onClick.AddListener(() => {
string text = input.text;
if (string.IsNullOrEmpty(text))
{
text = "-"; //<- なにか入れる
}
// パケットデータ生成
var packet = new PositionPacket(text, Player);
// データをJSON化
var data = JsonUtility.ToJson(packet);
// データ送信
StartCoroutine(SendJsonPOST(ServerURL + "/set_pos", data));
});
}
public override void ProcessPacket(BasePacket receivedPacket)
{
if (!isAuthenticated && receivedPacket.isAuthenticated())
{
isAuthenticated = true;
}
List <SubPacket> subPackets = receivedPacket.GetSubpackets();
foreach (SubPacket subPacket in subPackets)
{
DoAuthenticationChecks(receivedPacket, subPacket);
if (!receivedPacket.isAuthenticated())
{
Debug.Log("Not authenticated.. Do something here");
throw new NotImplementedException();
}
else
{
switch (subPacket.gameMessage.opcode)
{
case ((ushort)GamePacketOpCode.NearbyActorsQuery):
PositionPacket pos = new PositionPacket(subPacket.data);
ActorWrapper wrapper = new ActorWrapper(pos.XPos, pos.YPos, pos.Playable, pos.ActorId);
GameEventManager.TriggerActorNeedsDrawing(new GameEventArgs {
Actor = wrapper
});
break;
case ((ushort)GamePacketOpCode.PositionQuery):
PositionPacket otherCharacterPos = new PositionPacket(subPacket.data);
GameEventManager.TriggerPollerResponse(new GameEventArgs {
PollerPositionPacket = otherCharacterPos
});
break;
case ((ushort)GamePacketOpCode.OtherPlayerDisconnected):
DisconnectPacket dc = new DisconnectPacket(subPacket.data);
Character playerToDisconnect;
if (Data.drawnCharacters.TryGetValue(dc.CharacterId, out playerToDisconnect))
{
Data.drawnCharacters.Remove(dc.CharacterId);
destroyer.AddCharacter(playerToDisconnect);
}
break;
}
}
}
}
private void FixedUpdate()
{
if (NetworkProfile.BeginMatch && PlayerHaveNewPosition() && i == 5)
{
PositionPacket PositionPacket = new PositionPacket(transform.position.x, transform.position.y, transform.position.z, PlayerCharacterController.GetPitch(), PlayerCharacterController.GetYaw());
NetworkManager.SendPacket(PositionPacket);
i = 0;
}
if (i == 10)
{
i = 0;
}
WriteCurrentPosition();
i++;
}
public static PositionPacket Create(byte[] data)
{
var line = ByteArrayToString(data);
JsonData jsonData = JsonMapper.ToObject(line);
PositionPacket packet = new PositionPacket();
double angle = (double)jsonData["angle"];
Vector3 pos = new Vector3(
(int)jsonData["index_pos"][0],
(int)jsonData["index_pos"][1],
(int)jsonData["index_pos"][2]);
packet.angle = angle;
packet.pos = pos;
return(packet);
}
public static OpenedPacket Sort(NetIncomingMessage message, Game1 game)
{
int msg = message.ReadByte();
NetConnection senderConnection = message.SenderConnection;
GameScreen screen = (GameScreen)game.GetScreen();
int id;
int x;
int y;
string pClass;
int pRole;
OpenedPacket packet = new OpenedPacket();
switch (msg)
{
case ServerPackets.WORLDNAME:
packet.PacketType = ServerPackets.WORLDNAME;
packet.PacketMessage = new String[] { message.ReadString() };
return(packet);
case ServerPackets.PLAYERINFORMATION:
string name = message.ReadString();
x = message.ReadInt32();
y = message.ReadInt32();
id = message.ReadInt32();
pClass = message.ReadString();
pRole = message.ReadInt32();
PlayerPacket pPacket = new PlayerPacket(ServerPackets.PLAYERINFORMATION, x, y, name, id, pClass, pRole);
return(pPacket);
case ServerPackets.POSITION:
id = message.ReadInt32();
x = message.ReadInt32();
y = message.ReadInt32();
PositionPacket posPacket = new PositionPacket(ServerPackets.POSITION, id, x, y);
return(posPacket);
default:
break;
}
return(null);
}
private void HandlePositionQuery(SubPacket subPacket)
{
var targetActor = subPacket.header.targetId;
var sourceActor = subPacket.header.sourceId;
if (WorldServer.mConnectedPlayerList.TryGetValue(targetActor, out Character character))
{
PositionPacket positionQuery = new PositionPacket(character.XPos, character.YPos,
true, character.CharacterId);
SubPacket positionQuerySp = new SubPacket(GamePacketOpCode.PositionQuery, 0, targetActor,
positionQuery.GetBytes(), SubPacketTypes.GamePacket);
client.QueuePacket(positionQuerySp, true, false); //TODO: isAuthed
}
else
{
Console.WriteLine("Sending info to {0} that character ID:{1} has disconnected", client.GetFullAddress(), targetActor);
DisconnectPacket disconnectedPlayer = new DisconnectPacket(targetActor);
SubPacket disconnectedPlayerPacket = new SubPacket(GamePacketOpCode.OtherPlayerDisconnected, 0, targetActor,
disconnectedPlayer.GetBytes(), SubPacketTypes.GamePacket);
client.QueuePacket(disconnectedPlayerPacket, true, false);
}
}
private void SortMessage(NetIncomingMessage message)
{
int msg = message.ReadInt32();
if (msg == ServerPackets.POSITION)
{
int id = message.ReadInt32();
int x = message.ReadInt32();
int y = message.ReadInt32();
PositionPacket packet = new PositionPacket(msg, id, x, y);
Player pPlayer = null;
bool isIllegal = false;
foreach (Player player in players)
{
if (player.getID() == id)
{
pPlayer = player;
isIllegal = CheckCollide(player, x, y);
if (isIllegal)
{
Console.WriteLine(player.getName() + " is moving too fast!");
break;
}
int xDist = Math.Abs(player.GetX() - x);
int yDist = Math.Abs(player.GetY() - y);
if (xDist < 0)
{
xDist *= -1;
}
if (yDist < 0)
{
yDist *= -1;
}
if (xDist < 20 && yDist < 20)
{
player.SetPosition(new Vector2(x, y));
}
else
{
isIllegal = true;
}
break;
}
}
if (pPlayer != null)
{
NetOutgoingMessage outgoingMessage = server.CreateMessage();
outgoingMessage.Write(ServerPackets.POSITION);
outgoingMessage.Write(packet.playerID);
outgoingMessage.Write(pPlayer.GetX());
outgoingMessage.Write(pPlayer.GetY());
if (isIllegal)
{
server.SendToAll(outgoingMessage, NetDeliveryMethod.ReliableOrdered);
}
else
{
server.SendToAll(outgoingMessage, message.SenderConnection, NetDeliveryMethod.ReliableOrdered, 0);
}
}
}
else if (msg == ServerPackets.CHATPACKET)
{
int id = message.ReadInt32();
string text = message.ReadString();
string name = "";
foreach (Player player in players)
{
if (id == player.getID())
{
name = player.getName();
}
}
Console.WriteLine(name + ": " + text);
text = CheckCensor(text);
NetOutgoingMessage chatPacket = server.CreateMessage();
chatPacket.Write(ServerPackets.CHATPACKET);
chatPacket.Write(id);
chatPacket.Write(text);
server.SendToAll(chatPacket, NetDeliveryMethod.ReliableOrdered);
}
else if (msg == ServerPackets.SERVERCOMMAND)
{
int id = message.ReadInt32();
foreach (Player player in players)
{
if (player.getID() == id)
{
if (player.getRole() == ServerRoles.ADMIN || player.getRole() == ServerRoles.MODERATOR)
{
bool result = CommandProcessor.ProcessCommand(message.ReadString(), player.getRole(), player, this, server);
if (!result)
{
string text = "Command not found!";
string name = player.getName();
NetOutgoingMessage chatPacket = server.CreateMessage();
chatPacket.Write(ServerPackets.CHATPACKET);
chatPacket.Write(id);
chatPacket.Write(text);
server.SendMessage(chatPacket, message.SenderConnection, NetDeliveryMethod.ReliableOrdered);
}
}
else
{
string text = message.ReadString();
string name = player.getName();
Console.WriteLine(name + ": " + text);
text = CheckCensor(text);
NetOutgoingMessage chatPacket = server.CreateMessage();
chatPacket.Write(ServerPackets.CHATPACKET);
chatPacket.Write(id);
chatPacket.Write(text);
server.SendToAll(chatPacket, NetDeliveryMethod.ReliableOrdered);
}
}
break;
}
}
}
private void HandlePosition(PositionPacket packet)
{
//PlayerRef.Position = packet.Position;
Module.OnPosition(this);
}
private void HandlePositionData(PositionPacket p)
{
}
public void UpdatePositionServer(Vector3 position, bool inAir, bool alive, DateTime gameTime)
{
PositionPacket positionPacket = new PositionPacket(position, inAir, alive, gameTime);
if (positionList.Count > 0)
{
positionPacket.distanceFromLast = Math.Sqrt(
Math.Pow((positionPacket.position.X - positionList[positionList.Count - 1].position.X), 2) +
Math.Pow((positionPacket.position.Z - positionList[positionList.Count - 1].position.Z), 2));
positionPacket.deltaY = positionPacket.position.Y - positionList[positionList.Count - 1].position.Y;
}
positionList.Add(positionPacket);
if (positionList.Count > 10)
positionList.RemoveAt(0);
}
private void HandlePositionPacket(SubPacket subPacket)
{
PositionPacket packet = new PositionPacket(subPacket.data);
client.Character.SavePositions(packet.XPos, packet.YPos);
}
public void SetPacket(PositionPacket data)
{
angle = data.angle;
pos = data.pos;
isValid = data.isValid;
}
protected override void OnMessage(MessageEventArgs e)
{
// Console.WriteLine(e.Data);
Packet packet = JsonConvert.DeserializeObject <Packet>(e.Data);
string socketID = ID;
// join packet -- 0
if (packet.type == Packets.JOIN)
{
JoinPacket jPacket = JsonConvert.DeserializeObject <JoinPacket>(packet.data);
joinLobby(jPacket.lobbyID, jPacket.playerID, jPacket.name, socketID);
}
// create packet -- 1
else if (packet.type == Packets.CREATE)
{
try
{
Console.WriteLine("making new create packet");
// Create a lobby with given parameters
CreatePacket createPacket = JsonConvert.DeserializeObject <CreatePacket>(packet.data);
createLobby(createPacket.maxPlayers, createPacket.name, createPacket.playerID, socketID, Context.WebSocket);
}
catch (NullReferenceException nre)
{
Console.WriteLine("hi");
Console.WriteLine(nre);
}
}
// start packet -- 2
else if (packet.type == 2)
{
startGame(packet);
}
else if (packet.type == Packets.PLAYER_INPUT)
{
PlayerInputPacket playerInputPacket = JsonConvert.DeserializeObject <PlayerInputPacket>(packet.data);
Player currentPlayer = null;
foreach (Player player in lobbies[playerInputPacket.lobbyID].players)
{
if (player.socketID == ID)
{
currentPlayer = player;
}
}
if (currentPlayer == null)
{
// no valid player found in lobby
return;
}
// validate move
foreach (Player player in lobbies[playerInputPacket.lobbyID].players)
{
if (player.socketID != ID)
{
if (player.currentBlockPosition != null)
{
foreach (int[] pos1 in player.currentBlockPosition)
{
foreach (int[] pos2 in playerInputPacket.shapeIndices)
{
if (pos1 == pos2)
{
Send("COLLISION");
return;
}
}
}
}
}
}
UpdatePacket update = processInput(playerInputPacket);
if (playerInputPacket.move != "freeze")
{
currentPlayer.currentBlockPosition = playerInputPacket.shapeIndices;
playerInputPacket.playerID = currentPlayer.id;
foreach (Player player in lobbies[playerInputPacket.lobbyID].players)
{
if (player.socketID != ID)
{
Sessions.SendTo(JsonConvert.SerializeObject(update), player.socketID);
}
}
}
else
{
// remove column is ID # 2
// remove area is ID # 3
// area removes 2 up, 2 left, 2 right, 2 down
Lobby lobby = lobbies[playerInputPacket.lobbyID];
update.shapeIndices = playerInputPacket.shapeIndices;
foreach (int[] pos in playerInputPacket.shapeIndices)
{
// FREEZE
lobby.game.board.board[pos[0], pos[1]] = pos[2];
}
// Prints prints = new Prints();
// Console.WriteLine("LOBBY BOARD");
// prints.PrintMultiDimArr(lobby.game.board.board);
checkRows(lobby);
foreach (Player player in lobby.players)
{
if (player.socketID != ID)
{
Sessions.SendTo(JsonConvert.SerializeObject(update), player.socketID);
}
}
}
// on place piece put on board ;GJ
}
else if (packet.type == Packets.BOT_UPDATE) // 7
{
BotPacket bot = JsonConvert.DeserializeObject <BotPacket>(packet.data);
if (bot.action == 1)
{
lobbies[bot.lobbyID].botCount++;
lobbies[bot.lobbyID].numPlayers++;
alertLobby(-2, bot.lobbyID, Packets.ADD_BOT);
}
else if (bot.action == 0)
{
lobbies[bot.lobbyID].botCount--;
lobbies[bot.lobbyID].numPlayers--;
alertLobby(-2, bot.lobbyID, Packets.REMOVE_BOT);
}
}
else if (packet.type == Packets.SHAPE_BLUEPRINT)
{
ShapeBlueprintPacket sbp = JsonConvert.DeserializeObject <ShapeBlueprintPacket>(packet.data);
foreach (Player player in lobbies[sbp.lobbyID].players)
{
if (player.socketID != ID)
{
Sessions.SendTo(JsonConvert.SerializeObject(sbp), player.socketID);
}
else
{
//player.currentBlock = sbp.shapeBlueprint;
}
}
}
else if (packet.type == Packets.TEAM_NAME)
{
// format the packet to be a scors packet with all the team information
TeamPacket tPacket = JsonConvert.DeserializeObject <TeamPacket>(packet.data);
foreach (Player player in lobbies[tPacket.lobbyid].players)
{
if (player.socketID != ID)
{
Sessions.SendTo(JsonConvert.SerializeObject(tPacket), player.socketID);
}
else
{
//player.currentBlock = sbp.shapeBlueprint;
}
}
}
else if (packet.type == Packets.GAME_END)
{
EndPacket end = JsonConvert.DeserializeObject <EndPacket>(packet.data);
if (checkGameEnd(end))
{
foreach (Player player in lobbies[end.lobbyID].players)
{
Sessions.SendTo(JsonConvert.SerializeObject(end), player.socketID);
}
}
}
else if (packet.type == Packets.POS_UPDATE)
{
PositionPacket pp = JsonConvert.DeserializeObject <PositionPacket>(packet.data);
foreach (Player player in lobbies[pp.lobbyID].players)
{
if (player.socketID == ID)
{
player.currentBlockPosition = pp.shapeIndices;
}
}
}
else
{
Console.WriteLine("bad packet");
Console.WriteLine(packet.type);
Send("bad packet!!! :(");
}
}
protected override void OnReceiveDataEvent(uint packetID, ushort packetTypeID, Stream stream)
{
switch (packetTypeID)
{
case (ushort)UserPacketType.Velocity:
VelocityPacket velocityPacket = new VelocityPacket();
velocityPacket.Deserialize(stream);
//Debug.Log("Applying velocity received to " + gameObject.name);
Vector3 velocityReceived = new Vector3(
velocityPacket.payload.velocity.x,
velocityPacket.payload.velocity.y,
velocityPacket.payload.velocity.z
);
//rb.position += velocityReceived;
transform.Translate(velocityReceived, Space.Self);
if (NetworkManager.Instance.isServer)
{
NetworkMessageManager.Instance.SendPosition(transform.position, (uint)objectID, velocityPacket.payload.sequence);
}
break;
case (ushort)UserPacketType.Position:
PositionPacket positionPacket = new PositionPacket();
positionPacket.Deserialize(stream);
Vector3 position = new Vector3(
positionPacket.payload.position.x,
positionPacket.payload.position.y,
positionPacket.payload.position.z
);
//rb.position = position;
//Debug.Log("Position before reconciliation: " + position);
if (positionPacket.payload.sequence > lastSequenceServerReceived)
{
lastSequenceServerReceived = positionPacket.payload.sequence;
Vector3 reconciliationPosition = Vector3.zero;
for (uint currentInputKey = positionPacket.payload.sequence; currentInputKey < sequence; currentInputKey++)
{
if (inputs.ContainsKey(currentInputKey))
{
//Debug.Log("Removing input with ID " + currentInputKey);
reconciliationPosition += inputs[currentInputKey];
inputs.Remove(positionPacket.payload.sequence);
}
}
transform.position = position;
}
break;
case (ushort)UserPacketType.Shoot:
Shoot();
break;
case (ushort)UserPacketType.Damage:
DamagePacket damagePacket = new DamagePacket();
damagePacket.Deserialize(stream);
TakeDamage((int)damagePacket.payload.damage);
break;
case (ushort)UserPacketType.ShipDestroyed:
if (NetworkManager.Instance.isServer)
{
NetworkMessageManager.Instance.SendShipdestroyedPacket((uint)objectID);
}
Instantiate(explosionEffect, transform.position, Quaternion.identity);
Destroy(gameObject);
break;
}
}
public int Check()
{
NetIncomingMessage message;
OpenedPacket packet = new OpenedPacket();
if (client.ConnectionStatus == NetConnectionStatus.Connected && connecting == true)
{
connecting = false;
}
if (connecting == false)
{
if (client.ConnectionStatus == NetConnectionStatus.Disconnected)
{
game.SetScreen(new MenuScreen(game));
}
}
while ((message = client.ReadMessage()) != null)
{
switch (message.MessageType)
{
case NetIncomingMessageType.Data:
int type = message.ReadByte();
if (type == ServerPackets.PLAYERINFORMATION)
{
bool mine = false;
string name = message.ReadString();
int x = message.ReadInt32();
int y = message.ReadInt32();
int id = message.ReadInt32();
string playerClass = message.ReadString();
int playerRole = message.ReadInt32();
PlayerPacket pPacket = new PlayerPacket(ServerPackets.PLAYERINFORMATION, x, y, name, id, playerClass, playerRole);
if (pPacket.name == userName)
{
mine = true;
}
else
{
Console.WriteLine(String.Format("{0} joined the world!", name));
}
if (playerClass == CharacterSelections.NONE)
{
if (mine)
{
return(CheckConstants.CHARACTERSELECT);
}
}
else
{
gameScreen.AddPlayer(new Player(pPacket.id, pPacket.name, pPacket.x, pPacket.y, mine, this, pPacket.playerClass, pPacket.playerRole, gameScreen));
}
}
else if (type == ServerPackets.POSITION)
{
int id = message.ReadInt32();
int x = message.ReadInt32();
int y = message.ReadInt32();
PositionPacket pPacket = new PositionPacket(ServerPackets.POSITION, id, x, y);
Player posPlayer = gameScreen.GetPlayerByID(pPacket.playerID);
if (posPlayer != null)
{
posPlayer.SetPosition(new Vector2(pPacket.x, pPacket.y));
}
}
else if (type == ServerPackets.LEAVINGPLAYER)
{
int id = message.ReadInt32();
gameScreen.RemovePlayerByID(id);
}
else if (type == ServerPackets.CHATPACKET)
{
int id = message.ReadInt32();
string text = message.ReadString();
Player player = gameScreen.GetPlayerByID(id);
gameScreen.AddChat(new ChatHolder(player, text));
}
else if (type == ServerPackets.ENEMYSPAWN)
{
int enemyType = message.ReadInt32();
int enemyX = message.ReadInt32();
int enemyY = message.ReadInt32();
bool enemyAggressive = message.ReadBoolean();
int netID = message.ReadInt32();
Enemy enemy = new Enemy(new Vector2(enemyX, enemyY), enemyType, enemyAggressive, netID, gameScreen);
gameScreen.AddEntity(enemy);
gameScreen.AddEnemy(enemy);
}
else if (type == ServerPackets.ENEMYMOVE)
{
int x = message.ReadInt32();
int y = message.ReadInt32();
int id = message.ReadInt32();
Enemy e = gameScreen.GetEnemyByID(id);
if (e != null)
{
e.Move(x, y);
}
}
else if (type == ServerPackets.ENEMYDESTINATION)
{
int destX = message.ReadInt32();
int destY = message.ReadInt32();
int id = message.ReadInt32();
Enemy e = gameScreen.GetEnemyByID(id);
if (e != null)
{
e.SetDestination(destX, destY);
}
}
else if (type == ServerPackets.ENEMYSTOP)
{
int id = message.ReadInt32();
Enemy e = gameScreen.GetEnemyByID(id);
if (e != null)
{
e.ClearDestination();
}
}
break;
case NetIncomingMessageType.StatusChanged:
//SortConnections(message);
break;
case NetIncomingMessageType.DebugMessage:
try
{
if (ServerInfo.DEBUG)
{
Console.WriteLine(message.ReadString());
}
} catch (Exception e) { Console.Write(e); }
break;
case NetIncomingMessageType.ErrorMessage:
try
{
if (ServerInfo.DEBUG)
{
Console.WriteLine(message.ReadString());
}
} catch (Exception e) { Console.Write(e); }
break;
default:
break;
}
}
if (packet.PacketType >= 0)
{
Use(packet);
}
return(CheckConstants.FULFILLED);
}
