public virtual void OnMessage(NetIncomingMessage msg)
{
MessageTypes Type = (MessageTypes)msg.ReadByte();
switch (Type) {
case MessageTypes.ConnectionOkay:
Console.WriteLine("Connected to Remote Server");
break;
case MessageTypes.ChatMessage:
UIApi.AddChatMessage(msg.ReadString());
break;
case MessageTypes.RequestPlayerName:
Console.WriteLine("Server Requested Our Name");
NetOutgoingMessage Message = ClientConnection.CreateMessage();
Message.Write((byte)MessageTypes.PlayerNameResponse);
Message.Write(GameClient.Playername);
ClientConnection.SendMessage(Message, NetDeliveryMethod.ReliableUnordered);
Console.WriteLine("Responded to Server Name Request");
break;
case MessageTypes.IncomingMapData:
GameClient.Terrain.LoadTerrainFromNetwork(msg);
break;
case MessageTypes.MapDataChange:
GameClient.Terrain.UpdateTerrainTiles(msg);
break;
case MessageTypes.ActorCreate:
ActorManager.SpawnActor(msg);
break;
case MessageTypes.ActorMovement:
ActorManager.UpdateFromPacket(msg);
break;
case MessageTypes.ActorDestroy:
ActorManager.DrawableActors.Remove(msg.ReadInt64());
break;
case MessageTypes.ActorAnimate:
ActorManager.UpdateAnimationFromPacket(msg);
break;
case MessageTypes.CameraFocusAt:
GameClient.Camera.LookAtActor(ActorManager.DrawableActors[msg.ReadInt64()], true);
break;
case MessageTypes.AttributeSync:
Attributes.AttributeManager.UpdateAttributes(msg);
break;
default:
Console.WriteLine("Unhandled NetMessage Type: {0}", Type);
break;
}
}
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;
}
}
public Rock(NetIncomingMessage Message)
: base()
{
Texture = GameClient.ContentManager.Load<Texture2D>("RockFull");
ID = Message.ReadInt64();
BoundingBox = Message.ReadRectangle();
}
public override void DataReceived ( NetCommand command, NetIncomingMessage msg )
{
if (command==NetCommand.Snapshot) {
var frame = msg.ReadUInt32();
var prevFrame = msg.ReadUInt32();
var ackCmdID = msg.ReadUInt32();
var serverTicks = msg.ReadInt64();
var size = msg.ReadInt32();
//Log.Warning("{0}", offsetTicks );
if (prevFrame!=0) {
Log.Warning("Bad initial snapshot. Previous frame does not equal zero.");
return;
}
if (ackCmdID!=0) {
Log.Warning("Bad command ID {0}. Command ID for initial snapshot must be zero.", ackCmdID);
return;
}
// read snapshot :
var snapshot = NetDeflate.Decompress( msg.ReadBytes(size) );
// initial snapshot contains atom table :
gameClient.Atoms = new AtomCollection( msg );
gameClient.SetState( new Active( gameClient, frame, snapshot, serverTicks ) );
}
if (command==NetCommand.Notification) {
gameClient.FeedNotification( msg.ReadString() );
}
}
public ClientDisconnectedTransferableData(NetIncomingMessage message)
{
SessionID = message.ReadInt64();
ID = message.ReadInt32();
IsValid = message.ReadBoolean();
PlayerIndex = message.ReadInt16();
}
public ProjectileTransferableData(NetIncomingMessage message)
{
SessionID = message.ReadInt64();
ID = message.ReadInt32();
IsValid = message.ReadBoolean();
Position = message.ReadVector2();
Angle = message.ReadFloat();
}
public void Decode(NetIncomingMessage im)
{
Id = im.ReadInt64();
MessageTime = im.ReadDouble();
/*this.Position = im.ReadVector3();
this.Velocity = im.ReadVector3();*/
Rotation = im.ReadSingle();
}
public HealthTransferableData(NetIncomingMessage message)
{
SessionID = message.ReadInt64();
ID = message.ReadInt32();
IsValid = message.ReadBoolean();
PlayerIndex = message.ReadInt32();
Value = message.ReadFloat();
}
public override void Init(NetIncomingMessage msg, params float[] p_afInitFloats)
{
long iID = msg.ReadInt64();
if (Program.GetTheGame().dixPlayers.ContainsKey(iID))
{
this.xOwner = Program.GetTheGame().dixPlayers[iID].xEntity;
this.SpawnDemButters();
}
}
public override void Init(NetIncomingMessage msg, params float[] p_afInitFloats)
{
long key = msg.ReadInt64();
if (Program.game.dixPlayers.ContainsKey(key))
{
this.xPlayer = Program.game.dixPlayers[key];
this.xOwner = this.xPlayer.xEntity;
return;
}
this.bToBeDestroyed = true;
}
public override void OnAdvancedNetworkMessage(NetIncomingMessage msg)
{
if (msg.ReadByte() == 0)
{
this.bToBeDestroyed = true;
long iPlayerID = msg.ReadInt64();
if (Program.GetTheGame().dixPlayers.ContainsKey(iPlayerID))
{
this.Claim(Program.GetTheGame().dixPlayers[iPlayerID]);
}
}
}
public static void OnInteract(NetIncomingMessage Packet)
{
var ID = Packet.ReadInt64();
if (!LoadedObjects.ContainsKey(ID)) {
Console.WriteLine("Invalid Interaction Request for ObjectID: {0}", ID);
return;
}
if (!LoadedObjects[ID].Interactable)
return;
GameServer.TaskScheduler.AddTask(LoadedObjects[ID].Interact(Packet));
}
public override void Init(NetIncomingMessage msg, params float[] p_afInitFloats)
{
this.xRenderComponent.fVirtualHeight = p_afInitFloats[0];
this.iChargeLevel = (int)p_afInitFloats[1];
if (this.iChargeLevel >= 2)
{
AnimatedRenderComponent expr_2C_cp_0 = this.xRenderComponent;
expr_2C_cp_0.v2OffsetRenderPos.Y = expr_2C_cp_0.v2OffsetRenderPos.Y - 10f;
}
if (this.iChargeLevel == 3)
{
this.xRenderComponent.SwitchAnimation(10, Animation.CancelOptions.IgnoreIfPlaying);
this.iAnimPlus = 10;
}
long iID = msg.ReadInt64();
if (Program.GetTheGame().dixPlayers.ContainsKey(iID))
{
this.xOwner = Program.GetTheGame().dixPlayers[iID].xEntity;
}
}
public override void Init(NetIncomingMessage msg, params float[] p_afInitFloats)
{
long key = msg.ReadInt64();
if (Program.game.dixPlayers.ContainsKey(key))
{
this.xOwner = Program.game.dixPlayers[key].xEntity;
}
else
{
this.xOwner = new EntityShell(Vector2.Zero);
}
this.fVelocity = p_afInitFloats[0];
Program.GetTheGame().xSoundSystem.PlayCue("meteor_impact", this, false);
this.xRenderComponent.fVirtualHeight = p_afInitFloats[1];
this.iChargeLevel = (int)p_afInitFloats[2];
if (this.iChargeLevel == 3)
{
this.xRenderComponent.SwitchAnimation(2, Animation.CancelOptions.IgnoreIfPlaying);
}
}
private void HandleRequestIntroduction(NetIncomingMessage msg)
{
IPEndPoint clientInternal = msg.ReadIPEndpoint();
long hostId = msg.ReadInt64();
string token = msg.ReadString();
Object[] elist;
if (registeredHosts.TryGetValue(hostId, out elist))
{
peer.Introduce(
(IPEndPoint) elist[0],
(IPEndPoint) elist[1],
clientInternal,
msg.SenderEndpoint,
token
);
}
else
{
Console.WriteLine("Client requested introduction to nonlisted host!");
}
}
public override void Init(NetIncomingMessage msg, params float[] p_afInitFloats)
{
long key = msg.ReadInt64();
if (Program.game.dixPlayers.ContainsKey(key))
{
this.xOwner = Program.game.dixPlayers[key].xEntity;
}
else
{
this.xOwner = new EntityShell(Vector2.Zero);
}
this.fVelocity = p_afInitFloats[0];
Program.GetTheGame().xSoundSystem.PlayCue("throw_skill", this, false);
this.xRenderComponent.fVirtualHeight = p_afInitFloats[1];
this.iChargeLevel = (int)p_afInitFloats[2];
this.v2Target = new Vector2(p_afInitFloats[3], p_afInitFloats[4]);
this.enWeapon = (ItemCodex.ItemTypes)p_afInitFloats[5];
this.v2Direction = Utility.Normalize(this.v2Target - this.xTransform.v2Pos);
if (this.iChargeLevel == 3)
{
this.xRenderComponent.SwitchAnimation(2, Animation.CancelOptions.IgnoreIfPlaying);
}
}
public override void OnAdvancedNetworkMessage(NetIncomingMessage msg)
{
if (msg.ReadByte() == 0)
{
this.bToBeDestroyed = true;
if (Program.GetTheGame().xLocalPlayer.xJournalInfo.denbyKeys.ContainsKey(this.enRegion))
{
Dictionary<Level.WorldRegion, byte> denbyKeys;
Level.WorldRegion key;
(denbyKeys = Program.GetTheGame().xLocalPlayer.xJournalInfo.denbyKeys)[key = this.enRegion] = (byte)(denbyKeys[key] + 1);
}
else
{
Program.GetTheGame().xLocalPlayer.xJournalInfo.denbyKeys[this.enRegion] = 1;
}
Program.GetTheGame().xGameSessionData.henActiveFlags.Add(this.enFlagToTrigger);
long iPlayerID = msg.ReadInt64();
if (Program.GetTheGame().xLocalPlayer.iConnectionIdentifier == iPlayerID)
{
this.Claim(Program.GetTheGame().dixPlayers[iPlayerID]);
}
}
}
// TODO: consider outputting a NetIncomingMessage instead of byte[]
private (bool Success, byte[]? Hail, int HailLength) ValidateHandshakeData(int offset, int payloadLength)
{
// create temporary incoming message
NetIncomingMessage msg = Peer.SetupReadHelperMessage(offset, payloadLength);
try
{
string remoteAppIdentifier = msg.ReadString();
long remoteUniqueIdentifier = msg.ReadInt64();
InitializeRemoteTimeOffset(msg.ReadTimeSpan());
byte[]? hail = null;
int hailLength = payloadLength - (msg.BytePosition - offset);
if (hailLength > 0)
{
hail = msg.StoragePool.Rent(hailLength);
msg.Read(hail.AsSpan(0, hailLength));
}
if (remoteAppIdentifier != Peer.Configuration.AppIdentifier)
{
ExecuteDisconnect(NetMessageType.WrongAppIdentifier);
return(false, hail, hailLength);
}
RemoteUniqueIdentifier = remoteUniqueIdentifier;
return(true, hail, hailLength);
}
catch (Exception ex)
{
// whatever; we failed
ExecuteDisconnect(NetMessageType.InvalidHandshake);
Peer.LogWarning(new NetLogMessage(NetLogCode.InvalidHandshake, ex));
return(false, null, 0);
}
}
private bool ValidateHandshakeData(int ptr, int payloadLength, out byte[] hail)
{
hail = null;
// create temporary incoming message
NetIncomingMessage msg = m_peer.SetupReadHelperMessage(ptr, payloadLength);
try
{
string remoteAppIdentifier = msg.ReadString();
long remoteUniqueIdentifier = msg.ReadInt64();
InitializeRemoteTimeOffset(msg.ReadSingle());
int remainingBytes = payloadLength - (msg.PositionInBytes - ptr);
if (remainingBytes > 0)
{
hail = msg.ReadBytes(remainingBytes);
}
if (remoteAppIdentifier != m_peer.m_configuration.AppIdentifier)
{
// wrong app identifier
ExecuteDisconnect("Wrong application identifier!", true);
return(false);
}
m_remoteUniqueIdentifier = remoteUniqueIdentifier;
}
catch (Exception ex)
{
// whatever; we failed
ExecuteDisconnect("Handshake data validation failed", true);
m_peer.LogWarning("ReadRemoteHandshakeData failed: " + ex.Message);
return(false);
}
return(true);
}
public static void UpdateAttributes(NetIncomingMessage Packet)
{
var Count = 0;
var Max_Count = Packet.ReadInt32();
while(Count < Max_Count) {
var OwnerID = Packet.ReadInt64();
if (!KnownAttributes.ContainsKey(OwnerID))
KnownAttributes.Add(OwnerID, new AttributeList(OwnerID));
var ListCount = 0;
var List_MaxCount = Packet.ReadInt32();
while (ListCount < List_MaxCount) {
Attribute Attr = new Attribute();
Attr.Deserialize(Packet, OwnerID);
if (!KnownAttributes[OwnerID].HasKey(Attr.Key))
KnownAttributes[OwnerID].Create(Attr);
else {
KnownAttributes[OwnerID].Set(Attr.Key, Attr.Data);
}
ActorManager.DrawableActors[OwnerID].OnAttributeUpdate(Attr.Key, Attr.Data);
ListCount++;
}
Count++;
}
}
public override void OnAdvancedNetworkMessage(NetIncomingMessage msg)
{
if (msg.ReadByte() == 0)
{
long iPlayerID = msg.ReadInt64();
int ibitLayer = msg.ReadInt32();
float fVirtualHeightDif = msg.ReadFloat();
float fTargetY = msg.ReadFloat();
if (Program.GetTheGame().dixPlayers.ContainsKey(iPlayerID))
{
PlayerEntity xEntity = Program.GetTheGame().dixPlayers[iPlayerID].xEntity;
xEntity.xJumpDown = this;
this.ibitTargetLayer = ibitLayer;
this.fVirtualHeightDifference = fVirtualHeightDif;
this.fTargetY = fTargetY;
xEntity.xCollisionComponent.DeactivateGroup(CollisionComponent.ColliderGroup.All);
xEntity.xInput.Reset();
if (!xEntity.Owner.xViewStats.bIsDead)
{
xEntity.xRenderComponent.SwitchAnimation(85, Animation.CancelOptions.IgnoreIfPlaying);
}
}
}
}
public override void OnAdvancedNetworkMessage(NetIncomingMessage msg)
{
byte byMos = msg.ReadByte();
if (CAS.NetworkRole == NetworkHelperInterface.NetworkRole.Client)
{
if (byMos == 0)
{
long iID = msg.ReadInt64();
if (!Program.game.dixPlayers.ContainsKey(iID))
{
return;
}
this.SetPlayer(Program.game.dixPlayers[iID].xEntity);
return;
}
}
else if (byMos == 0 && this.Shake())
{
base.SendNetworkInstruction(new float[]
{
1f
});
}
}
public override void OnAdvancedNetworkMessage(NetIncomingMessage msg)
{
byte byID = msg.ReadByte();
if (CAS.NetworkRole == NetworkHelperInterface.NetworkRole.Client && byID == 1)
{
long iPlayerID = msg.ReadInt64();
if (Program.game.dixPlayers.ContainsKey(iPlayerID))
{
this.FireDelayedHomingBulletClient(Program.game.dixPlayers[iPlayerID], msg.ReadInt32(), msg.ReadFloat(), msg.ReadFloat(), msg.ReadUInt16());
}
}
}
private void HandleRegisterHost(NetIncomingMessage inc)
{
var id = inc.ReadInt64();
var name = inc.ReadString();
var population = inc.ReadUInt16();
var maxPopulation = inc.ReadUInt16();
var guid = inc.ReadString();
var endpoint = inc.ReadIPEndpoint();
var game = inc.ReadInt32();
//if (manager.Register(id, new Guid(guid)))
{
registeredHosts[id] = new Object[]
{
endpoint,
inc.SenderEndpoint,
name,
population,
maxPopulation,
NetTime.Now,
game
};
}
}
//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;
}
}
/// <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;
}
}
private void HandleSessionInit(NetIncomingMessage msg)
{
int slots = msg.ReadInt32();
Players.SetNumSlots(slots);
int numconnected = msg.ReadInt32();
for (int i = 0; i < numconnected; ++i)
{
long uniqueID = msg.ReadInt64();
string name = msg.ReadString();
int slot = msg.ReadInt32();
RemotePlayerStatus status = (RemotePlayerStatus)msg.ReadByte();
RemotePlayer player = new RemotePlayer(uniqueID, name);
Players.AddPlayer(player, false);
Players.MovePlayerToSlot(player, slot);
Players.SetStatus(player, status);
}
}
private void HandlePlayerSetStatus(NetIncomingMessage msg)
{
long id = msg.ReadInt64();
RemotePlayerStatus status = (RemotePlayerStatus)msg.ReadByte();
Players.SetStatus(Players.GetPlayer(id), status);
}
private void HandlePlayerSetSlot(NetIncomingMessage msg)
{
long id = msg.ReadInt64();
int slot = msg.ReadInt32();
Players.MovePlayerToSlot(Players.GetPlayer(id), slot);
}
private void HandlePlayerLeft(NetIncomingMessage msg)
{
long id = msg.ReadInt64();
chatHandler(string.Format("{0} disconnected...", Players.GetPlayer(id).PlayerName));
Players.RemovePlayer(id);
}
void HandleEchoMessage(NetMessageType NetMessageType, NetIncomingMessage NetIncomingMessage)
{
String ident = NetIncomingMessage.ReadString();
long unique = NetIncomingMessage.ReadInt64();
if(NetWorkEcho.ContainsKey(ident))
{
NetOutgoingMessage o = CreateMessage(NetWorking.NetMessageType.Echo);
o.Write(ident);
o.Write(unique);
SendMessageToAllClients(NetWorkEcho[ident].AnswerMessage(NetIncomingMessage,o),NetDeliveryMethod.ReliableOrdered);
}
}
private void HandlePlayerJoined(NetIncomingMessage msg)
{
long id = msg.ReadInt64();
string name = msg.ReadString();
RemotePlayerStatus status = (RemotePlayerStatus)msg.ReadByte();
RemotePlayer player = new RemotePlayer(id, name);
Players.AddPlayer(new RemotePlayer(id, name), false);
Players.SetStatus(player, status);
chatHandler(string.Format("{0} joined...", name));
}
