private void Login()
{
lclient = new ServerUtility.RequestClient(host, port);
lclient.UseSendThreadUpdate = true;
lclient.OnConnectCompleted = (s, e) =>
{
if (e.Success)
{
var login = lclient.CreateRequest <C2L_Login, L2C_Login>();
login.RequestMessage.Password = pwd;
login.RequestMessage.UserName = userName;
login.RequestMessage.Version = ProtoTool.GetVersion();
login.OnCompleted = (su, res) =>
{
if (res.Code == ErrorCode.OK)
{
GateServer = res.Server;
userID = res.UserID;
sessionKey = res.Session;
lclient.Disconnect();
MEvent.Set();
}
};
login.SendRequestSync();
}
};
lclient.Connect();
}
// Map容器中，每一个元素的编/解码
private static ulong EntryByteSizeWithoutLength <K, V, KP, VP>(K key, V value, KP keyType, VP valueType)
where KP : ProtoType
where VP : ProtoType
{
if (Cache <K, KP> .ByteSize == null)
{
throw new NotImplementedException();
}
if (Cache <V, VP> .ByteSize == null)
{
if (value is Enum && valueType is ProtoEnum)
{
Cache <V, VP> .ByteSize = (V parm) => ProtoTool.EnumByteSize(parm);
}
else
{
throw new NotImplementedException();
}
}
ulong bytes = 0;
bytes += KeyByteSize(1, (uint)keyType.GetWireType());
bytes += Cache <K, KP> .ByteSize(key);
bytes += KeyByteSize(2, (uint)valueType.GetWireType());
bytes += Cache <V, VP> .ByteSize(value);
return(bytes);
}
static ProtoTool()
{
Cache <bool, ProtoBool> .ByteSize = (bool value) => ProtoTool.BoolByteSize(value);
Cache <int, ProtoInt32> .ByteSize = (int value) => ProtoTool.Int32ByteSize(value);
Cache <int, ProtoSInt32> .ByteSize = (int value) => ProtoTool.SInt32ByteSize(value);
Cache <uint, ProtoUInt32> .ByteSize = (uint value) => ProtoTool.UInt32ByteSize(value);
Cache <long, ProtoInt64> .ByteSize = (long value) => ProtoTool.Int64ByteSize(value);
Cache <long, ProtoSInt64> .ByteSize = (long value) => ProtoTool.SInt64ByteSize(value);
Cache <ulong, ProtoUInt64> .ByteSize = (ulong value) => ProtoTool.UInt64ByteSize(value);
Cache <float, ProtoFloat> .ByteSize = (float value) => ProtoTool.FloatByteSize(value);
Cache <double, ProtoDouble> .ByteSize = (double value) => ProtoTool.DoubleByteSize(value);
Cache <string, ProtoString> .ByteSize = (string value) => ProtoTool.StringByteSize(value);
Cache <bool, ProtoBool> .Code = (bool value, Stream buf) => ProtoTool.BoolCode(value, buf);
Cache <int, ProtoInt32> .Code = (int value, Stream buf) => ProtoTool.Int32Code(value, buf);
Cache <int, ProtoSInt32> .Code = (int value, Stream buf) => ProtoTool.SInt32Code(value, buf);
Cache <uint, ProtoUInt32> .Code = (uint value, Stream buf) => ProtoTool.UInt32Code(value, buf);
Cache <long, ProtoInt64> .Code = (long value, Stream buf) => ProtoTool.Int64Code(value, buf);
Cache <long, ProtoSInt64> .Code = (long value, Stream buf) => ProtoTool.SInt64Code(value, buf);
Cache <ulong, ProtoUInt64> .Code = (ulong value, Stream buf) => ProtoTool.UInt64Code(value, buf);
Cache <float, ProtoFloat> .Code = (float value, Stream buf) => ProtoTool.FloatCode(value, buf);
Cache <double, ProtoDouble> .Code = (double value, Stream buf) => ProtoTool.DoubleCode(value, buf);
Cache <string, ProtoString> .Code = (string value, Stream buf) => ProtoTool.StringCode(value, buf);
Cache <bool, ProtoBool> .Decode = (ref bool value, Stream buf) => ProtoTool.BoolDecode(ref value, buf);
Cache <int, ProtoInt32> .Decode = (ref int value, Stream buf) => ProtoTool.Int32Decode(ref value, buf);
Cache <int, ProtoSInt32> .Decode = (ref int value, Stream buf) => ProtoTool.SInt32Decode(ref value, buf);
Cache <uint, ProtoUInt32> .Decode = (ref uint value, Stream buf) => ProtoTool.UInt32Decode(ref value, buf);
Cache <long, ProtoInt64> .Decode = (ref long value, Stream buf) => ProtoTool.Int64Decode(ref value, buf);
Cache <long, ProtoSInt64> .Decode = (ref long value, Stream buf) => ProtoTool.SInt64Decode(ref value, buf);
Cache <ulong, ProtoUInt64> .Decode = (ref ulong value, Stream buf) => ProtoTool.UInt64Decode(ref value, buf);
Cache <float, ProtoFloat> .Decode = (ref float value, Stream buf) => ProtoTool.FloatDecode(ref value, buf);
Cache <double, ProtoDouble> .Decode = (ref double value, Stream buf) => ProtoTool.DoubleDecode(ref value, buf);
Cache <string, ProtoString> .Decode = (ref string value, Stream buf) => ProtoTool.StringDecode(ref value, buf);
}
public static ulong EntryCode <K, V, KP, VP>(K key, V value, Stream buf, KP keyType, VP valueType)
where KP : ProtoType
where VP : ProtoType
{
if (Cache <K, KP> .Code == null)
{
throw new NotImplementedException();
}
if (Cache <V, VP> .Code == null)
{
if (value is Enum && valueType is ProtoEnum)
{
Cache <V, VP> .Code = (V parm1, Stream parm2) => ProtoTool.EnumCode(parm1, parm2);
}
else
{
throw new NotImplementedException();
}
}
ulong bytes = 0;
bytes += VarintCode(EntryByteSizeWithoutLength(key, value, keyType, valueType), buf);
bytes += KeyCode(1, (uint)keyType.GetWireType(), buf);
bytes += Cache <K, KP> .Code(key, buf);
bytes += KeyCode(2, (uint)valueType.GetWireType(), buf);
bytes += Cache <V, VP> .Code(value, buf);
return(bytes);
}
public override B2C_JoinBattle DoResponse(C2B_JoinBattle request, Client client)
{
if (!ProtoTool.CompareVersion(request.Version))
{
return(new B2C_JoinBattle {
Code = ErrorCode.VersionError
});
}
var result = ErrorCode.Error;
var req = Appliaction.Current.Client.R <B2L_CheckSession, L2B_CheckSession>();
req.RequestMessage.SessionKey = request.Session;
req.RequestMessage.UserID = request.UserID;
req.OnCompleted = (s, r) => { result = r.Code; };
req.SendRequest();
if (result == ErrorCode.OK)
{
client.UserState = request.UserID;
if (!MonitorPool.S.Get <MapSimulaterManager>().BindUser(request.UserID, client.ID))
{
result = ErrorCode.NOFoundUserOnBattleServer;
}
}
return(new B2C_JoinBattle {
Code = result
});
}
public static ulong EntryDecode <K, V, KP, VP>(ref K key, ref V value, Stream buf, KP keyType, VP valueType)
where KP : ProtoType
where VP : ProtoType
{
if (Cache <K, KP> .Decode == null)
{
throw new NotImplementedException();
}
if (Cache <V, VP> .Decode == null)
{
if (value is Enum && valueType is ProtoEnum)
{
Cache <V, VP> .Decode = (ref V parm1, Stream parm2) => ProtoTool.EnumDecode(ref parm1, parm2);
}
else
{
throw new NotImplementedException();
}
}
ulong bytes = 0;
ulong length = 0;
bytes += VarintDecode(ref length, buf);
uint tag = 0;
uint type = 0;
bytes += KeyDecode(ref tag, ref type, buf);
bytes += Cache <K, KP> .Decode(ref key, buf);
bytes += KeyDecode(ref tag, ref type, buf);
bytes += Cache <V, VP> .Decode(ref value, buf);
return(bytes);
}
private void RequestPlayer()
{
var request = Client.CreateRequest <C2G_Login, G2C_Login>();
request.RequestMessage.Session = UAppliaction.Singleton.SesssionKey;
request.RequestMessage.UserID = UAppliaction.Singleton.UserID;
request.RequestMessage.Version = ProtoTool.GetVersion();
request.OnCompleted = (su, r) =>
{
if (r.Code == ErrorCode.OK)
{
GetPlayerData(r);
}
else if (r.Code == ErrorCode.NoGamePlayerData)
{
ShowCreateHero();
}
else
{
UUITipDrawer.Singleton.ShowNotify("GateServer Response:" + r.Code);
UAppliaction.Singleton.GotoLoginGate();
}
};
request.SendRequest();
}
public static T Load <T>(string fileName) where T : ProtoBuf.IExtensible
{
TextAsset textAsset = null;
if (GameManager.Instance.ResFrom == ResourceFrom.Origin)
{
string protoPath = "ConfigData/" + fileName;
textAsset = Resources.Load(protoPath) as TextAsset;
}
else
{
textAsset = ResourceManager.GetInstance().LoadText("assetbundle/data/" + fileName, fileName);
if (null == textAsset)
{
Debug.LogError("prototool bundle 加载失败, 没有对应的资源: " + fileName);
}
}
T t = default(T);
try
{
t = ProtoTool.DeSerialize <T>(textAsset.bytes);
}
catch (ProtoException)
{
Debug.LogError(string.Format("解析配表：<color=red>{0}</color>出错,请相关人员检查配表!", fileName));
}
catch (Exception)
{
Debug.LogError(string.Format("解析配表：<color=red>{0}</color>出错,未知异常!", fileName));
}
return(t);
}
public override void Tick()
{
if (!IsInit)
{
if (Time.time - start < 0.1f)
{
return;
}
IsInit = true;
Operation = SceneManager.LoadSceneAsync(MapConfig.LevelName);
}
if (Operation != null)
{
if (Operation.isDone)
{
Operation = null;
Client = new RequestClient(ServerInfo.Host, ServerInfo.Port);
Client.RegAssembly(this.GetType().Assembly);
Client.RegisterHandler(MessageClass.Notify, new BattleNotifyHandler(this));
Client.OnConnectCompleted += (s, e) =>
{
UAppliaction.Singleton.ConnectTime = Time.time;
if (e.Success)
{
var request = Client.R <C2B_JoinBattle, B2C_JoinBattle>();
request.RequestMessage.Session = UAppliaction.Singleton.SesssionKey;
request.RequestMessage.UserID = UAppliaction.Singleton.UserID;
request.RequestMessage.Version = ProtoTool.GetVersion();
request.RequestMessage.MapID = MapID;
request.OnCompleted = (success, response) =>
{
// UUITipDrawer.Singleton.ShowNotify("BattleServer:"+response.Code);
if (response.Code != ErrorCode.OK)
{
UUITipDrawer.Singleton.ShowNotify("BattleServer:" + response.Code);
UAppliaction.Singleton.GoBackToMainGate();
}
};
request.SendRequest();
}
else
{
UUITipDrawer.Singleton.ShowNotify("Can't login BattleServer!");
UAppliaction.Singleton.GoBackToMainGate();
}
};
Client.OnDisconnect += OnDisconnect;
Client.Connect();
}
}
if (Client != null)
{
Client.Update();
UAppliaction.Singleton.ReceiveTotal = Client.ReceiveSize;
UAppliaction.Singleton.SendTotal = Client.SendSize;
UAppliaction.Singleton.PingDelay = (float)Client.Delay / (float)TimeSpan.TicksPerMillisecond;
}
}
public void Start()
{
if (IsRunning)
{
return;
}
IsRunning = true;
ResourcesLoader.Singleton.LoadAllConfig(configRoot);
var listenHandler = new RequestHandle();
//注册responser
listenHandler.RegAssembly(this.GetType().Assembly, HandleResponserType.CLIENT_SERVER);
ListenServer = new SocketServer(new ConnectionManager(), port);
ListenServer.HandlerManager = listenHandler;
ListenServer.Start();
Client = new RequestClient(ServiceHost, ServicePort);
Client.RegTaskHandlerFromAssembly(this.GetType().Assembly);
Client.UseSendThreadUpdate = true;
Client.OnConnectCompleted = (s, e) =>
{
if (e.Success)
{
var request = Client.CreateRequest <B2L_RegBattleServer, L2B_RegBattleServer>();
request.RequestMessage.MaxBattleCount = MaxBattleCount;
request.RequestMessage.ServiceHost = ServerHost;
request.RequestMessage.ServicePort = this.port;
request.RequestMessage.Version = ProtoTool.GetVersion();
request.OnCompleted = (success, r) =>
{
if (success && r.Code == ErrorCode.OK)
{
ServerID = r.ServiceServerID;
Debuger.Log("Server Reg Success!");
}
else
{
Debuger.Log("Can't Regsiter LoginServer!");
Stop();
}
};
request.SendRequestSync();
}
else
{
Debuger.Log("Can't connect LoginServer!");
Stop();
}
};
Client.OnDisconnect = (s, e) =>
{
Debuger.Log("disconnect from LoginServer!");
Stop();
};
Client.Connect();
MonitorPool.Singleton.Start();
}
public void LoadData(Action complate = null)
{
Debug.Log("加载资源中....");
UIFrameTable frameTable = ProtoTool.Load <UIFrameTable>("UIFrame");
m_UIFrame_Dict = ProtoTool.BuildMap <string, UIFrame>("WindowID", frameTable.tlist);
complate();
}
protected override void InitModel()
{
base.InitModel();
//Write Code here
bt_submit.onClick.AddListener(() =>
{
var userName = if_userName.text;
var pwd = if_pwd.text;
var gate = UAppliaction.Singleton.GetGate() as LoginGate;
if (gate == null)
{
return;
}
var request = gate.Client.CreateRequest <C2L_Login, L2C_Login>();
request.RequestMessage.Password = pwd;
request.RequestMessage.UserName = userName;
request.RequestMessage.Version = Proto.ProtoTool.GetVersion();
request.OnCompleted = (success, response) => {
if (response.Code == ErrorCode.OK)
{
UAppliaction.Singleton.GoServerMainGate(response.Server, response.UserID, response.Session);
}
else
{
UAppliaction.Singleton.ShowError(response.Code);
}
};
request.SendRequest();
});
bt_reg.onClick.AddListener(() =>
{
var userName = if_userName.text;
var pwd = if_pwd.text;
var gate = UAppliaction.Singleton.GetGate() as LoginGate;
var request = gate.Client.CreateRequest <C2L_Reg, L2C_Reg>();
request.RequestMessage.Password = pwd;
request.RequestMessage.UserName = userName;
request.RequestMessage.Version = ProtoTool.GetVersion();
request.OnCompleted = (s, r) => {
if (r.Code == ErrorCode.OK)
{
UAppliaction.Singleton.GoServerMainGate(r.Server, r.UserID, r.Session);
}
else
{
UUITipDrawer.Singleton.ShowNotify("Server Response:" + r.Code);
}
};
request.SendRequest();
});
}
private static ulong EntryDecode <T, P>(ref T value, Stream buf, P type)
{
if (Cache <T, P> .Decode == null)
{
if (value is Enum && type is ProtoEnum)
{
Cache <T, P> .Decode = (ref T parm1, Stream parm2) => ProtoTool.EnumDecode(ref parm1, parm2);
}
else
{
throw new NotImplementedException();
}
}
return(Cache <T, P> .Decode(ref value, buf));
}
// Array，Set容器中，每一个元素的编/解码
private static ulong EntryByteSize <T, P>(T value, P type)
{
if (Cache <T, P> .ByteSize == null)
{
if (value is Enum && type is ProtoEnum)
{
Cache <T, P> .ByteSize = (T parm) => ProtoTool.EnumByteSize(parm);
}
else
{
throw new NotImplementedException();
}
}
return(Cache <T, P> .ByteSize(value));
}
public override void OnMessage(byte[] data)
{
base.OnMessage(data);
object proto = ProtoTool.ToProtoObj(data);
if (proto.GetType() == typeof(message.LoginRequest))
{
// 发送SessionID作为key
EventManager.instance.Send(proto.GetType().ToString(), sessionId, proto);
}
else
{
// 发送PlayerID作为key
long playerID = ProxyManager.instance.GetProxy <PlayerProxy>().GetPlayerID(sessionId);
Debug.Log("receive ---> {0} {1} :len({2})", playerID, proto.GetType(), data.Length);
EventManager.instance.Send(proto.GetType().ToString(), playerID, proto);
}
}
public void BeginGame()
{
client = new ServerUtility.RequestClient(BattleServer.Host, BattleServer.Port);
client.UseSendThreadUpdate = true;
client.OnConnectCompleted = (s, e) =>
{
if (e.Success)
{
var login = client.CreateRequest <C2B_JoinBattle, B2C_JoinBattle>();
login.RequestMessage.MapID = 1;
login.RequestMessage.Session = sessionKey;
login.RequestMessage.UserID = userID;
login.RequestMessage.Version = ProtoTool.GetVersion();
login.SendRequestSync();
}
};
client.Connect();
}
public override L2G_Reg DoResponse(G2L_Reg request, Client client)
{
if (!ProtoTool.CompareVersion(request.Version))
{
return(new L2G_Reg {
Code = ErrorCode.VersionError
});
}
client.HaveAdmission = true;
client.UserState = request.ServerID;
var server = new GameServerInfo
{
ServerID = request.ServerID,
Host = request.Host,
Port = request.Port
};
var success = ServerManager
.S.AddGateServer(
client.ID,
request.CurrentPlayer,
server,
request.ServiceHost,
request.ServicesProt
);
if (!success)
{
return(new L2G_Reg {
Code = ErrorCode.Error
});
}
client.OnDisconnect += OnDisconnect;
return(new L2G_Reg {
Code = ErrorCode.OK
});
}
public static T Load<T>(string fileName)where T:ProtoBuf.IExtensible
{
TextAsset textAsset = null;
#if PC_RUN_ANDROID || PC_RUN_IOS
textAsset = ResourceManager.GetInstance().LoadText("ConfigData/" + fileName, fileName);
if (null == textAsset) {
CommonTools.MustLog("prototool bundle 加载失败, 没有对应的资源: " + fileName);
}
#else
if(Application.isEditor || !Application.isMobilePlatform){
string protoPath = "ConfigData/"+fileName;
textAsset = XFramework.AssetBundlePacker.ResourcesManager.Load<TextAsset>(protoPath) as TextAsset;
}else{
//textAsset = ResourceManager.LoadText("ConfigData/" + fileName, fileName);
//if (null == textAsset)
//{
// ///CommonTools.MustLog("prototool bundle 加载失败, 没有对应的资源: " + fileName);
////}
string protoPath = "ConfigData/" + fileName;
textAsset = XFramework.AssetBundlePacker.ResourcesManager.Load<TextAsset>(protoPath) as TextAsset;
}
#endif
T t = default(T);
try
{
t = ProtoTool.DeSerialize<T>(textAsset.bytes);
}
catch (ProtoException proex)
{
Debug.LogError(string.Format("解析配表：<color=red>{0}</color>出错,请相关人员检查配表! + ex:"+proex.Message, fileName));
}
catch (Exception ex)
{
Debug.LogError(string.Format("解析配表：<color=red>{0}</color>出错,未知异常!exception:{1}", fileName,ex.Message));
}
return t;
}
private void Gate()
{
gclient = new ServerUtility.RequestClient(GateServer.Host, GateServer.Port);
gclient.UseSendThreadUpdate = true;
gclient.OnConnectCompleted = (s, e) =>
{
if (e.Success)
{
var login = gclient.CreateRequest <C2G_Login, G2C_Login>();
login.RequestMessage.Session = sessionKey;
login.RequestMessage.UserID = userID;
login.RequestMessage.Version = ProtoTool.GetVersion();
login.OnCompleted = (t1, t2) =>
{
Debuger.Log(t2);
};
login.SendRequestSync();
var beginBattle = gclient.CreateRequest <C2G_BeginGame, G2C_BeginGame>();
beginBattle.RequestMessage.MapID = 1;
beginBattle.OnCompleted = (se, res) =>
{
if (res.Code == ErrorCode.OK)
{
BattleServer = res.ServerInfo;
gclient.Disconnect();
MEvent.Set();
}
};
beginBattle.SendRequestSync();
}
};
gclient.Connect();
}
public void Start()
{
if (IsRunning)
{
return;
}
MonitorPool.Singleton.Start();
ResourcesLoader.Singleton.LoadAllConfig(this.configRoot);
IsRunning = true;
//同时对外对内服务器不能使用全部注册
var listenHandler = new RequestHandle();
//2 对外
listenHandler.RegAssembly(this.GetType().Assembly, HandleResponserType.CLIENT_SERVER);
ListenServer = new SocketServer(new ConnectionManager(), port);
ListenServer.HandlerManager = listenHandler;
ListenServer.Start();
var serviceHandler = new RequestHandle();
serviceHandler.RegAssembly(this.GetType().Assembly, HandleResponserType.SERVER_SERVER);
ServiceServer = new SocketServer(new ConnectionManager(), ServicePort);
ServiceServer.HandlerManager = serviceHandler;
ServiceServer.Start();
Client = new RequestClient(LoginHost, LoginPort);
Client.RegTaskHandlerFromAssembly(this.GetType().Assembly);
Client.UseSendThreadUpdate = true;
Client.OnConnectCompleted = (s, e) =>
{
if (e.Success)
{
int currentPlayer = 0;
using (var db = new DataBaseContext.GameDb(Connection))
{
currentPlayer = db.TBGAmePlayer.Count();
}
var request = Client.CreateRequest <G2L_Reg, L2G_Reg>();
request.RequestMessage.ServerID = ServerID;
request.RequestMessage.Port = this.port;
request.RequestMessage.Host = serverHostName;
request.RequestMessage.ServiceHost = ServiceHost;
request.RequestMessage.ServicesProt = ServicePort;
request.RequestMessage.MaxPlayer = 100000; //最大玩家数
request.RequestMessage.CurrentPlayer = currentPlayer;
request.RequestMessage.Version = ProtoTool.GetVersion();
request.OnCompleted = (success, r) =>
{
if (success && r.Code == ErrorCode.OK)
{
Debuger.Log("Server Reg Success!");
}
};
request.SendRequestSync();
}
else
{
Debuger.Log("Can't connect LoginServer!");
Stop();
}
};
Client.OnDisconnect = (s, e) =>
{
Debuger.Log("Can't connect LoginServer!");
Stop();
};
Client.Connect();
}
public override G2C_Login DoResponse(C2G_Login request, Client client)
{
if (!ProtoTool.CompareVersion(request.Version))
{
return(new G2C_Login {
Code = ErrorCode.VersionError
});
}
if (string.IsNullOrWhiteSpace(request.Session))
{
return new G2C_Login {
Code = ErrorCode.Error
}
}
;
var req = Appliaction.Current.Client.CreateRequest <G2L_CheckUserSession, L2G_CheckUserSession>();
req.RequestMessage.Session = request.Session;
req.RequestMessage.UserID = request.UserID;
ErrorCode resultCode = ErrorCode.Error;
req.OnCompleted = (s, res) =>
{
if (s && res.Code == ErrorCode.OK)
{
//kick other
var clients = Appliaction.Current.ListenServer.CurrentConnectionManager.AllConnections;
foreach (var i in clients)
{
if (i.UserState != null && (long)i.UserState == request.UserID)
{
i.Close();
}
}
resultCode = ErrorCode.OK;
client.HaveAdmission = true;
client.UserState = request.UserID;
}
};
req.SendRequest();
if (client.HaveAdmission)
{
Managers.UserData data;
var manager = MonitorPool.S.Get <UserDataManager>();
if (!manager.TryToGetUserData(request.UserID, out data))
{
return(new G2C_Login {
Code = ErrorCode.NoGamePlayerData
});
}
return(new G2C_Login
{
Code = ErrorCode.OK,
Package = data.GetPackage(),
Hero = data.GetHero(),
Coin = data.Coin,
Gold = data.Gold
});
}
else
{
return(new G2C_Login {
Code = resultCode
});
}
}
}
public override L2C_Reg DoResponse(C2L_Reg request, Client client)
{
if (!ProtoTool.CompareVersion(request.Version))
{
return(new L2C_Reg {
Code = ErrorCode.VersionError
});
}
if (string.IsNullOrWhiteSpace(request.UserName) || string.IsNullOrWhiteSpace(request.Password))
{
return(new L2C_Reg {
Code = ErrorCode.RegInputEmptyOrNull
});
}
using (var db = Appliaction.Current.GetDBContext())
{
var query = db.TbaCCount.Where(t => t.UserName == request.UserName).Count();
if (query > 0)
{
return(new L2C_Reg
{
Code = ErrorCode.RegExistUserName
});
}
else
{
var free = ServerManager.S.GetFreeGateServer();
if (free == null)
{
return(new L2C_Reg()
{
Code = ErrorCode.NoFreeGateServer
});
}
var serverID = free.ServerInfo.ServerID;
var pwd = DBTools.GetPwd(request.Password, db);
var acc = new DataBaseContext.TbaCCount
{
UserName = request.UserName,
Password = pwd,
CreateDateTime = DateTime.UtcNow,
LoginCount = 0,
LastLoginDateTime = DateTime.UtcNow,
ServerID = serverID
};
db.TbaCCount.InsertOnSubmit(acc);
db.SubmitChanges();
//var userID = Convert.ToInt64( db.InsertWithIdentity(acc));
var session = DateTime.UtcNow.Ticks.ToString();
Appliaction.Current.SetSession(acc.ID, session);
var mapping = ServerManager.Singleton.GetGateServerMappingByServerID(acc.ServerID);
if (mapping == null)
{
return(new L2C_Reg {
Code = ErrorCode.NOFoundServerID
});
}
return(new L2C_Reg
{
Code = ErrorCode.OK,
Session = session,
UserID = acc.ID,
Server = mapping.ServerInfo
});
}
}
}
public void Send <T>(T proto)
{
byte[] data = ProtoTool.ToData(proto);
Send(NetType.Main, data);
}
public override L2C_Login DoResponse(C2L_Login request, Client client)
{
if (!ProtoTool.CompareVersion(request.Version))
{
return(new L2C_Login {
Code = ErrorCode.VersionError
});
}
using (var db = Appliaction.Current.GetDBContext())
{
var pwd = DBTools.GetPwd(request.Password, db);
var query = db.TbaCCount
.Where(t => t.UserName == request.UserName && t.Password == pwd)
.SingleOrDefault();
if (query == null)
{
return(new L2C_Login {
Code = ErrorCode.LoginFailure
});
}
else
{
var session = DateTime.UtcNow.Ticks.ToString();
Appliaction.Current.SetSession(query.ID, session);
query.LastLoginDateTime = DateTime.UtcNow;
query.LoginCount += 1;
db.SubmitChanges();
var mapp = ServerManager.Singleton.GetGateServerMappingByServerID(query.ServerID);
if (mapp == null)
{
return(new L2C_Login {
Code = ErrorCode.NOFoundServerID
});
}
UserServerInfo info;
if (BattleManager.Singleton.GetBattleServerByUserID(query.ID, out info))
{
var task = new Task_L2B_ExitUser {
UserID = query.ID
};
var server = ServerManager.Singleton.GetBattleServerMappingByServerID(info.BattleServerID);
if (server != null)
{
var connection = Appliaction.Current.GetServerConnectByClientID(server.ClientID);
if (connection != null)
{
var message = NetProtoTool.ToNetMessage(MessageClass.Task, task);
connection.SendMessage(message);
}
}
}
return(new L2C_Login
{
Code = ErrorCode.OK,
Server = mapp.ServerInfo,
Session = session,
UserID = query.ID
});
}
}
}
private void OnLine()
{
FamousActors.MongodbPlayerStatusActor.Tell(new InitStatus(_accountId));
// ICancelable scheduleTellRepeatedlyCancelable = Context.System.Scheduler.ScheduleTellRepeatedlyCancelable(
// TimeSpan.FromMinutes(10),
// TimeSpan.FromMinutes(10),
// Self, SavePlayerDB.Instance
// , ActorRefs.Nobody);
void ReallyLoginOk()
{
_temp.bankBaseResponse = Tools.GenBankBaseResponseByPlayBank(_myWallet);
_temp.charactersGetResponse = Tools.GenCharactersGetResponseByPlayerCharacters(_myCharacters);
var aMsg = new AMsg
{
type = AMsg.Type.ResponseMsg,
responseMsg = { head = ResponseMsg.Head.LoginResponse, loginResponse = _temp }
};
_tcpActorRef.Tell(GenTcpWrite(aMsg));
}
Receive <PlayerStatus>(status =>
{
_myWallet = status.PlayerBank;
_myGames = status.PlayerGames;
_myCharacters = status.PlayerCharacters;
ReallyLoginOk();
});
Receive <ErrorResponse>(response =>
_tcpActorRef.Tell(GenTcpWrite(
new AMsg
{
type = AMsg.Type.ResponseMsg,
responseMsg = { head = ResponseMsg.Head.ErrorResponse, errorResponse = response }
}
))
);
Receive <Tcp.ConnectionClosed>(closed =>
{
OffLineSave(OutReason.Drop);
_log.Info($"Stopped, remote connection [{_remote}] closed");
Context.Stop(Self);
});
Receive <Terminated>(terminated =>
{
OffLineSave(OutReason.Drop);
_log.Info($"Stopped, remote connection [{_remote}] died");
Context.Stop(Self);
});
Receive <LogoutResponse>(response =>
{
_tcpActorRef.Tell(GenTcpWrite(new AMsg
{
type = AMsg.Type.ResponseMsg,
responseMsg = { head = ResponseMsg.Head.LogoutResponse, logoutResponse = response }
}));
});
Receive <Tcp.Received>(received =>
{
var aMsg = ProtoTool.DeSerialize <AMsg>(received.Data.ToArray());
var aMsgType = aMsg.type;
if (aMsgType == AMsg.Type.RequestMsg && _gameState == GameState.Online && _accountId != null)
{
var aMsgRequestMsg = aMsg.requestMsg;
switch (aMsgRequestMsg.head)
{
case RequestMsg.Head.BankBaseRequest:
var genBankBaseResponseByPlayBank = Tools.GenBankBaseResponseByPlayBank(_myWallet);
Sender.Tell(GenTcpWrite(new AMsg()
{
type = AMsg.Type.ResponseMsg,
responseMsg = new ResponseMsg()
{
head = ResponseMsg.Head.BankBaseResponse,
bankBaseResponse = genBankBaseResponseByPlayBank
}
}));
break;
case RequestMsg.Head.BankItemAllRequest:
var genBankItemAllResponseByPlayBank = Tools.GenBankItemResponseByPlayBank(_myWallet);
Sender.Tell(GenTcpWrite(new AMsg()
{
type = AMsg.Type.ResponseMsg,
responseMsg = new ResponseMsg()
{
head = ResponseMsg.Head.BankItemResponse,
bankItemResponse = genBankItemAllResponseByPlayBank
}
}));
break;
case RequestMsg.Head.BankItemCustomRequest:
var genBankItemResponseByPlayBank =
Tools.GenBankItemResponseByPlayBank(_myWallet,
aMsgRequestMsg.bankCustomItemRequest.itemIds);
Sender.Tell(GenTcpWrite(new AMsg()
{
type = AMsg.Type.ResponseMsg,
responseMsg = new ResponseMsg()
{
head = ResponseMsg.Head.BankItemResponse,
bankItemResponse = genBankItemResponseByPlayBank
}
}));
break;
case RequestMsg.Head.LogoutRequest:
OffLineSave(OutReason.LogOut);
_gameState = GameState.OffLine;
Become(OffLine);
break;
default:
_tcpActorRef.Tell(Tcp.Close.Instance);
throw new ArgumentOutOfRangeException();
}
}
else
{
_tcpActorRef.Tell(Tcp.Close.Instance);
throw new ArgumentOutOfRangeException();
}
});
}
private static Tcp.Write GenTcpWrite(AMsg aMsg)
{
return(Tcp.Write.Create(ByteString.FromBytes(ProtoTool.Serialize(aMsg))));
}
private void OffLine()
{
Receive <Tcp.Received>(received =>
{
if (!Sender.Equals(_tcpActorRef))
{
_log.Error($"link error close link!");
Sender.Tell(Tcp.Close.Instance);
return;
}
var aMsg = ProtoTool.DeSerialize <AMsg>(received.Data.ToArray());
var aMsgType = aMsg.type;
if (aMsgType == AMsg.Type.RequestMsg)
{
var aMsgRequestMsg = aMsg.requestMsg;
switch (aMsgRequestMsg.head)
{
case RequestMsg.Head.LoginRequest:
var aMsgLoginRequest = aMsgRequestMsg.loginRequest;
var accountId = aMsgLoginRequest.accountId;
var password = aMsgLoginRequest.Password;
if (!Tools.CheckAccountIdOk(accountId))
{
var loginResponse = new LoginResponse()
{
reason = LoginResponse.Reason.NoGoodAccount, Nickname = ""
};
var msg = new AMsg()
{
type = AMsg.Type.ResponseMsg,
responseMsg = new ResponseMsg()
{
head = ResponseMsg.Head.LoginResponse, loginResponse = loginResponse
}
};
Sender.Tell(GenTcpWrite(msg));
}
else if (!Tools.CheckPasswordOk(password))
{
var loginResponse = new LoginResponse()
{
reason = LoginResponse.Reason.NoGoodPassword, Nickname = ""
};
var msg = new AMsg()
{
type = AMsg.Type.ResponseMsg,
responseMsg = new ResponseMsg()
{
head = ResponseMsg.Head.LoginResponse, loginResponse = loginResponse
}
};
Sender.Tell(GenTcpWrite(msg));
}
else
{
_accountId = accountId;
FamousActors.MongodbAccountActor.Tell(aMsgLoginRequest);
}
Become(LoginDoing);
break;
case RequestMsg.Head.FixAccountPasswordRequest:
var aMsgFixAccountPasswordRequest = aMsgRequestMsg.fixAccountPasswordRequest;
if (!Tools.CheckAccountIdOk(aMsgFixAccountPasswordRequest.accountId))
{
var loginResponse = new FixAccountPasswordResponse
{
reason = FixAccountPasswordResponse.Reason.NoGoodAccountId
};
var msg = new AMsg()
{
type = AMsg.Type.ResponseMsg,
responseMsg = new ResponseMsg()
{
head = ResponseMsg.Head.FixAccountPasswordResponse,
fixAccountPasswordResponse = loginResponse
}
};
Sender.Tell(GenTcpWrite(msg));
}
else if (!Tools.CheckPasswordOk(aMsgFixAccountPasswordRequest.newPassword) ||
!Tools.CheckPasswordOk(aMsgFixAccountPasswordRequest.oldPassword))
{
var loginResponse = new FixAccountPasswordResponse
{
reason = FixAccountPasswordResponse.Reason.NoGoodPassword
};
var msg = new AMsg()
{
type = AMsg.Type.ResponseMsg,
responseMsg = new ResponseMsg()
{
head = ResponseMsg.Head.FixAccountPasswordResponse,
fixAccountPasswordResponse = loginResponse
}
};
Sender.Tell(GenTcpWrite(msg));
}
else
{
FamousActors.MongodbAccountActor.Tell(aMsgFixAccountPasswordRequest);
}
break;
default:
_tcpActorRef.Tell(Tcp.Close.Instance);
throw new ArgumentOutOfRangeException();
}
}
});
Receive <FixAccountPasswordResponse>(response =>
{
var genTcpWrite = GenTcpWrite(new AMsg()
{
type = AMsg.Type.ResponseMsg, responseMsg =
new ResponseMsg
{
head = ResponseMsg.Head.FixAccountPasswordResponse,
fixAccountPasswordResponse = response
}
}
);
_tcpActorRef.Tell(genTcpWrite);
});
NormalAccident();
}
