using System;
using System.IO;
using System.Collections.Generic;
using System.Text;
using CommonAI.RTS;
using CommonLang.Vector;
using CommonLang.IO;
using CommonLang.ByteOrder;
using CommonLang.IO.Attribute;
using CommonLang;
using CommonLang.Protocol;
using CommonAI.Zone.Helper;
using CommonAI.ZoneClient;
using CommonAI.Zone.Instance;
using CommonLang.Log;
using CommonAI.ZoneServer.JSGModule;
using CommonAI.Data;
namespace CommonAI.Zone
{
#region ABSTRACT
/// <summary>
/// 向服务器端发送的指令
/// </summary>
abstract public class Action : IMessage, BattleMessage
{
//private static int Inxexer = 0;
public GameEntity sender;
public int MessageID { get; set; }
public Action() { }
abstract public void WriteExternal(IOutputStream output);
abstract public void ReadExternal(IInputStream input);
virtual public void BeforeWrite(TemplateManager templates) { }
virtual public void EndRead(TemplateManager templates) { }
}
/// <summary>
/// 客户端接收到的消息
/// </summary>
abstract public class Event : IMessage, BattleMessage
{
public GameEntity sender;
public int MessageID { get; set; }
abstract public void WriteExternal(IOutputStream output);
abstract public void ReadExternal(IInputStream input);
virtual public void BeforeWrite(TemplateManager templates) { }
virtual public void EndRead(TemplateManager templates) { }
}
public interface BattleMessage
{
void BeforeWrite(TemplateManager templates);
void EndRead(TemplateManager templates);
}
/// <summary>
/// 某个位置上的事件
/// </summary>
public interface PositionMessage
{
float X { get; }
float Y { get; }
}
/// <summary>
/// 主角的事件
/// </summary>
public interface ActorMessage
{
uint ObjectID { get; }
}
/** 单人事件 */
public abstract class PlayerSingleMsg : ObjectEvent
{
}
/// <summary>
/// 系统消息
/// </summary>
public interface SystemMessage
{
}
//--------------------------------------------------------------------------
/// <summary>
/// 向服务器端某个单位发送的指令
/// </summary>
abstract public class ObjectAction : Action
{
/// <summary>
/// 不需要传输object_id, 使用sender对象来绑定Session和InstanceUnit的关联//
/// </summary>
public uint object_id;
protected ObjectAction() { }
protected ObjectAction(uint obj_id)
{
this.object_id = obj_id;
}
override public void WriteExternal(IOutputStream output)
{
// 不需要传输object_id, 使用sender对象来绑定Session和InstanceUnit//
}
override public void ReadExternal(IInputStream input)
{
// 不需要传输object_id, 使用sender对象来绑定Session和InstanceUnit//
}
}
/// <summary>
/// 某个单位的事件消息
/// </summary>
abstract public class ObjectEvent : Event
{
public uint object_id;
public uint ObjectID { get { return object_id; } }
protected ObjectEvent() { }
protected ObjectEvent(uint obj_id)
{
this.object_id = obj_id;
}
override public void WriteExternal(IOutputStream output)
{
output.PutVU32(object_id);
}
override public void ReadExternal(IInputStream input)
{
this.object_id = input.GetVU32();
}
}
//--------------------------------------------------------------------------
/// <summary>
/// 向服务器端某个单位发送的请求
/// </summary>
abstract public class ActorRequest : ObjectAction
{
protected ActorRequest() { }
protected ActorRequest(uint obj_id)
: base(obj_id)
{
}
}
/// <summary>
/// 向服务器端某个单位发送请求对应的回馈
/// </summary>
abstract public class ActorResponse : ObjectEvent, ActorMessage
{
protected ActorResponse() { }
protected ActorResponse(uint obj_id)
: base(obj_id)
{
}
}
#endregion
//--------------------------------------------------------------------------
#region ZONE_EVENTS_0x8000
public abstract class ZoneEvent : Event
{
}
/// <summary>
/// 添加单位事件
/// </summary>
[MessageType(0x8001)]
public class AddUnitEvent : ZoneEvent
{
public SyncUnitInfo Sync;
public string ErrorMessage;
public byte flag; //标记：0：正常生成，1：归属某个服务器
public uint unit_id
{
get
{
if (Sync != null)
{
return Sync.ObjectID;
}
return 0;
}
}
public AddUnitEvent() { }
public AddUnitEvent(SyncUnitInfo sync)
{
this.Sync = sync;
}
override public void WriteExternal(IOutputStream output)
{
output.PutExt(Sync);
output.PutUTF(ErrorMessage);
output.PutU8(flag);
}
override public void ReadExternal(IInputStream input)
{
this.Sync = input.GetExt<SyncUnitInfo>();
this.ErrorMessage = input.GetUTF();
this.flag = input.GetU8();
}
}
/// <summary>
/// 添加法术/飞行道具效果事件
/// </summary>
[MessageType(0x8002)]
public class AddSpellEvent : ZoneEvent
{
private BitSet8 mask = new BitSet8();
public bool IsLauncherSender
{
get { return mask.Get(0); }
private set { mask.Set(0, value); }
}
public bool IsTargetPos
{
get { return mask.Get(1); }
private set { mask.Set(1, value); }
}
public bool IsTargetObject
{
get { return mask.Get(2); }
private set { mask.Set(2, value); }
}
public bool IsHeight
{
get { return mask.Get(3); }
private set { mask.Set(3, value); }
}
public bool IsSyncPos
{
get { return mask.Get(4); }
private set { mask.Set(4, value); }
}
public bool IsHalf
{
get { return mask.Get(7); }
private set { mask.Set(7, value); }
}
public int spell_template_id
{
get { return (launch_data != null) ? launch_data.SpellID : 0; }
}
public LaunchSpell LaunchData
{
get { return launch_data; }
}
private LaunchSpell launch_data;
private uint launch_data_sn = 0;
public uint spell_id;
public uint launcher_unit_id;
public uint sender_unit_id;
public uint target_obj_id;
public Vector2 target_pos;
public float x;
public float y;
public float direction;
public float height;
public int SpellID;
public AddSpellEvent() { }
public AddSpellEvent(InstanceSpell spell)
{
this.launch_data = spell.LaunchData;
this.spell_id = spell.ID;
this.sender_unit_id = spell.SenderID;
this.launcher_unit_id = spell.LauncherID;
this.target_obj_id = spell.TargetID;
this.target_pos = spell.TargetPos;
this.x = spell.X;
this.y = spell.Y;
this.direction = spell.Direction;
this.height = spell.Z;
//mask//
this.IsLauncherSender = (launcher_unit_id == sender_unit_id);
this.IsTargetPos = (spell.Info.MType == SpellTemplate.MotionType.Cannon || spell.Info.MType == SpellTemplate.MotionType.CurveMissile) && (target_pos != null);
this.IsTargetObject = (target_obj_id != 0);
this.IsHeight = (height != 0);
this.IsHalf = spell.Parent.IsHalfSync;
this.IsSyncPos = spell.Info.IsLaunchSpellEventSyncPos;
this.SpellID = this.launch_data.SpellID;
}
public override void BeforeWrite(TemplateManager templates)
{
base.BeforeWrite(templates);
if (launch_data != null)
{
this.launch_data_sn = this.LaunchData.IsCodeCreate() ? uint.MaxValue: launch_data.SerialNumber;
}
}
public override void EndRead(TemplateManager templates)
{
base.EndRead(templates);
if(this.launch_data_sn == uint.MaxValue)
{
this.launch_data = JSGGlobalData.GetUnConfigSpellByID((int)this.SpellID);
//System.Console.WriteLine("123123123: " + this.launch_data.SpellID + ", " + this.launch_data.FromUnitBody);
}
else
{
this.launch_data = templates.GetSnData<LaunchSpell>(launch_data_sn);
}
}
override public void WriteExternal(IOutputStream output)
{
output.PutU8(mask.Mask);
output.PutVU32(spell_id);
output.PutVU32(launch_data_sn);
if (this.IsLauncherSender)
{
output.PutVU32(launcher_unit_id);
}
else
{
output.PutVU32(sender_unit_id);
output.PutVU32(launcher_unit_id);
}
if (this.IsTargetObject)
{
output.PutVU32(target_obj_id);
}
if (this.IsTargetPos)
{
MoveHelper.WritePos(IsHalf, target_pos.X, target_pos.Y, output);
}
if (this.IsSyncPos)
{
MoveHelper.WritePosAndDirection(IsHalf, x, y, direction, output);
}
if (this.IsHeight)
{
MoveHelper.WritePos(IsHalf, height, output);
}
if (this.LaunchData.IsCodeCreate())
{
output.PutS32(this.SpellID);
}
//System.Console.WriteLine("AddSpell: " + this.launch_data.SpellID + ", ID: " + spell_id + ", XY:" + this.x + ", " + this.y + ", d:" + this.direction);
}
override public void ReadExternal(IInputStream input)
{
this.mask.Mask = input.GetU8();
this.spell_id = input.GetVU32();
this.launch_data_sn = input.GetVU32();
if (this.IsLauncherSender)
{
this.launcher_unit_id = this.sender_unit_id = input.GetVU32();
}
else
{
this.sender_unit_id = input.GetVU32();
this.launcher_unit_id = input.GetVU32();
}
if (this.IsTargetObject)
{
this.target_obj_id = input.GetVU32();
}
if (this.IsTargetPos)
{
this.target_pos = new Vector2();
MoveHelper.ReadPos(IsHalf, ref target_pos, input);
}
if (this.IsSyncPos)
{
MoveHelper.ReadPosAndDirection(IsHalf, out x, out y, out direction, input);
}
if (this.IsHeight)
{
MoveHelper.ReadPos(IsHalf, out height, input);
}
if(this.launch_data_sn == uint.MaxValue)
{
this.SpellID = input.GetS32();
}
}
}
/// <summary>
/// 单位动作中击中别的单位
/// </summary>
[MessageType(0x8003)]
public class AddEffectEvent : ZoneEvent, PositionMessage
{
public uint hostId = 0;
public float x;
public float y;
public float direction;
private uint effect_sn = 0;
public LaunchEffect effect { get; set; }
public AddEffectEvent() { }
public AddEffectEvent(uint hostId , float x, float y, float dir, LaunchEffect effect)
{
this.hostId = hostId;
this.x = x;
this.y = y;
this.direction = dir;
this.effect = effect;
}
override public void WriteExternal(IOutputStream output)
{
output.PutVU32(hostId);
output.PutF32(x);
output.PutF32(y);
output.PutF32(direction);
output.PutVU32(effect_sn);
}
override public void ReadExternal(IInputStream input)
{
this.hostId = input.GetVU32();
this.x = input.GetF32();
this.y = input.GetF32();
this.direction = input.GetF32();
this.effect_sn = input.GetVU32();
}
public override void BeforeWrite(TemplateManager templates)
{
if (effect != null)
{
this.effect_sn = effect.SerialNumber;
}
}
public override void EndRead(TemplateManager templates)
{
this.effect = templates.GetSnData<LaunchEffect>(effect_sn);
}
public float X { get { return x; } }
public float Y { get { return y; } }
}
/// <summary>
/// 添加道具事件
/// </summary>
[MessageType(0x8004)]
public class AddItemEvent : ZoneEvent
{
public SyncItemInfo Sync;
public string ErrorMessage;
public uint unit_id
{
get { if (Sync != null) { return Sync.ObjectID; } return 0; }
}
public AddItemEvent() { }
public AddItemEvent(SyncItemInfo sync)
{
this.Sync = sync;
}
override public void WriteExternal(IOutputStream output)
{
output.PutExt(Sync);
output.PutUTF(ErrorMessage);
}
override public void ReadExternal(IInputStream input)
{
this.Sync = input.GetExt<SyncItemInfo>();
this.ErrorMessage = input.GetUTF();
}
}
/// <summary>
/// 某个对象从场景中移除
/// </summary>
[MessageType(0x8005)]
public class RemoveObjectEvent : ZoneEvent
{
public uint object_id;
public RemoveObjectEvent() { }
public RemoveObjectEvent(uint oid)
{
this.object_id = oid;
}
override public void WriteExternal(IOutputStream output)
{
//Console.WriteLine(" - RemoveObjectEvent - " + this.object_id);
output.PutVU32(object_id);
}
override public void ReadExternal(IInputStream input)
{
this.object_id = input.GetVU32();
}
}
/// <summary>
/// 同步场景中移动单位的坐标
/// </summary>
[MessageType(0x8006)]
public class SyncPosEvent : ZoneEvent
{
public struct UnitPos : IVector2
{
private uint m_ID;
private float m_X;
private float m_Y;
private float m_Z;
private float m_Direction;
public uint ID { get { return m_ID; } }
public float Direction { get { return m_Direction; } set { m_Direction = value; } }
public float X { get { return m_X; } set { m_X = value; } }
public float Y { get { return m_Y; } set { m_Y = value; } }
public float Z { get { return m_Z; } set { m_Z = value; } }
public void SetObject(InstanceZoneObject obj)
{
this.m_ID = obj.ID;
this.m_X = obj.X;
this.m_Y = obj.Y;
this.m_Z = obj.Z;
this.m_Direction = obj.Direction;
}
internal void Write(IOutputStream output, bool half, bool sync_z)
{
output.PutVU32(m_ID);
if (half)
{
output.PutU16(MoveHelper.ToPos16(m_X));
output.PutU16(MoveHelper.ToPos16(m_Y));
if (sync_z) output.PutU16(MoveHelper.ToPos16(m_Z));
}
else
{
output.PutF32(m_X);
output.PutF32(m_Y);
if (sync_z) output.PutF32(m_Z);
}
output.PutU8(MoveHelper.ToDirectionD8(m_Direction));
//if (m_ID == 2649)
//{
// Console.WriteLine("SyncPos, " + TimeUtil.GetTimestampMS() + ", X: " + this.m_X + ",Y: " + this.m_Y);
//}
}
internal void Read(IInputStream input, bool half, bool sync_z)
{
m_ID = input.GetVU32();
if (half)
{
m_X = MoveHelper.ToPosF32(input.GetU16());
m_Y = MoveHelper.ToPosF32(input.GetU16());
if (sync_z) m_Z = MoveHelper.ToPosF32(input.GetU16());
}
else
{
m_X = input.GetF32();
m_Y = input.GetF32();
if (sync_z) m_Z = input.GetF32();
}
m_Direction = MoveHelper.ToDirectionF32(input.GetU8());
}
public void SetX(float value)
{
//throw new NotImplementedException();
}
public void SetY(float value)
{
//throw new NotImplementedException();
}
public void AddX(float value)
{
//throw new NotImplementedException();
}
public void AddY(float value)
{
//throw new NotImplementedException();
}
}
public struct UnitState
{
private uint m_ID;
private byte m_UnitMainState;
private byte m_UnitSubState;
public uint ID { get { return m_ID; } }
public UnitActionStatus UnitMainState
{
get { return (UnitActionStatus)m_UnitMainState; }
set { m_UnitMainState = (byte)value; }
}
public byte UnitSubState
{
get { return m_UnitSubState; }
set { m_UnitSubState = value; }
}
public void SetObject(InstanceUnit obj)
{
this.m_ID = obj.ID;
this.m_UnitMainState = (byte)obj.CurrentActionStatus;
this.m_UnitSubState = (byte)obj.CurrentActionSubstate;
}
internal void Write(IOutputStream output)
{
output.PutVU32(m_ID);
output.PutU8(m_UnitMainState);
output.PutU8(m_UnitSubState);
//if (m_ID == 2649)
//{
// Console.WriteLine("SyncPos - " + this.ID + ", m_UnitMainState = " + m_UnitMainState + ", m_UnitSubState = " + m_UnitSubState);
//}
}
internal void Read(IInputStream input)
{
m_ID = input.GetVU32();
m_UnitMainState = input.GetU8();
m_UnitSubState = input.GetU8();
}
}
private BitSet8 mask = new BitSet8();
private long pass_time_ms;
public UnitPos[] units_pos;
public UnitState[] units_st;
public bool IsHalf
{
get { return mask.Get(0); }
private set { mask.Set(0, value); }
}
public bool IsSyncZ
{
get { return mask.Get(1); }
private set { mask.Set(1, value); }
}
public long PassTimeMS { get { return pass_time_ms; } }
public bool IsEmpty { get { return (units_pos == null || units_pos.Length == 0) && (units_st == null || units_st.Length == 0); } }
public SyncPosEvent() { }
public SyncPosEvent(bool half, bool sync_z, long passtime)
{
this.IsHalf = half;
this.IsSyncZ = sync_z;
this.pass_time_ms = passtime;
}
override public void WriteExternal(IOutputStream output)
{
output.PutU8(mask.Mask);
output.PutVS64(pass_time_ms);
bool syncz = IsSyncZ;
bool half = IsHalf;
if (units_pos != null)
{
output.PutVS32(units_pos.Length);
for (int i = 0; i < units_pos.Length; i++)
{
units_pos[i].Write(output, half, syncz);
}
}
else
{
output.PutVS32(0);
}
if (units_st != null)
{
output.PutVS32(units_st.Length);
for (int i = 0; i < units_st.Length; i++)
{
units_st[i].Write(output);
}
}
else
{
output.PutVS32(0);
}
}
override public void ReadExternal(IInputStream input)
{
this.mask.Mask = input.GetU8();
this.pass_time_ms = input.GetVS64();
bool syncz = IsSyncZ;
bool half = IsHalf;
this.units_pos = new UnitPos[input.GetVS32()];
for (int i = 0; i < units_pos.Length; i++)
{
units_pos[i].Read(input, half, syncz);
}
this.units_st = new UnitState[input.GetVS32()];
for (int i = 0; i < units_st.Length; i++)
{
//UnityEngine.Debug.Log("m_ID = "+units_st[i].ID + " UnitMainState = " +units_st[i].UnitMainState);
units_st[i].Read(input);
}
}
}
/// <summary>
/// 服务端通知客户端执行一段脚本
/// </summary>
[MessageType(0x8007)]
public class DoScriptEvent : ZoneEvent
{
public string ScriptFileName;
public DoScriptEvent() { }
public DoScriptEvent(string filename)
{
this.ScriptFileName = filename;
}
override public void WriteExternal(IOutputStream output)
{
output.PutUTF(ScriptFileName);
}
override public void ReadExternal(IInputStream input)
{
this.ScriptFileName = input.GetUTF();
}
}
/// <summary>
/// 脚本系统指令
/// </summary>
[MessageType(0x8008)]
public class ScriptCommandEvent : ZoneEvent
{
public string message;
public ScriptCommandEvent() { }
public ScriptCommandEvent(string msg)
{
this.message = msg;
}
override public void WriteExternal(IOutputStream output)
{
output.PutUTF(message);
}
override public void ReadExternal(IInputStream input)
{
this.message = input.GetUTF();
}
}
/// <summary>
/// 游戏结束指令
/// </summary>
[MessageType(0x8009)]
public class GameOverEvent : ZoneEvent
{
public string message;
public int WinForce;
public GameOverEvent() { }
public GameOverEvent(int force, string msg)
{
this.WinForce = force;
this.message = msg;
}
override public void WriteExternal(IOutputStream output)
{
output.PutUTF(message);
output.PutS32(WinForce);
}
override public void ReadExternal(IInputStream input)
{
this.message = input.GetUTF();
this.WinForce = input.GetS32();
}
}
[MessageType(0x800A)]
public class DecorationChangedEvent : ZoneEvent
{
public string Name;
public bool Enable;
public DecorationChangedEvent() { }
public DecorationChangedEvent(string name, bool enable)
{
this.Name = name;
this.Enable = enable;
}
override public void WriteExternal(IOutputStream output)
{
output.PutUTF(Name);
output.PutBool(Enable);
}
override public void ReadExternal(IInputStream input)
{
this.Name = input.GetUTF();
this.Enable = input.GetBool();
}
}
[MessageType(0x800B)]
public class SyncEnvironmentVarEvent : ZoneEvent
{
public string Key;
public object Value;
public SyncEnvironmentVarEvent() { }
public SyncEnvironmentVarEvent(string key, object value)
{
this.Key = key;
this.Value = value;
}
override public void WriteExternal(IOutputStream output)
{
output.PutUTF(Key);
output.PutData(Value);
}
override public void ReadExternal(IInputStream input)
{
DataType dtype;
this.Key = input.GetUTF();
this.Value = input.GetData(out dtype);
}
}
[MessageType(0x800C)]
public class ChangeBGMEvent : ZoneEvent
{
public string FileName;
public ChangeBGMEvent() { }
public ChangeBGMEvent(string file)
{
this.FileName = file;
}
override public void WriteExternal(IOutputStream output)
{
output.PutUTF(FileName);
}
override public void ReadExternal(IInputStream input)
{
this.FileName = input.GetUTF();
}
}
[MessageType(0x800D)]
public class FlagTagChangedEvent : ZoneEvent
{
public string Name;
public string Tag;
public FlagTagChangedEvent() { }
public FlagTagChangedEvent(string name, string tag = null)
{
this.Name = name;
this.Tag = tag;
}
override public void WriteExternal(IOutputStream output)
{
output.PutUTF(Name);
output.PutUTF(Tag);
}
override public void ReadExternal(IInputStream input)
{
this.Name = input.GetUTF();
this.Tag = input.GetUTF();
}
}
#endregion
//--------------------------------------------------------------------------
#region OBJECT_EVENTS_0x8100
/// <summary>
/// 同步单位数据，频繁需要改变的数据
/// </summary>
[MessageType(0x8100)]
public class UnitFieldChangedEvent : ObjectEvent
{
public const uint MASK_ALL = 0xFFFF;
public const uint MASK_HP = 1;
public const uint MASK_MP = 1 << 1;
public const uint MASK_MAX_HP = 1 << 2;
public const uint MASK_MAX_MP = 1 << 3;
public const uint MASK_SPEED = 1 << 4;
public const uint MASK_SP = 1 << 5;
public const uint MASK_MAX_SP = 1 << 6;
public const uint MASK_FCR = 1 << 7;
public const uint MASK_MONEY = 1 << 8;
public const uint MASK_LEVEL = 1 << 9;
public const uint MASK_DUMMY_0 = 1 << 10;
public const uint MASK_DUMMY_1 = 1 << 11;
public const uint MASK_DUMMY_2 = 1 << 12;
public const uint MASK_DUMMY_3 = 1 << 13;
public const uint MASK_DUMMY_4 = 1 << 14;
public const uint MASK_DUMMY_5 = 1 << 15;
//-- NEW Property
public const uint MASK_SKILL_CD_ACC = 1 << 16;
public const uint MASK_CONTROLED_ACC = 1 << 17;
public uint mask = 0;
public int currentHP;
public int currentMP;
public int maxHP;
public int maxMP;
public int currentSP;
public int maxSP;
public float currentSpeed;
public float currentFCR;
public int currentMoney;
public int level;
public int dummy_0;
public int dummy_1;
public int dummy_2;
public int dummy_3;
public int dummy_4;
public int dummy_5;
//-- NEW Property
public int skill_cd_acc;
public int controled_acc;
public UnitFieldChangedEvent() { }
public UnitFieldChangedEvent(uint unit_id, ushort mask)
: base(unit_id)
{
this.mask = mask;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutVU32(mask);
if ((mask & MASK_HP) != 0) output.PutS32(currentHP);
if ((mask & MASK_MP) != 0) output.PutS32(currentMP);
if ((mask & MASK_MAX_HP) != 0) output.PutS32(maxHP);
if ((mask & MASK_MAX_MP) != 0) output.PutS32(maxMP);
if ((mask & MASK_SP) != 0) output.PutS32(currentSP);
if ((mask & MASK_MAX_SP) != 0) output.PutS32(maxSP);
if ((mask & MASK_SPEED) != 0) output.PutF32(currentSpeed);
if ((mask & MASK_FCR) != 0) output.PutF32(currentFCR);
if ((mask & MASK_MONEY) != 0) output.PutS32(currentMoney);
if ((mask & MASK_LEVEL) != 0) output.PutS32(level);
if ((mask & MASK_DUMMY_0) != 0) output.PutS32(dummy_0);
if ((mask & MASK_DUMMY_1) != 0) output.PutS32(dummy_1);
if ((mask & MASK_DUMMY_2) != 0) output.PutS32(dummy_2);
if ((mask & MASK_DUMMY_3) != 0) output.PutS32(dummy_3);
if ((mask & MASK_DUMMY_4) != 0) output.PutS32(dummy_4);
if ((mask & MASK_DUMMY_5) != 0) output.PutS32(dummy_5);
//-- NEW Property
if ((mask & MASK_SKILL_CD_ACC) != 0) output.PutS32(skill_cd_acc);
if ((mask & MASK_CONTROLED_ACC) != 0) output.PutS32(controled_acc);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.mask = input.GetVU32();
if ((mask & MASK_HP) != 0) this.currentHP = input.GetS32();
if ((mask & MASK_MP) != 0) this.currentMP = input.GetS32();
if ((mask & MASK_MAX_HP) != 0) this.maxHP = input.GetS32();
if ((mask & MASK_MAX_MP) != 0) this.maxMP = input.GetS32();
if ((mask & MASK_SP) != 0) this.currentSP = input.GetS32();
if ((mask & MASK_MAX_SP) != 0) this.maxSP = input.GetS32();
if ((mask & MASK_SPEED) != 0) this.currentSpeed = input.GetF32();
if ((mask & MASK_FCR) != 0) this.currentFCR = input.GetF32();
if ((mask & MASK_MONEY) != 0) this.currentMoney = input.GetS32();
if ((mask & MASK_LEVEL) != 0) this.level = input.GetS32();
if ((mask & MASK_DUMMY_0) != 0) this.dummy_0 = input.GetS32();
if ((mask & MASK_DUMMY_1) != 0) this.dummy_1 = input.GetS32();
if ((mask & MASK_DUMMY_2) != 0) this.dummy_2 = input.GetS32();
if ((mask & MASK_DUMMY_3) != 0) this.dummy_3 = input.GetS32();
if ((mask & MASK_DUMMY_4) != 0) this.dummy_4 = input.GetS32();
if ((mask & MASK_DUMMY_5) != 0) this.dummy_5 = input.GetS32();
//-- NEW Property
if ((mask & MASK_SKILL_CD_ACC) != 0) this.skill_cd_acc = input.GetS32();
if ((mask & MASK_CONTROLED_ACC) != 0) this.controled_acc = input.GetS32();
}
}
/// <summary>
/// 单位进入吟唱状态
/// </summary>
[MessageType(0x810a)]
public class UnitChantSkillEvent : ObjectEvent
{
public int skill_id;
public int chant_ms;
public UnitChantSkillEvent() { }
public UnitChantSkillEvent(uint unit_id, SkillTemplate sk)
: base(unit_id)
{
this.skill_id = sk.TemplateID;
this.chant_ms = sk.ChantTimeMS;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutS32(skill_id);
output.PutVS32(chant_ms);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.skill_id = input.GetS32();
this.chant_ms = input.GetVS32();
}
}
/// <summary>
/// 单位进入技能状态
/// </summary>
[MessageType(0x810b)]
public class UnitLaunchSkillEvent : ObjectEvent
{
public int skill_id { get; private set; }
/// <summary>
/// 如果是单一动作，则标识是哪一段攻击
/// </summary>
public byte action_index { get; private set; }
/// <summary>
/// 技能每段动作的时间，单一动作的话(SkillTemplate.IsSingleAction)，长度为1
/// </summary>
public int[] action_time_array { get; private set; }
public int TotalCDTimeMS { get; private set; }
public float action_speed { get; private set; }
public Vector2 spell_target_pos { get; private set; }
public uint target_object_id { get; private set; }
//节点动作加速（加法）
public float [] action_speed_add { get; private set; }
private BitSet8 bitMask = new BitSet8();
public bool IsSingleAction
{
get { return bitMask.Get(0); }
private set { bitMask.Set(0, value); }
}
public bool ActionSpeedAddition
{
get { return bitMask.Get(1); }
private set { bitMask.Set(1, value); }
}
public bool IsActionSpeedUP
{
get { return bitMask.Get(2); }
private set { bitMask.Set(2, value); }
}
public bool IsActionTimeChanged
{
get { return bitMask.Get(3); }
private set { bitMask.Set(3, value); }
}
public bool IsAutoFocusNearTarget
{
get { return bitMask.Get(4); }
private set { bitMask.Set(4, value); }
}
public bool IsSpellTargetPos
{
get { return bitMask.Get(5); }
private set { bitMask.Set(5, value); }
}
public bool IsTargetObject
{
get { return bitMask.Get(6); }
private set { bitMask.Set(6, value); }
}
public bool IsChangeTotalCDTime
{
get { return bitMask.Get(7); }
private set { bitMask.Set(7, value); }
}
public int TotalActionTimeMS
{
get
{
int total = 0;
if (action_time_array != null)
{
foreach (int timeMS in action_time_array)
{
total += timeMS;
}
}
return total;
}
}
public UnitLaunchSkillEvent() { }
public UnitLaunchSkillEvent(
uint unit_id,
SkillTemplate sk,
byte actionIndex,
float actionSpeed,
int totalCDTimeMS,
bool isAutoFaceToTarget,
Vector2 spellTargetPos,
uint targetObjectID,
int lockActionStep)
: base(unit_id)
{
this.skill_id = sk.TemplateID;
this.action_speed = actionSpeed;
this.TotalCDTimeMS = totalCDTimeMS;
this.spell_target_pos = spellTargetPos;
this.target_object_id = targetObjectID;
this.IsAutoFocusNearTarget = isAutoFaceToTarget;
this.IsSingleAction = sk.IsSingleAction;
this.IsActionSpeedUP = (actionSpeed != 1f);
this.IsTargetObject = (targetObjectID != 0);
this.IsSpellTargetPos = spellTargetPos != null;
this.IsChangeTotalCDTime = totalCDTimeMS != sk.CoolDownMS;
this.action_speed_add = new float[sk.ActionQueue.Count];
for(int i = 0; i < sk.ActionQueue.Count; i++)
{
if(sk.ActionQueue[i].ActionSpeedRate != 0.0f)
{
this.action_speed_add[i] = sk.ActionQueue[i].ActionSpeedRate;
this.ActionSpeedAddition = true;
}
}
if (sk.IsSingleAction || lockActionStep >= 0)
{
this.action_index = actionIndex;
this.action_time_array = new int[] { sk.ActionQueue[actionIndex].TotalTimeMS };
}
else
{
this.action_index = 0;
this.action_time_array = sk.ActionQueueTimeArray;
}
}
public override void BeforeWrite(TemplateManager templates)
{
base.BeforeWrite(templates);
var orgin_temp = templates.getSkill(skill_id);
if (this.action_time_array == null)
{
this.IsActionTimeChanged = false;
}
else if (this.IsSingleAction)
{
this.IsActionTimeChanged = (this.action_time_array[0] != orgin_temp.ActionQueue[action_index].TotalTimeMS);
}
else
{
this.IsActionTimeChanged = !CUtils.ArraysEqual<int>(this.action_time_array, orgin_temp.ActionQueueTimeArray);
}
}
public override void EndRead(TemplateManager templates)
{
base.EndRead(templates);
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutS32(skill_id);
output.PutU8(bitMask.Mask);
if (IsSingleAction)
{
output.PutU8(action_index);
if (IsActionTimeChanged) output.PutS32(action_time_array[0]);
}
else
{
if (IsActionTimeChanged) output.PutArray<int>(action_time_array, output.PutS32);
}
if (IsActionSpeedUP)
{
output.PutF32(action_speed);
}
if (IsChangeTotalCDTime)
{
output.PutVS32(TotalCDTimeMS);
}
if (IsTargetObject)
{
output.PutU32(this.target_object_id);
}
if (IsSpellTargetPos)
{
output.PutF32(spell_target_pos.X);
output.PutF32(spell_target_pos.Y);
}
if(ActionSpeedAddition)
{
output.PutArray<float>(this.action_speed_add, output.PutF32);
}
//System.Console.WriteLine("释放技能：" + this.skill_id + ", " + this.action_index);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.skill_id = input.GetS32();
this.bitMask.Mask = input.GetU8();
if (IsSingleAction)
{
this.action_index = input.GetU8();
if (IsActionTimeChanged) this.action_time_array = new int[] { input.GetS32() };
}
else
{
if (IsActionTimeChanged) this.action_time_array = input.GetArray<int>(input.GetS32);
}
if (IsActionSpeedUP)
{
this.action_speed = input.GetF32();
}
else
{
this.action_speed = 1f;
}
if (IsChangeTotalCDTime)
{
this.TotalCDTimeMS = input.GetVS32();
}
if (IsTargetObject)
{
this.target_object_id = input.GetU32();
}
if (IsSpellTargetPos)
{
spell_target_pos = new Vector2();
spell_target_pos.SetX(input.GetF32());
spell_target_pos.SetY(input.GetF32());
}
if (ActionSpeedAddition)
{
this.action_speed_add = input.GetArray<float>(input.GetF32);
}
}
public override string ToString()
{
return string.Format("LaunchSkill: {0}@{1}", skill_id, action_index);
}
}
/// <summary>
/// 单位动作中击中别的单位
/// </summary>
[MessageType(0x810d)]
public class UnitEffectEvent : ObjectEvent
{
private uint effect_sn = 0;
/// <summary>
/// 特效名字
/// </summary>
public LaunchEffect effect { get; set; }
public UnitEffectEvent() { }
public UnitEffectEvent(uint unit_id, LaunchEffect effect)
: base(unit_id)
{
this.effect = effect;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutVU32(effect_sn);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.effect_sn = input.GetVU32();
}
public override void BeforeWrite(TemplateManager templates)
{
if (effect != null)
{
this.effect_sn = effect.SerialNumber;
}
}
public override void EndRead(TemplateManager templates)
{
this.effect = templates.GetSnData<LaunchEffect>(effect_sn);
}
}
/// <summary>
/// 单位仅做一个动作
/// </summary>
[MessageType(0x810e)]
public class UnitDoActionEvent : ObjectEvent
{
public string ActionName;
public UnitDoActionEvent() { }
public UnitDoActionEvent(uint unit_id, string actionName)
: base(unit_id)
{
this.ActionName = actionName;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutUTF(ActionName);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
ActionName = input.GetUTF();
}
}
/// <summary>
/// 单位被击中
/// </summary>
[MessageType(0x810f)]
public class UnitHitEvent : ObjectEvent
{
public bool isDead
{
get { return BitMask.BitGetMask(bitMask, 0); }
set { BitMask.BitSetMask(ref bitMask, 0, value); }
}
//特殊来源的伤害
public bool isSpecialHit
{
get { return BitMask.BitGetMask(bitMask, 1); }
set { BitMask.BitSetMask(ref bitMask, 1, value); }
}
public bool isCritical
{
get { return BitMask.BitGetMask(bitMask, 2); }
set { BitMask.BitSetMask(ref bitMask, 2, value); }
}
public bool HasEffect
{
get { return BitMask.BitGetMask(bitMask, 3); }
private set { BitMask.BitSetMask(ref bitMask, 3, value); }
}
public bool HasSourceAttack
{
get { return BitMask.BitGetMask(bitMask, 6); }
private set { BitMask.BitSetMask(ref bitMask, 6, value); }
}
public uint senderId;
public int hp;
public byte client_state;
private byte bitMask = 0;
private LaunchEffect biteffect;
private uint biteffect_sn;
private AttackProp sourceAttack;
private uint sourceAttack_sn;
// 伤害来源，非def才需要额外处理
public DamageSource dmgSrc;
//内部字段
//针对特殊伤害的特殊处理
public bool InViewForceSend = false;
public uint senderMasterId; //如果sender为召唤物，这个存放主人id(用来广播判断，非网络字段)
public uint hitMasterId; //单位的masterid
public LaunchEffect effect
{
get { return biteffect; }
set
{
this.biteffect = value;
this.HasEffect = (value != null);
}
}
public AttackProp SourceAttack
{
get { return sourceAttack; }
set
{
this.sourceAttack = value;
this.HasSourceAttack = (value != null);
}
}
public UnitHitEvent() { }
public UnitHitEvent(uint unit_id)
: base(unit_id)
{
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutVU32(senderId);
output.PutVS32(hp);
output.PutU8(client_state);
output.PutU8(bitMask);
if (HasEffect)
{
output.PutVU32(biteffect_sn);
}
if (HasSourceAttack)
{
output.PutVU32(sourceAttack_sn);
}
if(isSpecialHit)
{
output.PutEnum8(dmgSrc);
}
//Console.WriteLine("WWW.object_id: " + object_id + ", senderId: " + senderId + ", hp: " + this.hp + ", mask : " + this.bitMask);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.senderId = input.GetVU32();
this.hp = input.GetVS32();
this.client_state = input.GetU8();
this.bitMask = input.GetU8();
if (HasEffect)
{
this.biteffect_sn = input.GetVU32();
}
if (HasSourceAttack)
{
this.sourceAttack_sn = input.GetVU32();
}
if(isSpecialHit)
{
this.dmgSrc = input.GetEnum8<DamageSource>();
}
//System.Console.WriteLine("sdfasdf: " + isSpecialHit + ", " + this.dmgSrc);
//UnityEngine.Debug.LogError("RRR.object_id: " + object_id + ", senderId: " + senderId + ", hp: " + this.hp + ", mask : " + this.bitMask);
}
public override void BeforeWrite(TemplateManager templates)
{
if (HasEffect)
{
this.biteffect_sn = biteffect.SerialNumber;
}
if (HasSourceAttack)
{
this.sourceAttack_sn = sourceAttack.SerialNumber;
}
}
public override void EndRead(TemplateManager templates)
{
if (HasEffect)
{
this.biteffect = templates.GetSnData<LaunchEffect>(biteffect_sn);
}
if (HasSourceAttack)
{
this.sourceAttack = templates.GetSnData<AttackProp>(sourceAttack_sn);
}
}
}
/// <summary>
/// 单位被击中
/// </summary>
[MessageType(0x8111)]
public class UnitDeadEvent : ObjectEvent
{
public bool Crushed;
public uint attacker_id;
public int RebirthTimeMS;
public UnitDeadEvent() { }
public UnitDeadEvent(uint unit_id, uint attacker_id, bool crushed, int rebirthTimeMS)
: base(unit_id)
{
this.Crushed = crushed;
this.attacker_id = attacker_id;
this.RebirthTimeMS = rebirthTimeMS;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutBool(Crushed);
output.PutVU32(attacker_id);
output.PutVS32(RebirthTimeMS);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.Crushed = input.GetBool();
this.attacker_id = input.GetVU32();
this.RebirthTimeMS = input.GetVS32();
}
}
/// <summary>
/// 单位中BUFF
/// </summary>
[MessageType(0x8112)]
public class UnitLaunchBuffEvent : ObjectEvent
{
public bool IsEquip
{
get { return BitMask.BitGetMask(bitMask, 0); }
set { BitMask.BitSetMask(ref bitMask, 0, value); }
}
public bool IsOverlayLevel
{
get { return BitMask.BitGetMask(bitMask, 1); }
set { BitMask.BitSetMask(ref bitMask, 1, value); }
}
public bool IsHasExtData
{
get { return BitMask.BitGetMask(bitMask, 2); }
set { BitMask.BitSetMask(ref bitMask, 2, value); }
}
private byte bitMask = 0;
public int buffTemplateID;
public int buffTimeMS;
public byte overlayLevel;
public uint senderID;
public int buffExtData; //buff的扩展字段，
public UnitLaunchBuffEvent() { }
public UnitLaunchBuffEvent(uint unit_id, int buffID, uint senderID, int timeMS, bool equip, byte overlayLevel, int extData)
: base(unit_id)
{
this.buffTemplateID = buffID;
this.buffTimeMS = timeMS;
this.senderID = senderID;
this.IsEquip = equip;
if (overlayLevel > 0)
{
this.IsOverlayLevel = true;
this.overlayLevel = overlayLevel;
}
if(extData > 0)
{
this.IsHasExtData = true;
this.buffExtData = extData;
}
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutU8(bitMask);
output.PutS32(buffTemplateID);
output.PutVU32(senderID);
if (!IsEquip)
{
output.PutVS32(buffTimeMS);
}
if (IsOverlayLevel)
{
output.PutU8(overlayLevel);
}
if (IsHasExtData)
{
output.PutVS32(buffExtData);
}
//System.Console.WriteLine("UnitLaunchBuffEvent: " + buffTemplateID + ", " + buffTimeMS);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.bitMask = input.GetU8();
this.buffTemplateID = input.GetS32();
this.senderID = input.GetVU32();
if (!IsEquip)
{
this.buffTimeMS = input.GetVS32();
}
if (IsOverlayLevel)
{
this.overlayLevel = input.GetU8();
}
if (IsHasExtData)
{
this.buffExtData = input.GetVS32();
}
}
}
/// <summary>
/// 单位停止BUFF
/// </summary>
[MessageType(0x8113)]
public class UnitStopBuffEvent : ObjectEvent
{
public int buffTemplateID;
public uint senderID;
public UnitStopBuffEvent() { }
public UnitStopBuffEvent(uint unit_id, int buffID, uint senderID)
: base(unit_id)
{
this.buffTemplateID = buffID;
this.senderID = senderID;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutS32(buffTemplateID);
output.PutVU32(senderID);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.buffTemplateID = input.GetS32();
this.senderID = input.GetVU32();
}
}
/// <summary>
/// 单位同步【库存道具】
/// </summary>
[MessageType(0x8114)]
public class UnitSyncInventoryItemEvent : ObjectEvent, ActorMessage
{
public int ItemTemplateID;
public int Index;
public int Count;
public UnitSyncInventoryItemEvent() { }
public UnitSyncInventoryItemEvent(uint unit_id, int itemID, int index, int count)
: base(unit_id)
{
this.ItemTemplateID = itemID;
this.Index = index;
this.Count = count;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutS32(ItemTemplateID);
output.PutVS32(Index);
output.PutVS32(Count);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.ItemTemplateID = input.GetS32();
this.Index = input.GetVS32();
this.Count = input.GetVS32();
}
}
/// <summary>
/// 单位使用道具
/// </summary>
[MessageType(0x8115)]
public class UnitUseItemEvent : ObjectEvent, ActorMessage
{
public int ItemTemplateID;
public UnitUseItemEvent() { }
public UnitUseItemEvent(uint unit_id, int itemID)
: base(unit_id)
{
this.ItemTemplateID = itemID;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutS32(ItemTemplateID);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.ItemTemplateID = input.GetS32();
}
}
[MessageType(0x8116)]
public class UnitSyncMultiTimeLine : ObjectEvent
{
public List<bool> timelines;
public UnitSyncMultiTimeLine() { }
public UnitSyncMultiTimeLine(uint unit_id) : base(unit_id) { }
public bool Update(List<MultiTimeLine> tlines)
{
bool ret = false;
if (timelines == null)
{
timelines = new List<bool>(tlines.Count);
}
if (timelines.Count != tlines.Count)
{
CUtils.SetListSize<bool>(timelines, tlines.Count);
ret = true;
}
for (int i = tlines.Count - 1; i >= 0; --i)
{
if (timelines[i] != tlines[i].Enable)
{
timelines[i] = tlines[i].Enable;
ret = true;
}
}
return ret;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutList(timelines, output.PutBool);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.timelines = input.GetList<bool>(input.GetBool);
}
}
/// <summary>
/// 单位复活
/// </summary>
[MessageType(0x8117)]
public class UnitRebirthEvent : ObjectEvent
{
public UnitRebirthEvent() { }
public UnitRebirthEvent(uint unit_id) : base(unit_id) { }
}
/// <summary>
/// 用户连斩数
/// </summary>
[MessageType(0x8118)]
public class UnitContinueKillValue : ObjectEvent
{
public short continuekills;
public UnitContinueKillValue() { }
public UnitContinueKillValue(uint unit_id, short continuekills)
: base(unit_id)
{
this.continuekills = continuekills;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutS16(continuekills);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
continuekills = input.GetS16();
}
}
/// <summary>
/// 单位受攻击
/// </summary>
[MessageType(0x8119)]
public class UnitDamageEvent : ObjectEvent
{
public bool HasDamageTime
{
get { return mask.Get(0); }
private set { mask.Set(0, value); }
}
public bool HasFly
{
get { return mask.Get(1); }
private set { mask.Set(1, value); }
}
public bool HasZLimit
{
get { return mask.Get(2); }
private set { mask.Set(2, value); }
}
public bool HasKnockDown
{
get { return mask.Get(3); }
private set { mask.Set(3, value); }
}
public bool HasZGravity
{
get { return mask.Get(4); }
private set { mask.Set(4, value); }
}
public bool HasMoveTime
{
get { return mask.Get(5); }
private set { mask.Set(5, value); }
}
public AttackProp Source { get; private set; }
/// <summary>
/// 总共受击时间（位移时间+受击时间）
/// </summary>
public int TotalTimeMS
{
get { return MoveTimeMS + DamageTimeMS; }
}
/// <summary>
/// 特殊受击动作
/// </summary>
public string DamageActionName
{
get { return Source.DamageActionName; }
}
/// <summary>
/// 受击的特殊动作
/// </summary>
public bool HasDamageAction
{
get { return !string.IsNullOrEmpty(Source.DamageActionName); }
}
private BitSet8 mask = new BitSet8();
private uint source_sn = 0;
public int DamageTimeMS = 0;
public int MoveTimeMS = 0;
public float ZSpeedSEC = 0;
public float ZLimit = 0;
public float ZGravity = 0;
public UnitDamageEvent() { }
public UnitDamageEvent(uint unit_id, int damageTimeMS, int moveTimeMS, float zspeed, float zgravity, float zlimit, bool knockDown, AttackProp source)
: base(unit_id)
{
this.Source = source;
this.DamageTimeMS = damageTimeMS;
this.MoveTimeMS = moveTimeMS;
this.ZSpeedSEC = zspeed;
this.ZLimit = zlimit;
this.ZGravity = zgravity;
this.HasDamageTime = (DamageTimeMS != 0);
this.HasMoveTime = (MoveTimeMS != 0);
this.HasFly = (zspeed != 0);
this.HasZGravity = (zgravity != 0);
this.HasZLimit = (zlimit > 0);
this.HasKnockDown = knockDown;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutU8(mask.Mask);
output.PutVU32(source_sn);
if (HasDamageTime)
{
output.PutVS32(DamageTimeMS);
}
if (HasMoveTime)
{
output.PutVS32(MoveTimeMS);
}
if (HasFly)
{
output.PutF32(ZSpeedSEC);
}
if (HasZLimit)
{
output.PutF32(ZLimit);
}
if (HasZGravity)
{
output.PutF32(ZGravity);
}
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.mask.Mask = input.GetU8();
this.source_sn = input.GetVU32();
if (HasDamageTime)
{
this.DamageTimeMS = input.GetVS32();
}
if (HasMoveTime)
{
this.MoveTimeMS = input.GetVS32();
}
if (HasFly)
{
this.ZSpeedSEC = input.GetF32();
}
if (HasZLimit)
{
this.ZLimit = input.GetF32();
}
if (HasZGravity)
{
this.ZGravity = input.GetF32();
}
}
public override void BeforeWrite(TemplateManager templates)
{
if (Source != null)
{
this.source_sn = Source.SerialNumber;
}
}
public override void EndRead(TemplateManager templates)
{
if (source_sn != 0)
{
this.Source = templates.GetSnData<AttackProp>(source_sn);
}
}
}
/// <summary>
/// 技能动作序列被意外取消
/// </summary>
[MessageType(0x811A)]
public class UnitSkillActionChangeEvent : ObjectEvent
{
public byte ActionIndex;
public UnitSkillActionChangeEvent() { }
public UnitSkillActionChangeEvent(uint unit_id, byte index)
: base(unit_id)
{
this.ActionIndex = index;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutU8(ActionIndex);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.ActionIndex = input.GetU8();
}
}
/// <summary>
/// 单位开始检取道具读条
/// </summary>
[MessageType(0x811B)]
public class UnitStartPickObjectEvent : ObjectEvent
{
public int PickTimeMS;
public uint PickObjectID;
public string PickStatus;
public UnitStartPickObjectEvent() { }
public UnitStartPickObjectEvent(uint unit_id, int pickTimeMS, uint pickObjID, string status)
: base(unit_id)
{
this.PickTimeMS = pickTimeMS;
this.PickObjectID = pickObjID;
this.PickStatus = status;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutVS32(PickTimeMS);
output.PutVU32(PickObjectID);
output.PutUTF(PickStatus);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.PickTimeMS = input.GetVS32();
this.PickObjectID = input.GetVU32();
this.PickStatus = input.GetUTF();
}
}
[MessageType(0x811C)]
public class UnitStopPickObjectEvent : ObjectEvent
{
public string StopReason;
public UnitStopPickObjectEvent() { }
public UnitStopPickObjectEvent(uint unit_id, string reason)
: base(unit_id)
{
this.StopReason = reason;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutUTF(StopReason);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.StopReason = input.GetUTF();
}
}
/// <summary>
/// 单位从场景中获得道具
/// </summary>
[MessageType(0x811D)]
public class UnitGotInstanceItemEvent : ObjectEvent, ActorMessage
{
public uint ItemObjectID;
public byte flag; //0-后续可以继续采集，1-后续不可继续采集
public UnitGotInstanceItemEvent() { }
public UnitGotInstanceItemEvent(uint unit_id, uint pickObjID, byte flag = 0)
: base(unit_id)
{
this.ItemObjectID = pickObjID;
this.flag = flag;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutU32(ItemObjectID);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.ItemObjectID = input.GetU32();
}
}
/// <summary>
/// 别的单位释放技能跳起
/// </summary>
[MessageType(0x811E)]
public class UnitJumpEvent : ObjectEvent
{
public float ZSpeed;
public float ZLimit;
public float ZGravity;
public UnitJumpEvent() { }
public UnitJumpEvent(uint unit_id, float zspeed, float zgravity, float zlimit)
: base(unit_id)
{
this.ZSpeed = zspeed;
this.ZLimit = zlimit;
this.ZGravity = zgravity;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutF32(ZSpeed);
output.PutF32(ZLimit);
output.PutF32(ZGravity);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.ZSpeed = input.GetF32();
this.ZLimit = input.GetF32();
this.ZGravity = input.GetF32();
}
}
/// <summary>
/// 立即同步客户端坐标，比如单位传送之类，用于MoveByClient的模式
/// </summary>
[MessageType(0x811F)]
public class UnitForceSyncPosEvent : ObjectEvent
{
public float X;
public float Y;
public float Direction;
public byte UnitMainState;
public byte UnitSubState;
public UnitForceSyncPosEvent() { }
public UnitForceSyncPosEvent(uint unit_id, float x, float y, float d, byte state, byte sub_state)
: base(unit_id)
{
this.X = x;
this.Y = y;
this.Direction = d;
this.UnitMainState = state;
this.UnitSubState = sub_state;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutF32(this.X);
output.PutF32(this.Y);
output.PutF32(this.Direction);
output.PutU8(this.UnitMainState);
output.PutU8(this.UnitSubState);
//if (this.object_id == 2649)
//{
// Console.WriteLine("ForceSync-" + this.object_id + ", X: " + this.X + ", \t Y: " + this.Y + ", " + this.UnitMainState + ", " + this.UnitSubState);
//}
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.X = input.GetF32();
this.Y = input.GetF32();
this.Direction = input.GetF32();
this.UnitMainState = input.GetU8();
this.UnitSubState = input.GetU8();
}
}
/// <summary>
/// 立即同步客户端坐标，比如单位传送之类，用于MoveByClient的模式
/// </summary>
[MessageType(0x8120)]
public class ObjectForceSyncPosEvent : ObjectEvent
{
public float X;
public float Y;
public float Direction;
public ObjectForceSyncPosEvent() { }
public ObjectForceSyncPosEvent(uint unit_id, float x, float y, float d)
: base(unit_id)
{
this.X = x;
this.Y = y;
this.Direction = d;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutF32(this.X);
output.PutF32(this.Y);
output.PutF32(this.Direction);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.X = input.GetF32();
this.Y = input.GetF32();
this.Direction = input.GetF32();
}
}
/// <summary>
/// Missile类法术，锁定单位时触发
/// </summary>
[MessageType(0x8130)]
public class SpellLockTargetEvent : ObjectEvent, PositionMessage
{
public uint target_obj_id;
private float x;
private float y;
public SpellLockTargetEvent() { }
public SpellLockTargetEvent(uint spell_id, uint target_obj_id, float x, float y)
: base(spell_id)
{
this.target_obj_id = target_obj_id;
this.x = x;
this.y = y;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutVU32(target_obj_id);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.target_obj_id = input.GetVU32();
}
public float X { get { return x; } }
public float Y { get { return y; } }
}
#endregion
//--------------------------------------------------------------------------
#region CONTROL_0x8200
/// <summary>
/// 单位待机
/// </summary>
[MessageType(0x8200)]
public class UnitGuardAction : ObjectAction
{
public bool guard = false;
public string reason = null;
public bool forceNotify = false;
public UnitGuardAction() { }
public UnitGuardAction(uint unit_id, bool guard)
: base(unit_id)
{
this.guard = guard;
}
public UnitGuardAction(uint unit_id, bool guard, string reason)
: base(unit_id)
{
this.guard = guard;
this.reason = reason;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutBool(guard);
output.PutUTF(reason);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.guard = input.GetBool();
this.reason = input.GetUTF();
}
}
/// <summary>
/// A过去
/// </summary>
[MessageType(0x8206)]
public class UnitAttackToAction : ObjectAction
{
public float targetX;
public float targetY;
public bool attack;
public UnitAttackToAction() { }
public UnitAttackToAction(uint unit_id, float x, float y, bool attack)
: base(unit_id)
{
this.targetX = x;
this.targetY = y;
this.attack = attack;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutF32(targetX);
output.PutF32(targetY);
output.PutBool(attack);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.targetX = input.GetF32();
this.targetY = input.GetF32();
this.attack = input.GetBool();
}
}
/// <summary>
/// 单位移动
/// </summary>
[MessageType(0x8201)]
public class UnitMoveAction : ObjectAction
{
public float x;
public float y;
public UnitMoveAction() { }
public UnitMoveAction(uint unit_id, float x, float y)
: base(unit_id)
{
this.x = x;
this.y = y;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutF32(x);
output.PutF32(y);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.x = input.GetF32();
this.y = input.GetF32();
}
}
/// <summary>
/// 玩家选择朝向
/// </summary>
[MessageType(0x8202)]
public class UnitFaceToAction : ObjectAction
{
public float Direction;
public UnitFaceToAction() { }
public UnitFaceToAction(uint unit_id, float d)
: base(unit_id)
{
this.Direction = d;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutF32(Direction);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.Direction = input.GetF32();
}
}
/// <summary>
/// 单位移动
/// </summary>
[MessageType(0x8203)]
public class UnitSlipAction : ObjectAction
{
public float x;
public float y;
public UnitSlipAction() { }
public UnitSlipAction(uint unit_id, float x, float y)
: base(unit_id)
{
this.x = x;
this.y = y;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutF32(x);
output.PutF32(y);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.x = input.GetF32();
this.y = input.GetF32();
}
}
/// <summary>
/// 锁定目标
/// </summary>
[MessageType(0x8204)]
public class UnitFocuseTargetAction : ObjectAction
{
public uint targetUnitID;
public UnitFocuseTargetAction() { }
public UnitFocuseTargetAction(uint unit_id, uint target_id)
: base(unit_id)
{
this.targetUnitID = target_id;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutU32(targetUnitID);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.targetUnitID = input.GetU32();
}
}
/// <summary>
/// 单位技能动作
/// </summary>
[MessageType(0x8205)]
public class UnitLaunchSkillAction : ObjectAction
{
private BitSet8 mask = new BitSet8();
public bool IsAutoFocusNearTarget
{
get { return mask.Get(0); }
set { mask.Set(0, value); }
}
private bool IsTargetID
{
get { return mask.Get(1); }
set { mask.Set(1, value); }
}
private bool IsTargetPos
{
get { return mask.Get(2); }
set { mask.Set(2, value); }
}
public bool SyncDirection
{
get { return mask.Get(3); }
set { mask.Set(3, value); }
}
public int SkillID;
public uint TargetObjID = 0;
public Vector2 SpellTargetPos = null;
public float Direction = 0;
public UnitLaunchSkillAction() { }
public UnitLaunchSkillAction(uint unit_id, int skill_id, bool autoFocuseTarget = false, uint targetObjID = 0, Vector2 spellTargetPos = null, float direction = 0.0f)
: base(unit_id)
{
this.SkillID = skill_id;
this.TargetObjID = targetObjID;
this.SpellTargetPos = spellTargetPos;
this.IsAutoFocusNearTarget = autoFocuseTarget;
this.Direction = direction;
}
override public void WriteExternal(IOutputStream output)
{
this.IsTargetID = (TargetObjID != 0);
this.IsTargetPos = (SpellTargetPos != null);
base.WriteExternal(output);
mask.WriteExternal(output);
output.PutS32(SkillID);
if (SyncDirection)
{
output.PutF32(Direction);
}
if (IsTargetID)
{
output.PutU32(TargetObjID);
}
if (IsTargetPos)
{
output.PutF32(SpellTargetPos.X);
output.PutF32(SpellTargetPos.Y);
}
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
mask.ReadExternal(input);
this.SkillID = input.GetS32();
if (SyncDirection)
{
this.Direction = input.GetF32();
}
if (IsTargetID)
{
this.TargetObjID = input.GetU32();
}
if (IsTargetPos)
{
this.SpellTargetPos = new Vector2();
this.SpellTargetPos.SetX(input.GetF32());
this.SpellTargetPos.SetY(input.GetF32());
}
}
}
/// <summary>
/// 客户端手动控制同步包
/// </summary>
[MessageType(0x8207)]
public class UnitAxisAction : ObjectAction
{
public bool IsZero { get { return dx == 0 && dy == 0; } }
public float dx;
public float dy;
public UnitAxisAction() { }
public UnitAxisAction(uint unit_id)
: base(unit_id)
{
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
float angle = (float)Math.Atan2(dy, dx);
output.PutS8((sbyte)(Math.Cos(angle) * 100f));
output.PutS8((sbyte)(Math.Sin(angle) * 100f));
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.dx = input.GetS8() / 100f;
this.dy = input.GetS8() / 100f;
}
public bool AxisEquals(UnitAxisAction obj)
{
if (obj == null) return false;
return (obj.dx == this.dx) && (obj.dy == this.dy);
}
}
/// <summary>
/// 客户端手动控制同步包
/// </summary>
[MessageType(0x8208)]
public class UnitStopMoveAction : ObjectAction
{
public UnitStopMoveAction() { }
public UnitStopMoveAction(uint unit_id)
: base(unit_id)
{
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
}
}
/// <summary>
/// 单位使用道具
/// </summary>
[MessageType(0x8209)]
public class UnitUseItemAction : ObjectAction
{
public int Index;
public int Count;
public UnitUseItemAction() { }
public UnitUseItemAction(uint unit_id, int index, int count = 1)
: base(unit_id)
{
this.Index = index;
this.Count = count;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutVS32(this.Index);
output.PutVS32(this.Count);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.Index = input.GetVS32();
this.Count = input.GetVS32();
}
}
/// <summary>
/// 单位手动检取场景道具
/// </summary>
[MessageType(0x820A)]
public class UnitPickObjectAction : ObjectAction
{
public uint PickableObjectID;
public UnitPickObjectAction() { }
public UnitPickObjectAction(uint unit_id, uint item_obj_id)
: base(unit_id)
{
this.PickableObjectID = item_obj_id;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutVU32(this.PickableObjectID);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.PickableObjectID = input.GetVU32();
}
}
/// <summary>
/// 单位移动
/// </summary>
[MessageType(0x820B)]
public class UnitUpdatePosAction : ObjectAction
{
public bool isHalf;
public float x;
public float y;
public float d;
public UnitActionStatus st;
public UnitUpdatePosAction() { }
public UnitUpdatePosAction(uint unit_id, bool isHalf, float x, float y, float d, UnitActionStatus s)
: base(unit_id)
{
this.isHalf = isHalf;
this.x = x;
this.y = y;
this.d = d;
this.st = s;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutBool(isHalf);
if (isHalf)
{
output.PutU16(MoveHelper.ToPos16(x));
output.PutU16(MoveHelper.ToPos16(y));
output.PutU8(MoveHelper.ToDirectionD8(d));
}
else
{
output.PutF32(x);
output.PutF32(y);
output.PutF32(d);
}
output.PutEnum8(st);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.isHalf = input.GetBool();
if (isHalf)
{
this.x = MoveHelper.ToPosF32(input.GetU16());
this.y = MoveHelper.ToPosF32(input.GetU16());
this.d = MoveHelper.ToDirectionF32(input.GetU8());
}
else
{
this.x = input.GetF32();
this.y = input.GetF32();
this.d = input.GetF32();
}
this.st = input.GetEnum8<UnitActionStatus>();
//Console.WriteLine("-------------------UnitUpdatePosAction : " + TimeUtil.GetTimestampMS() + this.x + ", " + this.y + " \t \t" + this.st);
}
public bool DataEquals(UnitUpdatePosAction o)
{
if (o == null) return false;
return o.x == this.x && o.y == this.y && o.d == this.d && o.st == this.st;
}
public void Set(UnitUpdatePosAction other)
{
this.object_id = other.object_id;
this.isHalf = other.isHalf;
this.x = other.x;
this.y = other.y;
this.d = other.d;
this.st = other.st;
}
}
[MessageType(0x820C)]
public class UnitSetSyncModeAction : ObjectAction
{
public SyncMode Mode;
public UnitSetSyncModeAction() { }
public UnitSetSyncModeAction(uint unit_id, SyncMode mode)
: base(unit_id)
{
this.Mode = mode;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutEnum8(Mode);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.Mode = input.GetEnum8<SyncMode>();
}
}
[MessageType(0x820D)]
public class UnitCancelBuffAction : ObjectAction
{
public int BuffID;
public UnitCancelBuffAction() { }
public UnitCancelBuffAction(uint unit_id, int buffID)
: base(unit_id)
{
this.BuffID = buffID;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutS32(BuffID);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.BuffID = input.GetS32();
}
}
/// <summary>
/// 单位统计数据
/// </summary>
public class UnitStatisticData : IExternalizable
{
public uint ObjectID;
/// <summary>
/// 死亡次数
/// </summary>
public int DeadCount;
/// <summary>
/// 总共杀死单位数量
/// </summary>
public int KillUnitCount;
/// <summary>
/// 总共杀死玩家数量
/// </summary>
public int KillPlayerCount;
/// <summary>
/// 承受伤害
/// </summary>
public long SelfDamage;
/// <summary>
/// 对所有单位造成的总伤害
/// </summary>
public long TotalDamage;
/// <summary>
/// 对玩家造成的总伤害
/// </summary>
public long PlayerDamage;
/// <summary>
/// 对所有单位输出的总治疗量
/// </summary>
public long TotalHealing;
/// <summary>
/// 对玩家输出的总治疗量
/// </summary>
public long PlayerHealing;
public virtual void WriteExternal(IOutputStream output)
{
output.PutVU32(ObjectID);
output.PutVS32(DeadCount);
output.PutVS32(KillUnitCount);
output.PutVS32(KillPlayerCount);
output.PutVS64(SelfDamage);
output.PutVS64(TotalDamage);
output.PutVS64(PlayerDamage);
output.PutVS64(TotalHealing);
output.PutVS64(PlayerHealing);
}
public virtual void ReadExternal(IInputStream input)
{
ObjectID = input.GetVU32();
DeadCount = input.GetVS32();
KillUnitCount = input.GetVS32();
KillPlayerCount = input.GetVS32();
SelfDamage = input.GetVS64();
TotalDamage = input.GetVS64();
PlayerDamage = input.GetVS64();
TotalHealing = input.GetVS64();
PlayerHealing = input.GetVS64();
}
}
[MessageType(0x8210)]
public class UnitGetStatisticRequest : ActorRequest
{
public uint[] RequestObjectsID;
public UnitGetStatisticRequest() { }
public UnitGetStatisticRequest(uint objID, params uint[] objectsID) : base(objID)
{
this.RequestObjectsID = objectsID;
}
public override void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutS32(MessageID);
output.PutArray(RequestObjectsID, output.PutU32);
}
public override void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.MessageID = input.GetS32();
this.RequestObjectsID = input.GetArray<uint>(input.GetU32);
}
}
[MessageType(0x8211)]
public class UnitGetStatisticResponse : ActorResponse
{
public HashMap<uint, UnitStatisticData> Statistics = new HashMap<uint, UnitStatisticData>();
public override void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutS32(MessageID);
output.PutVS32(Statistics.Count);
foreach (KeyValuePair<uint, UnitStatisticData> e in Statistics)
{
output.PutU32(e.Key);
output.PutExt(e.Value);
}
}
public override void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.MessageID = input.GetS32();
int count = input.GetVS32();
for (int i = 0; i < count; i++)
{
var key = input.GetU32();
var data = input.GetExtAny() as UnitStatisticData;
Statistics.Put(key, data);
}
}
}
/// <summary>
/// 设置子动做
/// </summary>
[MessageType(0x8212)]
public class UnitSetSubStateAction : ObjectAction
{
public byte UnitSubState;
public UnitSetSubStateAction() { }
public UnitSetSubStateAction(uint objID, byte state)
: base(objID)
{
this.UnitSubState = state;
}
public override void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutU8(UnitSubState);
}
public override void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.UnitSubState = input.GetU8();
}
}
/// <summary>
/// 单位准备完毕
/// </summary>
[MessageType(0x8213)]
public class UnitReadAction : ObjectAction
{
public UnitReadAction() { }
public UnitReadAction(uint objID)
: base(objID)
{
}
public override void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
}
public override void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
}
}
#endregion
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------
#region CLIENT_EVENTS_0x8300
public abstract class ClientEvent : ZoneEvent
{
}
/// <summary>
/// 显示箭头
/// </summary>
[MessageType(0x8300)]
public class LookAtEvent : ClientEvent
{
public string target;
public float x;
public float y;
public LookAtEvent() { }
public LookAtEvent(string target, float x, float y)
{
this.target = target;
this.x = x;
this.y = y;
}
override public void WriteExternal(IOutputStream output)
{
output.PutUTF(target);
output.PutF32(x);
output.PutF32(y);
}
override public void ReadExternal(IInputStream input)
{
this.target = input.GetUTF();
this.x = input.GetF32();
this.y = input.GetF32();
}
}
/// <summary>
/// 改变游戏运行速度
/// </summary>
[MessageType(0x8301)]
public class ChangeTimeScaleEvent : ClientEvent
{
/// <summary>
/// 时间尺度百分比
/// </summary>
public float TimeScalePct = 100f;
public ChangeTimeScaleEvent() { }
public ChangeTimeScaleEvent(float pct)
{
this.TimeScalePct = pct;
}
override public void WriteExternal(IOutputStream output)
{
output.PutF32(TimeScalePct);
}
override public void ReadExternal(IInputStream input)
{
this.TimeScalePct = input.GetF32();
}
}
/// <summary>
/// 暂停游戏
/// </summary>
[MessageType(0x8302)]
public class GamePauseEvent : ClientEvent
{
/// <summary>
/// 暂停多少秒，如果为0，则无限暂停
/// </summary>
public float Seconds = 0f;
public GamePauseEvent() { }
public GamePauseEvent(float sec)
{
this.Seconds = sec;
}
override public void WriteExternal(IOutputStream output)
{
output.PutF32(Seconds);
}
override public void ReadExternal(IInputStream input)
{
this.Seconds = input.GetF32();
}
}
/// <summary>
/// 继续游戏
/// </summary>
[MessageType(0x8303)]
public class GameResumeEvent : ClientEvent
{
public GameResumeEvent() { }
public override void WriteExternal(IOutputStream output)
{
}
public override void ReadExternal(IInputStream input)
{
}
}
/// <summary>
/// 移动镜头到
/// </summary>
[MessageType(0x8304)]
public class CameraMoveToEvent : ClientEvent
{
/// <summary>
/// 镜头移动速度(每秒距离)
/// </summary>
public float MoveSpeedSec = 1f;
/// <summary>
/// 移动过去的总时间，如果为0，则按速度计算
/// </summary>
public int TimeMS = 0;
public float x;
public float y;
public CameraMoveToEvent() { }
public CameraMoveToEvent(float x, float y, float speed, int timeMS)
{
this.x = x;
this.y = y;
this.MoveSpeedSec = speed;
this.TimeMS = timeMS;
}
override public void WriteExternal(IOutputStream output)
{
output.PutF32(x);
output.PutF32(y);
output.PutF32(MoveSpeedSec);
output.PutS32(TimeMS);
}
override public void ReadExternal(IInputStream input)
{
this.x = input.GetF32();
this.y = input.GetF32();
this.MoveSpeedSec = input.GetF32();
this.TimeMS = input.GetS32();
}
}
/// <summary>
/// 锁定镜头到单位
/// </summary>
[MessageType(0x8305)]
public class CameraFocusUnitEvent : ClientEvent
{
public uint ObjectID;
public CameraFocusUnitEvent() { }
public CameraFocusUnitEvent(uint oid)
{
this.ObjectID = oid;
}
override public void WriteExternal(IOutputStream output)
{
output.PutU32(ObjectID);
}
override public void ReadExternal(IInputStream input)
{
this.ObjectID = input.GetU32();
}
}
/// <summary>
/// 拉近镜头
/// </summary>
[MessageType(0x8306)]
public class CameraZoomToEvent : ClientEvent
{
/// <summary>
/// 镜头拉近距离
/// </summary>
public float ZoomDistance = 10f;
/// <summary>
/// 镜头拉近速度(每秒距离)
/// </summary>
public float ZoomSpeedSec = 1f;
public CameraZoomToEvent() { }
public CameraZoomToEvent(float distance, float speed)
{
this.ZoomDistance = distance;
this.ZoomSpeedSec = speed;
}
override public void WriteExternal(IOutputStream output)
{
output.PutF32(ZoomDistance);
output.PutF32(ZoomSpeedSec);
}
override public void ReadExternal(IInputStream input)
{
this.ZoomDistance = input.GetF32();
this.ZoomSpeedSec = input.GetF32();
}
}
/// <summary>
/// 旋转镜头
/// </summary>
[MessageType(0x8307)]
public class CameraRotateToEvent : ClientEvent
{
/// <summary>
/// 镜头旋转角度（0～360）
/// </summary>
public float RotateAngle = 10f;
/// <summary>
/// 镜头旋转速度(每秒角度)
/// </summary>
public float RotateSpeedSec = 1f;
public CameraRotateToEvent() { }
public CameraRotateToEvent(float angle, float speed)
{
this.RotateAngle = angle;
this.RotateSpeedSec = speed;
}
override public void WriteExternal(IOutputStream output)
{
output.PutF32(RotateAngle);
output.PutF32(RotateSpeedSec);
}
override public void ReadExternal(IInputStream input)
{
this.RotateAngle = input.GetF32();
this.RotateSpeedSec = input.GetF32();
}
}
/// <summary>
/// 重置镜头
/// </summary>
[MessageType(0x8308)]
public class CameraResetEvent : ClientEvent
{
public override void WriteExternal(IOutputStream output)
{
}
public override void ReadExternal(IInputStream input)
{
}
}
/// <summary>
/// 客户端动作序列
/// </summary>
[MessageType(0x8309)]
public class ClientEventQueue : ClientEvent
{
public List<ClientEvent> EventQueue = new List<ClientEvent>();
override public void WriteExternal(IOutputStream output)
{
output.PutU8((byte)EventQueue.Count);
foreach (ClientEvent e in EventQueue)
{
output.PutExt(e);
}
}
override public void ReadExternal(IInputStream input)
{
int count = input.GetU8();
for (int i = 0; i < count; i++)
{
EventQueue.Add(input.GetExtAny() as ClientEvent);
}
}
}
/// <summary>
/// 移动锁定一段时间
/// </summary>
[MessageType(0x830B)]
public class CameraHoldEvent : ClientEvent
{
public float x;
public float y;
public int TimeMS;
public CameraHoldEvent() { }
public CameraHoldEvent(float x, float y, int timeMS)
{
this.x = x;
this.y = y;
this.TimeMS = timeMS;
}
override public void WriteExternal(IOutputStream output)
{
output.PutF32(x);
output.PutF32(y);
output.PutS32(TimeMS);
}
override public void ReadExternal(IInputStream input)
{
this.x = input.GetF32();
this.y = input.GetF32();
this.TimeMS = input.GetS32();
}
}
#endregion
//--------------------------------------------------------------------------
#region PLAYER_EVENTS_0x8400
public abstract class PlayerEvent : ObjectEvent
{
public PlayerEvent() { }
public PlayerEvent(uint objID) : base(objID) { }
}
[MessageType(0x8400)]
public class PlayerCDEvent : PlayerEvent
{
private byte mask = 0;
public bool is_all
{
get { return BitMask.BitGetMask(mask, 0); }
set { BitMask.BitSetMask(ref mask, 0, value); }
}
public bool is_decrease_time
{
get { return BitMask.BitGetMask(mask, 1); }
set { BitMask.BitSetMask(ref mask, 1, value); }
}
public bool is_decrease_pct
{
get { return BitMask.BitGetMask(mask, 2); }
set { BitMask.BitSetMask(ref mask, 2, value); }
}
public bool is_clear
{
get { return BitMask.BitGetMask(mask, 3); }
set { BitMask.BitSetMask(ref mask, 3, value); }
}
public int decrease_timeMS;
public float decrease_pct;
public int skill_template_id;
public PlayerCDEvent() { }
public PlayerCDEvent(uint unit_id) : base(unit_id) { }
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutU8(mask);
if (is_all)
{
if (is_decrease_pct)
output.PutF32(decrease_pct);
if (is_decrease_time)
output.PutVS32(decrease_timeMS);
}
else
{
output.PutS32(skill_template_id);
if (is_decrease_pct)
output.PutF32(decrease_pct);
if (is_decrease_time)
output.PutVS32(decrease_timeMS);
}
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.mask = input.GetU8();
if (is_all)
{
if (is_decrease_pct)
decrease_pct = input.GetF32();
if (is_decrease_time)
decrease_timeMS = input.GetVS32();
}
else
{
skill_template_id = input.GetS32();
if (is_decrease_pct)
decrease_pct = input.GetF32();
if (is_decrease_time)
decrease_timeMS = input.GetVS32();
}
}
}
[MessageType(0x8401)]
public class PlayerSkillChangedEvent : PlayerEvent
{
public SkillTemplate baseSkill;
public List<SkillTemplate> skills = new List<SkillTemplate>();
public float unitFastCastRate;
public PlayerSkillChangedEvent() { }
public PlayerSkillChangedEvent(uint unit_id) : base(unit_id) { }
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutF32(this.unitFastCastRate);
output.PutExt(this.baseSkill);
output.PutList<SkillTemplate>(this.skills, output.PutExt);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.unitFastCastRate = input.GetF32();
this.baseSkill = input.GetExt<SkillTemplate>();
this.skills = input.GetList<SkillTemplate>(input.GetExt<SkillTemplate>);
}
}
[MessageType(0x8402)]
public class PlayerSyncEnvironmentVarEvent : PlayerEvent
{
public string Key;
public object Value;
public PlayerSyncEnvironmentVarEvent() { }
public PlayerSyncEnvironmentVarEvent(uint unit_id, string key, object value)
: base(unit_id)
{
this.Key = key;
this.Value = value;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutUTF(Key);
output.PutData(Value);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
DataType dtype;
this.Key = input.GetUTF();
this.Value = input.GetData(out dtype);
}
}
[MessageType(0x8403)]
public class PlayerSkillStopEvent : PlayerEvent
{
public int SkillID;
public PlayerSkillStopEvent() { }
public PlayerSkillStopEvent(uint unit_id, int skillID)
: base(unit_id)
{
this.SkillID = skillID;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutS32(SkillID);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.SkillID = input.GetS32();
}
}
[MessageType(0x8404)]
public class PlayerSkillAddedEvent : PlayerEvent
{
public SkillTemplate Skill;
public bool IsDefault;
public PlayerSkillAddedEvent() { }
public PlayerSkillAddedEvent(uint unit_id, SkillTemplate sk, bool isDefault)
: base(unit_id)
{
this.Skill = sk;
this.IsDefault = isDefault;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutExt(this.Skill);
output.PutBool(this.IsDefault);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.Skill = input.GetExt<SkillTemplate>();
this.IsDefault = input.GetBool();
}
}
[MessageType(0x8405)]
public class PlayerSkillRemovedEvent : PlayerEvent
{
public int SkillID;
public PlayerSkillRemovedEvent() { }
public PlayerSkillRemovedEvent(uint unit_id, int skillID)
: base(unit_id)
{
this.SkillID = skillID;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutS32(this.SkillID);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.SkillID = input.GetS32();
}
}
/// <summary>
/// 脚本系统指令
/// </summary>
[MessageType(0x8406)]
public class PlayerScriptCommandEvent : PlayerEvent
{
public string message;
public PlayerScriptCommandEvent() { }
public PlayerScriptCommandEvent(uint unit_id, string msg)
: base(unit_id)
{
this.message = msg;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutUTF(message);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.message = input.GetUTF();
}
}
/// <summary>
/// 技能可用性发生变化
/// </summary>
[MessageType(0x8407)]
public class PlayerSkillActiveChangedEvent : PlayerEvent
{
public struct State
{
public int SkillTemplateID;
public SkillActiveState ST;
public bool IsActive { get { return ST == SkillActiveState.Active; } }
public bool IsPauseOnDeactive { get { return ST == SkillActiveState.DeactiveAndPause; } }
}
public List<State> Skills;
public PlayerSkillActiveChangedEvent() { this.Skills = new List<State>(); }
public PlayerSkillActiveChangedEvent(uint unit_id, int skillCount) : base(unit_id)
{
this.Skills = new List<State>(skillCount);
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutVS32(Skills.Count);
for (int i = 0; i < Skills.Count; i++)
{
State sat = Skills[i];
output.PutS32(sat.SkillTemplateID);
output.PutEnum8(sat.ST);
}
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
int count = input.GetVS32();
this.Skills.Capacity = count;
for (int i = 0; i < count; i++)
{
State sat = new State();
sat.SkillTemplateID = input.GetS32();
sat.ST = input.GetEnum8<SkillActiveState>();
this.Skills.Add(sat);
}
}
}
[MessageType(0x8408)]
public class PlayerSkillTimeChangedEvent : PlayerEvent
{
public int SkillTemplateID;
public int SkillPassTimeMS;
public int SkillTotalTimeMS;
public PlayerSkillTimeChangedEvent() { }
public PlayerSkillTimeChangedEvent(uint unit_id, int skillID, int passTimeMS, int totalTimeMS)
: base(unit_id)
{
this.SkillTemplateID = skillID;
this.SkillPassTimeMS = passTimeMS;
this.SkillTotalTimeMS = totalTimeMS;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutS32(this.SkillTemplateID);
output.PutVS32(this.SkillPassTimeMS);
output.PutVS32(this.SkillTotalTimeMS);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.SkillTemplateID = input.GetS32();
this.SkillPassTimeMS = input.GetVS32();
this.SkillTotalTimeMS = input.GetVS32();
}
}
/// <summary>
/// 锁定目标
/// </summary>
[MessageType(0x8409)]
public class PlayerFocuseTargetEvent : PlayerEvent
{
public uint targetUnitID;
public SkillTemplate.CastTarget expectTarget;
public PlayerFocuseTargetEvent() { }
public PlayerFocuseTargetEvent(uint unit_id, uint target_id, SkillTemplate.CastTarget expect)
: base(unit_id)
{
this.targetUnitID = target_id;
this.expectTarget = expect;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutU32(targetUnitID);
output.PutEnum8(expectTarget);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.targetUnitID = input.GetU32();
this.expectTarget = input.GetEnum8<SkillTemplate.CastTarget>();
}
}
#endregion
//--------------------------------------------------------------------------
#region TEXT_0x8500
public enum ChatMessageType : byte
{
SystemToAll,
SystemToForce,
SystemToPlayer,
PlayerToAll,
PlayerToForce,
PlayerToPlayer,
}
[MessageType(0x8500)]
public class ChatAction : ObjectAction
{
public string Message;
public ChatMessageType To = ChatMessageType.SystemToAll;
public string TargetPlayerUUID;
public override void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutU8((byte)this.To);
output.PutUTF(this.Message);
output.PutUTF(this.TargetPlayerUUID);
}
public override void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.To = (ChatMessageType)input.GetU8();
this.Message = input.GetUTF();
this.TargetPlayerUUID = input.GetUTF();
}
}
[MessageType(0x8501)]
public class ChatEvent : ZoneEvent
{
public ChatMessageType To = ChatMessageType.SystemToAll;
public int Force;
public string FromPlayerUUID;
public string ToPlayerUUID;
public string Message;
public uint KeepTimeMS;
public ChatEvent() { }
public ChatEvent(ChatMessageType to, uint timeMS = 2000)
{
this.To = to;
KeepTimeMS = timeMS;
}
public override void WriteExternal(IOutputStream output)
{
output.PutU8((byte)this.To);
output.PutVS32((int)KeepTimeMS);
output.PutUTF(this.Message);
switch (To)
{
case ChatMessageType.PlayerToAll:
output.PutUTF(this.FromPlayerUUID);
break;
case ChatMessageType.PlayerToForce:
output.PutUTF(this.FromPlayerUUID);
output.PutVS32(this.Force);
break;
case ChatMessageType.PlayerToPlayer:
output.PutUTF(this.FromPlayerUUID);
output.PutUTF(this.ToPlayerUUID);
break;
case ChatMessageType.SystemToAll:
break;
case ChatMessageType.SystemToForce:
output.PutVS32(this.Force);
break;
case ChatMessageType.SystemToPlayer:
output.PutUTF(this.ToPlayerUUID);
break;
}
}
public override void ReadExternal(IInputStream input)
{
this.To = (ChatMessageType)input.GetU8();
this.KeepTimeMS = (uint)input.GetVS32();
this.Message = input.GetUTF();
switch (To)
{
case ChatMessageType.PlayerToAll:
this.FromPlayerUUID = input.GetUTF();
break;
case ChatMessageType.PlayerToForce:
this.FromPlayerUUID = input.GetUTF();
this.Force = input.GetVS32();
break;
case ChatMessageType.PlayerToPlayer:
this.FromPlayerUUID = input.GetUTF();
this.ToPlayerUUID = input.GetUTF();
break;
case ChatMessageType.SystemToAll:
break;
case ChatMessageType.SystemToForce:
this.Force = input.GetVS32();
break;
case ChatMessageType.SystemToPlayer:
this.ToPlayerUUID = input.GetUTF();
break;
}
}
}
[MessageType(0x8502)]
public class BubbleTalkEvent : ZoneEvent
{
public bool PauseBattle;
public List<TalkInfo> TalkInfos = new List<TalkInfo>();
public BubbleTalkEvent() { }
override public void WriteExternal(IOutputStream output)
{
output.PutBool(PauseBattle);
output.PutExtList<TalkInfo>(this.TalkInfos);
}
override public void ReadExternal(IInputStream input)
{
this.PauseBattle = input.GetBool();
this.TalkInfos = input.GetExtList<TalkInfo>();
}
public class TalkInfo : IExternalizable
{
public uint TalkUnit;
public string TalkContent;
public string TalkActionType;
public int TalkDelayTimeMS;
public int TalkKeepTimeMS;
public TalkInfo() { }
public TalkInfo(uint TalkUnit, string TalkContent, string TalkActionType, int TalkDelayTimeMS, int TalkKeepTimeMS)
{
this.TalkUnit = TalkUnit;
this.TalkContent = TalkContent;
this.TalkActionType = TalkActionType;
this.TalkDelayTimeMS = TalkDelayTimeMS;
this.TalkKeepTimeMS = TalkKeepTimeMS;
}
public void WriteExternal(IOutputStream output)
{
output.PutVU32(TalkUnit);
output.PutUTF(TalkContent);
output.PutUTF(TalkActionType);
output.PutVS32(TalkDelayTimeMS);
output.PutVS32(TalkKeepTimeMS);
}
public void ReadExternal(IInputStream input)
{
this.TalkUnit = input.GetVU32();
this.TalkContent = input.GetUTF();
this.TalkActionType = input.GetUTF();
this.TalkDelayTimeMS = input.GetVS32();
this.TalkKeepTimeMS = input.GetVS32();
}
}
}
[MessageType(0x8503)]
public class PlayerSkillUseTimeChangedEvent : PlayerEvent
{
public int SkillTemplateID;
public byte useTimes;
public byte hasNext; //0-不用继续叠层，1-继续增加叠层
public PlayerSkillUseTimeChangedEvent() { }
public PlayerSkillUseTimeChangedEvent(uint unit_id, int skillID, byte useTimes)
: base(unit_id)
{
this.SkillTemplateID = skillID;
this.useTimes = useTimes;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutS32(this.SkillTemplateID);
output.PutU8(this.useTimes);
output.PutU8(this.hasNext);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.SkillTemplateID = input.GetS32();
this.useTimes = input.GetU8();
this.hasNext = input.GetU8();
}
}
/// <summary>
/// 单位中BUFF
/// </summary>
[MessageType(0x8504)]
public class SyncUnitBuffState : ObjectEvent
{
public int buffTemplateID;
public byte overlayLevel;
public int buffExtData; //buff的扩展字段，
public SyncUnitBuffState() { }
public SyncUnitBuffState(uint unit_id, int buffID, byte overlayLevel, int extData)
: base(unit_id)
{
this.buffTemplateID = buffID;
this.overlayLevel = overlayLevel;
this.buffExtData = extData;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutVS32(buffTemplateID);
output.PutU8(overlayLevel);
output.PutVS32(buffExtData);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.buffTemplateID = input.GetVS32();
this.overlayLevel = input.GetU8();
this.buffExtData = input.GetVS32();
}
}
/// <summary>
/// 单位触发能力
/// </summary>
[MessageType(0x8505)]
public class UnitTriggerAblity : ObjectEvent
{
public int ablityID;
public UnitTriggerAblity() { }
public UnitTriggerAblity(uint unit_id, int id)
: base(unit_id)
{
this.ablityID = id;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutVS32(ablityID);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.ablityID = input.GetVS32();
}
}
/// <summary>
/// 单位触发破碎效果
/// </summary>
[MessageType(0x8506)]
public class UnitHitBreak : ObjectEvent
{
public UnitHitBreak() { }
public UnitHitBreak(uint unit_id)
: base(unit_id)
{
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
//output.PutVS32(ablityID);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
//this.ablityID = input.GetVS32();
}
}
/// <summary>
/// 单位触发隐身效果
/// </summary>
[MessageType(0x8507)]
public class UnitStealthInfo : ObjectEvent
{
public byte stealth;
public short flag;
public UnitStealthInfo() { }
public UnitStealthInfo(uint unit_id, byte stealth, short flag)
: base(unit_id)
{
this.stealth = stealth;
this.flag = flag;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutU8(this.stealth);
output.PutS16(this.flag);
//Console.WriteLine("UnitStealthInfo: " + this.stealth + ", " + flag);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.stealth = input.GetU8();
this.flag = input.GetS16();
}
}
/// <summary>
/// buff数据推送：针对单一buff事件内的信息变更
/// </summary>
[MessageType(0x8508)]
public class BuffDataNotify : ObjectEvent
{
public int buffId;
public uint senderId;
public byte overlayLevel;
public BuffDataNotify() { }
public BuffDataNotify(uint unit_id, int buffId, uint senderId, int layer)
: base(unit_id)
{
this.buffId = buffId;
this.senderId = senderId;
this.overlayLevel = (byte)layer;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutS32(this.buffId);
output.PutU32(this.senderId);
output.PutU8(this.overlayLevel);
//System.Console.WriteLine("-----BuffDataNotify: " + buffId + ", " + this.object_id + ", " + overlayLevel);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.buffId = input.GetS32();
this.senderId = input.GetU32();
this.overlayLevel = input.GetU8();
}
}
#endregion
//--------------------------------------------------------------------------
#region SYSTEM_0x8600
[MessageType(0x8600)]
public class Ping : Action, SystemMessage
{
public uint DayOfMS;
public Ping()
{
DayOfMS = (uint)CUtils.CurrentTimeMS;
}
public void Begin()
{
DayOfMS = (uint)CUtils.CurrentTimeMS;
}
public override void WriteExternal(IOutputStream output)
{
output.PutU32(DayOfMS);
}
public override void ReadExternal(IInputStream input)
{
DayOfMS = input.GetU32();
}
}
[MessageType(0x8601)]
public class Pong : Event, SystemMessage
{
public uint ClientTimeDayOfMS;
public Pong() { }
public Pong(Ping ping) { this.ClientTimeDayOfMS = ping.DayOfMS; }
public override void WriteExternal(IOutputStream output)
{
output.PutU32(ClientTimeDayOfMS);
}
public override void ReadExternal(IInputStream input)
{
ClientTimeDayOfMS = input.GetU32();
}
}
/// <summary>
/// 打包一组消息，一次性发出
/// </summary>
[MessageType(0x8602)]
public class PackEvent : Event, SystemMessage
{
protected static readonly Logger log = LoggerFactory.GetDefLogger();
public int sequenceNo;
public List<IMessage> events = new List<IMessage>();
public override string ToString()
{
var sb = new StringBuilder("PackEvent: no=").Append(sequenceNo).AppendLine();
foreach (IMessage e in events)
{
sb.AppendLine(e.ToString());
}
return sb.ToString();
}
public override void WriteExternal(IOutputStream output)
{
output.PutVS32(sequenceNo);
output.PutVS32(events.Count);
#if JSGProfile
long startSize = output.GetBuffPos();
#endif
foreach (IMessage e in events)
{
//if (!e.ToString().EndsWith("Pong") && !e.ToString().EndsWith("SyncPosEvent"))
//{
// Console.WriteLine("PackEvent: " + e);
//}
output.PutExt(e);
#if JSGProfile
long tempSize = output.GetBuffPos();
JSGServerProfile.RecordSend(output.GetTypeID(e), tempSize - startSize);
startSize = tempSize;
#endif
}
}
public override void ReadExternal(IInputStream input)
{
this.sequenceNo = input.GetVS32();
int count = input.GetVS32();
events.Clear();
events.Capacity = count;
for (int i = 0; i < count; i++)
{
try
{
IMessage e = (IMessage)input.GetExtAny();
events.Add(e);
}
catch (Exception err)
{
log.Error("PackEvent readExt catch:" + err);
}
}
}
public override void BeforeWrite(TemplateManager templates)
{
foreach (IMessage e in events)
{
if (e is BattleMessage)
{
(e as BattleMessage).BeforeWrite(templates);
}
}
}
public override void EndRead(TemplateManager templates)
{
foreach (IMessage e in events)
{
if (e is BattleMessage)
{
(e as BattleMessage).EndRead(templates);
}
}
}
}
/// <summary>
/// 系统消息框，测试用
/// </summary>
[MessageType(0x8603)]
public class TestMessageBox : Event, SystemMessage
{
public string msg;
public TestMessageBox() { }
public TestMessageBox(string msg)
{
this.msg = msg;
}
public override void WriteExternal(IOutputStream output)
{
output.PutUTF(this.msg);
}
public override void ReadExternal(IInputStream input)
{
this.msg = input.GetUTF();
}
}
/// <summary>
/// 通知客户端服务器运行状态
/// </summary>
[MessageType(0x8604)]
public class ServerStatusB2C : Event, SystemMessage
{
public int PID;
public long PrivateMemorySize64;
public int ActiveGameObjectCount;
public int ActiveInstanceZoneCount;
public int AllocGameObjectCount;
public int AllocInstanceZoneCount;
public ServerStatusB2C() { }
public void Update(System.Diagnostics.Process p)
{
this.PID = p.Id;
this.PrivateMemorySize64 = p.PrivateMemorySize64;
this.ActiveGameObjectCount = InstanceZoneObject.ActiveObjectCount;
this.ActiveInstanceZoneCount = InstanceZone.ActiveZoneCount;
this.AllocGameObjectCount = InstanceZoneObject.AllocObjectCount;
this.AllocInstanceZoneCount = InstanceZone.AllocZoneCount;
}
public override void WriteExternal(IOutputStream output)
{
output.PutVS32(this.PID);
output.PutVS64(this.PrivateMemorySize64);
output.PutVS32(this.ActiveGameObjectCount);
output.PutVS32(this.ActiveInstanceZoneCount);
output.PutVS32(this.AllocGameObjectCount);
output.PutVS32(this.AllocInstanceZoneCount);
}
public override void ReadExternal(IInputStream input)
{
this.PID = input.GetVS32();
this.PrivateMemorySize64 = input.GetVS64();
this.ActiveGameObjectCount = input.GetVS32();
this.ActiveInstanceZoneCount = input.GetVS32();
this.AllocGameObjectCount = input.GetVS32();
this.AllocInstanceZoneCount = input.GetVS32();
}
}
/// <summary>
/// 通知客户端服务器报错
/// </summary>
[MessageType(0x8605)]
public class ServerExceptionB2C : Event, SystemMessage
{
public string Message;
public string StackTrace;
public ServerExceptionB2C() { }
public ServerExceptionB2C(string message, string stackTrace)
{
this.Message = message;
this.StackTrace = stackTrace;
}
public override void WriteExternal(IOutputStream output)
{
output.PutUTF(this.Message);
output.PutUTF(this.StackTrace);
}
public override void ReadExternal(IInputStream input)
{
this.Message = input.GetUTF();
this.StackTrace = input.GetUTF();
}
}
[MessageType(0x8606)]
public class UnitFollowAction : ObjectAction
{
public bool follow = false;
public string reason = null;
public UnitFollowAction() { }
public UnitFollowAction(uint unit_id, bool guard)
: base(unit_id)
{
this.follow = guard;
}
public UnitFollowAction(uint unit_id, bool guard, string reason)
: base(unit_id)
{
this.follow = guard;
this.reason = reason;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutBool(follow);
output.PutUTF(reason);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.follow = input.GetBool();
this.reason = input.GetUTF();
}
}
#endregion
//--------------------------------------------------------------------------
/// <summary>
/// 新增技能移动的协议
/// </summary>
[MessageType(0x8700)]
public class SkillMove : ObjectAction
{
public int SkillID;
public Vector2 SkillPos;
public SkillMove() { }
public SkillMove(uint unit_id, int skill_id, Vector2 vec):base(unit_id)
{
this.SkillID = skill_id;
this.SkillPos = vec;
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutS32(SkillID);
output.PutF32(SkillPos.X);
output.PutF32(SkillPos.Y);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.SkillID = input.GetS32();
this.SkillPos = new Vector2();
this.SkillPos.SetX(input.GetF32());
this.SkillPos.SetY(input.GetF32());
}
}
/// <summary>
/// 法术Dispose后，在播放一个过渡特效
/// </summary>
[MessageType(0x8701)]
public class PlayDestoryEffect : ZoneEvent
{
public string EffectName;
public float X;
public float Y;
public float Z;
//rotation
public float Direction;
public PlayDestoryEffect() { }
public PlayDestoryEffect(string effectName, float x, float y, float z, float direction)
{
EffectName = effectName;
X = x;
Y = y;
Z = z;
Direction = direction;
}
override public void WriteExternal(IOutputStream output)
{
output.PutUTF(EffectName);
output.PutF32(X);
output.PutF32(Y);
output.PutF32(Z);
output.PutF32(Direction);
}
override public void ReadExternal(IInputStream input)
{
this.EffectName = input.GetUTF();
this.X = input.GetF32();
this.Y = input.GetF32();
this.Z = input.GetF32();
this.Direction = input.GetF32();
}
}
/// <summary>
/// 随从瞬移
/// </summary>
[MessageType(0x8702)]
public class PlayPetTeleportAction : ObjectAction
{
public PlayPetTeleportAction() { }
override public void WriteExternal(IOutputStream output)
{
}
override public void ReadExternal(IInputStream input)
{
}
}
/// <summary>
/// 刷新玩家天赋相关信息
///
/// </summary>
[MessageType(0x8703)]
public class RefreshTalnetInfo: PlayerSingleMsg
{
//根据不同职业，不同解读
//战士：value：怒气值，lv:无
//法师：value: 剑气值，lv:剑气层数
public short value; //天赋值，每秒降低，服务器刷新
public byte lv;
public int lvUpdateTime; //等级最后刷新时间，变化不频繁，需要根据本地时间自己做进度效果(lv=0无)
public RefreshTalnetInfo() { }
public RefreshTalnetInfo(short value, byte lv = 0, int updateTime = 0)
{
this.value = value;
this.lv = lv;
this.lvUpdateTime = updateTime;
}
override public void WriteExternal(IOutputStream output)
{
output.PutS16(this.value);
output.PutU8(this.lv);
if(this.lv > 0)
{
output.PutS32(this.lvUpdateTime);
}
}
override public void ReadExternal(IInputStream input)
{
this.value = input.GetS16();
this.lv = input.GetU8();
if(this.lv > 0)
{
this.lvUpdateTime = input.GetS32();
}
//System.Console.WriteLine("RefreshTalnetInfo: " + this.value + ", " + this.lv + ", " + this.lvUpdateTime);
}
}
/// <summary>
/// 刷新玩家卡牌珠相关信息
/// </summary>
[MessageType(0x8704)]
public class RefreshCardInfo : PlayerSingleMsg
{
public byte[] cardData = new byte[(int)CardType.Max]; //0-3代表有
public RefreshCardInfo()
{
for(int i = 0; i < (int)CardType.Max; i++)
{
cardData[i] = (byte)CardType.Max;
}
}
override public void WriteExternal(IOutputStream output)
{
for(int i = 0; i < (int)CardType.Max; i++)
{
output.PutU8(cardData[i]);
}
//System.Console.WriteLine("--------RefreshCardInfo: " + cardData[0] + ", " + cardData[1] + ", " + cardData[2] + ", " + cardData[3]);
}
override public void ReadExternal(IInputStream input)
{
//System.Console.WriteLine("--------RefreshCardInfo");
for (int i = 0; i < (int)CardType.Max; i++)
{
cardData[i] = input.GetU8();
}
//System.Console.WriteLine("--------RefreshCardInfo: " + cardData[0] + ", " + cardData[1] + ", " + cardData[2] + ", " + cardData[3]);
}
}
/// <summary>
/// 玩家卡牌释放逻辑
/// </summary>
[MessageType(0x8705)]
public class PlayerLaunchCardSkill : PlayerSingleMsg
{
public int cardSkill;
public CardType type;
public byte layer;
public byte[] cardData = new byte[(int)CardType.Max]; //0-3代表有
public PlayerLaunchCardSkill() { }
override public void WriteExternal(IOutputStream output)
{
output.PutS32(this.cardSkill);
output.PutEnum8(type);
output.PutU8(this.layer);
for (int i = 0; i < (int)CardType.Max; i++)
{
output.PutU8(cardData[i]);
}
//System.Console.WriteLine("--------PlayerLaunchCardSkill: " + cardSkill + ", " + this.type);
}
override public void ReadExternal(IInputStream input)
{
//
this.cardSkill = input.GetS32();
this.type = input.GetEnum8<CardType>();
this.layer = input.GetU8();
for (int i = 0; i < (int)CardType.Max; i++)
{
cardData[i] = input.GetU8();
}
//System.Console.WriteLine("--------PlayerLaunchCardSkill: " + cardSkill + ", " + this.type);
}
}
/// <summary>
/// 刷新Boss卡牌珠相关信息
/// </summary>
[MessageType(0x8706)]
public class RefreshBossCardInfo : ObjectEvent
{
public byte[] cardData = new byte[(int)CardType.Max]; //0-3代表有
public RefreshBossCardInfo()
{
for (int i = 0; i < (int)CardType.Max; i++)
{
cardData[i] = (byte)CardType.Max;
}
}
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
for (int i = 0; i < (int)CardType.Max; i++)
{
output.PutU8(cardData[i]);
}
//System.Console.WriteLine("RefreshBossCardInfo: " + this.object_id +", " + cardData[0] + ", " + cardData[1] + ", " + cardData[2] + ", " + cardData[3]);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
for (int i = 0; i < (int)CardType.Max; i++)
{
cardData[i] = input.GetU8();
}
//System.Console.WriteLine("objectID: " + this.object_id);
//System.Console.WriteLine("--------RefreshBossCardInfo: " + this.object_id + ", " + cardData[0] + ", " + cardData[1] + ", " + cardData[2] + ", " + cardData[3]);
}
}
/// <summary>
/// 玩家卡牌释放逻辑
/// </summary>
[MessageType(0x8707)]
public class BossTriggerCardSkill : ObjectEvent
{
public int cardSkill;
public CardType type;
public byte layer;
public byte[] cardData = new byte[(int)CardType.Max]; //0-3代表有
public BossTriggerCardSkill() { }
override public void WriteExternal(IOutputStream output)
{
base.WriteExternal(output);
output.PutS32(this.cardSkill);
output.PutEnum8(type);
output.PutU8(this.layer);
for (int i = 0; i < (int)CardType.Max; i++)
{
output.PutU8(cardData[i]);
}
//System.Console.WriteLine("BossTriggerCardSkill: " + this.object_id + ", " + cardData[0] + ", " + cardData[1] + ", " + cardData[2] + ", " + cardData[3]);
}
override public void ReadExternal(IInputStream input)
{
base.ReadExternal(input);
this.cardSkill = input.GetS32();
this.type = input.GetEnum8<CardType>();
this.layer = input.GetU8();
for (int i = 0; i < (int)CardType.Max; i++)
{
cardData[i] = input.GetU8();
}
//System.Console.WriteLine("BossTriggerCardSkill: " + this.object_id + ", " + cardData[0] + ", " + cardData[1] + ", " + cardData[2] + ", " + cardData[3]);
}
}
}