public void Decode(NetIncomingMessage im)
{
this.BlockID = im.ReadByte();
this.X = im.ReadInt16();
this.Y = im.ReadInt16();
this.Z = im.ReadByte();
}
public void Decode(NetIncomingMessage im)
{
this.ServerName = im.ReadString();
this.Description = im.ReadString();
this.Intro = im.ReadString();
this.Online = im.ReadByte();
int roomsLength = im.ReadByte();
for (int i = 0; i < roomsLength; i++)
{
Rooms.Add(new LobbySaveData(im.ReadString(), im.ReadInt16(), im.ReadString(), im.ReadByte(), im.ReadInt16(), im.ReadDouble()));
}
}
public ClientDisconnectedTransferableData(NetIncomingMessage message)
{
SessionID = message.ReadInt64();
ID = message.ReadInt32();
IsValid = message.ReadBoolean();
PlayerIndex = message.ReadInt16();
}
public static void ToOtherPlayers(NetIncomingMessage im, OtherPlayer[] d)
{
bool alive = im.ReadBoolean();
float xp = im.ReadFloat();
float yp = im.ReadFloat();
float zp = im.ReadFloat();
Int32 id = im.ReadInt32();
float xr = im.ReadFloat();
float yr = im.ReadFloat();
Int16 model = im.ReadInt16();
if (d[id] == null)
{
d[id] = new OtherPlayer(xp, yp, zp, id, model, xr, yr);
}
d[id].model = model;
d[id].xr = xr;
d[id].yr = yr;
if (!alive)
{
d[id].ChangeLifeStatus(false);
}
d[id].position = new Vector3(xp, yp, zp);
d[id].boundingSphere.Center = new Vector3(d[id].position.X, d[id].position.Y + Constants.HEADMAX/2, d[id].position.Z);
}
public virtual S2C.Message.ResLogin ResLogin(NetIncomingMessage im)
{
Message.ResLogin data = new Message.ResLogin();
data.ret = im.ReadInt16();
if(OnResLogin != null) OnResLogin(im, data);
return data;
}
public void Decode(NetIncomingMessage im)
{
this.Username = im.ReadString();
this.Password = im.ReadString();
this.Color = ColorExtensions.ColorFromHSV(im.ReadInt16(), Client.IO.ColorSaturation / 255f, Client.IO.ColorValue / 255f);
if (Username.Length > Settings.MaxNameLength) //Clamp name length
Username = Username.Truncate(Settings.MaxNameLength);
}
public virtual S2C.Message.ResSendAll ResSendAll(NetIncomingMessage im)
{
Message.ResSendAll data = new Message.ResSendAll();
data.ret = im.ReadInt16();
data.ret_message = im.ReadString();
if(OnResSendAll != null) OnResSendAll(im, data);
return data;
}
public PlayerTransferableData(NetIncomingMessage message)
{
SessionID = message.ReadInt64();
ID = message.ReadInt32();
Index = message.ReadInt16();
Position = message.ReadVector2();
Angle = message.ReadFloat();
IsValid = message.ReadBoolean();
}
protected override void Read(NetIncomingMessage message)
{
var length = message.ReadUInt16();
Program = new short[length];
for (var i = 0; i < length; i++)
{
Program[i] = message.ReadInt16();
}
}
public override void Decode(NetIncomingMessage msg)
{
int temp = msg.ReadInt32();
if (temp > teamScores[player.TeamOf()])
teamScores[this.player.TeamOf()] = temp;
temp = msg.ReadInt32();
TeamFinalTest LPuzzle = ((TeamFinalTest)Game1.pStates[Game1.localPlayer].puzzle);
if (LPuzzle.countUpdates < temp)
{
LPuzzle.countUpdates = temp;
LPuzzle.circleLarge.Location = new Point(msg.ReadInt16(), msg.ReadInt16());
LPuzzle.smallPosition = new Vector2(msg.ReadFloat(), msg.ReadFloat());
LPuzzle.largeDirection.X = msg.ReadFloat();
LPuzzle.largeDirection.Y = msg.ReadFloat();
LPuzzle.smallDirection.X = msg.ReadFloat();
LPuzzle.smallDirection.Y = msg.ReadFloat();
LPuzzle.scale = msg.ReadFloat();
}
}
public virtual S2C.Message.ResSend ResSend(NetIncomingMessage im)
{
Message.ResSend data = new Message.ResSend();
data.ret = im.ReadInt16();
data.ret_message = im.ReadString();
data.to_id = im.ReadString();
if(OnResSend != null) OnResSend(im, data);
return data;
}
/// <summary>
/// Handles an incoming entity component message
/// </summary>
/// <param name="message">Raw network message</param>
/// <returns>An IncomingEntityComponentMessage object</returns>
public IncomingEntityComponentMessage HandleEntityComponentNetworkMessage(NetIncomingMessage message)
{
var componentFamily = (ComponentFamily) message.ReadByte();
var messageParams = new List<object>();
while (message.Position < message.LengthBits)
{
switch ((NetworkDataType) message.ReadByte())
{
case NetworkDataType.d_enum:
messageParams.Add(message.ReadInt32());
break;
case NetworkDataType.d_bool:
messageParams.Add(message.ReadBoolean());
break;
case NetworkDataType.d_byte:
messageParams.Add(message.ReadByte());
break;
case NetworkDataType.d_sbyte:
messageParams.Add(message.ReadSByte());
break;
case NetworkDataType.d_ushort:
messageParams.Add(message.ReadUInt16());
break;
case NetworkDataType.d_short:
messageParams.Add(message.ReadInt16());
break;
case NetworkDataType.d_int:
messageParams.Add(message.ReadInt32());
break;
case NetworkDataType.d_uint:
messageParams.Add(message.ReadUInt32());
break;
case NetworkDataType.d_ulong:
messageParams.Add(message.ReadUInt64());
break;
case NetworkDataType.d_long:
messageParams.Add(message.ReadInt64());
break;
case NetworkDataType.d_float:
messageParams.Add(message.ReadFloat());
break;
case NetworkDataType.d_double:
messageParams.Add(message.ReadDouble());
break;
case NetworkDataType.d_string:
messageParams.Add(message.ReadString());
break;
case NetworkDataType.d_byteArray:
int length = message.ReadInt32();
messageParams.Add(message.ReadBytes(length));
break;
}
}
return new IncomingEntityComponentMessage(componentFamily, messageParams);
}
public void Decode(NetIncomingMessage im)
{
map.Width = Width = im.ReadInt16();
map.Height = Height= im.ReadInt16();
map.Tiles = new Tile[map.Width, map.Height, 2];
for (int z = 0; z < 2; z++)
{
for (int y = 0; y < map.Height; y++)
{
for (int x = 0; x < map.Width; x++)
{
if (z == 0)
map.Tiles[x, y, 1] = new Tile(BlockType.FromID(im.ReadByte()));
else
map.Tiles[x, y, 0] = new Tile(BlockType.FromID(im.ReadByte()));
}
}
}
}
public static OtherPlayer MsgToOtherPlayers(NetIncomingMessage im)
{
bool alive = im.ReadBoolean();
float xp = im.ReadFloat();
float yp = im.ReadFloat();
float zp = im.ReadFloat();
Int32 id = im.ReadInt32();
float xr = im.ReadFloat();
float yr = im.ReadFloat();
Int16 model = im.ReadInt16();
OtherPlayer d = new OtherPlayer(xp, yp, zp, id, xr, yr, false);
d.model = model;
return d;
}
public void Decode(NetIncomingMessage im)
{
map.Width = im.ReadInt16();
map.Height = im.ReadInt16();
map.Tiles = new Tile[map.Width, map.Height, 2];
map.Minimap = new Minimap(map, map.Width, map.Height);
map.Minimap.Position = new Microsoft.Xna.Framework.Vector2(16, 16);
for (int z = 0; z < 2; z++)
{
for (int y = 0; y < map.Height; y++)
{
byte[] b = im.ReadBytes(map.Width);
for (int x = 0; x < map.Width; x++)
{
if (z == 0)
map.Tiles[x, y, 1] = new Tile(BlockType.BlockList[b[x]]);
else
map.Tiles[x, y, 0] = new Tile(BlockType.BlockList[b[x]]);
}
}
}
}
void processUnitHarvestCommandBatch(NetIncomingMessage msg)
{
float scheduledTime = msg.ReadFloat();
short team = msg.ReadInt16();
bool queued = msg.ReadBoolean();
short count = msg.ReadInt16();
for (int i = 0; i < count; i++)
{
Unit unit = Player.Players[team].UnitArray[msg.ReadInt16()];
Resource targetResource = Resource.ResourceArray[msg.ReadInt16()];
Player.Players[team].ScheduledActions.Add(new ScheduledUnitTargetedCommand(scheduledTime, new HarvestCommand(unit, targetResource), targetResource, queued));
}
}
//Message Handler
private void MessageReceive(NetIncomingMessage message)
{
byte packetHeader;
try
{
packetHeader = message.ReadByte(); //Try read Header
}
catch
{
return;
}
switch ((Network.PacketTypes) packetHeader) //Switch PacketHeaderType
{
case Network.PacketTypes.RECEIVEPLAYER: //Receive a new player
string name = message.ReadString();
long uid = message.ReadInt64();
int bufferLength = message.ReadInt32();
byte[] buffer = message.ReadBytes(bufferLength);
PlayerStore.Add(uid, new Player(name, buffer, 0));
Console.WriteLine("Player {0} connected with ID: {1}", name, uid);
load.Invoke(new Action(() => load.RefreshDisplay()));
break;
case Network.PacketTypes.GETPOS: //Receive someones score
long id = message.ReadInt64();
int score = message.ReadInt16();
Console.WriteLine(id);
PlayerStore[id].Score = score;
load.Invoke(new Action(() => RefreshDisplay()));
Console.WriteLine("Player: {0} Score: {1}", PlayerStore[id].Name, PlayerStore[id].Score);
if (PlayerStore[id].Score >= 100 & Program.SetWinner == false)
{
Program.Realwinner = PlayerStore[id].Name;
Program.SetWinner = true;
Program.LeaderBoardList.Add(String.Format("{0} : {1}", Program.Realwinner,
globalGameTime));
Invoke(new Action(() => LeaderBoard.DataSource = Program.LeaderBoardList));
}
break;
case Network.PacketTypes.HOST: //If we receive this then we are the host
load.Invoke(new Action(() => load.buttonStart.Visible = true));
string fix = message.ReadString();
break;
case Network.PacketTypes.STARTGAME: //Start the Game form.
load.Invoke(new Action(() => TheSpacebarGame.Menu.game.Show()));
string fix2 = message.ReadString();
break;
case Network.PacketTypes.SCOREWIN: //Someone has Won
string person = message.ReadString();
Program.Place = message.ReadInt16();
if (Program.Place == 1 & person == Program.Ourname)
{
Program.LeaderBoardList.Add(String.Format("{0} : {1}", person,globalGameTime));
Invoke(new Action(() => LeaderBoard.DataSource = Program.LeaderBoardList));
}
else
{
Program.LeaderBoardList.Add(String.Format("{0} : {1}", person, globalGameTime));
Invoke(new Action(() => LeaderBoard.DataSource = Program.LeaderBoardList));
}
break;
case Network.PacketTypes.DISCONNECT: //Someone has Disconnected
long thereID = message.ReadInt64();
if (PlayerStore.ContainsKey(thereID))
{
PlayerStore.Remove(thereID);
}
else
{
Console.WriteLine("Tried to remove non existant ID");
}
if (Program.Started)
{
load.Invoke(new Action(() => RefreshDisplay()));
}
break;
case Network.PacketTypes.CHATREC: //Start the Game form.
long idrec = message.ReadInt64();
string recMessage = message.ReadString();
Console.WriteLine(idrec);
Console.WriteLine(recMessage);
Game.ChatMessages.Add(LoadScreen.RandomNumber(1, 99999999), new ChatMessage(PlayerStore[idrec], recMessage));
load.Invoke(new Action(() => load.RefreshChat()));
break;
}
}
public void HandleMessages(object fromPlayer)
{
if ((inmsg = ((NetServer)fromPlayer).ReadMessage()) == null) return;
NetOutgoingMessage outmsg;
switch(inmsg.MessageType)
{
/*
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.WarningMessage:
*/
case NetIncomingMessageType.ConnectionApproval:
{
if (players.Count==0) idCount = 0;
Console.WriteLine("Incoming login request. " + inmsg.SenderConnection.ToString());
AddNewPlayer(inmsg);
if (gamePhase == (int)GameState.InGame || gamePhase == (int)GameState.Intro)
{
// Auto Join Game
StartGame(players.Find(p => p.Connection == inmsg.SenderConnection));
}
}
break;
case NetIncomingMessageType.Data:
PlayerObject player = players.Find(p => p.Connection == inmsg.SenderConnection);
if (player == null || inmsg.LengthBytes < 1)
break; //Don't accept data from connections that don't have a player attached.
switch ((PacketTypes)inmsg.ReadByte())
{
case PacketTypes.LobbyMessage:
{
string msg = inmsg.ReadString();
SendLobbyMessage(player.Name, msg);
Console.WriteLine("Chat "+player.Name + ": " + msg);
}
break;
case PacketTypes.SettingsChange:
{
if(inmsg.LengthBytes<2) break;
//Difficulty or health mod changed, broadcast changes to all clients.
gameDifficulty = inmsg.ReadInt16();
healthMod = inmsg.ReadInt16();
crab.CalculateHealth();
Console.WriteLine(player.Name+ " (Id"+player.Id+") changed difficulty/healthmod to " + gameDifficulty + "/" + healthMod + ".");
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.SettingsChange);
outmsg.Write((Int16)gameDifficulty);
outmsg.Write((Int16)healthMod);
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableOrdered, 5);
}
break;
case PacketTypes.KeepAlive:
{
// one way heartbeat from client. Server sets a timestamp.
// Unity can potentially keep unstable client threads open that waist server resources
player.keepAlive = NetTime.Now;
}
break;
case PacketTypes.Beat:
{
if (inmsg.LengthBytes<2) break;// .PeekInt16()) break;
//if (!player.Ready) break;
player.LastBeat = inmsg.ReadInt16();
player.X = inmsg.ReadFloat();
player.Y = inmsg.ReadFloat();
if (crab.CurrentTarget == player.Id)
{
float CrabX = inmsg.ReadFloat();
float CrabZ = inmsg.ReadFloat();
crab.RealPosition.X = CrabX;
crab.RealPosition.Z = CrabZ;
if (crab.random.Next(0, 10) > 8)
crab.Direction = !crab.Direction;
//Crab position and target sync.
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.EnemySync);
outmsg.Write((Int16)player.Id); //Id of the current crab controller.
outmsg.Write(CrabX); //EnemyX
outmsg.Write(CrabZ); //EnemyZ
outmsg.Write(player.X);
outmsg.Write(player.Y);
outmsg.Write(crab.Direction);
outmsg.Write(player.Connection.AverageRoundtripTime/2f); //Divide by 2 to get trip time.
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableOrdered, 3);
}
}
break;
case PacketTypes.Ready:
{
//Player is ready to start the game.
player.Ready = inmsg.ReadBoolean();
Console.WriteLine(player.Name + " (Id"+player.Id+") changed their ready status to " + player.Ready);
if (player.Ready)
SendLobbyMessage("Server", player.Name + " is now Ready.");
else
SendLobbyMessage("Server", player.Name + " is no longer ready.");
}
break;
case PacketTypes.PlayIntro:
{
if(gamePhase == (int)GameState.InGame || gamePhase == (int)GameState.Intro)
{
SendConsoleMessage("cannot change intro while game is in play",inmsg.SenderConnection);
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.PlayIntro);
outmsg.Write(false);
server.SendMessage(outmsg, inmsg.SenderConnection, NetDeliveryMethod.ReliableOrdered, 5);
break;
}
//Player changed the status of Play Intro
playintro = inmsg.ReadBoolean();
if(playintro) introlength = new TimeSpan(0, 0, 21);
else introlength = new TimeSpan(0, 0, 7);
Console.WriteLine(player.Name + " (Id"+player.Id+") changed PlayInto to " + playintro);
if (playintro)
SendLobbyMessage("Server", player.Name + " enabled play intro.");
else
SendLobbyMessage("Server", player.Name + " skipped play intro.");
// Now sync everyone up.
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.PlayIntro);
outmsg.Write(playintro);
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableOrdered, 5);
}
break;
case PacketTypes.UpdateName:
{
//Player changed their name. Since the clients aren't aware of each other until the game starts,
//there's no need to broadcast this message to other users.
string newname = inmsg.ReadString();
Console.WriteLine(player.Name + " (Id"+player.Id+") changed their name to '" + newname + "'.");
SendLobbyMessage("Server", player.Name + " (Id"+player.Id+") changed their name to '" + newname + "'.");
player.Name = newname;
// let all other clients know that player changed his/her name
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.UpdateName);
outmsg.Write(player.Name);
outmsg.Write(player.Id);
server.SendToAll(outmsg, inmsg.SenderConnection, NetDeliveryMethod.ReliableOrdered, 5);
}
break;
case PacketTypes.Disconnect:
{
//Player requests to disconnect from the server.
Console.WriteLine(player.Name+" (Id"+player.Id+") has disconnected, removing player object.");
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.RemovePlayer);
outmsg.Write((Int16)player.Id);
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableOrdered, 1);
players.Remove(player);
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.PlayerCount);
outmsg.Write((Int16)players.Count);
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableOrdered, 6);
}
break;
case PacketTypes.StartGame:
{
StartGame(player);
}
break;
case PacketTypes.PlayerSpecial:
{
int shottype = inmsg.ReadInt16();
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.PlayerSpecial);
outmsg.Write((Int16)player.Id);
outmsg.Write((Int16)shottype);
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableUnordered, 2);
//Console.WriteLine("Relaying Special Action Message for " + player.Name + ".");
}
break;
case PacketTypes.PlayerAction:
{
if(inmsg.LengthBytes<2) break;
//Player hit a key or something! Change their status, broadcast to other users.
//Set player values
//inmsg.ReadInt16(); //Player id is submitted, but not used.
player.X = inmsg.ReadFloat();
player.Y = inmsg.ReadFloat();
player.VelocityX = inmsg.ReadFloat();
player.VelocityY = inmsg.ReadFloat();
player.Firing = inmsg.ReadBoolean();
//Broadcast them to everyone else
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.PlayerAction);
outmsg.Write((Int16)player.Id);
outmsg.Write(player.X);
outmsg.Write(player.Y);
outmsg.Write(player.VelocityX);
outmsg.Write(player.VelocityY);
outmsg.Write(player.Firing);
outmsg.Write(player.Connection.AverageRoundtripTime/2f); //Not an exact science, but we'll use this to predict their position.
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableOrdered, 2);
//Console.WriteLine("Relaying Action Message for " + player.Name + ". "+player.VelocityX + " " + player.VelocityY);
}
break;
case PacketTypes.HurtTarget:
{
int damage = inmsg.ReadInt16();
crab.CurrentHealth -= damage;
bool hittype = inmsg.ReadBoolean();
if (!hittype)
player.dmgnormal += damage;
else
player.dmgweakpoint += damage;
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.EnemyHealth);
outmsg.Write((Int16)crab.CurrentHealth);
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableUnordered, 3);
}
break;
case PacketTypes.PlayerHit:
{
player.hitstaken += 1;
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.PlayerHit);
outmsg.Write((Int16)player.Id);
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableUnordered, 2);
}
break;
}
break;
case NetIncomingMessageType.StatusChanged:
{
player = players.Find(p => p.Connection == inmsg.SenderConnection);
if (player == null)
break; //Don't accept data from connections that don't have a player attached.
NetConnectionStatus status = (NetConnectionStatus)inmsg.ReadByte();
string reason = inmsg.ReadString();
if (player.Connection.Status == NetConnectionStatus.Disconnected || player.Connection.Status == NetConnectionStatus.Disconnecting)
{
SendLobbyMessage("Server", player.Name + " (Id"+player.Id+") has disconnected.");
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.RemovePlayer);
outmsg.Write((Int16)player.Id);
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableOrdered, 1);
players.Remove(player);
outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.PlayerCount);
outmsg.Write((Int16)players.Count);
server.SendMessage(outmsg, server.Connections, NetDeliveryMethod.ReliableOrdered, 6);
}
Console.WriteLine(player.Name + " (Id"+player.Id+") status changed to "+status+" (" + reason + ") "+players.Count);
}
break;
default:
break;
}
}
void processUnitStopCommandBatch(NetIncomingMessage msg)
{
float scheduledTime = msg.ReadFloat();
short team = msg.ReadInt16();
bool queued = msg.ReadBoolean();
short count = msg.ReadInt16();
for (int i = 0; i < count; i++)
{
short unitID = msg.ReadInt16();
Unit unit = Player.Players[team].UnitArray[unitID];
Player.Players[team].ScheduledActions.Add(new ScheduledUnitCommand(scheduledTime, new StopCommand(unit), queued));
}
}
void processUnitStatusUpdate(NetIncomingMessage msg)
{
short unitID = msg.ReadInt16();
short team = msg.ReadInt16();
short hp = msg.ReadInt16();
Vector2 position = new Vector2(msg.ReadFloat(), msg.ReadFloat());
float rotation = msg.ReadFloat();
bool idle = msg.ReadBoolean();
Unit unit = Player.Players[team].UnitArray[unitID];
if (unit != null)
{
if (hp < unit.Hp && !unit.IsDead)
{
unit.Hp = hp;
if (hp <= 0)
unit.Die();
return;
}
//if (unit.IsIdle)
if (idle)
{
//if (unit.IsIdle)
// unit.CenterPoint = position;
if (!unit.IsIdle)
unit.NextCommand();
}
else
{
Vector2 expectedPosition = new Vector2(position.X + unit.Speed * connection.AverageRoundtripTime / 2 * (float)Math.Cos(rotation), position.Y + unit.Speed * connection.AverageRoundtripTime / 2 * (float)Math.Sin(rotation));
if (Vector2.Distance(expectedPosition, unit.CenterPoint) > unit.Radius)
{
//unit.CenterPoint -= new Vector2((unit.CenterPoint.X - expectedPosition.X), (unit.CenterPoint.Y - expectedPosition.Y));
unit.CenterPoint = expectedPosition;
}
}
// read current command ID
int commandID = msg.ReadInt16();
// if its not the same as our current command, look for it in queue
if (commandID != -1 && unit.Commands.Count > 0 && commandID != unit.Commands[0].ID)
{
for (int i = 1; i < unit.Commands.Count; i++)
{
UnitCommand command = unit.Commands[i];
if (command.ID == commandID)
{
// do NextCommand enough times to catch up
for (int s = 0; s < i; s++)
unit.NextCommand();
}
}
}
// read cargoAmount at end if worker
WorkerNublet worker = unit as WorkerNublet;
if (worker != null)
{
short cargoAmount = msg.ReadInt16();
worker.CargoAmount = cargoAmount;
}
}
}
void processUnitReturnCargoCommandBatch(NetIncomingMessage msg)
{
float scheduledTime = msg.ReadFloat();
short team = msg.ReadInt16();
short count = msg.ReadInt16();
for (int i = 0; i < count; i++)
{
short unitID = msg.ReadInt16();
short townHallID = msg.ReadInt16();
short resourceID = msg.ReadInt16();
Unit unit = Player.Players[team].UnitArray[unitID];
Structure townHall = Player.Players[team].StructureArray[townHallID];
Resource resource;
if (resourceID == -1)
resource = null;
else
resource = Resource.ResourceArray[resourceID];
Player.Players[team].ScheduledActions.Add(new ScheduledReturnCargoCommand(scheduledTime, new ReturnCargoCommand(unit, townHall, resource)));
}
}
void processUnitMoveCommandBatch(NetIncomingMessage msg)
{
float scheduledTime = msg.ReadFloat();
short team = msg.ReadInt16();
bool queued = msg.ReadBoolean();
short numberOfCommands = msg.ReadInt16();
for (int i = 0; i < numberOfCommands; i++)
{
short unitID = msg.ReadInt16();
Unit unit = Player.Players[team].UnitArray[unitID];
Vector2 destination = new Vector2(msg.ReadFloat(), msg.ReadFloat());
if (unit != null)
{
MoveCommand moveCommand = new MoveCommand(unit, destination);
Player.Players[team].ScheduledActions.Add(new ScheduledUnitCommand(scheduledTime, moveCommand, queued));
//Rts.pathFinder.AddHighPriorityPathFindRequest(moveCommand, (int)Vector2.DistanceSquared(moveCommand.Unit.CenterPoint, moveCommand.Destination), false);
}
else
{
int wut = 0;
}
}
}
void processUnitDeath(NetIncomingMessage msg)
{
short unitID = msg.ReadInt16();
short team = msg.ReadInt16();
Unit unit = Player.Players[team].UnitArray[unitID];
if (unit != null && !unit.IsDead)
unit.Die();
}
void processStructureStatusUpdate(NetIncomingMessage msg)
{
short structureID = msg.ReadInt16();
short team = msg.ReadInt16();
short hp = msg.ReadInt16();
Structure structure = Player.Players[team].StructureArray[structureID];
if (structure != null && hp < structure.Hp && structure.HasTakenDamageEver)
{
structure.Hp = hp;
if (hp <= 0)
structure.Die();
}
}
void processStructureDeath(NetIncomingMessage msg)
{
short structureID = msg.ReadInt16();
short team = msg.ReadInt16();
Structure structure = Player.Players[team].StructureArray[structureID];
if (structure != null && !structure.IsDead)
structure.Die();
}
void processStructureCommand(NetIncomingMessage msg)
{
float scheduledTime = msg.ReadFloat();
short team = msg.ReadInt16();
short structureID = msg.ReadInt16();
short commandTypeID = msg.ReadInt16();
short unitID = msg.ReadInt16();
Structure structure = Player.Players[team].StructureArray[structureID];
CommandButtonType commandType = CommandButtonType.CommandButtonTypes[commandTypeID];
if (structure == null)
{
int wut = 0;
}
Player.Players[team].ScheduledActions.Add(new ScheduledStructureCommand(scheduledTime, structure, commandType, unitID));
}
void processUnitAttackCommandBatch(NetIncomingMessage msg)
{
float scheduledTime = msg.ReadFloat();
short team = msg.ReadInt16();
bool queued = msg.ReadBoolean();
short count = msg.ReadInt16();
RtsObject target;
short targetIsStructure = msg.ReadInt16();
if (targetIsStructure == 0)
{
short targetID = msg.ReadInt16();
short targetTeam = msg.ReadInt16();
target = Player.Players[targetTeam].UnitArray[targetID];
}
else
{
short targetID = msg.ReadInt16();
short targetTeam = msg.ReadInt16();
target = Player.Players[targetTeam].StructureArray[targetID];
}
for (int i = 0; i < count; i++)
{
Unit unit = Player.Players[team].UnitArray[msg.ReadInt16()];
if (unit != null)
{
AttackCommand attackCommand = new AttackCommand(unit, target, false, false);
Player.Players[target.Team].ScheduledActions.Add(new ScheduledUnitCommand(scheduledTime, attackCommand, queued));
//Rts.pathFinder.AddHighPriorityPathFindRequest(attackCommand, (int)Vector2.DistanceSquared(attackCommand.Unit.CenterPoint, attackCommand.Destination), false);
}
}
}
void processUnitHpUpdate(NetIncomingMessage msg)
{
short unitID = msg.ReadInt16();
short team = msg.ReadInt16();
short hp = msg.ReadInt16();
Unit unit = Player.Players[team].UnitArray[unitID];
if (unit != null && hp < unit.Hp)
{
unit.Hp = hp;
if (hp <= 0)
unit.Die();
}
}
protected override void Read(NetIncomingMessage message)
{
x = message.ReadInt16();
y = message.ReadInt16();
rotation = message.ReadUInt16().FromNetworkRotation() * (180f / (float)Math.PI);
}
void processUnitBuildCommand(NetIncomingMessage msg)
{
float scheduledTime = msg.ReadFloat();
short team = msg.ReadInt16();
Unit unit = Player.Players[team].UnitArray[msg.ReadInt16()];
StructureType structureType = StructureType.StructureTypes[msg.ReadInt16()];
Point location = new Point(msg.ReadInt16(), msg.ReadInt16());
bool queued = msg.ReadBoolean();
BuildStructureCommand buildStructureCommand = new BuildStructureCommand(unit, structureType, location, new Vector2(location.X * map.TileSize + structureType.Size * map.TileSize / 2, location.Y * map.TileSize + structureType.Size * map.TileSize / 2));
Player.Players[team].ScheduledActions.Add(new ScheduledUnitBuildCommand(scheduledTime, buildStructureCommand, queued));
//Rts.pathFinder.AddPathFindRequest(buildStructureCommand, queued, false, false);
}
