simtactics/mysimulation
1
0
Fork 0
mirror of https://github.com/simtactics/mysimulation.git synced 2025-07-04 21:50:35 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Removed NioTSO client and server

Browse source 
- NioTSO client isn't needed because we're using RayLib
- Added FreeSO's API server to handle most backend operations
This commit is contained in:
Tony Bark 2024-05-01 02:55:43 -04:00
parent f12ba1502b
commit 22191ce648
591 changed files with 53264 additions and 3362 deletions
Download patch file Download diff file Expand all files Collapse all files

33
server/FSO.Server.Protocol/Voltron/AbstractVoltronPacket.cs Executable file
View file

@ -0,0 +1,33 @@
using FSO.Common.Serialization;
using FSO.Server.Protocol.Voltron.Model;
using Mina.Core.Buffer;
namespace FSO.Server.Protocol.Voltron
{
public abstract class AbstractVoltronPacket : IVoltronPacket
{
public static Sender GetSender(IoBuffer buffer)
{
var ariesID = buffer.GetPascalString();
var masterID = buffer.GetPascalString();
return new Sender { AriesID = ariesID, MasterAccountID = masterID };
}
public static void PutSender(IoBuffer buffer, Sender sender)
{
buffer.PutPascalString(sender.AriesID);
buffer.PutPascalString(sender.MasterAccountID);
}
public static IoBuffer Allocate(int size)
{
IoBuffer buffer = IoBuffer.Allocate(size);
buffer.Order = ByteOrder.BigEndian;
return buffer;
}
public abstract VoltronPacketType GetPacketType();
public abstract void Serialize(IoBuffer output, ISerializationContext context);
public abstract void Deserialize(IoBuffer input, ISerializationContext context);
}
}

20
server/FSO.Server.Protocol/Voltron/DataService/Avatar.cs Executable file
View file

@ -0,0 +1,20 @@
namespace FSO.Server.Protocol.Voltron.DataService
{
public class Avatar
{
public bool Avatar_IsFounder { get; set; }
public string Avatar_Name { get; set; }
public string Avatar_Description { get; set; }
public bool Avatar_IsParentalControlLocked { get; set; }
/*public bool Avatar_IsOnline { get; set; }
public uint Avatar_LotGridXY { get; set; }
public uint Avatar_Age { get; set; }
public ushort Avatar_SkillsLockPoints { get; set; }
public AvatarAppearance Avatar_Appearance { get; set; }
public AvatarSkills Avatar_Skills { get; set; }
public List<Bookmark> Avatar_BookmarksVec { get; set; }*/
}
}

9
server/FSO.Server.Protocol/Voltron/DataService/AvatarAppearance.cs Executable file
View file

@ -0,0 +1,9 @@
namespace FSO.Server.Protocol.Voltron.DataService
{
public class AvatarAppearance
{
public ulong AvatarAppearance_BodyOutfitID { get; set; }
public byte AvatarAppearance_SkinTone { get; set; }
public ulong AvatarAppearance_HeadOutfitID { get; set; }
}
}

18
server/FSO.Server.Protocol/Voltron/DataService/AvatarSkills.cs Executable file
View file

@ -0,0 +1,18 @@
namespace FSO.Server.Protocol.Voltron.DataService
{
public class AvatarSkills
{
public ushort AvatarSkills_Logic { get; set; }
public ushort AvatarSkills_LockLv_Logic { get; set; }
public ushort AvatarSkills_Body { get; set; }
public ushort AvatarSkills_LockLv_Body { get; set; }
public ushort AvatarSkills_LockLv_Mechanical { get; set; }
public ushort AvatarSkills_LockLv_Creativity { get; set; }
public ushort AvatarSkills_LockLv_Cooking { get; set; }
public ushort AvatarSkills_Cooking { get; set; }
public ushort AvatarSkills_Charisma { get; set; }
public ushort AvatarSkills_LockLv_Charisma { get; set; }
public ushort AvatarSkills_Mechanical { get; set; }
public ushort AvatarSkills_Creativity { get; set; }
}
}

13
server/FSO.Server.Protocol/Voltron/DataService/Bookmark.cs Executable file
View file

@ -0,0 +1,13 @@
namespace FSO.Server.Protocol.Voltron.DataService
{
public class Bookmark
{
public uint Bookmark_TargetID { get; set; }
public BookmarkType Bookmark_Type { get; set; }
}
public enum BookmarkType : byte
{
BOOKMARK = 0x01
}
}

6
server/FSO.Server.Protocol/Voltron/DataService/Location.cs Executable file
View file

@ -0,0 +1,6 @@
namespace FSO.Server.Protocol.Voltron.DataService
{
public class Location
{
}
}

7
server/FSO.Server.Protocol/Voltron/DataService/Lot.cs Executable file
View file

@ -0,0 +1,7 @@
namespace FSO.Server.Protocol.Voltron.DataService
{
public class Lot
{
}
}

41
server/FSO.Server.Protocol/Voltron/DataService/cITSOProperty.cs Executable file
View file

@ -0,0 +1,41 @@
using System.Collections.Generic;
using Mina.Core.Buffer;
using FSO.Common.Serialization;
namespace FSO.Server.Protocol.Voltron.DataService
{
public class cITSOProperty : IoBufferSerializable
{
public uint StructType;
public List<cITSOField> StructFields;
/**cTSOValue<class cRZAutoRefCount<class cITSOProperty> > body:
* dword Body clsid (iid=896E3E90 or "GZIID_cITSOProperty"; clsid should be 0x89739A79 for cTSOProperty)
* dword Body
* dword Struct type (e.g. 0x3B0430BF for AvatarAppearance)
* dword Field count
* Fields - for each field:
* dword Field name (e.g. 0x1D530275 for AvatarAppearance_BodyOutfitID)
* dword cTSOValue clsid
* cTSOValue body**/
public void Serialize(IoBuffer output, ISerializationContext context)
{
output.PutUInt32(0x89739A79);
output.PutUInt32(StructType);
output.PutUInt32((uint)StructFields.Count);
foreach(var item in StructFields){
output.PutUInt32(item.ID);
output.PutUInt32(item.Value.Type);
output.PutSerializable(item.Value.Value, context);
}
}
}
public class cITSOField
{
public uint ID;
public cTSOValue Value;
}
}

398
server/FSO.Server.Protocol/Voltron/DataService/cTSOSerializer.cs Executable file
View file

@ -0,0 +1,398 @@
using FSO.Common.Serialization;
using FSO.Files.Formats.tsodata;
using Mina.Core.Buffer;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
namespace FSO.Server.Protocol.Voltron.DataService
{
/// <summary>
/// TODO: Rewrite this to have much tighter performance
/// </summary>
public class cTSOSerializer
{
//private static Logger LOG = LogManager.GetCurrentClassLogger();
public static cTSOSerializer INSTANCE = null;
public static cTSOSerializer Get(){
return INSTANCE;
}
public const uint cTSOValue_bool = 0x696D1183;
public const uint cTSOValue_uint8 = 0xC976087C;
public const uint cTSOValue_uint16 = 0xE9760891;
public const uint cTSOValue_uint32 = 0x696D1189;
public const uint cTSOValue_uint64 = 0x69D3E3DB;
public const uint cTSOValue_sint8 = 0xE976088A;
public const uint cTSOValue_sint16 = 0xE9760897;
public const uint cTSOValue_sint32 = 0x896D1196;
public const uint cTSOValue_sint64 = 0x89D3E3EF;
public const uint cTSOValue_string = 0x896D1688;
public const uint cTSOValue_property = 0xA96E7E5B;
private TSODataDefinition Format;
private Dictionary<uint, Type> ClassesById = new Dictionary<uint, Type>();
private Dictionary<Type, uint> IdByClass = new Dictionary<Type, uint>();
private Dictionary<uint, Type> cNetMessageParametersById = new Dictionary<uint, Type>();
public cTSOSerializer(TSODataDefinition data){
INSTANCE = this;
this.Format = data;
//Scan for classes with decorations
var assembly = Assembly.GetAssembly(typeof(cTSOSerializer));
foreach (Type type in assembly.GetTypes())
{
System.Attribute[] attributes = System.Attribute.GetCustomAttributes(type);
foreach (Attribute attribute in attributes)
{
if (attribute is clsid){
ClassesById.Add(((clsid)attribute).Value, type);
IdByClass.Add(type, ((clsid)attribute).Value);
}else if(attribute is cTSONetMessageParameter)
{
var param = (cTSONetMessageParameter)attribute;
object paramValue = param.Value;
/*if(paramValue is DBRequestType){
paramValue = ((DBRequestType)paramValue).GetRequestID();
}else if(paramValue is DBResponseType)
{
paramValue = ((DBResponseType)paramValue).GetResponseID();
}*/
cNetMessageParametersById.Add((uint)paramValue, type);
}
}
}
}
public object Deserialize(uint clsid, IoBuffer buffer)
{
if (cNetMessageParametersById.ContainsKey(clsid))
{
var instance = (IoBufferDeserializable)Activator.CreateInstance(cNetMessageParametersById[clsid]);
//instance.Deserialize(buffer);
return instance;
}
else if (ClassesById.ContainsKey(clsid))
{
var instance = (IoBufferDeserializable)Activator.CreateInstance(ClassesById[clsid]);
//instance.Deserialize(buffer);
return instance;
}
else if(clsid == cTSOValue_string)
{
return buffer.GetPascalVLCString();
}
return null;
}
public object Serialize(object obj)
{
if(obj is IoBufferSerializable)
{
return (IoBufferSerializable)obj;
}
return GetValue(obj).Value;
}
public cTSOValue GetValue(object obj){
var type = obj.GetType();
if (IdByClass.ContainsKey(type))
{
uint clsid = IdByClass[type];
return new cTSOValue() { Type = clsid, Value = obj };
}
throw new Exception("Unknown class " + type);
}
public DerivedStruct GetDerivedStruct(uint id)
{
return Format.DerivedStructs.FirstOrDefault(x => x.ID == id);
}
public DerivedStruct GetDerivedStruct(string name)
{
return Format.DerivedStructs.FirstOrDefault(x => x.Name == name);
}
/*public List<DataServiceWrapperPDU> SerializeDerivedUpdate(uint avatarId, string derivedTypeName, uint structId, object instance)
{
var type = GetDerivedStruct(derivedTypeName);
var fields = SerializeDerived(derivedTypeName, structId, instance);
var result = new List<DataServiceWrapperPDU>();
foreach(var update in fields){
result.Add(new DataServiceWrapperPDU() {
SendingAvatarID = avatarId,
RequestTypeID = 0x3998426C,
Body = update
});
}
return result;
}*/
/*
public List<cTSOTopicUpdateMessage> SerializeDerived(string derivedTypeName, uint structId, object instance)
{
return SerializeDerived(GetDerivedStruct(derivedTypeName).ID, structId, instance);
}
public List<cTSOTopicUpdateMessage> SerializeDerived(uint derivedType, uint structId, object instance){
var result = new List<cTSOTopicUpdateMessage>();
var type = Format.DerivedStructs.First(x => x.ID == derivedType);
var parent = Format.Structs.First(x => x.ID == type.Parent);
foreach(var field in parent.Fields){
var mask = type.FieldMasks.FirstOrDefault(x => x.ID == field.ID);
var action = DerivedStructFieldMaskType.KEEP;
if (mask != null){
action = mask.Type;
}
if(action == DerivedStructFieldMaskType.REMOVE){
continue;
}
object value = GetFieldValue(instance, field.Name);
if (value == null) { continue; }
try {
var serialized = SerializeField(field, value);
serialized.StructType = parent.ID;
serialized.StructId = structId;
result.Add(serialized);
}catch(Exception ex)
{
LOG.Error(ex);
}
}
return result;
}*/
private object GetFieldValue(object obj, string fieldName)
{
var objectField = obj.GetType().GetProperty(fieldName);
if (objectField == null) { return null; }
var value = objectField.GetValue(obj);
return value;
}
/*private cTSOTopicUpdateMessage SerializeField(StructField field, object value){
cTSOTopicUpdateMessage result = new cTSOTopicUpdateMessage();
result.StructField = field.ID;
if(field.Classification == StructFieldClassification.List)
{
IoBuffer resultBytes = AbstractVoltronPacket.Allocate(4);
resultBytes.AutoExpand = true;
var serializedValues = new List<cTSOValue>();
System.Collections.ICollection list = (System.Collections.ICollection)value;
foreach (var item in list){
serializedValues.Add(SerializeValue(field.TypeID, item));
}
var itemType = serializedValues.First().Type;
var vectorType = GetVectorClsId(itemType);
resultBytes.PutUInt32((uint)serializedValues.Count);
foreach (var serializedValue in serializedValues){
//resultBytes.PutSerializable(serializedValue.Value);
}
resultBytes.Flip();
/*result.cTSOValue = new cTSOValue {
Type = 0xA97384A3,//field.TypeID,
Value = resultBytes
};
}else if(field.Classification == StructFieldClassification.SingleField)
{
var serializedValue = SerializeValue(field.TypeID, value);
//result.cTSOValue = serializedValue;
}
return result;
}*/
private uint GetVectorClsId(uint clsid)
{
switch (clsid)
{
//cTSOValue < unsigned long>
case 0x696D1189:
//cTSOValueVector < unsigned long>
return 0x89738496;
//cTSOValue < long >
case 0x896D1196:
//cTSOValueVector < long >
return 0x8973849A;
//cTSOValue < unsigned short>
case 0xE9760891:
//cTSOValueVector < unsigned short>
return 0x097608B3;
//cTSOValue < short >
case 0xE9760897:
//cTSOValueVector < short >
return 0x097608B6;
//cTSOValue<class cRZAutoRefCount<class cITSOProperty> >
case 0xA96E7E5B:
//cTSOValueVector<class cRZAutoRefCount<class cITSOProperty> >
return 0xA97384A3;
//cTSOValue <class cRZAutoRefCount<class cIGZString> >
default:
throw new Exception("Cannot map clsid to vector clsid, " + clsid);
}
}
private cTSOValue SerializeValue(uint type, object value)
{
var result = new cTSOValue();
IoBuffer buffer = null;
switch (type)
{
case 0x48BC841E:
if (!(value is sbyte) && !(value is Enum))
{
return null;
}
result.Type = cTSOValue_sint8;
result.Value = new sbyte[] { Convert.ToSByte(value) };
break;
case 0x74336731:
if (!(value is ushort))
{
return null;
}
buffer = AbstractVoltronPacket.Allocate(2);
buffer.PutUInt16((ushort)value);
buffer.Flip();
result.Type = cTSOValue_uint16;
result.Value = buffer;
break;
case 0xF192ECA6:
if (!(value is short))
{
return null;
}
buffer = AbstractVoltronPacket.Allocate(2);
buffer.PutInt16((short)value);
buffer.Flip();
result.Type = cTSOValue_sint16;
result.Value = buffer;
break;
case 0xE0463A2F:
if (!(value is uint))
{
return null;
}
buffer = AbstractVoltronPacket.Allocate(4);
buffer.PutUInt32((uint)value);
buffer.Flip();
result.Type = cTSOValue_uint32;
result.Value = buffer;
break;
case 0xA0587098:
if (!(value is int))
{
return null;
}
buffer = AbstractVoltronPacket.Allocate(4);
buffer.PutInt32((int)value);
buffer.Flip();
result.Type = cTSOValue_sint32;
result.Value = buffer;
break;
case 0x385070C9:
if (!(value is ulong))
{
return null;
}
buffer = AbstractVoltronPacket.Allocate(8);
buffer.PutUInt64((ulong)value);
buffer.Flip();
result.Type = cTSOValue_uint64;
result.Value = buffer;
break;
case 0x90D315F7:
if (!(value is long))
{
return null;
}
buffer = AbstractVoltronPacket.Allocate(8);
buffer.PutInt64((long)value);
buffer.Flip();
result.Type = cTSOValue_sint64;
result.Value = buffer;
break;
default:
//It may be a struct
var _struct = Format.Structs.FirstOrDefault(x => x.ID == type);
if (_struct != null)
{
var body = new cITSOProperty();
body.StructType = _struct.ID;
body.StructFields = new List<cITSOField>();
foreach(var field in _struct.Fields){
object fieldValue = GetFieldValue(value, field.Name);
if (fieldValue == null) { continue; }
body.StructFields.Add(new cITSOField {
ID = field.ID,
Value = SerializeValue(field.TypeID, fieldValue)
});
}
result.Type = cTSOValue_property;
result.Value = body;
return result;
}
return null;
}
return result;
}
}
}

8
server/FSO.Server.Protocol/Voltron/DataService/cTSOValue.cs Executable file
View file

@ -0,0 +1,8 @@
namespace FSO.Server.Protocol.Voltron.DataService
{
public class cTSOValue
{
public uint Type { get; set; }
public object Value { get; set; }
}
}

12
server/FSO.Server.Protocol/Voltron/DataService/clsid.cs Executable file
View file

@ -0,0 +1,12 @@
namespace FSO.Server.Protocol.Voltron.DataService
{
[System.AttributeUsage(System.AttributeTargets.Class)]
public class clsid : System.Attribute
{
public uint Value;
public clsid(uint value) {
this.Value = value;
}
}
}

14
server/FSO.Server.Protocol/Voltron/IVoltronPacket.cs Executable file
View file

@ -0,0 +1,14 @@
using FSO.Common.Serialization;
namespace FSO.Server.Protocol.Voltron
{
public interface IVoltronPacket : IoBufferDeserializable, IoBufferSerializable
{
/**
* Get packet type
*
* @return
*/
VoltronPacketType GetPacketType();
}
}

8
server/FSO.Server.Protocol/Voltron/Model/Gender.cs Executable file
View file

@ -0,0 +1,8 @@
namespace FSO.Server.Protocol.Voltron.Model
{
public enum Gender
{
MALE,
FEMALE
}
}

338
server/FSO.Server.Protocol/Voltron/Model/MagicNumberEnum.cs Executable file
View file

@ -0,0 +1,338 @@
namespace FSO.Server.Protocol.Voltron.Model
{
public enum MagicNumberEnum
{
VAL_E4E9B25D,
VAL_A46E47DC,
VAL_B5D630DD,
VAL_211D969E,
VAL_D042E9D6,
VAL_3998426C,
VAL_75FFC299,
VAL_87102FBA,
VAL_486B3F7E,
VAL_14656565,
VAL_0C0CB1E6,
VAL_227BED60,
VAL_77A46FE8,
VAL_9062B390,
VAL_13639511,
VAL_94016F9F,
VAL_B2C6ED04,
VAL_67281FA4,
VAL_404D4CB1,
VAL_0350C667,
VAL_C5521020,
VAL_8D7F9BF2,
VAL_55D2AE37,
VAL_74AF57D1,
VAL_D3B216CA,
VAL_4BD42E0C,
VAL_DFAEA619,
VAL_E3FC98F9,
VAL_1C364C5D,
VAL_196546F1,
VAL_9702D009,
VAL_DC07F91F,
VAL_AF3D3F6D
}
public static class MagicNumberEnumUtils
{
public static int ToInt(this MagicNumberEnum value)
{
switch (value)
{
case MagicNumberEnum.VAL_E4E9B25D:
return 0;
case MagicNumberEnum.VAL_A46E47DC:
return 0;
case MagicNumberEnum.VAL_B5D630DD:
return 4;
case MagicNumberEnum.VAL_211D969E:
return 0;
case MagicNumberEnum.VAL_D042E9D6:
return 0;
case MagicNumberEnum.VAL_3998426C:
return 0;
case MagicNumberEnum.VAL_75FFC299:
return 0;
case MagicNumberEnum.VAL_87102FBA:
return 0;
case MagicNumberEnum.VAL_486B3F7E:
return 2;
case MagicNumberEnum.VAL_14656565:
return 20;
case MagicNumberEnum.VAL_0C0CB1E6:
return 0;
case MagicNumberEnum.VAL_227BED60:
return 2;
case MagicNumberEnum.VAL_77A46FE8:
return 0;
case MagicNumberEnum.VAL_9062B390:
return 100;
case MagicNumberEnum.VAL_13639511:
return 0;
case MagicNumberEnum.VAL_94016F9F:
return 10;
case MagicNumberEnum.VAL_B2C6ED04:
return 0;
case MagicNumberEnum.VAL_67281FA4:
return 20;
case MagicNumberEnum.VAL_404D4CB1:
return 0;
case MagicNumberEnum.VAL_0350C667:
return 30;
case MagicNumberEnum.VAL_C5521020:
return 10;
case MagicNumberEnum.VAL_8D7F9BF2:
return 3;
case MagicNumberEnum.VAL_55D2AE37:
return 10;
case MagicNumberEnum.VAL_74AF57D1:
return 100;
case MagicNumberEnum.VAL_D3B216CA:
return 64;
case MagicNumberEnum.VAL_4BD42E0C:
return 64;
case MagicNumberEnum.VAL_DFAEA619:
return 30;
case MagicNumberEnum.VAL_E3FC98F9:
return 60;
case MagicNumberEnum.VAL_1C364C5D:
return 30;
case MagicNumberEnum.VAL_196546F1:
return 2;
case MagicNumberEnum.VAL_9702D009:
return 60;
case MagicNumberEnum.VAL_DC07F91F:
return 0;
case MagicNumberEnum.VAL_AF3D3F6D:
return 60;
}
return 0;
}
public static float ToFloat(this MagicNumberEnum value)
{
switch (value)
{
case MagicNumberEnum.VAL_E4E9B25D:
return 0.2f;
case MagicNumberEnum.VAL_A46E47DC:
return 0.2f;
case MagicNumberEnum.VAL_B5D630DD:
return 4.0f;
case MagicNumberEnum.VAL_211D969E:
return 0.1f;
case MagicNumberEnum.VAL_D042E9D6:
return 0.5f;
case MagicNumberEnum.VAL_3998426C:
return 0.5f;
case MagicNumberEnum.VAL_75FFC299:
return 0.5f;
case MagicNumberEnum.VAL_87102FBA:
return 0.5f;
case MagicNumberEnum.VAL_486B3F7E:
return 1.0f;
case MagicNumberEnum.VAL_14656565:
return 10.0f;
case MagicNumberEnum.VAL_0C0CB1E6:
return 0.5f;
case MagicNumberEnum.VAL_227BED60:
return 4.0f;
case MagicNumberEnum.VAL_77A46FE8:
return 0.5f;
case MagicNumberEnum.VAL_9062B390:
return 100.0f;
case MagicNumberEnum.VAL_13639511:
return 0.5f;
case MagicNumberEnum.VAL_94016F9F:
return 2.0f;
case MagicNumberEnum.VAL_B2C6ED04:
return 0.5f;
case MagicNumberEnum.VAL_67281FA4:
return 10.0f;
case MagicNumberEnum.VAL_404D4CB1:
return 0.5f;
case MagicNumberEnum.VAL_0350C667:
return 2.0f;
case MagicNumberEnum.VAL_C5521020:
return 2.0f;
case MagicNumberEnum.VAL_8D7F9BF2:
return 3.0f;
case MagicNumberEnum.VAL_55D2AE37:
return 1.0f;
case MagicNumberEnum.VAL_74AF57D1:
return 2.0f;
case MagicNumberEnum.VAL_D3B216CA:
return 64.0f;
case MagicNumberEnum.VAL_4BD42E0C:
return 64.0f;
case MagicNumberEnum.VAL_DFAEA619:
return 30.0f;
case MagicNumberEnum.VAL_E3FC98F9:
return 60.0f;
case MagicNumberEnum.VAL_1C364C5D:
return 6.0f;
case MagicNumberEnum.VAL_196546F1:
return 0.5f;
case MagicNumberEnum.VAL_9702D009:
return 60.0f;
case MagicNumberEnum.VAL_DC07F91F:
return 0.5f;
case MagicNumberEnum.VAL_AF3D3F6D:
return 60.0f;
}
return 0.0f;
}
public static uint ToID(this MagicNumberEnum value)
{
switch (value)
{
case MagicNumberEnum.VAL_E4E9B25D:
return 0xE4E9B25D;
case MagicNumberEnum.VAL_A46E47DC:
return 0xA46E47DC;
case MagicNumberEnum.VAL_B5D630DD:
return 0xB5D630DD;
case MagicNumberEnum.VAL_211D969E:
return 0x211D969E;
case MagicNumberEnum.VAL_D042E9D6:
return 0xD042E9D6;
case MagicNumberEnum.VAL_3998426C:
return 0x3998426C;
case MagicNumberEnum.VAL_75FFC299:
return 0x75FFC299;
case MagicNumberEnum.VAL_87102FBA:
return 0x87102FBA;
case MagicNumberEnum.VAL_486B3F7E:
return 0x486B3F7E;
case MagicNumberEnum.VAL_14656565:
return 0x14656565;
case MagicNumberEnum.VAL_0C0CB1E6:
return 0x0C0CB1E6;
case MagicNumberEnum.VAL_227BED60:
return 0x227BED60;
case MagicNumberEnum.VAL_77A46FE8:
return 0x77A46FE8;
case MagicNumberEnum.VAL_9062B390:
return 0x9062B390;
case MagicNumberEnum.VAL_13639511:
return 0x13639511;
case MagicNumberEnum.VAL_94016F9F:
return 0x94016F9F;
case MagicNumberEnum.VAL_B2C6ED04:
return 0xB2C6ED04;
case MagicNumberEnum.VAL_67281FA4:
return 0x67281FA4;
case MagicNumberEnum.VAL_404D4CB1:
return 0x404D4CB1;
case MagicNumberEnum.VAL_0350C667:
return 0x0350C667;
case MagicNumberEnum.VAL_C5521020:
return 0xC5521020;
case MagicNumberEnum.VAL_8D7F9BF2:
return 0x8D7F9BF2;
case MagicNumberEnum.VAL_55D2AE37:
return 0x55D2AE37;
case MagicNumberEnum.VAL_74AF57D1:
return 0x74AF57D1;
case MagicNumberEnum.VAL_D3B216CA:
return 0xD3B216CA;
case MagicNumberEnum.VAL_4BD42E0C:
return 0x4BD42E0C;
case MagicNumberEnum.VAL_DFAEA619:
return 0xDFAEA619;
case MagicNumberEnum.VAL_E3FC98F9:
return 0xE3FC98F9;
case MagicNumberEnum.VAL_1C364C5D:
return 0x1C364C5D;
case MagicNumberEnum.VAL_196546F1:
return 0x196546F1;
case MagicNumberEnum.VAL_9702D009:
return 0x9702D009;
case MagicNumberEnum.VAL_DC07F91F:
return 0xDC07F91F;
case MagicNumberEnum.VAL_AF3D3F6D:
return 0xAF3D3F6D;
}
return 0;
}
public static MagicNumberEnum FromID(uint id)
{
switch (id)
{
case 0xE4E9B25D:
return MagicNumberEnum.VAL_E4E9B25D;
case 0xA46E47DC:
return MagicNumberEnum.VAL_A46E47DC;
case 0xB5D630DD:
return MagicNumberEnum.VAL_B5D630DD;
case 0x211D969E:
return MagicNumberEnum.VAL_211D969E;
case 0xD042E9D6:
return MagicNumberEnum.VAL_D042E9D6;
case 0x3998426C:
return MagicNumberEnum.VAL_3998426C;
case 0x75FFC299:
return MagicNumberEnum.VAL_75FFC299;
case 0x87102FBA:
return MagicNumberEnum.VAL_87102FBA;
case 0x486B3F7E:
return MagicNumberEnum.VAL_486B3F7E;
case 0x14656565:
return MagicNumberEnum.VAL_14656565;
case 0x0C0CB1E6:
return MagicNumberEnum.VAL_0C0CB1E6;
case 0x227BED60:
return MagicNumberEnum.VAL_227BED60;
case 0x77A46FE8:
return MagicNumberEnum.VAL_77A46FE8;
case 0x9062B390:
return MagicNumberEnum.VAL_9062B390;
case 0x13639511:
return MagicNumberEnum.VAL_13639511;
case 0x94016F9F:
return MagicNumberEnum.VAL_94016F9F;
case 0xB2C6ED04:
return MagicNumberEnum.VAL_B2C6ED04;
case 0x67281FA4:
return MagicNumberEnum.VAL_67281FA4;
case 0x404D4CB1:
return MagicNumberEnum.VAL_404D4CB1;
case 0x0350C667:
return MagicNumberEnum.VAL_0350C667;
case 0xC5521020:
return MagicNumberEnum.VAL_C5521020;
case 0x8D7F9BF2:
return MagicNumberEnum.VAL_8D7F9BF2;
case 0x55D2AE37:
return MagicNumberEnum.VAL_55D2AE37;
case 0x74AF57D1:
return MagicNumberEnum.VAL_74AF57D1;
case 0xD3B216CA:
return MagicNumberEnum.VAL_D3B216CA;
case 0x4BD42E0C:
return MagicNumberEnum.VAL_4BD42E0C;
case 0xDFAEA619:
return MagicNumberEnum.VAL_DFAEA619;
case 0xE3FC98F9:
return MagicNumberEnum.VAL_E3FC98F9;
case 0x1C364C5D:
return MagicNumberEnum.VAL_1C364C5D;
case 0x196546F1:
return MagicNumberEnum.VAL_196546F1;
case 0x9702D009:
return MagicNumberEnum.VAL_9702D009;
case 0xDC07F91F:
return MagicNumberEnum.VAL_DC07F91F;
case 0xAF3D3F6D:
return MagicNumberEnum.VAL_AF3D3F6D;
}
return default(MagicNumberEnum);
}
}
}

61
server/FSO.Server.Protocol/Voltron/Model/RPCRequest.cs Executable file
View file

@ -0,0 +1,61 @@
using FSO.Common.Serialization;
using Mina.Core.Buffer;
using System;
namespace FSO.Server.Protocol.Voltron.Model
{
/// <summary>
/// DBRequestWrapperPDU
/// </summary>
public class RPCRequest
{
public object[] Parameters { get; set; }
public RPCRequest(IoBuffer buffer)
{
var bodyType = buffer.GetUInt32();
switch (bodyType)
{
case 0x125194E5:
ParseFormat1(buffer);
break;
default:
throw new Exception("Unknown RPC request type");
}
}
private void ParseFormat1(IoBuffer buffer)
{
var unknown = buffer.GetUInt32();
var sendingAvatarId = buffer.GetUInt32();
var flags = (byte)buffer.Get();
var messageId = buffer.GetUInt32();
if ((((flags) >> 1) & 0x01) == 0x01)
{
var unknown2 = buffer.GetUInt32();
}
if ((((flags) >> 2) & 0x01) == 0x01)
{
var parameter = new byte[4];
buffer.Get(parameter, 0, 4);
}
if ((((flags) >> 3) & 0x01) == 0x01)
{
var unknown3 = buffer.GetUInt32();
}
if ((((flags) >> 5) & 0x01) == 0x01)
{
var requestResponseID = buffer.GetUInt32();
/** Variable bytes **/
}
}
}
}

8
server/FSO.Server.Protocol/Voltron/Model/Sender.cs Executable file
View file

@ -0,0 +1,8 @@
namespace FSO.Server.Protocol.Voltron.Model
{
public class Sender
{
public string AriesID;
public string MasterAccountID;
}
}

9
server/FSO.Server.Protocol/Voltron/Model/SkinTone.cs Executable file
View file

@ -0,0 +1,9 @@
namespace FSO.Server.Protocol.Voltron.Model
{
public enum SkinTone
{
LIGHT,
MEDIUM,
DARK
}
}

40
server/FSO.Server.Protocol/Voltron/Packets/AnnouncementMsgPDU.cs Executable file
View file

@ -0,0 +1,40 @@
using FSO.Common.Serialization;
using Mina.Core.Buffer;
namespace FSO.Server.Protocol.Voltron.Packets
{
public class AnnouncementMsgPDU : AbstractVoltronPacket
{
public string SenderID = "??ARIES_OPERATIONS";
public string SenderAccount = "";
public byte Badge;
public byte IsAlertable;
public string Subject = "";
public string Message = "";
public override void Deserialize(IoBuffer input, ISerializationContext context)
{
this.SenderID = input.GetPascalString();
this.SenderAccount = input.GetPascalString();
this.Badge = input.Get();
this.IsAlertable = input.Get();
this.Subject = input.GetPascalString();
this.Message = input.GetPascalString();
}
public override VoltronPacketType GetPacketType()
{
return VoltronPacketType.AnnouncementMsgPDU;
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
output.PutPascalString(SenderID);
output.PutPascalString(SenderAccount);
output.Put(Badge);
output.Put(IsAlertable);
output.PutPascalString(Subject);
output.PutPascalString(Message);
}
}
}

38
server/FSO.Server.Protocol/Voltron/Packets/ChatMsgPDU.cs Executable file
View file

@ -0,0 +1,38 @@
using FSO.Common.Serialization;
using Mina.Core.Buffer;
using FSO.Server.Protocol.Voltron.Model;
namespace FSO.Server.Protocol.Voltron.Packets
{
public class ChatMsgPDU : AbstractVoltronPacket
{
public bool EchoRequested;
public Sender Sender;
public byte Badge;
public byte Alertable;
public string Message;
public override void Deserialize(IoBuffer input, ISerializationContext context)
{
EchoRequested = input.Get() == 0x01;
Sender = GetSender(input);
Badge = input.Get();
Alertable = input.Get();
Message = input.GetPascalString();
}
public override VoltronPacketType GetPacketType()
{
return VoltronPacketType.ChatMsgPDU;
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
output.Put(EchoRequested ? (byte)1 : (byte)0);
PutSender(output, Sender);
output.Put(Badge);
output.Put(Alertable);
output.PutPascalString(Message);
}
}
}

36
server/FSO.Server.Protocol/Voltron/Packets/ClientByePDU.cs Executable file
View file

@ -0,0 +1,36 @@
using Mina.Core.Buffer;
using FSO.Common.Serialization;
namespace FSO.Server.Protocol.Voltron.Packets
{
public class ClientByePDU : AbstractVoltronPacket
{
public uint ReasonCode;
public string ReasonText;
public byte RequestTicket;
public override void Deserialize(IoBuffer input, ISerializationContext context)
{
this.ReasonCode = input.GetUInt32();
this.ReasonText = input.GetPascalString();
this.RequestTicket = input.Get();
}
public override VoltronPacketType GetPacketType()
{
return VoltronPacketType.ClientByePDU;
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
var text = ReasonText;
if(text == null){
text = "";
}
output.PutUInt32(ReasonCode);
output.PutPascalString(text);
output.Put(RequestTicket);
}
}
}

57
server/FSO.Server.Protocol/Voltron/Packets/ClientOnlinePDU.cs Executable file
View file

@ -0,0 +1,57 @@
using FSO.Common.Serialization;
using Mina.Core.Buffer;
namespace FSO.Server.Protocol.Voltron.Packets
{
public class ClientOnlinePDU : AbstractVoltronPacket
{
public ushort MajorVersion { get; set; }
public ushort MinorVersion { get; set; }
public ushort PointVersion { get; set; }
public ushort ArtVersion { get; set; }
public ulong Timestamp { get; set; }
public byte NumberOfAttempts { get; set; }
public byte LastExitCode { get; set; }
public byte LastFailureType { get; set; }
public byte FailureCount { get; set; }
public byte IsRunning { get; set; }
public byte IsReLogging { get; set; }
public override VoltronPacketType GetPacketType()
{
return VoltronPacketType.ClientOnlinePDU;
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
output.PutUInt16(MajorVersion);
output.PutUInt16(MinorVersion);
output.PutUInt16(PointVersion);
output.PutUInt16(ArtVersion);
output.PutUInt64(this.Timestamp);
output.Put(NumberOfAttempts);
output.Put(LastExitCode);
output.Put(LastFailureType);
output.Put(FailureCount);
output.Put(IsRunning);
output.Put(IsReLogging);
}
public override void Deserialize(IoBuffer input, ISerializationContext context)
{
this.MajorVersion = input.GetUInt16();
this.MinorVersion = input.GetUInt16();
this.PointVersion = input.GetUInt16();
this.ArtVersion = input.GetUInt16();
this.Timestamp = input.GetUInt64();
this.NumberOfAttempts = input.Get();
this.LastExitCode = input.Get();
this.LastFailureType = input.Get();
this.FailureCount = input.Get();
this.IsRunning = input.Get();
this.IsReLogging = input.Get();
}
}
}

56
server/FSO.Server.Protocol/Voltron/Packets/DBRequestWrapperPDU.cs Executable file
View file

@ -0,0 +1,56 @@
using Mina.Core.Buffer;
using FSO.Server.Protocol.Voltron.Model;
using System.ComponentModel;
using FSO.Common.Serialization;
namespace FSO.Server.Protocol.Voltron.Packets
{
public class DBRequestWrapperPDU : AbstractVoltronPacket
{
public uint SendingAvatarID { get; set; }
public Sender Sender { get; set; }
public byte Badge { get; set; }
public byte IsAlertable { get; set; }
public object BodyType { get; set; }
[TypeConverter(typeof(ExpandableObjectConverter))]
public object Body { get; set; }
public override void Deserialize(IoBuffer input, ISerializationContext context)
{
SendingAvatarID = input.GetUInt32();
Sender = GetSender(input);
Badge = input.Get();
IsAlertable = input.Get();
var bodySize = input.GetUInt32();
var bodyType = input.GetUInt32();
var bodyBytes = new byte[bodySize-4];
input.Get(bodyBytes, 0, (int)bodySize-4);
var bodyBuffer = IoBuffer.Wrap(bodyBytes);
this.Body = context.ModelSerializer.Deserialize(bodyType, bodyBuffer, context);
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
output.PutUInt32(SendingAvatarID);
PutSender(output, Sender);
output.Put(Badge);
output.Put(IsAlertable);
if (Body != null)
{
var bodyBytes = context.ModelSerializer.SerializeBuffer(Body, context, true);
output.PutUInt32((uint)bodyBytes.Remaining);
output.Put(bodyBytes);
}
}
public override VoltronPacketType GetPacketType(){
return VoltronPacketType.DBRequestWrapperPDU;
}
}
}

53
server/FSO.Server.Protocol/Voltron/Packets/DataServiceWrapperPDU.cs Executable file
View file

@ -0,0 +1,53 @@
using Mina.Core.Buffer;
using System.ComponentModel;
using FSO.Common.Serialization;
namespace FSO.Server.Protocol.Voltron.Packets
{
public class DataServiceWrapperPDU : AbstractVoltronPacket
{
public uint SendingAvatarID { get; set; }
public uint RequestTypeID { get; set; }
[TypeConverter(typeof(ExpandableObjectConverter))]
public object Body { get; set; }
public override VoltronPacketType GetPacketType()
{
return VoltronPacketType.DataServiceWrapperPDU;
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
output.PutUInt32(SendingAvatarID);
output.PutUInt32(RequestTypeID);
if(Body != null){
var bodyBytes = context.ModelSerializer.SerializeBuffer(Body, context, true);
output.PutUInt32((uint)bodyBytes.Remaining);
output.Put(bodyBytes);
}
//output.PutUInt32(RequestTypeID);
//output.PutUInt32(0);
}
public override void Deserialize(IoBuffer input, ISerializationContext context)
{
this.SendingAvatarID = input.GetUInt32();
this.RequestTypeID = input.GetUInt32();
var bodySize = input.GetUInt32();
var bodyBytes = new byte[bodySize];
input.Get(bodyBytes, 0, (int)bodySize);
this.Body = bodyBytes;
var bodyBuffer = IoBuffer.Wrap(bodyBytes);
var bodyType = bodyBuffer.GetUInt32();
this.Body = context.ModelSerializer.Deserialize(bodyType, bodyBuffer, context);
}
}
}

29
server/FSO.Server.Protocol/Voltron/Packets/FindPlayerPDU.cs Executable file
View file

@ -0,0 +1,29 @@
using Mina.Core.Buffer;
using FSO.Server.Protocol.Voltron.Model;
using FSO.Common.Serialization;
namespace FSO.Server.Protocol.Voltron.Packets
{
public class FindPlayerPDU : AbstractVoltronPacket
{
public Sender Sender;
public override void Deserialize(IoBuffer input, ISerializationContext context)
{
this.Sender = GetSender(input);
}
public override VoltronPacketType GetPacketType()
{
return VoltronPacketType.FindPlayerPDU;
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
//var result = Allocate(8);
//result.AutoExpand = true;
PutSender(output, Sender);
//return result;
}
}
}

95
server/FSO.Server.Protocol/Voltron/Packets/FindPlayerResponsePDU.cs Executable file
View file

@ -0,0 +1,95 @@
using Mina.Core.Buffer;
using FSO.Common.Serialization;
namespace FSO.Server.Protocol.Voltron.Packets
{
public class FindPlayerResponsePDU : AbstractVoltronPacket
{
public uint StatusCode;
public string ReasonText;
public int AvatarID;
public int RoomID;
public int StageID;
public override void Deserialize(IoBuffer input, ISerializationContext context)
{
StatusCode = input.GetUInt32();
ReasonText = input.GetPascalString();
//Room Info
}
public override VoltronPacketType GetPacketType()
{
return VoltronPacketType.FindPlayerResponsePDU;
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
//var result = Allocate(8);
//result.AutoExpand = true;
output.PutUInt32(StatusCode);
output.PutPascalString(ReasonText);
//Room Info
output.PutPascalString("A 16318812");
output.PutPascalString("1");
output.Put((byte)0);
//Owner
output.PutPascalString("A 65538");
output.PutPascalString("1");
//Stage id
output.PutPascalString("A 16318812");
output.PutPascalString("1");
//Currnet ocupancy
output.PutUInt32(10);
//Max occupancy
output.PutUInt32(50);
//pswd required
output.Put((byte)0);
//room type
output.Put((byte)1);
//Group
output.PutPascalString("1");
//Admin list
output.PutUInt16(0);
//m_EnabledFlag
output.Put(0);
//m_AdmitList
output.PutUInt16(0);
//m_EnabledFlag
output.Put(0);
//m_DenyList
output.PutUInt16(0);
//m_EnabledFlag
output.Put(0);
output.PutUInt32(0);
output.PutUInt32(0);
output.PutUInt32(0);
//player info
output.PutPascalString("A "+AvatarID.ToString());
output.PutPascalString("");
output.Put(0);
output.Put(0);
//return result;
}
}
}

33
server/FSO.Server.Protocol/Voltron/Packets/HostOnlinePDU.cs Executable file
View file

@ -0,0 +1,33 @@
using FSO.Common.Serialization;
using Mina.Core.Buffer;
namespace FSO.Server.Protocol.Voltron.Packets
{
public class HostOnlinePDU : AbstractVoltronPacket
{
public ushort HostReservedWords;
public ushort HostVersion;
public ushort ClientBufSize = 4096;
public override VoltronPacketType GetPacketType()
{
return VoltronPacketType.HostOnlinePDU;
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
//IoBuffer result = Allocate(6);
output.PutUInt16(HostReservedWords);
output.PutUInt16(HostVersion);
output.PutUInt16(ClientBufSize);
//return result;
}
public override void Deserialize(IoBuffer input, ISerializationContext context)
{
HostReservedWords = input.GetUInt16();
HostVersion = input.GetUInt16();
ClientBufSize = input.GetUInt16();
}
}
}

32
server/FSO.Server.Protocol/Voltron/Packets/OccupantArrivedPDU.cs Executable file
View file

@ -0,0 +1,32 @@
using Mina.Core.Buffer;
using FSO.Server.Protocol.Voltron.Model;
using FSO.Common.Serialization;
namespace FSO.Server.Protocol.Voltron.Packets
{
public class OccupantArrivedPDU : AbstractVoltronPacket
{
public Sender Sender;
public byte Badge;
public bool IsAlertable;
public override void Deserialize(IoBuffer input, ISerializationContext context)
{
Sender = GetSender(input);
Badge = input.Get();
IsAlertable = input.Get() == 0x1;
}
public override VoltronPacketType GetPacketType()
{
return VoltronPacketType.OccupantArrivedPDU;
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
PutSender(output, Sender);
output.Put(Badge);
output.Put((IsAlertable ? (byte)0x01 : (byte)0x00));
}
}
}

76
server/FSO.Server.Protocol/Voltron/Packets/RSGZWrapperPDU.cs Executable file
View file

@ -0,0 +1,76 @@
using Mina.Core.Buffer;
using FSO.Server.Protocol.Voltron.Model;
using FSO.Common.Serialization;
namespace FSO.Server.Protocol.Voltron.Packets
{
public class RSGZWrapperPDU : AbstractVoltronPacket
{
public string Name { get; set; }
public string Description { get; set; }
public Gender Gender { get; set; }
public SkinTone SkinTone { get; set; }
public uint HeadOutfitId { get; set; }
public uint BodyOutfitId { get; set; }
public override void Deserialize(IoBuffer input, ISerializationContext context)
{
//ignoring the dbwrapper junk
//byte 17 and 18 change without changing settings, perhaps a message id?
input.Skip(37);
this.Name = input.GetPascalVLCString();
this.Description = input.GetPascalVLCString();
this.Gender = input.Get() == 0x1 ? Gender.FEMALE : Gender.MALE;
var skin = input.Get();
switch (skin) {
default:
case 0x00:
SkinTone = SkinTone.LIGHT;
break;
case 0x01:
SkinTone = SkinTone.MEDIUM;
break;
case 0x02:
SkinTone = SkinTone.DARK;
break;
}
this.HeadOutfitId = input.GetUInt32();
input.Skip(4); //Unknown
this.BodyOutfitId = input.GetUInt32();
}
public override VoltronPacketType GetPacketType()
{
return VoltronPacketType.RSGZWrapperPDU;
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
output.Skip(37);
output.PutPascalVLCString(Name);
output.PutPascalVLCString(Description);
output.Put(Gender == Gender.FEMALE ? (byte)0x01 : (byte)0x00);
switch (SkinTone)
{
case SkinTone.LIGHT:
output.Put(0x00);
break;
case SkinTone.MEDIUM:
output.Put(0x01);
break;
case SkinTone.DARK:
output.Put(0x02);
break;
}
output.PutUInt32(HeadOutfitId);
output.Skip(4);//Unknown
output.PutUInt32(BodyOutfitId);
}
}
}

36
server/FSO.Server.Protocol/Voltron/Packets/ServerByePDU.cs Executable file
View file

@ -0,0 +1,36 @@
using Mina.Core.Buffer;
using FSO.Common.Serialization;
namespace FSO.Server.Protocol.Voltron.Packets
{
public class ServerByePDU : AbstractVoltronPacket
{
public uint ReasonCode;
public string ReasonText;
public string Ticket;
public override void Deserialize(IoBuffer input, ISerializationContext context)
{
this.ReasonCode = input.GetUInt32();
this.ReasonText = input.GetPascalString();
this.Ticket = input.GetPascalString();
}
public override VoltronPacketType GetPacketType()
{
return VoltronPacketType.ServerByePDU;
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
var text = ReasonText;
if(text == null){
text = "";
}
output.PutUInt32(ReasonCode);
output.PutPascalString(text);
output.PutPascalString(Ticket);
}
}
}

43
server/FSO.Server.Protocol/Voltron/Packets/SetIgnoreListPDU.cs Executable file
View file

@ -0,0 +1,43 @@
using System.Collections.Generic;
using Mina.Core.Buffer;
using FSO.Common.Serialization;
namespace FSO.Server.Protocol.Voltron.Packets
{
public class SetIgnoreListPDU : AbstractVoltronPacket
{
public List<uint> PlayerIds;
public override void Deserialize(IoBuffer input, ISerializationContext context)
{
var length = input.GetUInt16();
PlayerIds = new List<uint>();
for(var i=0; i < length; i++)
{
PlayerIds.Add(input.GetUInt32());
}
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
var len = 0;
if(PlayerIds != null)
{
len = PlayerIds.Count;
}
output.PutUInt16((ushort)len);
for(int i=0; i < len; i++)
{
output.PutUInt32(PlayerIds[i]);
}
}
public override VoltronPacketType GetPacketType()
{
return VoltronPacketType.SetIgnoreListPDU;
}
}
}

33
server/FSO.Server.Protocol/Voltron/Packets/SetIgnoreListResponsePDU.cs Executable file
View file

@ -0,0 +1,33 @@
using Mina.Core.Buffer;
using FSO.Common.Serialization;
namespace FSO.Server.Protocol.Voltron.Packets
{
public class SetIgnoreListResponsePDU : AbstractVoltronPacket
{
public uint StatusCode;
public string ReasonText;
public uint MaxNumberOfIgnored;
public override void Deserialize(IoBuffer input, ISerializationContext context)
{
this.StatusCode = input.GetUInt32();
this.ReasonText = input.GetPascalString();
this.MaxNumberOfIgnored = input.GetUInt32();
}
public override VoltronPacketType GetPacketType()
{
return VoltronPacketType.SetIgnoreListResponsePDU;
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
//var result = Allocate(8 + 4 + ReasonText.Length);
output.PutUInt32(StatusCode);
output.PutPascalString(this.ReasonText);
output.PutUInt32(MaxNumberOfIgnored);
//return result;
}
}
}

25
server/FSO.Server.Protocol/Voltron/Packets/SetInvinciblePDU.cs Executable file
View file

@ -0,0 +1,25 @@
using Mina.Core.Buffer;
using FSO.Common.Serialization;
namespace FSO.Server.Protocol.Voltron.Packets
{
public class SetInvinciblePDU : AbstractVoltronPacket
{
public uint Action;
public override void Deserialize(IoBuffer input, ISerializationContext context)
{
this.Action = input.GetUInt32();
}
public override VoltronPacketType GetPacketType()
{
return VoltronPacketType.SetInvinciblePDU;
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
output.PutUInt32(Action);
}
}
}

23
server/FSO.Server.Protocol/Voltron/Packets/TransmitCreateAvatarNotificationPDU.cs Executable file
View file

@ -0,0 +1,23 @@
using Mina.Core.Buffer;
using FSO.Common.Serialization;
namespace FSO.Server.Protocol.Voltron.Packets
{
public class TransmitCreateAvatarNotificationPDU : AbstractVoltronPacket
{
public override void Deserialize(IoBuffer input, ISerializationContext context)
{
}
public override VoltronPacketType GetPacketType()
{
return VoltronPacketType.TransmitCreateAvatarNotificationPDU;
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
output.Put(10);
}
}
}

34
server/FSO.Server.Protocol/Voltron/Packets/VariableVoltronPacket.cs Executable file
View file

@ -0,0 +1,34 @@
using System;
using Mina.Core.Buffer;
using FSO.Common.Serialization;
namespace FSO.Server.Protocol.Voltron.Packets
{
public class VariableVoltronPacket : AbstractVoltronPacket
{
public ushort Type;
public byte[] Bytes;
public VariableVoltronPacket(ushort type, byte[] bytes)
{
this.Type = type;
this.Bytes = bytes;
}
public override void Deserialize(IoBuffer input, ISerializationContext context)
{
throw new NotImplementedException();
}
public override VoltronPacketType GetPacketType()
{
return VoltronPacketTypeUtils.FromPacketCode(Type);
}
public override void Serialize(IoBuffer output, ISerializationContext context)
{
output.Put(Bytes, 0, Bytes.Length);
}
}
}

776
server/FSO.Server.Protocol/Voltron/VoltronPacketType.cs Executable file
View file

@ -0,0 +1,776 @@
namespace FSO.Server.Protocol.Voltron
{
public enum VoltronPacketType
{
AlertHandledPDU,
AlertMsgPDU,
AlertMsgResponsePDU,
AnnouncementMsgResponsePDU,
AnnouncementMsgPDU,
ClientByePDU,
ServerByePDU,
ChatMsgFailedPDU,
ChatMsgPDU,
ClientOnlinePDU,
CreateAndJoinRoomFailedPDU,
CreateAndJoinRoomPDU,
CreateRoomPDU,
CreateRoomResponsePDU,
DestroyRoomPDU,
DestroyRoomResponsePDU,
DetachFromRoomFailedPDU,
DetachFromRoomPDU,
EjectOccupantPDU,
EjectOccupantResponsePDU,
ErrorPDU,
ExitRoomFailedPDU,
ExitRoomPDU,
FindPlayerPDU,
FindPlayerResponsePDU,
FlashMsgResponsePDU,
FlashMsgPDU,
HandleAlertPDU,
HostOfflinePDU,
HostOnlinePDU,
InvitationMsgResponsePDU,
InvitationMsgPDU,
JoinPlayerFailedPDU,
JoinPlayerPDU,
JoinRoomFailedPDU,
JoinRoomPDU,
ListOccupantsPDU,
ListOccupantsResponsePDU,
ListRoomsPDU,
ListRoomsResponsePDU,
LogEventPDU,
LogEventResponsePDU,
MessageLostPDU,
OccupantArrivedPDU,
OccupantDepartedPDU,
ReadProfilePDU,
ReadProfileResponsePDU,
ReleaseProfilePDU,
ReleaseProfileResponsePDU,
SetAcceptAlertsPDU,
SetAcceptAlertsResponsePDU,
SetIgnoreListPDU,
SetIgnoreListResponsePDU,
SetInvinciblePDU,
SetInvincibleResponsePDU,
SetInvisiblePDU,
SetInvisibleResponsePDU,
SetRoomNamePDU,
SetRoomNameResponsePDU,
UpdateOccupantsPDU,
UpdatePlayerPDU,
UpdateProfilePDU,
UpdateRoomPDU,
YankPlayerFailedPDU,
YankPlayerPDU,
SetAcceptFlashesPDU,
SetAcceptFlashesResponsePDU,
SplitBufferPDU,
ActionRoomNamePDU,
ActionRoomNameResponsePDU,
NotifyRoomActionedPDU,
ModifyProfilePDU,
ModifyProfileResponsePDU,
ListBBSFoldersPDU,
ListBBSFoldersResponsePDU,
GetBBSMessageListPDU,
GetBBSMessageListResponsePDU,
PostBBSMessagePDU,
PostBBSReplyPDU,
PostBBSMessageResponsePDU,
GetMPSMessagesPDU,
GetMPSMessagesResponsePDU,
DeleteMPSMessagePDU,
DeleteMPSMessageResponsePDU,
BBSMessageDataPDU,
UpdateRoomAdminListPDU,
GetRoomAdminListPDU,
GetRoomAdminListResponsePDU,
GroupInfoRequestPDU,
GroupInfoResponsePDU,
GroupAdminRequestPDU,
GroupAdminResponsePDU,
GroupMembershipRequestPDU,
GroupMembershipResponsePDU,
FlashGroupPDU,
FlashGroupResponsePDU,
UpdateGroupMemberPDU,
UpdateGroupMemberResponsePDU,
UpdateGroupAdminPDU,
UpdateGroupAdminResponsePDU,
ListGroupsPDU,
ListGroupsResponsePDU,
ListJoinedGroupsPDU,
ListJoinedGroupsResponsePDU,
GpsChatPDU,
GpsChatResponsePDU,
PetitionStatusUpdatePDU,
LogGPSPetitionPDU,
LogGPSPetitionResponsePDU,
List20RoomsPDU,
List20RoomsResponsePDU,
UpdateIgnoreListPDU,
ResetWatchdogPDU,
ResetWatchdogResponsePDU,
BroadcastDataBlobPDU,
TransmitDataBlobPDU,
DBRequestWrapperPDU,
TransmitCreateAvatarNotificationPDU,
BC_PlayerLoginEventPDU,
BC_PlayerLogoutEventPDU,
RoomserverUserlistPDU,
LotEntryRequestPDU,
ClientConfigPDU,
KickoutRoommatePDU,
GenericFlashPDU,
GenericFlashRequestPDU,
GenericFlashResponsePDU,
TransmitGenericGDMPDU,
EjectAvatarPDU,
TestPDU,
HouseSimConstraintsPDU,
HouseSimConstraintsResponsePDU,
LoadHouseResponsePDU,
ComponentVersionRequestPDU,
ComponentVersionResponsePDU,
InviteRoommatePDU,
RoommateInvitationAnswerPDU,
RoommateGDMPDU,
HSB_ShutdownSimulatorPDU,
RoommateGDMResponsePDU,
RSGZWrapperPDU,
AvatarHasNewLotIDPDU,
CheatPDU,
DataServiceWrapperPDU,
CsrEjectAvatarPDU,
CsrEjectAvatarResponsePDU,
cTSONetMessagePDU,
LogCsrActionPDU,
LogAvatarActionPDU,
Unknown
}
public static class VoltronPacketTypeUtils
{
public static VoltronPacketType FromPacketCode(ushort code)
{
switch (code)
{
case 0x0001:
return VoltronPacketType.AlertHandledPDU;
case 0x0002:
return VoltronPacketType.AlertMsgPDU;
case 0x0003:
return VoltronPacketType.AlertMsgResponsePDU;
case 0x0004:
return VoltronPacketType.AnnouncementMsgResponsePDU;
case 0x0005:
return VoltronPacketType.AnnouncementMsgPDU;
case 0x0006:
return VoltronPacketType.ClientByePDU;
case 0x0007:
return VoltronPacketType.ServerByePDU;
case 0x0008:
return VoltronPacketType.ChatMsgFailedPDU;
case 0x0009:
return VoltronPacketType.ChatMsgPDU;
case 0x000a:
return VoltronPacketType.ClientOnlinePDU;
case 0x000b:
return VoltronPacketType.CreateAndJoinRoomFailedPDU;
case 0x000c:
return VoltronPacketType.CreateAndJoinRoomPDU;
case 0x000d:
return VoltronPacketType.CreateRoomPDU;
case 0x000e:
return VoltronPacketType.CreateRoomResponsePDU;
case 0x000f:
return VoltronPacketType.DestroyRoomPDU;
case 0x0010:
return VoltronPacketType.DestroyRoomResponsePDU;
case 0x0011:
return VoltronPacketType.DetachFromRoomFailedPDU;
case 0x0012:
return VoltronPacketType.DetachFromRoomPDU;
case 0x0013:
return VoltronPacketType.EjectOccupantPDU;
case 0x0014:
return VoltronPacketType.EjectOccupantResponsePDU;
case 0x0015:
return VoltronPacketType.ErrorPDU;
case 0x0016:
return VoltronPacketType.ExitRoomFailedPDU;
case 0x0017:
return VoltronPacketType.ExitRoomPDU;
case 0x0018:
return VoltronPacketType.FindPlayerPDU;
case 0x0019:
return VoltronPacketType.FindPlayerResponsePDU;
case 0x001a:
return VoltronPacketType.FlashMsgResponsePDU;
case 0x001b:
return VoltronPacketType.FlashMsgPDU;
case 0x001c:
return VoltronPacketType.HandleAlertPDU;
case 0x001d:
return VoltronPacketType.HostOfflinePDU;
case 0x001e:
return VoltronPacketType.HostOnlinePDU;
case 0x001f:
return VoltronPacketType.InvitationMsgResponsePDU;
case 0x0020:
return VoltronPacketType.InvitationMsgPDU;
case 0x0021:
return VoltronPacketType.JoinPlayerFailedPDU;
case 0x0022:
return VoltronPacketType.JoinPlayerPDU;
case 0x0023:
return VoltronPacketType.JoinRoomFailedPDU;
case 0x0024:
return VoltronPacketType.JoinRoomPDU;
case 0x0025:
return VoltronPacketType.ListOccupantsPDU;
case 0x0026:
return VoltronPacketType.ListOccupantsResponsePDU;
case 0x0027:
return VoltronPacketType.ListRoomsPDU;
case 0x0028:
return VoltronPacketType.ListRoomsResponsePDU;
case 0x0029:
return VoltronPacketType.LogEventPDU;
case 0x002a:
return VoltronPacketType.LogEventResponsePDU;
case 0x002b:
return VoltronPacketType.MessageLostPDU;
case 0x002c:
return VoltronPacketType.OccupantArrivedPDU;
case 0x002d:
return VoltronPacketType.OccupantDepartedPDU;
case 0x002e:
return VoltronPacketType.ReadProfilePDU;
case 0x002f:
return VoltronPacketType.ReadProfileResponsePDU;
case 0x0030:
return VoltronPacketType.ReleaseProfilePDU;
case 0x0031:
return VoltronPacketType.ReleaseProfileResponsePDU;
case 0x0032:
return VoltronPacketType.SetAcceptAlertsPDU;
case 0x0033:
return VoltronPacketType.SetAcceptAlertsResponsePDU;
case 0x0034:
return VoltronPacketType.SetIgnoreListPDU;
case 0x0035:
return VoltronPacketType.SetIgnoreListResponsePDU;
case 0x0036:
return VoltronPacketType.SetInvinciblePDU;
case 0x0037:
return VoltronPacketType.SetInvincibleResponsePDU;
case 0x0038:
return VoltronPacketType.SetInvisiblePDU;
case 0x0039:
return VoltronPacketType.SetInvisibleResponsePDU;
case 0x003a:
return VoltronPacketType.SetRoomNamePDU;
case 0x003b:
return VoltronPacketType.SetRoomNameResponsePDU;
case 0x003c:
return VoltronPacketType.UpdateOccupantsPDU;
case 0x003d:
return VoltronPacketType.UpdatePlayerPDU;
case 0x003e:
return VoltronPacketType.UpdateProfilePDU;
case 0x003f:
return VoltronPacketType.UpdateRoomPDU;
case 0x0040:
return VoltronPacketType.YankPlayerFailedPDU;
case 0x0041:
return VoltronPacketType.YankPlayerPDU;
case 0x0042:
return VoltronPacketType.SetAcceptFlashesPDU;
case 0x0043:
return VoltronPacketType.SetAcceptFlashesResponsePDU;
case 0x0044:
return VoltronPacketType.SplitBufferPDU;
case 0x0045:
return VoltronPacketType.ActionRoomNamePDU;
case 0x0046:
return VoltronPacketType.ActionRoomNameResponsePDU;
case 0x0047:
return VoltronPacketType.NotifyRoomActionedPDU;
case 0x0048:
return VoltronPacketType.ModifyProfilePDU;
case 0x0049:
return VoltronPacketType.ModifyProfileResponsePDU;
case 0x004a:
return VoltronPacketType.ListBBSFoldersPDU;
case 0x004b:
return VoltronPacketType.ListBBSFoldersResponsePDU;
case 0x004c:
return VoltronPacketType.GetBBSMessageListPDU;
case 0x004d:
return VoltronPacketType.GetBBSMessageListResponsePDU;
case 0x004e:
return VoltronPacketType.PostBBSMessagePDU;
case 0x004f:
return VoltronPacketType.PostBBSReplyPDU;
case 0x0050:
return VoltronPacketType.PostBBSMessageResponsePDU;
case 0x0051:
return VoltronPacketType.GetMPSMessagesPDU;
case 0x0052:
return VoltronPacketType.GetMPSMessagesResponsePDU;
case 0x0053:
return VoltronPacketType.DeleteMPSMessagePDU;
case 0x0054:
return VoltronPacketType.DeleteMPSMessageResponsePDU;
case 0x0055:
return VoltronPacketType.BBSMessageDataPDU;
case 0x0056:
return VoltronPacketType.UpdateRoomAdminListPDU;
case 0x0057:
return VoltronPacketType.GetRoomAdminListPDU;
case 0x0058:
return VoltronPacketType.GetRoomAdminListResponsePDU;
case 0x0059:
return VoltronPacketType.GroupInfoRequestPDU;
case 0x005a:
return VoltronPacketType.GroupInfoResponsePDU;
case 0x005b:
return VoltronPacketType.GroupAdminRequestPDU;
case 0x005c:
return VoltronPacketType.GroupAdminResponsePDU;
case 0x005d:
return VoltronPacketType.GroupMembershipRequestPDU;
case 0x005e:
return VoltronPacketType.GroupMembershipResponsePDU;
case 0x005f:
return VoltronPacketType.FlashGroupPDU;
case 0x0060:
return VoltronPacketType.FlashGroupResponsePDU;
case 0x0061:
return VoltronPacketType.UpdateGroupMemberPDU;
case 0x0062:
return VoltronPacketType.UpdateGroupMemberResponsePDU;
case 0x0063:
return VoltronPacketType.UpdateGroupAdminPDU;
case 0x0064:
return VoltronPacketType.UpdateGroupAdminResponsePDU;
case 0x0065:
return VoltronPacketType.ListGroupsPDU;
case 0x0066:
return VoltronPacketType.ListGroupsResponsePDU;
case 0x0067:
return VoltronPacketType.ListJoinedGroupsPDU;
case 0x0068:
return VoltronPacketType.ListJoinedGroupsResponsePDU;
case 0x0069:
return VoltronPacketType.GpsChatPDU;
case 0x006a:
return VoltronPacketType.GpsChatResponsePDU;
case 0x006b:
return VoltronPacketType.PetitionStatusUpdatePDU;
case 0x006c:
return VoltronPacketType.LogGPSPetitionPDU;
case 0x006d:
return VoltronPacketType.LogGPSPetitionResponsePDU;
case 0x006e:
return VoltronPacketType.List20RoomsPDU;
case 0x006f:
return VoltronPacketType.List20RoomsResponsePDU;
case 0x0070:
return VoltronPacketType.UpdateIgnoreListPDU;
case 0x0071:
return VoltronPacketType.ResetWatchdogPDU;
case 0x0072:
return VoltronPacketType.ResetWatchdogResponsePDU;
case 0x2710:
return VoltronPacketType.BroadcastDataBlobPDU;
case 0x2711:
return VoltronPacketType.TransmitDataBlobPDU;
case 0x2712:
return VoltronPacketType.DBRequestWrapperPDU;
case 0x2713:
return VoltronPacketType.TransmitCreateAvatarNotificationPDU;
case 0x2715:
return VoltronPacketType.BC_PlayerLoginEventPDU;
case 0x2716:
return VoltronPacketType.BC_PlayerLogoutEventPDU;
case 0x2718:
return VoltronPacketType.RoomserverUserlistPDU;
case 0x2719:
return VoltronPacketType.LotEntryRequestPDU;
case 0x271a:
return VoltronPacketType.ClientConfigPDU;
case 0x271c:
return VoltronPacketType.KickoutRoommatePDU;
case 0x271d:
return VoltronPacketType.GenericFlashPDU;
case 0x271e:
return VoltronPacketType.GenericFlashRequestPDU;
case 0x271f:
return VoltronPacketType.GenericFlashResponsePDU;
case 0x2722:
return VoltronPacketType.TransmitGenericGDMPDU;
case 0x2723:
return VoltronPacketType.EjectAvatarPDU;
case 0x2724:
return VoltronPacketType.TestPDU;
case 0x2725:
return VoltronPacketType.HouseSimConstraintsPDU;
case 0x2726:
return VoltronPacketType.HouseSimConstraintsResponsePDU;
case 0x2728:
return VoltronPacketType.LoadHouseResponsePDU;
case 0x2729:
return VoltronPacketType.ComponentVersionRequestPDU;
case 0x272a:
return VoltronPacketType.ComponentVersionResponsePDU;
case 0x272b:
return VoltronPacketType.InviteRoommatePDU;
case 0x272c:
return VoltronPacketType.RoommateInvitationAnswerPDU;
case 0x272d:
return VoltronPacketType.RoommateGDMPDU;
case 0x272e:
return VoltronPacketType.HSB_ShutdownSimulatorPDU;
case 0x272f:
return VoltronPacketType.RoommateGDMResponsePDU;
case 0x2730:
return VoltronPacketType.RSGZWrapperPDU;
case 0x2731:
return VoltronPacketType.AvatarHasNewLotIDPDU;
case 0x2733:
return VoltronPacketType.CheatPDU;
case 0x2734:
return VoltronPacketType.DataServiceWrapperPDU;
case 0x2735:
return VoltronPacketType.CsrEjectAvatarPDU;
case 0x2736:
return VoltronPacketType.CsrEjectAvatarResponsePDU;
case 0x2737:
return VoltronPacketType.cTSONetMessagePDU;
case 0x2738:
return VoltronPacketType.LogCsrActionPDU;
case 0x2739:
return VoltronPacketType.LogAvatarActionPDU;
case 0xffff:
return VoltronPacketType.Unknown;
}
return VoltronPacketType.Unknown;
}
public static ushort GetPacketCode(this VoltronPacketType type)
{
switch (type)
{
case VoltronPacketType.AlertHandledPDU:
return 0x0001;
case VoltronPacketType.AlertMsgPDU:
return 0x0002;
case VoltronPacketType.AlertMsgResponsePDU:
return 0x0003;
case VoltronPacketType.AnnouncementMsgResponsePDU:
return 0x0004;
case VoltronPacketType.AnnouncementMsgPDU:
return 0x0005;
case VoltronPacketType.ClientByePDU:
return 0x0006;
case VoltronPacketType.ServerByePDU:
return 0x0007;
case VoltronPacketType.ChatMsgFailedPDU:
return 0x0008;
case VoltronPacketType.ChatMsgPDU:
return 0x0009;
case VoltronPacketType.ClientOnlinePDU:
return 0x000a;
case VoltronPacketType.CreateAndJoinRoomFailedPDU:
return 0x000b;
case VoltronPacketType.CreateAndJoinRoomPDU:
return 0x000c;
case VoltronPacketType.CreateRoomPDU:
return 0x000d;
case VoltronPacketType.CreateRoomResponsePDU:
return 0x000e;
case VoltronPacketType.DestroyRoomPDU:
return 0x000f;
case VoltronPacketType.DestroyRoomResponsePDU:
return 0x0010;
case VoltronPacketType.DetachFromRoomFailedPDU:
return 0x0011;
case VoltronPacketType.DetachFromRoomPDU:
return 0x0012;
case VoltronPacketType.EjectOccupantPDU:
return 0x0013;
case VoltronPacketType.EjectOccupantResponsePDU:
return 0x0014;
case VoltronPacketType.ErrorPDU:
return 0x0015;
case VoltronPacketType.ExitRoomFailedPDU:
return 0x0016;
case VoltronPacketType.ExitRoomPDU:
return 0x0017;
case VoltronPacketType.FindPlayerPDU:
return 0x0018;
case VoltronPacketType.FindPlayerResponsePDU:
return 0x0019;
case VoltronPacketType.FlashMsgResponsePDU:
return 0x001a;
case VoltronPacketType.FlashMsgPDU:
return 0x001b;
case VoltronPacketType.HandleAlertPDU:
return 0x001c;
case VoltronPacketType.HostOfflinePDU:
return 0x001d;
case VoltronPacketType.HostOnlinePDU:
return 0x001e;
case VoltronPacketType.InvitationMsgResponsePDU:
return 0x001f;
case VoltronPacketType.InvitationMsgPDU:
return 0x0020;
case VoltronPacketType.JoinPlayerFailedPDU:
return 0x0021;
case VoltronPacketType.JoinPlayerPDU:
return 0x0022;
case VoltronPacketType.JoinRoomFailedPDU:
return 0x0023;
case VoltronPacketType.JoinRoomPDU:
return 0x0024;
case VoltronPacketType.ListOccupantsPDU:
return 0x0025;
case VoltronPacketType.ListOccupantsResponsePDU:
return 0x0026;
case VoltronPacketType.ListRoomsPDU:
return 0x0027;
case VoltronPacketType.ListRoomsResponsePDU:
return 0x0028;
case VoltronPacketType.LogEventPDU:
return 0x0029;
case VoltronPacketType.LogEventResponsePDU:
return 0x002a;
case VoltronPacketType.MessageLostPDU:
return 0x002b;
case VoltronPacketType.OccupantArrivedPDU:
return 0x002c;
case VoltronPacketType.OccupantDepartedPDU:
return 0x002d;
case VoltronPacketType.ReadProfilePDU:
return 0x002e;
case VoltronPacketType.ReadProfileResponsePDU:
return 0x002f;
case VoltronPacketType.ReleaseProfilePDU:
return 0x0030;
case VoltronPacketType.ReleaseProfileResponsePDU:
return 0x0031;
case VoltronPacketType.SetAcceptAlertsPDU:
return 0x0032;
case VoltronPacketType.SetAcceptAlertsResponsePDU:
return 0x0033;
case VoltronPacketType.SetIgnoreListPDU:
return 0x0034;
case VoltronPacketType.SetIgnoreListResponsePDU:
return 0x0035;
case VoltronPacketType.SetInvinciblePDU:
return 0x0036;
case VoltronPacketType.SetInvincibleResponsePDU:
return 0x0037;
case VoltronPacketType.SetInvisiblePDU:
return 0x0038;
case VoltronPacketType.SetInvisibleResponsePDU:
return 0x0039;
case VoltronPacketType.SetRoomNamePDU:
return 0x003a;
case VoltronPacketType.SetRoomNameResponsePDU:
return 0x003b;
case VoltronPacketType.UpdateOccupantsPDU:
return 0x003c;
case VoltronPacketType.UpdatePlayerPDU:
return 0x003d;
case VoltronPacketType.UpdateProfilePDU:
return 0x003e;
case VoltronPacketType.UpdateRoomPDU:
return 0x003f;
case VoltronPacketType.YankPlayerFailedPDU:
return 0x0040;
case VoltronPacketType.YankPlayerPDU:
return 0x0041;
case VoltronPacketType.SetAcceptFlashesPDU:
return 0x0042;
case VoltronPacketType.SetAcceptFlashesResponsePDU:
return 0x0043;
case VoltronPacketType.SplitBufferPDU:
return 0x0044;
case VoltronPacketType.ActionRoomNamePDU:
return 0x0045;
case VoltronPacketType.ActionRoomNameResponsePDU:
return 0x0046;
case VoltronPacketType.NotifyRoomActionedPDU:
return 0x0047;
case VoltronPacketType.ModifyProfilePDU:
return 0x0048;
case VoltronPacketType.ModifyProfileResponsePDU:
return 0x0049;
case VoltronPacketType.ListBBSFoldersPDU:
return 0x004a;
case VoltronPacketType.ListBBSFoldersResponsePDU:
return 0x004b;
case VoltronPacketType.GetBBSMessageListPDU:
return 0x004c;
case VoltronPacketType.GetBBSMessageListResponsePDU:
return 0x004d;
case VoltronPacketType.PostBBSMessagePDU:
return 0x004e;
case VoltronPacketType.PostBBSReplyPDU:
return 0x004f;
case VoltronPacketType.PostBBSMessageResponsePDU:
return 0x0050;
case VoltronPacketType.GetMPSMessagesPDU:
return 0x0051;
case VoltronPacketType.GetMPSMessagesResponsePDU:
return 0x0052;
case VoltronPacketType.DeleteMPSMessagePDU:
return 0x0053;
case VoltronPacketType.DeleteMPSMessageResponsePDU:
return 0x0054;
case VoltronPacketType.BBSMessageDataPDU:
return 0x0055;
case VoltronPacketType.UpdateRoomAdminListPDU:
return 0x0056;
case VoltronPacketType.GetRoomAdminListPDU:
return 0x0057;
case VoltronPacketType.GetRoomAdminListResponsePDU:
return 0x0058;
case VoltronPacketType.GroupInfoRequestPDU:
return 0x0059;
case VoltronPacketType.GroupInfoResponsePDU:
return 0x005a;
case VoltronPacketType.GroupAdminRequestPDU:
return 0x005b;
case VoltronPacketType.GroupAdminResponsePDU:
return 0x005c;
case VoltronPacketType.GroupMembershipRequestPDU:
return 0x005d;
case VoltronPacketType.GroupMembershipResponsePDU:
return 0x005e;
case VoltronPacketType.FlashGroupPDU:
return 0x005f;
case VoltronPacketType.FlashGroupResponsePDU:
return 0x0060;
case VoltronPacketType.UpdateGroupMemberPDU:
return 0x0061;
case VoltronPacketType.UpdateGroupMemberResponsePDU:
return 0x0062;
case VoltronPacketType.UpdateGroupAdminPDU:
return 0x0063;
case VoltronPacketType.UpdateGroupAdminResponsePDU:
return 0x0064;
case VoltronPacketType.ListGroupsPDU:
return 0x0065;
case VoltronPacketType.ListGroupsResponsePDU:
return 0x0066;
case VoltronPacketType.ListJoinedGroupsPDU:
return 0x0067;
case VoltronPacketType.ListJoinedGroupsResponsePDU:
return 0x0068;
case VoltronPacketType.GpsChatPDU:
return 0x0069;
case VoltronPacketType.GpsChatResponsePDU:
return 0x006a;
case VoltronPacketType.PetitionStatusUpdatePDU:
return 0x006b;
case VoltronPacketType.LogGPSPetitionPDU:
return 0x006c;
case VoltronPacketType.LogGPSPetitionResponsePDU:
return 0x006d;
case VoltronPacketType.List20RoomsPDU:
return 0x006e;
case VoltronPacketType.List20RoomsResponsePDU:
return 0x006f;
case VoltronPacketType.UpdateIgnoreListPDU:
return 0x0070;
case VoltronPacketType.ResetWatchdogPDU:
return 0x0071;
case VoltronPacketType.ResetWatchdogResponsePDU:
return 0x0072;
case VoltronPacketType.BroadcastDataBlobPDU:
return 0x2710;
case VoltronPacketType.TransmitDataBlobPDU:
return 0x2711;
case VoltronPacketType.DBRequestWrapperPDU:
return 0x2712;
case VoltronPacketType.TransmitCreateAvatarNotificationPDU:
return 0x2713;
case VoltronPacketType.BC_PlayerLoginEventPDU:
return 0x2715;
case VoltronPacketType.BC_PlayerLogoutEventPDU:
return 0x2716;
case VoltronPacketType.RoomserverUserlistPDU:
return 0x2718;
case VoltronPacketType.LotEntryRequestPDU:
return 0x2719;
case VoltronPacketType.ClientConfigPDU:
return 0x271a;
case VoltronPacketType.KickoutRoommatePDU:
return 0x271c;
case VoltronPacketType.GenericFlashPDU:
return 0x271d;
case VoltronPacketType.GenericFlashRequestPDU:
return 0x271e;
case VoltronPacketType.GenericFlashResponsePDU:
return 0x271f;
case VoltronPacketType.TransmitGenericGDMPDU:
return 0x2722;
case VoltronPacketType.EjectAvatarPDU:
return 0x2723;
case VoltronPacketType.TestPDU:
return 0x2724;
case VoltronPacketType.HouseSimConstraintsPDU:
return 0x2725;
case VoltronPacketType.HouseSimConstraintsResponsePDU:
return 0x2726;
case VoltronPacketType.LoadHouseResponsePDU:
return 0x2728;
case VoltronPacketType.ComponentVersionRequestPDU:
return 0x2729;
case VoltronPacketType.ComponentVersionResponsePDU:
return 0x272a;
case VoltronPacketType.InviteRoommatePDU:
return 0x272b;
case VoltronPacketType.RoommateInvitationAnswerPDU:
return 0x272c;
case VoltronPacketType.RoommateGDMPDU:
return 0x272d;
case VoltronPacketType.HSB_ShutdownSimulatorPDU:
return 0x272e;
case VoltronPacketType.RoommateGDMResponsePDU:
return 0x272f;
case VoltronPacketType.RSGZWrapperPDU:
return 0x2730;
case VoltronPacketType.AvatarHasNewLotIDPDU:
return 0x2731;
case VoltronPacketType.CheatPDU:
return 0x2733;
case VoltronPacketType.DataServiceWrapperPDU:
return 0x2734;
case VoltronPacketType.CsrEjectAvatarPDU:
return 0x2735;
case VoltronPacketType.CsrEjectAvatarResponsePDU:
return 0x2736;
case VoltronPacketType.cTSONetMessagePDU:
return 0x2737;
case VoltronPacketType.LogCsrActionPDU:
return 0x2738;
case VoltronPacketType.LogAvatarActionPDU:
return 0x2739;
case VoltronPacketType.Unknown:
return 0xffff;
}
return 0;
}
}
}

50
server/FSO.Server.Protocol/Voltron/VoltronPackets.cs Executable file
View file

@ -0,0 +1,50 @@
using FSO.Server.Protocol.Voltron.Packets;
using System;
using System.Collections.Generic;
namespace FSO.Server.Protocol.Voltron
{
public class VoltronPackets
{
public static Dictionary<ushort, Type> VOLTRON_PACKET_BY_TYPEID;
public static Type[] VOLTRON_PACKETS = new Type[] {
typeof(ClientOnlinePDU),
typeof(HostOnlinePDU),
typeof(SetIgnoreListPDU),
typeof(SetIgnoreListResponsePDU),
typeof(SetInvinciblePDU),
typeof(RSGZWrapperPDU),
typeof(TransmitCreateAvatarNotificationPDU),
typeof(DataServiceWrapperPDU),
typeof(DBRequestWrapperPDU),
typeof(OccupantArrivedPDU),
typeof(ClientByePDU),
typeof(ServerByePDU),
typeof(FindPlayerPDU),
typeof(FindPlayerResponsePDU),
typeof(ChatMsgPDU),
typeof(AnnouncementMsgPDU)
};
static VoltronPackets()
{
VOLTRON_PACKET_BY_TYPEID = new Dictionary<ushort, Type>();
foreach (Type packetType in VOLTRON_PACKETS)
{
IVoltronPacket packet = (IVoltronPacket)Activator.CreateInstance(packetType);
VOLTRON_PACKET_BY_TYPEID.Add(packet.GetPacketType().GetPacketCode(), packetType);
}
}
public static Type GetByPacketCode(ushort code)
{
if (VOLTRON_PACKET_BY_TYPEID.ContainsKey(code))
{
return VOLTRON_PACKET_BY_TYPEID[code];
}
else {
return null;
}
}
}
}

15
server/FSO.Server.Protocol/Voltron/cTSONetMessageParameter.cs Executable file
View file

@ -0,0 +1,15 @@
using System;
namespace FSO.Server.Protocol.Voltron
{
[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
public class cTSONetMessageParameter : Attribute
{
public object Value;
public cTSONetMessageParameter(object value)
{
this.Value = value;
}
}
}