public void Decode(NetIncomingMessage im)
{
this.Id = im.ReadInt32();
this.MessageTime = im.ReadDouble();
this.MoveUp = im.ReadBoolean();
this.MoveDown = im.ReadBoolean();
this.MoveLeft = im.ReadBoolean();
this.MoveRight = im.ReadBoolean();
}
public override void Decode(NetIncomingMessage msg)
{
findSixes = msg.ReadBoolean();
nPosition = new HashSet<int>();
for (int i = msg.ReadByte(); i > 0; i--)
nPosition.Add(msg.ReadByte());
}
public void Decode(NetIncomingMessage im)
{
this.Username = im.ReadString();
this.ID = im.ReadByte();
this.Me = im.ReadBoolean();
this.Color = new Color(im.ReadByte(), im.ReadByte(), im.ReadByte());
}
private void ReadData(AttributeTypeID Type, NetIncomingMessage Message)
{
switch(Type) {
case AttributeTypeID.Float:
Data = Message.ReadFloat();
break;
case AttributeTypeID.Int:
Data = Message.ReadInt32();
break;
case AttributeTypeID.List:
Console.WriteLine("AttributeSystem: List<> Type not supported on network sync");
break;
case AttributeTypeID.Long:
Data = Message.ReadInt64();
break;
case AttributeTypeID.Rectangle:
Data = Message.ReadRectangle();
break;
case AttributeTypeID.String:
Data = Message.ReadString();
break;
case AttributeTypeID.Vector2:
Data = Message.ReadVector2();
break;
case AttributeTypeID.Bool:
Data = Message.ReadBoolean();
break;
default:
Console.WriteLine("Invalid Attribute Type: {0}", Type.ToString());
break;
}
}
/// <summary>
/// Writes a <see cref="NetIncomingMessage"/> buffer into the BitStream.
/// </summary>
/// <param name="source">The <see cref="NetIncomingMessage"/> who's contents will be copied to this BitStream.</param>
public void Write(NetIncomingMessage source)
{
#if DEBUG
var startBSPos = PositionBits;
var startMsgPos = (int)source.Position;
#endif
// Read full 32-bit integers
while (source.LengthBits - source.Position >= _bitsInt)
{
var v = source.ReadUInt32();
Write(v);
}
// Read full 8-bit integers
while (source.LengthBits - source.Position >= _bitsByte)
{
var v = source.ReadByte();
Write(v);
}
// Read the remaining bits
while (source.LengthBits > source.Position)
{
var v = source.ReadBoolean();
Write(v);
}
Debug.Assert(source.Position == source.LengthBits);
#if DEBUG
Debug.Assert(PositionBits - startBSPos == source.LengthBits - startMsgPos);
#endif
}
public static Line ReadLine(NetIncomingMessage message, bool isServer=false)
{
float removeAnimation = message.ReadFloat();
Vector2 animationEnd = message.ReadVector2();
int turn = message.ReadInt32();
bool wasGrowing = message.ReadBoolean();
Vector2 begin = message.ReadVector2();
Vector2 end = message.ReadVector2();
float thickness = message.ReadFloat();
if (!isServer) {
animationEnd = Constants.FromField(animationEnd);
begin = Constants.FromField(begin);
end = Constants.FromField(end);
}
Line l = new Line (begin, end);
l.removeAnimationTime = removeAnimation;
l.animationEnd = animationEnd;
l.turn = turn;
l.color = Constants.COLORS[turn];
l.wasGrowing = wasGrowing;
l.thickness = thickness;
return l;
}
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 ProjectileTransferableData(NetIncomingMessage message)
{
SessionID = message.ReadInt64();
ID = message.ReadInt32();
IsValid = message.ReadBoolean();
Position = message.ReadVector2();
Angle = message.ReadFloat();
}
public void Decode(NetIncomingMessage im)
{
this.ID = im.ReadByte();
this.Position = new Point(im.ReadInt32(), im.ReadInt32());
this.Velocity = new Point(im.ReadInt32(), im.ReadInt32());
this.Movement = new Point(im.ReadInt32(), im.ReadInt32());
this.IsJumping = im.ReadBoolean();
}
public HealthTransferableData(NetIncomingMessage message)
{
SessionID = message.ReadInt64();
ID = message.ReadInt32();
IsValid = message.ReadBoolean();
PlayerIndex = message.ReadInt32();
Value = message.ReadFloat();
}
/// <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);
}
// TODO: Merge opcodes for move direction, something like that: Move(LookDirection)
void DataProcessing(NetIncomingMessage message, ref Client client)
{
switch (message.ReadByte())
{
case (byte)MessageType.ClientMessage.NeedMap:
Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Need map ! Let's give it to him :)");
ReceiveNeedMap(client);
break;
case (byte)MessageType.ClientMessage.MapSelection:
Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Has selected a map to play ! :)");
ReceiveMapSelection(client, message.ReadString());
break;
case (byte)MessageType.ClientMessage.Credentials:
ReceiveCredentials(client, message.ReadString(), message.ReadString());
break;
case (byte)MessageType.ClientMessage.Ready:
Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Ready message !");
ReceiveReady(client, message.ReadBoolean());
break;
case (byte)MessageType.ClientMessage.WantToStartGame:
Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] WantToStartGame message !");
ReceiveWantToStartGame();
break;
case (byte)MessageType.ClientMessage.HasMap:
Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] HasMap message !");
ReceiveHasMap(client);
break;
case (byte)MessageType.ClientMessage.MoveDown:
Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Want to move down !");
ReceiveMovePlayer(client, LookDirection.Down);
break;
case (byte)MessageType.ClientMessage.MoveLeft:
Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Want to move left !");
ReceiveMovePlayer(client, LookDirection.Left);
break;
case (byte)MessageType.ClientMessage.MoveRight:
Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Want to move right !");
ReceiveMovePlayer(client, LookDirection.Right);
break;
case (byte)MessageType.ClientMessage.MoveUp:
Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Want to move up !");
ReceiveMovePlayer(client, LookDirection.Up);
break;
case (byte)MessageType.ClientMessage.Standing:
Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Want to stay here !");
ReceiveMovePlayer(client, LookDirection.Idle, message.ReadTime(client.ClientConnection, true));
break;
case (byte)MessageType.ClientMessage.PlaceBomb:
Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Want to place bomb !");
ReceiveBombPlacing(client);
break;
}
}
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 static Player MsgToPlayer(NetIncomingMessage im, GraphicsDevice device)
{
bool alive = im.ReadBoolean();
float xp = im.ReadFloat();
float yp = im.ReadFloat();
float zp = im.ReadFloat();
Int32 id = im.ReadInt32();
float xr = im.ReadFloat();
xr = im.ReadFloat();
Int32 mo = im.ReadInt32();
Player d = new Player(xp, yp, zp, id, mo, device);
Globals.player = d;
return d;
}
public void Read(NetIncomingMessage im)
{
if (FileInfoList == null)
{
FileInfoList = new List<Tuple<string, uint, bool>>();
}
int ListCount = im.ReadInt32();
for (int i = 0; i < ListCount; ++i)
{
string Name = im.ReadString();
uint Size = im.ReadUInt32();
bool IsDire = im.ReadBoolean();
FileInfoList.Add(Tuple.Create<string, uint, bool>(Name, Size, IsDire));
}
}
public void LoadTerrainFromNetwork(NetIncomingMessage MapDataMessage)
{
TerrainTiles = new SpriteSheet(GameClient.ContentManager.Load<Texture2D>("Terrain2"), 40, 40);
int TerrainCount = MapDataMessage.ReadInt32();
for (int i = 0; i < TerrainCount; i++) {
Terrain.Add(new TerrainTile() {
X = MapDataMessage.ReadInt32(),
Y = MapDataMessage.ReadInt32(),
TileID = MapDataMessage.ReadByte(),
Passable = MapDataMessage.ReadBoolean(),
});
}
Console.WriteLine("TerrainData Loaded");
}
public void R(NetIncomingMessage im)
{
if(PlayerPack == null)
{
PlayerPack = new List<Tuple<uint, int, int, bool, uint>>();
}
int l = im.ReadInt32();
for(int i = 0; i < l; ++i)
{
var id = im.ReadUInt32();
var x = im.ReadInt32();
var y = im.ReadInt32();
var alive = im.ReadBoolean();
var sid = im.ReadUInt32();
PlayerPack.Add(Tuple.Create<uint, int, int, bool, uint>(id, x, y, alive, sid));
}
}
public void HandleData(NetIncomingMessage msg)
{
NetMsgType datatype = (NetMsgType)msg.ReadByte();
if (datatype == NetMsgType.Control)
{
Soul soul = (Soul)msg.SenderConnection.Tag;
var key = (ControlKey)msg.ReadByte();
var edge = msg.ReadBoolean();
//Console.WriteLine("Received Control Message: " + key + (edge ? "Pressed" : "Released"));
soul.currentShip.Controls.ReceiveMessage(key, edge);
}
else if (datatype == NetMsgType.ControlUpdate)
{
Soul soul = (Soul)msg.SenderConnection.Tag;
var Pitch = msg.ReadFloat();
var Yaw = msg.ReadFloat();
var Roll = msg.ReadFloat();
soul.currentShip.Controls.ReceiveMessage(Pitch, Yaw, Roll);
}
else if (datatype == NetMsgType.ShipDataOutput)
{
ShipDataOutputMessage data;
data = new ShipDataOutputMessage(msg);
Soul soul = new Soul(msg.SenderConnection);
soul.currentSector = Sector.Redria;
msg.SenderConnection.Tag = soul;
soul.currentSector.Terrain.Load(msg.SenderConnection);
soul.currentSector.Ships.Load(msg.SenderConnection);
soul.currentSector.Objects.Load(msg.SenderConnection);
var idRandomizer = new Random();
var NewShip = new ShipObj(new Vector3(0, 100, 2), Quaternion.Identity,
data.GeneratedData);
soul.currentShip = NewShip;
NewShip.Client = soul;
//Console.WriteLine(msg.SenderEndpoint.Address + "'s Ship ID: " + NewShip.ID);
foreach (NetConnection c in Network.Server.Connections)
{
MessageWriter.ClientEntityCreationMessage(c,
NewShip.ID, NewShip.Position, NewShip.Orientation,
data.GeneratedData.NoseID, data.GeneratedData.CoreID, data.GeneratedData.EngineID,
data.Weapons, msg.SenderConnection.RemoteUniqueIdentifier);
}
}
}
private void BuildList(NetIncomingMessage message)
{
byte playerCount = message.ReadByte();
int yOffset = 40;
for (int i = 0; i < playerCount; i++)
{
string name = message.ReadString();
var status = (SessionStatus) message.ReadByte();
string job = message.ReadString();
string ip = message.ReadString();
bool isAdmin = message.ReadBoolean();
var line = new Label("Name: " + name + " Status: " + status + " Job: " + job + " IP: " + ip,
"CALIBRI", _resourceManager)
{
Position = new Point(5, yOffset + 5),
Text = {Color = isAdmin ? Color.DarkCyan : Color.Black}
};
components.Add(line);
var kickButton = new Button("Kick", _resourceManager)
{
Position =
new Point(line.ClientArea.Right + 10,
yOffset + (int) (line.ClientArea.Height/3f))
};
components.Add(kickButton);
kickButton.UserData = ip;
kickButton.Clicked += KickButtonClicked;
kickButton.Update(0);
var banButt = new Button("Ban", _resourceManager)
{
Position =
new Point(kickButton.ClientArea.Right + 5,
yOffset + (int) (line.ClientArea.Height/3f))
};
components.Add(banButt);
banButt.UserData = ip;
banButt.Clicked += BanButtonClicked;
yOffset += 35;
}
}
public static new Packet FromNetBuffer(NetIncomingMessage incomingMessage)
{
object o = null;
var locked = incomingMessage.ReadBoolean();
var type = (ContentType) incomingMessage.ReadByte();
if (!locked)
{
var length = incomingMessage.ReadInt32();
var bytes = incomingMessage.ReadBytes(length);
o = SerializationHelper.ByteArrayToObject(bytes);
}
var packet = new ContentResultPacket(o, locked, type);
return packet;
}
internal void Read(NetIncomingMessage Message)
{
ChunkCoords.Read(Message);
Vector3i BlockCoords = ChunkCoords * Size;
for (int x = 0; x < Size.X; x++) {
for (int y = 0; y < Size.Y; y++) {
for (int z = 0; z < Size.Z; z++) {
Vector3i BlockAt = BlockCoords + new Vector3i(x, y, z);
bool Value = Message.ReadBoolean();
if (Value) {
BlockData[x, y, z] = new Block();
BlockData[x, y, z].Read(Message);
}
}
}
}
}
// Read in a list of cards from an incoming message.
public static List<Card> ReadCards( NetIncomingMessage inc )
{
// Read the size of the list of cards.
int size = inc.ReadInt32();
List<Card> cards = new List<Card>();
// Read the values of the properties of each card.
for ( int i = 0; i < size; ++i )
{
string name = inc.ReadString();
CardType type = (CardType)inc.ReadByte();
string value = inc.ReadString();
PropertyType color = (PropertyType)inc.ReadByte();
PropertyType altColor = (PropertyType)inc.ReadByte();
string uriPath = inc.ReadString();
string actionID = inc.ReadString();
string cardID = inc.ReadString();
bool isFlipped = inc.ReadBoolean();
cards.Add(new Card(name, type, Convert.ToInt32(value), color, altColor, uriPath, Convert.ToInt32(actionID), Convert.ToInt32(cardID), isFlipped));
}
return cards;
}
public void HandleAdminMessage(NetMessage adminMsgType, NetIncomingMessage messageBody)
{
switch (adminMsgType)
{
case NetMessage.RequestAdminLogin:
UserInterfaceManager.DisposeAllComponents<AdminPasswordDialog>(); //Remove old ones.
UserInterfaceManager.AddComponent(new AdminPasswordDialog(new Size(200, 50), NetworkManager,
ResourceManager)); //Create a new one.
break;
case NetMessage.RequestAdminPlayerlist:
UserInterfaceManager.DisposeAllComponents<AdminPlayerPanel>();
UserInterfaceManager.AddComponent(new AdminPlayerPanel(new Size(600, 200), NetworkManager,
ResourceManager, messageBody));
break;
case NetMessage.RequestBanList:
var banList = new Banlist();
int entriesCount = messageBody.ReadInt32();
for (int i = 0; i < entriesCount; i++)
{
string ipAddress = messageBody.ReadString();
string reason = messageBody.ReadString();
bool tempBan = messageBody.ReadBoolean();
uint minutesLeft = messageBody.ReadUInt32();
var entry = new BanEntry
{
ip = ipAddress,
reason = reason,
tempBan = tempBan,
expiresAt = DateTime.Now.AddMinutes(minutesLeft)
};
banList.List.Add(entry);
}
UserInterfaceManager.DisposeAllComponents<AdminUnbanPanel>();
UserInterfaceManager.AddComponent(new AdminUnbanPanel(new Size(620, 200), banList, NetworkManager,
ResourceManager));
break;
}
}
private void DataProcessing(byte type, NetIncomingMessage message)
{
_counter++;
Debug.Print("[" + _counter + "]Message received from server !");
switch (type)
{
case (byte)MessageType.ServerMessage.ClientId:
Debug.Print("A message type 'ClientId' have been received from server !");
ReceiveMyClientId(message.ReadInt32());
break;
case (byte)MessageType.ServerMessage.NewClientInfo:
Debug.Print("A message type 'NewClientInfo' have been received from server !");
ReceiveNewClientInfo(message.ReadInt32(), message.ReadString(), message.ReadBoolean());
break;
case (byte)MessageType.ServerMessage.IsReady:
Debug.Print("A message type 'IsReady' have been received from server !");
ReceiveIsReady(message.ReadInt32(), message.ReadBoolean());
break;
case (byte)MessageType.ServerMessage.AvailableMaps:
Debug.Print("A message type 'AvailableMaps' have been received from server !");
ReceiveAvailableMaps(message);
break;
case (byte)MessageType.ServerMessage.SelectedMap:
Debug.Print("A message type 'SelectedMap' have been received from server !");
ReceiveSelectedMap(message.ReadString());
break;
case (byte)MessageType.ServerMessage.Map:
Debug.Print("A message type 'Map' have been received from server !");
ReceiveMap(message);
break;
case (byte)MessageType.ServerMessage.GameWillStart:
Debug.Print("A message type 'GameWillStart' have been received from server !");
ReceiveGameWillStart();
break;
case (byte)MessageType.ServerMessage.StartGame:
Debug.Print("A message type 'StartGame' have been received from server !");
ReceiveStartGame(message);
break;
case (byte)MessageType.ServerMessage.PlayerPosition:
Debug.Print("A message type 'PlayerPosition' have been received from server !");
ReceivePosition(message.ReadFloat(), message.ReadFloat(), message.ReadByte(), message.ReadInt32());
break;
case (byte)MessageType.ServerMessage.RemovePlayer:
Debug.Print("A message type 'RemovePlayer' have been received from server !");
ReceiveRemovePlayer(message.ReadInt32());
break;
case (byte)MessageType.ServerMessage.PlayerPlacingBomb:
Debug.Print("A message type 'PlayerPlacingBomb' have been received from server !");
ReceivePlacingBomb(message.ReadInt32(), message.ReadPoint());
break;
case (byte)MessageType.ServerMessage.BombExploded:
ReceiveBombExploded(message);
break;
case (byte)MessageType.ServerMessage.PlayerKill:
ReceivePlayerKill(message.ReadInt32(), message.ReadInt32());
break;
case (byte)MessageType.ServerMessage.PlayerSuicide:
ReceivePlayerSuicide(message.ReadInt32());
break;
case (byte)MessageType.ServerMessage.PowerUpDrop:
ReceivePowerupDrop((PowerUpType)message.ReadByte(), message.ReadPoint());
break;
case (byte)MessageType.ServerMessage.PowerUpPickUp:
ReceivePowerUpPickUp(message.ReadInt32(), message.ReadPoint(), (PowerUpType)message.ReadByte());
break;
case (byte)MessageType.ServerMessage.SuddenDeath:
//ReceiveSuddenDeath();
break;
case (byte)MessageType.ServerMessage.RoundEnd:
Debug.Print("A message type 'RoundEnd' have been received from server !");
ReceiveRoundEnd();
break;
case (byte)MessageType.ServerMessage.End:
Debug.Print("A message type 'End' have been received from server !");
ReceiveEnd(message.ReadBoolean());
break;
case (byte)MessageType.ServerMessage.Pings:
//Debug.Print("A message type 'Pings have been received from server !");
ReceivePings(message);
break;
}
}
protected override void Read(NetIncomingMessage message)
{
Type = (AuthType)message.ReadByte();
Success = message.ReadBoolean();
Message = message.ReadString();
}
/// <summary>
/// Method to process the received information.
/// </summary>
/// <param name="type">Type of the message. Indicates what the message's contents are.</param>
/// <param name="msg">The message to process.</param>
private void ProgressData(MPMessageType msgType, NetIncomingMessage msg)
{
Log.Message("Client received " + msgType);
switch (msgType)
{
case MPMessageType.MoneyUpdate: // Receiving money
long t = msg.ReadInt64();
EcoExtBase.MPInternalMoneyAmount = t;
break;
case MPMessageType.DemandUpdate: // Receiving demand
DemandExtBase.MPCommercialDemand = msg.ReadInt32();
DemandExtBase.MPResidentalDemand = msg.ReadInt32();
DemandExtBase.MPWorkplaceDemand = msg.ReadInt32();
break;
case MPMessageType.TileUpdate: // Receiving tile coordinates to unlock
AreaExtBase.MPXCoordinate = msg.ReadInt32();
AreaExtBase.MPZCoordinate = msg.ReadInt32();
// INFO: The unlock process is activated simutaniously with the
// EcoExtBase.OnUpdateMoneyAmount(long internalMoneyAmount).
// Maybe I find a direct way to unlock a tile within AreaExtBase
break;
case MPMessageType.SimulationUpdate: // Receiving update on simulation information
SimulationManager.instance.SelectedSimulationSpeed = msg.ReadInt32();
SimulationManager.instance.SimulationPaused = msg.ReadBoolean();
break;
case MPMessageType.CitizenUpdate:
CitizenManager.instance.m_citizenCount = msg.ReadInt32();
break;
default: // Unhandled ID (MPMessageType)
OnClientReceivedUnhandledMessage(new ReceivedUnhandledMessageEventArgs(msg, msgType.ToString()));
break;
}
}
public static void Read(Packets Packet, NetIncomingMessage I)
{
switch (Packet)
{
case Packets.Connection:
if (MultiPlayer.Type("Game") == MultiPlayer.Types.Server)
{
ulong ClientVersion = I.ReadUInt64();
if (ClientVersion == Globe.Version)
{
Player Connector = Player.Add(new Player(I.ReadString()) { Connection = I.SenderConnection });
if (Connector != null)
{
MultiPlayer.Send("Game", MultiPlayer.Construct("Game", Packet, Connector.Slot, Connector.Name), I.SenderConnection);
List<object> Details = new List<object>();
for (byte i = 0; i < Players.Length; i++)
if ((Players[i] != null) && (Players[i] != Connector))
{
Details.Add(true);
Details.Add(Players[i].Name);
}
else Details.Add(false);
I.SenderConnection.Approve(MultiPlayer.Construct("Game", Packets.Initial, (byte)Players.Length, Connector.Slot, Details));
}
else I.SenderConnection.Deny("Full");
}
else I.SenderConnection.Deny("Version indifference, Client: " + ClientVersion + " - Server: " + Globe.Version);
}
else if (MultiPlayer.Type("Game") == MultiPlayer.Types.Client) { byte Slot = I.ReadByte(); Player.Set(Slot, new Player(I.ReadString())); }
break;
case Packets.Disconnection:
Player Disconnector = ((MultiPlayer.Type("Game") == MultiPlayer.Types.Server) ? Player.Get(I.SenderConnection) :
((MultiPlayer.Type("Game") == MultiPlayer.Types.Client) ? Players[I.ReadByte()] : null));
if (Disconnector != null) Player.Remove(Disconnector);
if (MultiPlayer.Type("Game") == MultiPlayer.Types.Server) MultiPlayer.Send("Game", MultiPlayer.Construct("Game", Packets.Disconnection, Disconnector.Slot), I.SenderConnection);
break;
case Packets.Initial:
if (MultiPlayer.Type("Game") == MultiPlayer.Types.Client)
{
Players = new Player[I.ReadByte()];
Self = Player.Set(I.ReadByte(), new Player(MpName) { });
for (byte i = 0; i < Players.Length; i++)
if (I.ReadBoolean())
{
Players[i] = new Player(i, I.ReadString());
}
Timers.Add("Positions", (1 / 30d));
State = States.Game;
}
break;
case Packets.Position:
Player Sender = ((MultiPlayer.Type("Game") == MultiPlayer.Types.Server) ? Player.Get(I.SenderConnection) : null);
Vector2 Position; float Angle;
if (MultiPlayer.Type("Game") == MultiPlayer.Types.Server)
{
if (Sender != null)
{
Sender.Position = I.ReadVector2();
Sender.Angle = I.ReadFloat();
}
}
else if (MultiPlayer.Type("Game") == MultiPlayer.Types.Client)
{
byte Count = (byte)((I.LengthBytes - 1) / 12);
for (byte i = 0; i < Count; i++)
{
Sender = Players[I.ReadByte()];
Position = I.ReadVector2();
Angle = I.ReadFloat();
if (Sender != null)
{
Sender.Position = Position;
Sender.Angle = Angle;
}
}
}
break;
}
}
public override void OnAdvancedNetworkMessage(NetIncomingMessage msg)
{
byte byInstruction = msg.ReadByte();
if (byInstruction == 0)
{
this.xPlayerLockedOnto = Program.game._EntityMaster_ReadActor(msg);
if (this.xPlayerLockedOnto == null)
{
this.ChangeAction(SummerFaeAI.Action.Chillin);
this.iCounter = 0;
return;
}
}
else if (byInstruction == 1)
{
SummerFaeAI.Action enAction = (SummerFaeAI.Action)msg.ReadInt32();
this.ChangeAction(enAction);
this.sSubAction = msg.ReadString();
if (msg.ReadBoolean())
{
this.iCounter = 0;
}
}
}
protected void NewPlayerResponse(NetIncomingMessage msg)
{
int ownUid = msg.ReadInt32();
NetManager.RemoteUID = ownUid;
bool gameStarted = msg.ReadBoolean();
string levelName = msg.ReadString();
string levelData = msg.ReadString();
int otherClientsCount = msg.ReadInt32();
for (int i = 0; i < otherClientsCount; i++)
{
string name = msg.ReadString();
int uid = msg.ReadInt32();
NetPlayer player = new NetPlayer(0, 0);
ClientInfo clientInfo = new ClientInfo();
clientInfo.Name = name;
clientInfo.X = player.X;
clientInfo.Y = player.Y;
clientInfo.UID = uid;
player.UID = uid;
if (!NetManager.connectedClients.ContainsKey(uid))
{
NetManager.connectedClients.Add(clientInfo.UID, clientInfo);
EntityManager.AddNetPlayer(player);
JapeLog.WriteLine("New Player Added: " + name);
}
}
if (gameStarted)
{
DownloadLevel(levelName, levelData);
OnChangedLevel(levelName, 0);
}
JapeLog.WriteLine("Remote ID recieved: " + ownUid);
}
