/// <summary>
/// Serializes this message object into the provided outgoing lidgren message.
/// Requires server time to mark when this message was prepared for sending.
/// Uses reflection to serialize fields and properties from the payload object.
/// </summary>
/// <param name="msg"></param>
/// <param name="serverTime"></param>
public void Encode(NetOutgoingMessage msg, double serverTime)
{
MessageSentTime = serverTime;
// write "header" properties
msg.Write(MessageSentTime);
msg.Write((byte)MessageType);
msg.Write(Id);
msg.Write(PayloadTypeId);
try
{
// Lidgren methods automatically write correct type for field types via reflection
msg.WriteAllFields(Payload, DefaultBinding);
msg.WriteAllProperties(Payload, DefaultBinding);
}
catch (NetException ex)
{
throw new RedGrinException("Error writing entity state to network message.", ex);
}
catch (SystemException ex)
{
throw new RedGrinException("Unknown message error.", ex);
}
}
public static void UpdateAllPlayers()
{
List <Player> Players = PlayersController.GetAll();
foreach (var Player in Players)
{
NetOutgoingMessage Msg = NetServer.CreateMessage();
Msg.Write((int)Shared.NetworkMessageType.UpdatePlayer);
PlayerUpdateStruct PlayerData = new PlayerUpdateStruct();
PlayerData.ID = Player.ID;
PlayerData.Name = Player.Name;
PlayerData.Model = Player.Model;
PlayerData.Health = Player.Health;
PlayerData.Armor = Player.Armor;
PlayerData.CurrentVehicle = Player.CurrentVehicle;
PlayerData.VehicleSeat = Player.VehicleSeat;
PlayerData.Pos_X = Player.Position.X;
PlayerData.Pos_Y = Player.Position.Y;
PlayerData.Pos_Z = Player.Position.Z;
PlayerData.Vel_X = Player.Velocity.X;
PlayerData.Vel_Y = Player.Velocity.Y;
PlayerData.Vel_Z = Player.Velocity.Z;
PlayerData.Heading = Player.Heading;
PlayerData.IsWalking = Player.IsWalking;
PlayerData.IsRunning = Player.IsRunning;
PlayerData.IsJumping = Player.IsJumping;
PlayerData.IsCrouching = Player.IsCrouching;
PlayerData.IsGettingIntoVehicle = Player.IsGettingIntoVehicle;
PlayerData.IsGettingOutOfVehicle = Player.IsGettingOutOfVehicle;
Msg.WriteAllFields(PlayerData);
NetServer.SendToAll(Msg, Player.NetConnection, NetDeliveryMethod.Unreliable, 1);
}
}
private void SendPlayerShot(int playerId, Vector3 hitPoint, Vector3 hitDirection)
{
MultiplayerManager mInstance = MultiplayerManager.instance;
int playerID = GetComponent <Player>().m_playerId;
MessagePlayerShotBullet message = new MessagePlayerShotBullet();
message.playerId = playerID;
message.hitPosition = hitPoint;
message.hitDirection = hitDirection;
if (mInstance.m_isServer)
{
List <NetConnection> sendTo = mInstance.m_server.Connections;
if (sendTo.Count > 0)
{
NetOutgoingMessage om = mInstance.m_server.CreateMessage();
om.Write((int)MessageFunction.PlayerShotBullet);
om.WriteAllFields(message);
mInstance.m_server.SendToAll(om, NetDeliveryMethod.ReliableOrdered);
}
}
else
{
NetOutgoingMessage om = mInstance.m_client.CreateMessage();
om.Write((int)MessageFunction.PlayerShotBullet);
om.WriteAllFields(message);
mInstance.m_client.SendMessage(om, NetDeliveryMethod.ReliableOrdered);
}
}
public void SendNetworkMessage(Message message, SendTo sendTo, NetIncomingMessage netMessage = null, NetDeliveryMethod deliveryMethod = NetDeliveryMethod.ReliableOrdered)
{
if (m_isServer)
{
Type messageType = message.GetType();
NetOutgoingMessage om = m_server.CreateMessage();
om.Write((int)MessageFunction.ClassMessage);;
om.Write(messageType.Assembly.ToString());
om.Write(messageType.ToString());
om.WriteAllFields(message);
NetConnection sender = null;
if (netMessage != null)
{
sender = netMessage.SenderConnection;
}
switch (sendTo)
{
case SendTo.All:
message.OnCalled(message, netMessage);
m_server.SendToAll(om, sender, deliveryMethod, 0);
break;
case SendTo.Others:
m_server.SendToAll(om, sender, deliveryMethod, 0);
if (sender != null) //If server diden't send the message
{
message.OnCalled(message, netMessage);
}
break;
case SendTo.Server:
message.OnCalled(message, netMessage);
break;
}
}
else
{
Type messageType = message.GetType();
NetOutgoingMessage om = m_client.CreateMessage();
om.Write((int)MessageFunction.ClassMessage);
om.Write((int)sendTo);
om.Write(messageType.Assembly.ToString());
om.Write(messageType.ToString());
om.WriteAllFields(message);
m_client.SendMessage(om, deliveryMethod);
if (sendTo == SendTo.All) //Trigger for sender if you sent it to everybody
{
message.OnCalled(message, netMessage);
}
}
}
public static NetOutgoingMessage PackMessage(NetOutgoingMessage outMsg, NetworkMessage msg)
{
outMsg.Write(msg.GetType().GetHashCode());
if (msg.CustomPack())
{
outMsg = msg.Pack(outMsg);
}
else
{
outMsg.WriteAllFields(msg);
}
return(outMsg);
}
public static void UpdateAllVehicles()
{
List <Vehicle> Vehicles = VehiclesController.GetAll();
foreach (var Vehicle in Vehicles)
{
NetOutgoingMessage Msg = NetServer.CreateMessage();
VehicleUpdateStruct VehicleData = new VehicleUpdateStruct();
VehicleData.ID = Vehicle.ID;
VehicleData.Model = Vehicle.Model;
VehicleData.Pos_X = Vehicle.Position.X;
VehicleData.Pos_Y = Vehicle.Position.Y;
VehicleData.Pos_Z = Vehicle.Position.Z;
VehicleData.Vel_X = Vehicle.Velocity.X;
VehicleData.Vel_Y = Vehicle.Velocity.Y;
VehicleData.Vel_Z = Vehicle.Velocity.Z;
VehicleData.Rot_X = Vehicle.Rotation.X;
VehicleData.Rot_Y = Vehicle.Rotation.Y;
VehicleData.Rot_Z = Vehicle.Rotation.Z;
VehicleData.Rot_A = Vehicle.Rotation.W;
VehicleData.Heading = Vehicle.Heading;
VehicleData.Speed = Vehicle.Speed;
Msg.Write((int)Shared.NetworkMessageType.UpdateVehicle);
Msg.WriteAllFields(VehicleData);
if (Vehicle.Driver == null)
{
NetServer.SendToAll(Msg, NetDeliveryMethod.Unreliable);
}
else
{
NetServer.SendToAll(Msg, Vehicle.Driver.NetConnection, NetDeliveryMethod.Unreliable, 2);
}
}
}
public void TestScenario()
{
var peer = TestHelper.CreatePeer();
NetOutgoingMessage msg = peer.CreateMessage();
msg.Write(false);
msg.Write(-3, 6);
msg.Write(42);
msg.Write("duke of earl");
msg.Write((byte)43);
msg.Write((ushort)44);
msg.Write(UInt64.MaxValue, 64);
msg.Write(true);
msg.WritePadBits();
int bcnt = 0;
msg.Write(567845.0f);
msg.WriteVariableInt32(2115998022);
msg.Write(46.0);
msg.Write((ushort)14, 9);
bcnt += msg.WriteVariableInt32(-47);
msg.WriteVariableInt32(470000);
msg.WriteVariableUInt32(48);
bcnt += msg.WriteVariableInt64(-49);
if (bcnt != 2)
{
throw new NetException("WriteVariable* wrote too many bytes!");
}
byte[] data = msg.Data;
NetIncomingMessage inc = TestHelper.CreateIncomingMessage(data, msg.LengthBits);
StringBuilder bdr = new StringBuilder();
bdr.Append(inc.ReadBoolean());
bdr.Append(inc.ReadInt32(6));
bdr.Append(inc.ReadInt32());
string strResult;
bool ok = inc.ReadString(out strResult);
if (ok == false)
{
throw new NetException("Read/write failure");
}
bdr.Append(strResult);
bdr.Append(inc.ReadByte());
if (inc.PeekUInt16() != (ushort)44)
{
throw new NetException("Read/write failure");
}
bdr.Append(inc.ReadUInt16());
if (inc.PeekUInt64(64) != UInt64.MaxValue)
{
throw new NetException("Read/write failure");
}
bdr.Append(inc.ReadUInt64());
bdr.Append(inc.ReadBoolean());
inc.SkipPadBits();
bdr.Append(inc.ReadSingle());
bdr.Append(inc.ReadVariableInt32());
bdr.Append(inc.ReadDouble());
bdr.Append(inc.ReadUInt32(9));
bdr.Append(inc.ReadVariableInt32());
bdr.Append(inc.ReadVariableInt32());
bdr.Append(inc.ReadVariableUInt32());
bdr.Append(inc.ReadVariableInt64());
if (bdr.ToString().Equals("False-342duke of earl434418446744073709551615True56784521159980224614-4747000048-49"))
{
Console.WriteLine("Read/write tests OK");
}
else
{
throw new NetException("Read/write tests FAILED!");
}
msg = peer.CreateMessage();
NetOutgoingMessage tmp = peer.CreateMessage();
tmp.Write((int)42, 14);
msg.Write(tmp);
msg.Write(tmp);
if (msg.LengthBits != tmp.LengthBits * 2)
{
throw new NetException("NetOutgoingMessage.Write(NetOutgoingMessage) failed!");
}
tmp = peer.CreateMessage();
Test test = new Test();
test.Number = 42;
test.Name = "Hallon";
test.Age = 8.2f;
tmp.WriteAllFields(test, BindingFlags.Public | BindingFlags.Instance);
data = tmp.Data;
inc = TestHelper.CreateIncomingMessage(data, tmp.LengthBits);
Test readTest = new Test();
inc.ReadAllFields(readTest, BindingFlags.Public | BindingFlags.Instance);
NetException.Assert(readTest.Number == 42);
NetException.Assert(readTest.Name == "Hallon");
NetException.Assert(readTest.Age == 8.2f);
// test aligned WriteBytes/ReadBytes
msg = peer.CreateMessage();
byte[] tmparr = new byte[] { 5, 6, 7, 8, 9 };
msg.Write(tmparr);
inc = TestHelper.CreateIncomingMessage(msg.Data, msg.LengthBits);
byte[] result = inc.ReadBytes(tmparr.Length);
for (int i = 0; i < tmparr.Length; i++)
{
if (tmparr[i] != result[i])
{
throw new Exception("readbytes fail");
}
}
}
static void Main(string[] args)
{
Dictionary <long, CarGoServer.ServerData> registeredHosts = new Dictionary <long, CarGoServer.ServerData>();
NetPeerConfiguration config = new NetPeerConfiguration("masterserver");
config.SetMessageTypeEnabled(NetIncomingMessageType.UnconnectedData, true);
config.Port = CommonConstants.MasterServerPort;
NetPeer peer = new NetPeer(config);
peer.Start();
// keep going until ESCAPE is pressed
Console.WriteLine("Press ESC to quit");
while (!Console.KeyAvailable || Console.ReadKey().Key != ConsoleKey.Escape)
{
NetIncomingMessage msg;
while ((msg = peer.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.UnconnectedData:
//
// We've received a message from a client or a host
//
// by design, the first byte always indicates action
switch ((MasterServerMessageType)msg.ReadByte())
{
case MasterServerMessageType.RegisterHost:
// It's a host wanting to register its presence
var id = msg.ReadInt64(); // server unique identifier
//var name = msg.ReadString();
CarGoServer.ServerData serverData = new CarGoServer.ServerData();
msg.ReadAllFields(serverData);
IPAddress address;
IPAddress.TryParse(serverData.localAddress, out address);
IPEndPoint hostEndPoint = new IPEndPoint(address, serverData.serverPort);
Console.WriteLine("Got registration for host " + id);
registeredHosts[id] = serverData;
break;
case MasterServerMessageType.RequestHostList:
// It's a client wanting a list of registered hosts
//Console.WriteLine("Sending list of " + registeredHosts.Count + " hosts to client " + msg.SenderEndPoint);
foreach (var hostData in registeredHosts)
{
if (hostData.Value.showInServerList)
{
// send registered host to client
//Console.WriteLine("sending " + hostData.Value.serverName);
NetOutgoingMessage om = peer.CreateMessage();
om.Write((byte)CarGo.Network.MessageType.ServerInList);
om.Write(hostData.Key);
om.WriteAllFields(hostData.Value);
peer.SendUnconnectedMessage(om, msg.SenderEndPoint);
}
}
break;
case MasterServerMessageType.RequestIntroduction:
// It's a client wanting to connect to a specific (external) host
IPEndPoint clientInternal = msg.ReadIPEndPoint();
long hostId = msg.ReadInt64();
string token = msg.ReadString();
Console.WriteLine(msg.SenderEndPoint + " requesting introduction to " + hostId + " (token " + token + ")");
// find in list
IPEndPoint[] elist;
CarGoServer.ServerData data;
long publicAddress;
IPAddress localAddress;
if (registeredHosts.TryGetValue(hostId, out data))
{
IPAddress.TryParse(data.localAddress, out localAddress);
if (long.TryParse(data.publicAddress, out publicAddress))
{
// found in list - introduce client and host to eachother
Console.WriteLine("Sending introduction...");
peer.Introduce(
new IPEndPoint(localAddress, data.serverPort), // host internal
new IPEndPoint(publicAddress, data.serverPort), // host external
clientInternal, // client internal
msg.SenderEndPoint, // client external
token // request token
);
}
}
else
{
Console.WriteLine("Client requested introduction to nonlisted host!");
}
break;
case MasterServerMessageType.GetHostByCode:
CarGoServer.ServerData serverData1;
if (registeredHosts.TryGetValue(msg.ReadInt64(), out serverData1))
{
NetOutgoingMessage om = peer.CreateMessage();
om.Write((byte)CarGo.Network.MessageType.ReceiveServerAddress);
om.WriteAllFields(serverData1);
peer.SendUnconnectedMessage(om, msg.SenderEndPoint);
}
else
{
Console.WriteLine("Code not correct");
}
break;
}
break;
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
// print diagnostics message
Console.WriteLine(msg.ReadString());
break;
}
}
}
peer.Shutdown("shutting down");
}
public static void OnTick(object sender, EventArgs e)
{
if (NetClient == null)
{
return;
}
NetIncomingMessage Msg;
while ((Msg = NetClient.ReadMessage()) != null)
{
switch (Msg.MessageType)
{
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)Msg.ReadByte();
switch (status)
{
case NetConnectionStatus.InitiatedConnect:
Game.Console.Print("Connecting to server.");
break;
case NetConnectionStatus.Connected:
Game.Console.Print("Connected to server.");
World.CarDensity = 0;
World.PedDensity = 0;
Game.WantedMultiplier = 0;
Game.LocalPlayer.WantedLevel = 0;
GTA.Native.Function.Call("CLEAR_AREA", 0.0f, 0.0f, 0.0f, 4000.0f, true);
Game.LocalPlayer.Character.BlockGestures = true;
Game.LocalPlayer.Character.BlockPermanentEvents = true;
Game.LocalPlayer.Character.PreventRagdoll = true;
Game.LocalPlayer.Character.WillFlyThroughWindscreen = false;
Ped[] Peds = World.GetAllPeds();
foreach (var Ped in Peds)
{
if (Ped.Exists())
{
if (Ped != Game.LocalPlayer.Character)
{
Ped.Delete();
}
}
}
Vehicle[] Vehicles = World.GetAllVehicles();
foreach (var Vehicle in Vehicles)
{
if (Vehicle.Exists())
{
Vehicle.Delete();
}
}
RemotePlayersController = new RemotePlayersController();
RemoteVehiclesController = new RemoteVehiclesController();
ResourcesManager = new Shared.Scripting.ResourcesManager();
EventsManager = new Shared.Scripting.EventsManager();
IsSpawned = false;
Game.FadeScreenOut(1);
Game.LocalPlayer.Model = "F_Y_SWAT";
Initialized = true;
break;
case NetConnectionStatus.Disconnected:
Game.Console.Print("Disconnected from server.");
Game.FadeScreenIn(500);
break;
}
break;
case NetIncomingMessageType.Data:
if (!Initialized)
{
continue;
}
int MsgType = Msg.ReadInt32();
switch (MsgType)
{
case (int)Shared.NetworkMessageType.PlayerConnected:
{
break;
}
case (int)Shared.NetworkMessageType.PlayerDisconnected:
{
int ID = Msg.ReadInt32();
RemotePlayer Player = RemotePlayersController.GetByID(ID);
if (Player != null)
{
RemotePlayersController.Remove(Player);
Player.Destroy();
Player = null;
}
break;
}
case (int)Shared.NetworkMessageType.LoadResource:
{
string ResourceName = Msg.ReadString();
Shared.Scripting.Resource Resource = new Shared.Scripting.Resource();
Resource.Name = ResourceName;
ResourcesManager.Resources.Add(Resource);
break;
}
case (int)Shared.NetworkMessageType.StartResource:
{
string ResourceName = Msg.ReadString();
Shared.Scripting.Resource Resource = ResourcesManager.GetByName(ResourceName);
if (Resource != null)
{
Resource.Start();
}
break;
}
case (int)Shared.NetworkMessageType.ResourceFile:
{
string ResourceName = Msg.ReadString();
string ScriptName = Msg.ReadString();
string ScriptCode = Msg.ReadString();
ResourcesManager.GetByName(ResourceName).AddScript(ScriptName, ScriptCode);
break;
}
case (int)Shared.NetworkMessageType.UpdatePlayer:
{
PlayerUpdateStruct PlayerData = new PlayerUpdateStruct();
Msg.ReadAllFields(PlayerData);
RemotePlayer Player = RemotePlayersController.GetByID(PlayerData.ID);
if (Player == null)
{
Player = new RemotePlayer(PlayerData.Model);
Player.ID = PlayerData.ID;
RemotePlayersController.Add(Player);
}
Player.Name = PlayerData.Name;
Player.SetHealth(PlayerData.Health);
Player.SetArmor(PlayerData.Armor);
if (PlayerData.CurrentVehicle > 0)
{
Player.CurrentVehicle = RemoteVehiclesController.GetByID(PlayerData.CurrentVehicle);
Player.CurrentSeat = (VehicleSeat)PlayerData.VehicleSeat;
Player.Update();
}
else
{
if (Player.CurrentVehicle != null)
{
Player.CurrentVehicle = null;
}
Vector3 Position = new Vector3();
Position.X = PlayerData.Pos_X;
Position.Y = PlayerData.Pos_Y;
Position.Z = PlayerData.Pos_Z - 1.0f;
Vector3 Velocity = new Vector3();
Velocity.X = PlayerData.Vel_X;
Velocity.Y = PlayerData.Vel_Y;
Velocity.Z = PlayerData.Vel_Z;
Player.SetPosition(Position);
Player.SetVelocity(Velocity);
Player.SetHeading(PlayerData.Heading);
Player.IsWalking = PlayerData.IsWalking;
Player.IsRunning = PlayerData.IsRunning;
if (!Player.IsJumping && PlayerData.IsJumping == true)
{
Player.TaskJumpAdded = false;
}
Player.IsJumping = PlayerData.IsJumping;
Player.IsCrouching = PlayerData.IsCrouching;
Player.Interpolation_Start = DateTime.Now;
Player.Interpolation_End = DateTime.Now.AddMilliseconds((double)Shared.Settings.TickRate).AddMilliseconds(NetClient.ServerConnection.AverageRoundtripTime / 1000);
Player.Update();
}
break;
}
case (int)Shared.NetworkMessageType.SpawnPlayer:
{
Vector3 Position = new Vector3();
Position.X = Msg.ReadFloat();
Position.Y = Msg.ReadFloat();
Position.Z = Msg.ReadFloat();
float Heading = Msg.ReadFloat();
IsSpawned = true;
Game.LocalPlayer.Character.Position = Position;
Game.LocalPlayer.Character.Heading = Heading;
break;
}
case (int)Shared.NetworkMessageType.FadeScreenIn:
{
int Duration = Msg.ReadInt32();
Game.FadeScreenIn(Duration);
break;
}
case (int)Shared.NetworkMessageType.FadeScreenOut:
{
int Duration = Msg.ReadInt32();
Game.FadeScreenOut(Duration);
break;
}
case (int)Shared.NetworkMessageType.UpdateVehicle:
{
VehicleUpdateStruct VehicleData = new VehicleUpdateStruct();
Msg.ReadAllFields(VehicleData);
RemoteVehicle Vehicle = RemoteVehiclesController.GetByID(VehicleData.ID);
if (Vehicle == null)
{
Vehicle = new RemoteVehicle(VehicleData.Model);
Vehicle.ID = VehicleData.ID;
RemoteVehiclesController.Add(Vehicle);
}
Vehicle.Model = VehicleData.Model;
Vector3 Position = new Vector3();
Position.X = VehicleData.Pos_X;
Position.Y = VehicleData.Pos_Y;
Position.Z = VehicleData.Pos_Z;
Vehicle.SetPosition(Position);
Vector3 Velocity = new Vector3();
Velocity.X = VehicleData.Vel_X;
Velocity.Y = VehicleData.Vel_Y;
Velocity.Z = VehicleData.Vel_Z;
Vehicle.SetVelocity(Velocity);
Vehicle.SetHeading(VehicleData.Heading);
Quaternion Rotation = new Quaternion();
Rotation.X = VehicleData.Rot_X;
Rotation.Y = VehicleData.Rot_Y;
Rotation.Z = VehicleData.Rot_Z;
Rotation.W = VehicleData.Rot_A;
Vehicle.SetRotation(Rotation);
Vehicle.Interpolation_Start = DateTime.Now;
Vehicle.Interpolation_End = DateTime.Now.AddMilliseconds((double)Shared.Settings.TickRate).AddMilliseconds(NetClient.ServerConnection.AverageRoundtripTime / 1000);
break;
}
default:
{
break;
}
}
break;
default:
Game.Console.Print("Unhandled message type: " + Msg.MessageType);
break;
}
}
if (NetClient.ConnectionStatus == NetConnectionStatus.Connected)
{
NetOutgoingMessage OutMsg = NetClient.CreateMessage();
PlayerUpdateStruct PlayerData = new PlayerUpdateStruct();
Vector3 PlayerPos = Game.LocalPlayer.Character.Position;
Vector3 PlayerRot = Game.LocalPlayer.Character.Direction;
float PlayerHeading = Game.LocalPlayer.Character.Heading;
PlayerData.Name = PlayerName;
PlayerData.Health = Game.LocalPlayer.Character.Health;
PlayerData.Armor = Game.LocalPlayer.Character.Armor;
if (Game.LocalPlayer.Character.isInVehicle())
{
Vehicle CurrentVehicle = Game.LocalPlayer.Character.CurrentVehicle;
PlayerData.CurrentVehicle = RemoteVehiclesController.GetByGame(CurrentVehicle).ID;
VehicleSeat CurrentSeat = VehicleSeat.None;
if (CurrentVehicle.GetPedOnSeat(VehicleSeat.Driver) == Game.LocalPlayer.Character)
{
CurrentSeat = VehicleSeat.Driver;
}
else if (CurrentVehicle.GetPedOnSeat(VehicleSeat.RightFront) == Game.LocalPlayer.Character)
{
CurrentSeat = VehicleSeat.RightFront;
}
else if (CurrentVehicle.GetPedOnSeat(VehicleSeat.LeftRear) == Game.LocalPlayer.Character)
{
CurrentSeat = VehicleSeat.LeftRear;
}
else if (CurrentVehicle.GetPedOnSeat(VehicleSeat.RightRear) == Game.LocalPlayer.Character)
{
CurrentSeat = VehicleSeat.RightRear;
}
PlayerData.VehicleSeat = (int)CurrentSeat;
PlayerData.Pos_X = CurrentVehicle.Position.X;
PlayerData.Pos_Y = CurrentVehicle.Position.Y;
PlayerData.Pos_Z = CurrentVehicle.Position.Z;
Vector3 Velocity = CurrentVehicle.Velocity;
Velocity.Normalize();
PlayerData.Vel_X = Velocity.X;
PlayerData.Vel_Y = Velocity.Y;
PlayerData.Vel_Z = Velocity.Z;
PlayerData.Rot_X = CurrentVehicle.RotationQuaternion.X;
PlayerData.Rot_Y = CurrentVehicle.RotationQuaternion.Y;
PlayerData.Rot_Z = CurrentVehicle.RotationQuaternion.Z;
PlayerData.Rot_A = CurrentVehicle.RotationQuaternion.W;
PlayerData.Heading = CurrentVehicle.Heading;
PlayerData.Speed = CurrentVehicle.Speed;
}
else
{
Vector3 PlayerVel = Game.LocalPlayer.Character.Velocity;
PlayerData.Pos_X = PlayerPos.X;
PlayerData.Pos_Y = PlayerPos.Y;
PlayerData.Pos_Z = PlayerPos.Z;
PlayerData.Vel_X = PlayerVel.X;
PlayerData.Vel_Y = PlayerVel.Y;
PlayerData.Vel_Z = PlayerVel.Z;
PlayerData.Heading = PlayerHeading;
PlayerData.IsWalking = Game.isGameKeyPressed(GameKey.MoveBackward) ||
Game.isGameKeyPressed(GameKey.MoveForward) ||
Game.isGameKeyPressed(GameKey.MoveLeft) ||
Game.isGameKeyPressed(GameKey.MoveRight);
PlayerData.IsRunning = Game.isGameKeyPressed(GameKey.Sprint);
PlayerData.IsJumping = Game.isGameKeyPressed(GameKey.Jump);
PlayerData.IsCrouching = GTA.Native.Function.Call <bool>("IS_CHAR_DUCKING", Game.LocalPlayer.Character);
}
OutMsg.Write((int)NetworkMessageType.UpdatePlayer);
OutMsg.WriteAllFields(PlayerData);
NetClient.SendMessage(OutMsg, NetDeliveryMethod.UnreliableSequenced);
}
}
// TODO: better and cleaner/more readable tests
public static void Run(NetPeer peer)
{
NetOutgoingMessage msg = peer.CreateMessage();
msg.Write(false);
msg.Write(-3, 6);
msg.Write(42);
msg.Write("duke of earl");
msg.Write((byte)43);
msg.Write((ushort)44);
msg.Write(ulong.MaxValue, 64);
msg.Write(true);
msg.WritePadBits();
int bcnt = 0;
msg.Write(567845.0f);
msg.WriteVar(2115998022);
msg.Write(46.0);
msg.Write((ushort)14, 9);
bcnt += msg.WriteVar(-47);
msg.WriteVar(470000);
msg.WriteVar((uint)48);
bcnt += msg.WriteVar((long)-49);
if (bcnt != 2)
{
throw new LidgrenException("WriteVar* wrote too many bytes!");
}
NetIncomingMessage inc = Program.CreateIncomingMessage(msg.GetBuffer(), msg.BitLength);
var bdr = new StringBuilder();
char space = ' ';
bdr.Append(inc.ReadBool()).Append(space);
bdr.Append(inc.ReadInt32(6)).Append(space);
bdr.Append(inc.ReadInt32()).Append(space);
if (!inc.ReadString(out string strResult))
{
throw new LidgrenException("Read/write failure");
}
bdr.Append(strResult).Append(space);
bdr.Append(inc.ReadByte()).Append(space);
if (inc.PeekUInt16() != 44)
{
throw new LidgrenException("Read/write failure");
}
bdr.Append(inc.ReadUInt16()).Append(space);
var pp = inc.PeekUInt64(64);
if (pp != ulong.MaxValue)
{
throw new LidgrenException("Read/write failure");
}
bdr.Append(inc.ReadUInt64()).Append(space);
bdr.Append(inc.ReadBool()).Append(space);
inc.SkipPadBits();
bdr.Append(inc.ReadSingle()).Append(space);
bdr.Append(inc.ReadVarInt32()).Append(space);
bdr.Append(inc.ReadDouble()).Append(space);
bdr.Append(inc.ReadUInt32(9)).Append(space);
bdr.Append(inc.ReadVarInt32()).Append(space);
bdr.Append(inc.ReadVarInt32()).Append(space);
bdr.Append(inc.ReadVarUInt32()).Append(space);
bdr.Append(inc.ReadVarInt64()).Append(space);
var bdrr = bdr.ToString();
if (bdrr.Equals("False -3 42 duke of earl 43 44 18446744073709551615 True 567845 2115998022 46 14 -47 470000 48 -49 "))
{
Console.WriteLine("Read/write tests OK");
}
else
{
throw new LidgrenException($"Read/write tests FAILED! ({bdrr})");
}
msg = peer.CreateMessage();
NetOutgoingMessage tmp = peer.CreateMessage();
tmp.Write(42, 14);
tmp.BitPosition = 0;
msg.Write(tmp);
msg.Write(tmp);
if (msg.BitLength != tmp.BitLength * 2)
{
throw new LidgrenException("NetOutgoingMessage.Write(NetOutgoingMessage) failed!");
}
tmp = peer.CreateMessage();
var test = new Test();
test.Number = 42;
test.Name = "Hallon";
test.Age = 8.2f;
tmp.WriteAllFields(test, BindingFlags.Public | BindingFlags.Instance);
inc = Program.CreateIncomingMessage(tmp.GetBuffer(), tmp.BitLength);
var readTest = new Test();
inc.ReadAllFields(readTest, BindingFlags.Public | BindingFlags.Instance);
LidgrenException.Assert(readTest.Number == 42);
LidgrenException.Assert(readTest.Name == "Hallon");
LidgrenException.Assert(readTest.Age == 8.2f);
// test aligned WriteBytes/ReadBytes
msg = peer.CreateMessage();
var originalData = new byte[] { 5, 6, 7, 8, 9 };
msg.Write(originalData);
inc = Program.CreateIncomingMessage(msg.GetBuffer(), msg.BitLength);
var readData = new byte[originalData.Length];
inc.Read(readData);
if (!readData.AsSpan().SequenceEqual(originalData))
{
throw new Exception("Read fail");
}
}
public static void Run(NetPeer peer)
{
NetOutgoingMessage msg = peer.CreateMessage();
msg.Write(false);
msg.Write(-3, 6);
msg.Write(42);
msg.Write("duke of earl");
msg.Write((byte)43);
msg.Write((ushort)44);
msg.Write(true);
msg.WritePadBits();
int bcnt = 0;
msg.Write(45.0f);
msg.Write(46.0);
bcnt += msg.WriteVariableInt32(-47);
msg.WriteVariableInt32(470000);
msg.WriteVariableUInt32(48);
bcnt += msg.WriteVariableInt64(-49);
if (bcnt != 2)
{
throw new NetException("WriteVariable* wrote too many bytes!");
}
byte[] data = msg.PeekDataBuffer();
NetIncomingMessage inc = Program.CreateIncomingMessage(data, msg.LengthBits);
StringBuilder bdr = new StringBuilder();
bdr.Append(inc.ReadBoolean());
bdr.Append(inc.ReadInt32(6));
bdr.Append(inc.ReadInt32());
bdr.Append(inc.ReadString());
bdr.Append(inc.ReadByte());
if (inc.PeekUInt16() != (ushort)44)
{
throw new NetException("Read/write failure");
}
bdr.Append(inc.ReadUInt16());
bdr.Append(inc.ReadBoolean());
inc.SkipPadBits();
bdr.Append(inc.ReadSingle());
bdr.Append(inc.ReadDouble());
bdr.Append(inc.ReadVariableInt32());
bdr.Append(inc.ReadVariableInt32());
bdr.Append(inc.ReadVariableUInt32());
bdr.Append(inc.ReadVariableInt64());
if (bdr.ToString().Equals("False-342duke of earl4344True4546-4747000048-49"))
{
Console.WriteLine("Read/write tests OK");
}
else
{
throw new NetException("Read/write tests FAILED!");
}
msg = peer.CreateMessage();
NetOutgoingMessage tmp = peer.CreateMessage();
tmp.Write((int)42, 14);
msg.Write(tmp);
msg.Write(tmp);
if (msg.LengthBits != tmp.LengthBits * 2)
{
throw new NetException("NetOutgoingMessage.Write(NetOutgoingMessage) failed!");
}
tmp = peer.CreateMessage();
Test test = new Test();
test.Number = 42;
test.Name = "Hallon";
test.Age = 8.2f;
tmp.WriteAllFields(test, BindingFlags.Public | BindingFlags.Instance);
data = tmp.PeekDataBuffer();
inc = Program.CreateIncomingMessage(data, tmp.LengthBits);
Test readTest = new Test();
inc.ReadAllFields(readTest, BindingFlags.Public | BindingFlags.Instance);
NetException.Assert(readTest.Number == 42);
NetException.Assert(readTest.Name == "Hallon");
NetException.Assert(readTest.Age == 8.2f);
// test aligned WriteBytes/ReadBytes
msg = peer.CreateMessage();
byte[] tmparr = new byte[] { 5, 6, 7, 8, 9 };
msg.Write(tmparr);
inc = Program.CreateIncomingMessage(msg.PeekDataBuffer(), msg.LengthBits);
byte[] result = inc.ReadBytes(tmparr.Length);
for (int i = 0; i < tmparr.Length; i++)
{
if (tmparr[i] != result[i])
{
throw new Exception("readbytes fail");
}
}
}
static void Main(string[] args)
{
IPEndPoint masterServerEndpoint = NetUtility.Resolve(CommonConstants.MasterServerAddress, CommonConstants.MasterServerPort);
NetPeerConfiguration config = new NetPeerConfiguration("GameServer");
config.MaximumConnections = 4;
config.EnableMessageType(NetIncomingMessageType.UnconnectedData);
serverData = new ServerData();
serverData.serverPort = 14242;
config.Port = 14242;
if (args.Length >= 1)
{
int port;
if (Int32.TryParse(args[0], out port))
{
serverData.serverPort = port;
config.Port = port;
}
}
serverData.serverName = "CarGoServer";
if (args.Length >= 2)
{
serverData.serverName = args[1];
}
if (args.Length >= 3)
{
if (args[2] == "true")
{
registerOnline = true;
}
else
{
registerOnline = false;
}
}
serverData.publicAddress = GetIPAddress();
serverData.showInServerList = registerOnline;
s_server = new NetServer(config);
s_server.Start();
s_server.RegisterReceivedCallback(new SendOrPostCallback(CheckForMessages), new SynchronizationContext());
clients = new Dictionary <int, NetConnection>();
clientNames = new Dictionary <int, string>();
Console.WriteLine("Server started on Port " + config.Port);
serverData.uniqueID = s_server.UniqueIdentifier;
var lastRegistered = -60.0f;
while ((Console.KeyAvailable == false || Console.ReadKey().Key != ConsoleKey.Escape) && !gameRunning)
{
// (re-)register periodically with master server
if (NetTime.Now > lastRegistered + 60)
{
// register with master server
NetOutgoingMessage regMsg = s_server.CreateMessage();
regMsg.Write((byte)CarGo.Network.MasterServerMessageType.RegisterHost);
IPAddress mask;
serverData.localAddress = NetUtility.GetMyAddress(out mask).ToString();
regMsg.Write(s_server.UniqueIdentifier);
regMsg.WriteAllFields(serverData);
//regMsg.Write(new IPEndPoint(adr, 14242));
Console.WriteLine("Sending registration to master server");
s_server.SendUnconnectedMessage(regMsg, masterServerEndpoint);
lastRegistered = (float)NetTime.Now;
}
}
}
public virtual bool Pack(NetOutgoingMessage buffer)
{
// by default we serialize
buffer.WriteAllFields(this, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
return(true);
}
