private void SendRequest(ISerializerable request, int requestIndex)
{
if (this.IsConnect)
{
var index = 0;
if (MessageHandleTypes.GetTypeIndex(request.GetType(), out index))
{
using (var mem = new MemoryStream())
{
using (var bw = new BinaryWriter(mem))
{
bw.Write(requestIndex);
request.ToBinary(bw);
if (NetProtoTool.EnableLog)
{
Debuger.Log(request.GetType() + "-->" + JsonTool.Serialize(request));
}
}
var result = new Message(MessageClass.Request, index, mem.ToArray());
SendMessage(result);
}
}
}
else
{
IHandler handler;
if (Handler._handlers.TryToGetValue(requestIndex, out handler))
{
handler.OnHandle(false, null);
}
}
}
public void OnHandle(bool success, ISerializerable message)
{
UUIManager.S.UnMaskEvent();
completed = true;
if (OnCompleted != null)
{
OnCompleted(success, message as R);
}
}
public static void SendTask(Client client, ISerializerable task)
{
var message = ToNetMessage(MessageClass.Task, task);
client.SendMessage(message);
if (EnableLog)
{
Debuger.Log(string.Format("Task-->{0}", JsonTool.Serialize(task)));
}
}
public static Message ToNetMessage(MessageClass @class, ISerializerable m)
{
int flag;
MessageHandleTypes.GetTypeIndex(m.GetType(), out flag);
using (var mem = new MemoryStream())
{
using (var bw = new BinaryWriter(mem))
{
m.ToBinary(bw);
}
return(new Message(@class, flag, mem.ToArray()));
}
}
public void OnHandle(bool isSuccess, ISerializerable message)
{
RequestCompleted = true;
{
IsSuccess = isSuccess;
Result = message;
if (isSync)
{
if (OnCompleted != null)
{
OnCompleted(isSuccess, Result as R);
}
}
}
}
public void AddNotify(ISerializerable notify)
{
_notify.Enqueue(notify);
}
/// <summary>
/// 处理网络包的解析
/// </summary>
/// <param name="notify">Notify.</param>
public void Process(ISerializerable notify)
{
var per = UPerceptionView.S as IBattlePerception;
if (notify is Notify_CreateBattleCharacter)
{
var createcharacter = notify as Notify_CreateBattleCharacter;
var resources = ExcelConfig.ExcelToJSONConfigManager.Current.GetConfigByID <ExcelConfig.CharacterData>(createcharacter.ConfigID);
var view = per.CreateBattleCharacterView(
resources.ResourcesPath,
createcharacter.Position.ToGVer3(),
createcharacter.Forward.ToGVer3());
var character = view as UCharacterView;
character.index = createcharacter.Index;
character.UserID = createcharacter.UserID;
view.SetSpeed(createcharacter.Speed * 1.1f);
foreach (var i in createcharacter.Magics)
{
view.AttachMaigc(i.MagicID, i.CDTime);
}
views.Add(view.Index, view);
if (OnCreateUser != null)
{
OnCreateUser(view);
}
}
else if (notify is Notify_CreateReleaser)
{
var creater = notify as Notify_CreateReleaser;
var releaer = views[creater.ReleaserIndex] as UCharacterView;
var target = views[creater.TargetIndex] as UCharacterView;
var viewer = per.CreateReleaserView(releaer, target, null);
var releaser = viewer as UMagicReleaserView;
releaser.SetCharacter(releaer, target);
releaser.index = creater.Index;
views.Add(viewer.Index, viewer);
}
else if (notify is Notify_CreateMissile)
{
var create = notify as Notify_CreateMissile;
var releaser = views[create.ReleaserIndex] as UMagicReleaserView;
var layout = new Layout.LayoutElements.MissileLayout
{
fromBone = create.formBone,
toBone = create.toBone,
offset = create.offset.ToLVer3(),
resourcesPath = create.ResourcesPath,
speed = create.Speed
};
var view = per.CreateMissile(releaser, layout);
var missile = view as UBattleMissileView;
missile.index = create.Index;
views.Add(view.Index, view);
}
else if (notify is Notify_LayoutPlayParticle)
{
var particle = notify as Notify_LayoutPlayParticle;
var layout = new Layout.LayoutElements.ParticleLayout
{
path = particle.Path,
destoryTime = particle.DestoryTime,
destoryType = (Layout.LayoutElements.ParticleDestoryType)particle.DestoryType,
fromBoneName = particle.FromBoneName,
fromTarget = (Layout.TargetType)particle.FromTarget,
toBoneName = particle.ToBoneName,
toTarget = (Layout.TargetType)particle.ToTarget,
Bind = particle.Bind
};
var releaser = views[particle.ReleaseIndex] as UMagicReleaserView;
per.CreateParticlePlayer(releaser, layout);
}
else if (notify is Notify_LookAtCharacter)
{
var look = notify as Notify_LookAtCharacter;
var owner = views[look.Own] as IBattleCharacter;
var target = views[look.Target] as IBattleCharacter;
owner.LookAtTarget(target);
}
else if (notify is Notify_CharacterPosition)
{
var position = notify as Notify_CharacterPosition;
var view = views[position.Index] as IBattleCharacter;
view.MoveTo(position.TargetPosition.ToGVer3());
}
else if (notify is Notify_LayoutPlayMotion)
{
var motion = notify as Notify_LayoutPlayMotion;
var view = views[motion.Index] as IBattleCharacter;
view.PlayMotion(motion.Motion);
}
else if (notify is Notify_HPChange)
{
var change = notify as Proto.Notify_HPChange;
var view = views[change.Index] as IBattleCharacter;
view.ShowHPChange(change.HP, change.TargetHP, change.Max);
if (change.TargetHP == 0)
{
if (OnDeath != null)
{
OnDeath(view);
}
view.Death();
}
}
else if (notify is Notify_ElementExitState)
{
var exit = notify as Notify_ElementExitState;
var view = views[exit.Index];
views.Remove(exit.Index);
//GameObject.Destroy(view.gameObject);
}
else if (notify is Notify_ElementJoinState)
{
var joinState = notify as Proto.Notify_ElementJoinState;
var view = views[joinState.Index];
//view.Joined();
}
else if (notify is Notify_DamageResult)
{
/*var damage = notify as Proto.Notify_DamageResult;
* var view = views[damage.Index];
* var character = view as UCharacterView;
* character.NotifyDamage(damage);*/
}
else if (notify is Notify_MPChange)
{
var mpChanged = notify as Notify_MPChange;
var view = views[mpChanged.Index] as IBattleCharacter;
view.ShowMPChange(mpChanged.MP, mpChanged.TargetMP, mpChanged.Max);
}
else if (notify is Notify_PropertyValue)
{
var pV = notify as Notify_PropertyValue;
var view = views[pV.Index] as IBattleCharacter;
view.ProtertyChange(pV.Type, pV.FinallyValue);
}
else if (notify is Notify_PlayerJoinState)
{
//package
var package = notify as Notify_PlayerJoinState;
if (this.OnJoined != null)
{
OnJoined(package);
}
}
else if (notify is Notify_Drop)
{
var drop = notify as Notify_Drop;
if (OnDrop != null)
{
OnDrop(drop);
}
//var drop = notify as Notify_Drop;
if (drop.Gold > 0)
{
//gold += drop.Gold;
UAppliaction.S.ShowNotify("Gold +" + drop.Gold);
}
foreach (var i in drop.Items)
{
var item = ExcelToJSONConfigManager.Current.GetConfigByID <ItemData>(i.ItemID);
UAppliaction.S.ShowNotify(string.Format("{0}+{1}", item.Name, i.Num));
}
}
else if (notify is Notify_ReleaseMagic)
{
var release = notify as Notify_ReleaseMagic;
var view = views[release.Index] as IBattleCharacter;
view.AttachMaigc(release.MagicID, release.CdCompletedTime);
}
else
{
Debug.LogError("NO Handle:" + notify.GetType());
}
}
private void Process(ISerializerable notify)
{
player.Process(notify);
}
private void DoHandle(Message message, Client client)
{
var handlerID = message.Flag;
Type m;
if (_handler.TryGetValue(handlerID, out m))
{
var type = MessageHandleTypes.GetTypeByIndex(handlerID);
if (type == null)
{
Debuger.Log(string.Format("TypeId:{0} no found!", handlerID));
return;
}
ISerializerable request;
int requestIndex = 0;
using (var mem = new MemoryStream(message.Content))
{
using (var br = new BinaryReader(mem))
{
requestIndex = br.ReadInt32();
request = Activator.CreateInstance(type) as Proto.ISerializerable;
request.ParseFormBinary(br);
if (NetProtoTool.EnableLog)
{
Debuger.Log(request.GetType() + "-->" + JsonTool.Serialize(request));
}
}
}
var responser = Activator.CreateInstance(m);
var NeedAccess = (bool)m.GetProperty("NeedAccess").GetValue(responser);
if (NeedAccess)
{
if (!client.HaveAdmission)
{
//直接断开
client.Server.DisConnectClient(client, 1);
return;
}
}
var begin = DateTime.Now;
ISerializerable result = null;
try
{
result = m.GetMethod("DoResponse")
.Invoke(responser, new object[] { request, client })
as ISerializerable;
}
catch (Exception ex)
{
Debuger.LogError(ex.ToString());
}
if (result == null)
{
var rem = m.GetMethod("DoResponse");
var emptyResult = Activator.CreateInstance(rem.ReturnType) as ISerializerable;
result = emptyResult;
//Debuger.LogWaring("Empty")
}
if (NetProtoTool.EnableLog)
{
var processTime = DateTime.Now - begin;
Debuger.Log(
string.Format("{1}({0}ms)-->{2}",
processTime.TotalMilliseconds,
request.GetType(),
JsonTool.Serialize(result))
);
}
var index = 0;
if (MessageHandleTypes.GetTypeIndex(result.GetType(), out index))
{
using (var mem = new MemoryStream())
{
using (var bw = new BinaryWriter(mem))
{
bw.Write(requestIndex);
result.ToBinary(bw);
}
var response = new Message(MessageClass.Response, index, mem.ToArray());
client.SendMessage(response);
}
}
}
else
{
Debuger.LogError(string.Format("TypeID:{0} no Handle!", handlerID));
}
}
public void ProcessNotify(ISerializerable notify)
{
player.Process(notify);
}
