public static NetMsg Create(NetMsgType msgType)
{
var msgEvent = new NetMsg();
msgEvent.MsgType = msgType;
return(msgEvent);
}
public static NetMsg Create(NetMsgType msgType, byte[] msg)
{
var msgEvent = new NetMsg();
msgEvent.MsgType = msgType;
msgEvent.Data = msg;
return(msgEvent);
}
public static NetMsg Create(NetMsgType msgType, string msg)
{
var msgEvent = new NetMsg();
msgEvent.MsgType = msgType;
if (!string.IsNullOrEmpty(msg))
{
msgEvent.Data = Encoding.UTF8.GetBytes(msg);
}
return(msgEvent);
}
private void CallRespEvent(NetMsgType msgType, byte[] data)
{
if (_onNetRespEvent != null)
{
var msgEvent = new NetMsg
{
MsgType = msgType,
Data = data
};
_onNetRespEvent(msgEvent);
}
}
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);
}
}
}
public NetMsg send_msg(NetMsgType _type,NetMsgDel _del)
{
NetMsg _nm=new NetMsg();
switch(_type){
case NetMsgType.LOGIN:
default:
_nm.sub_url="login";
break;
case NetMsgType.ENTER_SERVER:
_nm.sub_url="enter";
break;
case NetMsgType.SAVE_SHIP_DATA:
_nm.sub_url="save_ship_data";
break;
case NetMsgType.GET_SHIP_DATA:
_nm.sub_url="get_ship_data";
break;
}
_nm.msg_type=_type;
_nm.m_del=_del;
m_waitl_que.Enqueue(_nm);
return _nm;
}
object net_object_parse(string _msg,NetMsgType _msg_type)
{
switch(_msg_type){
default:
return NbaLitJson.JsonMapper.ToObject<NetMsgBase>(_msg);
case NetMsgType.LOGIN:
return NbaLitJson.JsonMapper.ToObject<NmLoginResult>(_msg);
case NetMsgType.ENTER_SERVER:
return NbaLitJson.JsonMapper.ToObject<NmEnterServerResult>(_msg);
case NetMsgType.GET_SHIP_DATA:
return NbaLitJson.JsonMapper.ToObject<NmGetShipResult>(_msg);
}
}
public override void HandleData(NetIncomingMessage msg)
{
NetEntityType Type;
ushort ID;
Vector3 Position;
Vector3 Velocity;
Quaternion Orientation;
NetMsgType datatype = (NetMsgType)msg.ReadByte();
switch (datatype)
{
case NetMsgType.Chat:
Console.WriteLine(msg.ReadString());
break;
case NetMsgType.CreateOnClient:
#region CreateOnClient
Type = (NetEntityType)msg.ReadByte();
ID = msg.ReadUInt16();
Position = new Vector3(msg.ReadFloat(), msg.ReadFloat(), msg.ReadFloat());
Orientation = new Quaternion(msg.ReadFloat(), msg.ReadFloat(), msg.ReadFloat(), msg.ReadFloat());
ushort Resource;
long OwnerID;
//DEBUG
if (Type == NetEntityType.Ship)
{
int[] shipWeapons = null;
var shipNose = msg.ReadInt32();
var shipCore = msg.ReadInt32();
var shipTail = msg.ReadInt32();
int weaponLength = msg.ReadInt32();
if (weaponLength > 0)
{
shipWeapons = new int[weaponLength];
for (int i = 0; i < weaponLength; i++)
{
shipWeapons[i] = msg.ReadInt32();
}
}
Resource = 0;
OwnerID = msg.ReadInt64();
var shipData = new ShipData(shipNose, shipCore, shipTail);
WeaponsFromData(shipData, shipWeapons);
var ship = new ShipObj(MobileFortressClient.Game, Position, Orientation, shipData);
ship.ID = ID;
if (OwnerID == Network.Client.UniqueIdentifier)
{
Network.JoinedGame = true;
Camera.Setup(MobileFortressClient.Game, ship, new Vector3(0, 2f, 6f));
var HUD = new ShipHUD();
if (shipWeapons != null)
{
for (int i = 0; i < shipWeapons.Length; i++)
{
HUD.MakeAmmoIndicator(shipWeapons[i]);
}
}
MenuManager.Menu = HUD;
}
}
else
{
Resource = msg.ReadUInt16();
if (Type == NetEntityType.Building)
{
new Building(Position, Resource);
}
else if (Type == NetEntityType.Missile)
{
var obj = new Rocket(MobileFortressClient.Game, Resource, Position, Orientation);
obj.ID = ID;
}
else
{
var obj = new PhysicsObj(MobileFortressClient.Game, Position, Orientation, Resource);
obj.ID = ID;
}
}
#endregion
break;
case NetMsgType.MapLoading:
#region MapLoading
if (msg.ReadByte() == 0)
{
var Seed = msg.ReadInt32();
var Power = msg.ReadInt32();
var Roughness = msg.ReadFloat();
Sector.Redria.Terrain.Terrain = new Heightmap(Seed, Power, Roughness);
}
else
{
var terrain = Sector.Redria.Terrain.Terrain;
int alterations = msg.ReadInt32();
Console.WriteLine(alterations + " Recieved Alterations.");
for (int i = 0; i < alterations; i++)
{
Rectangle flattenedArea = new Rectangle(msg.ReadInt32(),
msg.ReadInt32(), msg.ReadInt32(), msg.ReadInt32());
terrain.FlattenArea(flattenedArea);
}
terrain.Graphics.ResetVertexBuffer();
}
#endregion
break;
case NetMsgType.EntityUpdate:
#region EntityUpdate
Type = (NetEntityType)msg.ReadByte();
ID = msg.ReadUInt16();
Position = new Vector3(msg.ReadFloat(), msg.ReadFloat(), msg.ReadFloat());
Velocity = new Vector3(msg.ReadFloat(), msg.ReadFloat(), msg.ReadFloat());
Orientation = new Quaternion(msg.ReadFloat(), msg.ReadFloat(), msg.ReadFloat(), msg.ReadFloat());
if (Type == NetEntityType.Ship)
{
var ship = Sector.Redria.Ships.Retrieve(ID);
if (ship == null)
{
Console.WriteLine("No such ship ID: " + ID);
break;
}
ship.UpdateFromNet(Position, Orientation, Velocity);
}
else if (Type == NetEntityType.Missile)
{
var missile = Sector.Redria.Objects.Retrieve(ID);
if (missile == null)
{
break;
}
missile.UpdateFromNet(Position, Orientation, Velocity);
}
#endregion
break;
case NetMsgType.Bullet:
#region Bullet
ID = msg.ReadUInt16();
Position = new Vector3(msg.ReadFloat(), msg.ReadFloat(), msg.ReadFloat());
Velocity = new Vector3(msg.ReadFloat(), msg.ReadFloat(), msg.ReadFloat());
Orientation = new Quaternion(msg.ReadFloat(), msg.ReadFloat(), msg.ReadFloat(), msg.ReadFloat());
var Projectile = ProjectileData.ProjectileTable[ID];
var ping = Network.Client.ServerConnection.AverageRoundtripTime;
Projectile.Create(Position + Velocity * (ping / 2), Orientation, Velocity);
var Audio = new AudioEmitter();
Audio.Position = Position / Resources.AudioPositionQuotient;
Audio.Forward = Vector3.Transform(Vector3.Forward, Orientation);
Audio.Up = Vector3.Up;
Audio.Velocity = Velocity;
var sound = Resources.Sounds.WeaponSounds[ID].CreateInstance();
sound.Apply3D(Camera.Audio, Audio);
sound.Play();
#endregion
break;
case NetMsgType.ShipExplode:
#region ShipExplode
ID = msg.ReadUInt16();
var deadship = Sector.Redria.Ships.Retrieve(ID);
deadship.Explode();
#endregion
break;
case NetMsgType.Explosion:
#region Explosion
ID = msg.ReadUInt16();
var Radius = msg.ReadFloat();
var exploding = Sector.Redria.Objects.Retrieve(ID);
if (exploding != null)
{
new Explosion(exploding.Position, Radius);
exploding.Destroy();
}
#endregion
break;
case NetMsgType.Lockon:
#region Lockon
if (!(MenuManager.Menu is ShipHUD))
{
break;
}
ID = msg.ReadUInt16();
var LockonStatus = (LockonStatus)msg.ReadByte();
ShipHUD Menu = (ShipHUD)MenuManager.Menu;
if (LockonStatus > LockonStatus.Locked)
{
if (LockonStatus == LockonStatus.EnemyLock)
{
Menu.enemyLock = true;
}
else if (LockonStatus == LockonStatus.EnemyMissile)
{
Menu.enemyLock = false;
Menu.enemyMissile = true;
}
else
{
Menu.enemyMissile = false;
Menu.enemyLock = false;
}
}
else
{
if (ID == ushort.MaxValue)
{
Menu.Target = null;
Menu.LockStatus = LockonStatus.NotLocked;
}
else
{
Menu.Target = Sector.Redria.Ships.Retrieve(ID);
Menu.LockStatus = LockonStatus;
if (Menu.LockStatus == LockonStatus.Locking)
{
Resources.Sounds.LockingOn.Play();
}
else if (Menu.LockStatus == LockonStatus.Locked)
{
Resources.Sounds.LockedOn.Play();
}
}
}
#endregion
break;
case NetMsgType.ShipUpdate:
#region ShipUpdate
var Health = msg.ReadFloat();
var Throttle = msg.ReadFloat();
var AmmoCount = msg.ReadByte();
var Ammo = new ushort[AmmoCount];
for (byte i = 0; i < AmmoCount; i++)
{
Ammo[i] = msg.ReadUInt16();
}
if (MenuManager.Menu is ShipHUD)
{
var HUD = (ShipHUD)MenuManager.Menu;
HUD.SetHealth((int)Health);
for (int i = 0; i < Ammo.Length; i++)
{
HUD.SetAmmo(i, Ammo[i]);
}
ping = msg.SenderConnection.AverageRoundtripTime * 1000;
HUD.SetPing(ping);
var ship = (ShipObj)Camera.Target;
ship.SetThrottle(Throttle);
}
#endregion
break;
default:
Console.WriteLine("Unhandled NetMsgType: " + datatype);
break;
}
}
private static Type GetClassFromNetMsgType(NetMsgType type)
{
switch (type)
{
//FXServer
case NetMsgType.Currency:
return typeof(CurrencyMsg);
//FateAndGW
case NetMsgType.Stock:
return typeof(StockMsg);
case NetMsgType.Commodity:
return typeof(CommodityMsg);
case NetMsgType.Surplus:
case NetMsgType.Shortage:
return typeof(ForecastMsg);
//trader
case NetMsgType.Buy:
return typeof(BuyMsg);
case NetMsgType.LocalSale:
return typeof(LocalSaleMsg);
case NetMsgType.Future:
return typeof(FutureMsg);
case NetMsgType.AdvertiseMove:
case NetMsgType.ConfirmMove:
return typeof(MoveContractMsg);
//shippingcompany
case NetMsgType.Departure:
case NetMsgType.Arrival:
return typeof(MovingMsg);
case NetMsgType.AcceptMove:
return typeof(MoveContractMsg);
//bank
case NetMsgType.BuyConfirm:
case NetMsgType.FutureSettle:
return typeof(BankConfirmMsg);
//shared
case NetMsgType.DebugTimer:
return typeof(DebugTimerMsg);
default:
throw new TaiPanException("GetClassFromNetMsgType received unknown type");
}
}
private static object DeserializeData(NetMsgType type, string data)
{
Type classType = GetClassFromNetMsgType(type);
object ret = System.Activator.CreateInstance(classType);
TextReader tw = new StringReader(data);
try
{
XmlSerializer sr = new XmlSerializer(classType);
ret = sr.Deserialize(tw);
}
catch (SerializationException e)
{
throw new Exception("Failed to deserialize. Reason: " + e.Message);
}
finally
{
tw.Close();
}
return ret;
}
public static string Serialize(NetMsgType type, object obj)
{
Type classType = GetClassFromNetMsgType(type);
TextWriter tw = new StringWriter();
XmlSerializer sr = new XmlSerializer(classType);
string cereal = "";
try
{
sr.Serialize(tw, obj);
cereal = tw.ToString();
}
catch (SerializationException e)
{
throw new Exception("Failed to serialize. Reason: " + e.Message);
}
finally
{
tw.Close();
}
//Add message type to front of string, padded to two figures, and a :: end of message delimiter
return String.Format("{0,2}{1}::", (int)type, cereal);
}
public static void Deserialize(string str, out NetMsgType type, out object data)
{
type = NetContract.GetNetMsgTypeFromStr(str);
data = NetContract.DeserializeData(type, str.Substring(2));
}
public DeserializedMsg(NetMsgType type, object data)
{
this.type = type;
this.data = data;
}
