public async Task <RegisterClientReq.Callback> RegisterClientAsync(global::System.UInt64 hostId, global::System.String hostName, global::System.Action <global::Fenix.Common.DefaultErrCode, global::Fenix.HostInfo> callback = null)
#endif
{
#if FENIX_CODEGEN
#if !RUNTIME
var t = new TaskCompletionSource <dynamic>();
#else
var t = new TaskCompletionSource <RegisterClientReq.Callback>();
#endif
#else
var t = new TaskCompletionSource <RegisterClientReq.Callback>();
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
global::System.Action <global::Fenix.Common.DefaultErrCode, global::Fenix.HostInfo> _cb = (code, arg1) =>
{
var cbMsg = new RegisterClientReq.Callback();
cbMsg.code = code;
cbMsg.arg1 = arg1;
callback?.Invoke(cbMsg.code, cbMsg.arg1);
t.TrySetResult(cbMsg);
};
var protoCode = OpCode.REGISTER_CLIENT_REQ;
if (Math.Abs(protoCode) < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetRemotePeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { hostId, hostName, _cb, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { hostId, hostName, _cb });
}
}
else
{
Action <RegisterClientReq.Callback> _cb = (cbMsg) =>
{
callback?.Invoke(cbMsg.code, cbMsg.arg1);
t.TrySetResult(cbMsg);
};
await Task.Run(() => {
var msg = new RegisterClientReq()
{
hostId = hostId,
hostName = hostName
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null ? new RegisterClientReq.Callback() : global::Fenix.Common.Utils.RpcUtil.Deserialize <RegisterClientReq.Callback>(cbData);
_cb?.Invoke(cbMsg);
});
this.CallRemoteMethod(OpCode.REGISTER_CLIENT_REQ, msg, cb);
});
}
#endif
return(await t.Task);
}
public async Task <__ServerGModule__MatchService__FindMatchReq.Callback> rpc_find_match_async(global::System.String uid, global::System.Action <global::Shared.Protocol.ErrCode, global::Server.DataModel.Account> callback = null)
#endif
{
#if FENIX_CODEGEN
#if !RUNTIME
var t = new TaskCompletionSource <dynamic>();
#else
var t = new TaskCompletionSource <__ServerGModule__MatchService__FindMatchReq.Callback>();
#endif
#else
var t = new TaskCompletionSource <__ServerGModule__MatchService__FindMatchReq.Callback>();
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
global::System.Action <global::Shared.Protocol.ErrCode, global::Server.DataModel.Account> _cb = (code, user) =>
{
var cbMsg = new __ServerGModule__MatchService__FindMatchReq.Callback();
cbMsg.code = code;
cbMsg.user = user;
callback?.Invoke(cbMsg.code, cbMsg.user);
t.TrySetResult(cbMsg);
};
var protoCode = ProtocolCode.__SERVERGMODULE__MATCHSERVICE__FIND_MATCH_REQ;
if (Math.Abs(protoCode) < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetRemotePeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { uid, _cb, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { uid, _cb });
}
}
else
{
Action <__ServerGModule__MatchService__FindMatchReq.Callback> _cb = (cbMsg) =>
{
callback?.Invoke(cbMsg.code, cbMsg.user);
t.TrySetResult(cbMsg);
};
await Task.Run(() => {
var msg = new __ServerGModule__MatchService__FindMatchReq()
{
uid = uid
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null ? new __ServerGModule__MatchService__FindMatchReq.Callback() : global::Fenix.Common.Utils.RpcUtil.Deserialize <__ServerGModule__MatchService__FindMatchReq.Callback>(cbData);
_cb?.Invoke(cbMsg);
});
this.CallRemoteMethod(ProtocolCode.__SERVERGMODULE__MATCHSERVICE__FIND_MATCH_REQ, msg, cb);
});
}
#endif
return(await t.Task);
}
public async Task <__Client__Avatar__ApiTestNtf.Callback> client_api_test_async(global::System.String uid, global::System.Action <Shared.Protocol.ErrCode> callback = null)
#endif
{
#if FENIX_CODEGEN
#if !RUNTIME
var t = new TaskCompletionSource <dynamic>();
#else
var t = new TaskCompletionSource <__Client__Avatar__ApiTestNtf.Callback>();
#endif
#else
var t = new TaskCompletionSource <__Client__Avatar__ApiTestNtf.Callback>();
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
global::System.Action <Shared.Protocol.ErrCode> _cb = (code) =>
{
var cbMsg = new __Client__Avatar__ApiTestNtf.Callback();
cbMsg.code = code;
callback?.Invoke(cbMsg.code);
t.TrySetResult(cbMsg);
};
var protoCode = ProtocolCode.__CLIENT__AVATAR__API_TEST_NTF;
if (Math.Abs(protoCode) < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetRemotePeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { uid, _cb, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { uid, _cb });
}
}
else
{
Action <__Client__Avatar__ApiTestNtf.Callback> _cb = (cbMsg) =>
{
callback?.Invoke(cbMsg.code);
t.TrySetResult(cbMsg);
};
await Task.Run(() => {
var msg = new __Client__Avatar__ApiTestNtf()
{
uid = uid
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null ? new __Client__Avatar__ApiTestNtf.Callback() : global::Fenix.Common.Utils.RpcUtil.Deserialize <__Client__Avatar__ApiTestNtf.Callback>(cbData);
_cb?.Invoke(cbMsg);
});
this.CallRemoteMethod(ProtocolCode.__CLIENT__AVATAR__API_TEST_NTF, msg, cb);
});
}
#endif
return(await t.Task);
}
public async Task <__ServerUModule__Avatar__M__ServerUModule__ItemModule__TestItemApiReq.Callback> rpc_test_item_api_async(global::System.Action callback = null)
#endif
{
#if FENIX_CODEGEN
#if !RUNTIME
var t = new TaskCompletionSource <dynamic>();
#else
var t = new TaskCompletionSource <__ServerUModule__Avatar__M__ServerUModule__ItemModule__TestItemApiReq.Callback>();
#endif
#else
var t = new TaskCompletionSource <__ServerUModule__Avatar__M__ServerUModule__ItemModule__TestItemApiReq.Callback>();
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
global::System.Action _cb = () =>
{
var cbMsg = new __ServerUModule__Avatar__M__ServerUModule__ItemModule__TestItemApiReq.Callback();
callback?.Invoke();
t.TrySetResult(cbMsg);
};
var protoCode = ProtocolCode.__SERVERUMODULE__AVATAR__M__SERVERUMODULE__ITEMMODULE__TEST_ITEM_API_REQ;
if (Math.Abs(protoCode) < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetRemotePeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { _cb, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { _cb });
}
}
else
{
Action <__ServerUModule__Avatar__M__ServerUModule__ItemModule__TestItemApiReq.Callback> _cb = (cbMsg) =>
{
callback?.Invoke();
t.TrySetResult(cbMsg);
};
await Task.Run(() => {
var msg = new __ServerUModule__Avatar__M__ServerUModule__ItemModule__TestItemApiReq()
{
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null ? new __ServerUModule__Avatar__M__ServerUModule__ItemModule__TestItemApiReq.Callback() : global::Fenix.Common.Utils.RpcUtil.Deserialize <__ServerUModule__Avatar__M__ServerUModule__ItemModule__TestItemApiReq.Callback>(cbData);
_cb?.Invoke(cbMsg);
});
this.CallRemoteMethod(ProtocolCode.__SERVERUMODULE__AVATAR__M__SERVERUMODULE__ITEMMODULE__TEST_ITEM_API_REQ, msg, cb);
});
}
#endif
return(await t.Task);
}
public async Task <ReconnectServerActorNtf.Callback> ReconnectServerActorAsync(global::System.UInt64 hostId, global::System.String hostName, global::System.String hostIP, global::System.Int32 hostPort, global::System.UInt64 actorId, global::System.String actorName, global::System.String aTypeName, global::System.Action <global::Fenix.Common.DefaultErrCode> callback = null)
{
var t = new TaskCompletionSource <ReconnectServerActorNtf.Callback>();
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
global::System.Action <global::Fenix.Common.DefaultErrCode> _cb = (code) =>
{
var cbMsg = new ReconnectServerActorNtf.Callback();
cbMsg.code = code;
callback?.Invoke(cbMsg.code);
t.TrySetResult(cbMsg);
};
var protoCode = OpCode.RECONNECT_SERVER_ACTOR_NTF;
if (protoCode < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetPeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { hostId, hostName, hostIP, hostPort, actorId, actorName, aTypeName, _cb, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { hostId, hostName, hostIP, hostPort, actorId, actorName, aTypeName, _cb });
}
}
else
{
Action <ReconnectServerActorNtf.Callback> _cb = (cbMsg) =>
{
callback?.Invoke(cbMsg.code);
t.TrySetResult(cbMsg);
};
await Task.Run(() => {
var msg = new ReconnectServerActorNtf()
{
hostId = hostId,
hostName = hostName,
hostIP = hostIP,
hostPort = hostPort,
actorId = actorId,
actorName = actorName,
aTypeName = aTypeName
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null ? new ReconnectServerActorNtf.Callback() : RpcUtil.Deserialize <ReconnectServerActorNtf.Callback>(cbData);
_cb?.Invoke(cbMsg);
});
this.CallRemoteMethod(OpCode.RECONNECT_SERVER_ACTOR_NTF, msg, cb);
});
}
return(await t.Task);
}
public async Task <__ServerGModule__LoginService__LoginReq.Callback> rpc_login_async(global::System.String username, global::System.String password, global::System.Action <global::Shared.Protocol.ErrCode, global::System.String, global::System.UInt64, global::System.String, global::System.String> callback = null)
{
var t = new TaskCompletionSource <__ServerGModule__LoginService__LoginReq.Callback>();
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
global::System.Action <global::Shared.Protocol.ErrCode, global::System.String, global::System.UInt64, global::System.String, global::System.String> _cb = (code, arg1, arg2, arg3, arg4) =>
{
var cbMsg = new __ServerGModule__LoginService__LoginReq.Callback();
cbMsg.code = code;
cbMsg.arg1 = arg1;
cbMsg.arg2 = arg2;
cbMsg.arg3 = arg3;
cbMsg.arg4 = arg4;
callback?.Invoke(cbMsg.code, cbMsg.arg1, cbMsg.arg2, cbMsg.arg3, cbMsg.arg4);
t.TrySetResult(cbMsg);
};
var protoCode = ProtocolCode.__SERVERGMODULE__LOGINSERVICE__LOGIN_REQ;
if (protoCode < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetPeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { username, password, _cb, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { username, password, _cb });
}
}
else
{
Action <__ServerGModule__LoginService__LoginReq.Callback> _cb = (cbMsg) =>
{
callback?.Invoke(cbMsg.code, cbMsg.arg1, cbMsg.arg2, cbMsg.arg3, cbMsg.arg4);
t.TrySetResult(cbMsg);
};
await Task.Run(() => {
var msg = new __ServerGModule__LoginService__LoginReq()
{
username = username,
password = password
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null ? new __ServerGModule__LoginService__LoginReq.Callback() : global::Fenix.Common.Utils.RpcUtil.Deserialize <__ServerGModule__LoginService__LoginReq.Callback>(cbData);
_cb?.Invoke(cbMsg);
});
this.CallRemoteMethod(ProtocolCode.__SERVERGMODULE__LOGINSERVICE__LOGIN_REQ, msg, cb);
});
}
return(await t.Task);
}
public async Task <CreateActorReq.Callback> CreateActorAsync(global::System.String typename, global::System.String name, global::System.Action <global::Fenix.Common.DefaultErrCode, global::System.String, global::System.UInt64> callback = null)
{
var t = new TaskCompletionSource <CreateActorReq.Callback>();
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
global::System.Action <global::Fenix.Common.DefaultErrCode, global::System.String, global::System.UInt64> _cb = (code, arg1, arg2) =>
{
var cbMsg = new CreateActorReq.Callback();
cbMsg.code = code;
cbMsg.arg1 = arg1;
cbMsg.arg2 = arg2;
callback?.Invoke(cbMsg.code, cbMsg.arg1, cbMsg.arg2);
t.TrySetResult(cbMsg);
};
var protoCode = OpCode.CREATE_ACTOR_REQ;
if (protoCode < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetPeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { typename, name, _cb, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { typename, name, _cb });
}
}
else
{
Action <CreateActorReq.Callback> _cb = (cbMsg) =>
{
callback?.Invoke(cbMsg.code, cbMsg.arg1, cbMsg.arg2);
t.TrySetResult(cbMsg);
};
await Task.Run(() => {
var msg = new CreateActorReq()
{
typename = typename,
name = name
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null ? new CreateActorReq.Callback() : RpcUtil.Deserialize <CreateActorReq.Callback>(cbData);
_cb?.Invoke(cbMsg);
});
this.CallRemoteMethod(OpCode.CREATE_ACTOR_REQ, msg, cb);
});
}
return(await t.Task);
}
public async Task <CreateAccountReq.Callback> rpc_create_account_async(global::System.String username, global::System.String password, global::System.Action <global::Shared.Protocol.ErrCode> callback = null)
{
var t = new TaskCompletionSource <CreateAccountReq.Callback>();
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
global::System.Action <global::Shared.Protocol.ErrCode> _cb = (code) =>
{
var cbMsg = new CreateAccountReq.Callback();
cbMsg.code = code;
callback?.Invoke(cbMsg.code);
t.TrySetResult(cbMsg);
};
var protoCode = ProtocolCode.CREATE_ACCOUNT_REQ;
if (protoCode < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetPeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { username, password, _cb, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { username, password, _cb });
}
}
else
{
Action <CreateAccountReq.Callback> _cb = (cbMsg) =>
{
callback?.Invoke(cbMsg.code);
t.TrySetResult(cbMsg);
};
await Task.Run(() => {
var msg = new CreateAccountReq()
{
username = username,
password = password
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null ? new CreateAccountReq.Callback() : RpcUtil.Deserialize <CreateAccountReq.Callback>(cbData);
_cb?.Invoke(cbMsg);
});
this.CallRemoteMethod(ProtocolCode.CREATE_ACCOUNT_REQ, msg, cb);
});
}
return(await t.Task);
}
public async Task <__ServerGModule__MatchService__JoinMatchReq.Callback> rpc_join_match_async(global::System.String uid, global::System.Int32 match_type, global::System.Action <global::Shared.Protocol.ErrCode> callback = null)
{
var t = new TaskCompletionSource <__ServerGModule__MatchService__JoinMatchReq.Callback>();
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
global::System.Action <global::Shared.Protocol.ErrCode> _cb = (code) =>
{
var cbMsg = new __ServerGModule__MatchService__JoinMatchReq.Callback();
cbMsg.code = code;
callback?.Invoke(cbMsg.code);
t.TrySetResult(cbMsg);
};
var protoCode = ProtocolCode.__SERVERGMODULE__MATCHSERVICE__JOIN_MATCH_REQ;
if (protoCode < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetPeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { uid, match_type, _cb, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { uid, match_type, _cb });
}
}
else
{
Action <__ServerGModule__MatchService__JoinMatchReq.Callback> _cb = (cbMsg) =>
{
callback?.Invoke(cbMsg.code);
t.TrySetResult(cbMsg);
};
await Task.Run(() => {
var msg = new __ServerGModule__MatchService__JoinMatchReq()
{
uid = uid,
match_type = match_type
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null ? new __ServerGModule__MatchService__JoinMatchReq.Callback() : global::Fenix.Common.Utils.RpcUtil.Deserialize <__ServerGModule__MatchService__JoinMatchReq.Callback>(cbData);
_cb?.Invoke(cbMsg);
});
this.CallRemoteMethod(ProtocolCode.__SERVERGMODULE__MATCHSERVICE__JOIN_MATCH_REQ, msg, cb);
});
}
return(await t.Task);
}
public async Task <RemoveClientActorReq.Callback> RemoveClientActorAsync(global::System.UInt64 actorId, global::Fenix.Common.DisconnectReason reason, global::System.Action <global::Fenix.Common.DefaultErrCode> callback = null)
{
var t = new TaskCompletionSource <RemoveClientActorReq.Callback>();
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
global::System.Action <global::Fenix.Common.DefaultErrCode> _cb = (code) =>
{
var cbMsg = new RemoveClientActorReq.Callback();
cbMsg.code = code;
callback?.Invoke(cbMsg.code);
t.TrySetResult(cbMsg);
};
var protoCode = OpCode.REMOVE_CLIENT_ACTOR_REQ;
if (protoCode < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetPeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { actorId, reason, _cb, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { actorId, reason, _cb });
}
}
else
{
Action <RemoveClientActorReq.Callback> _cb = (cbMsg) =>
{
callback?.Invoke(cbMsg.code);
t.TrySetResult(cbMsg);
};
await Task.Run(() => {
var msg = new RemoveClientActorReq()
{
actorId = actorId,
reason = reason
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null ? new RemoveClientActorReq.Callback() : RpcUtil.Deserialize <RemoveClientActorReq.Callback>(cbData);
_cb?.Invoke(cbMsg);
});
this.CallRemoteMethod(OpCode.REMOVE_CLIENT_ACTOR_REQ, msg, cb);
});
}
return(await t.Task);
}
public void rpc_find_match(global::System.String uid, global::System.Action <global::Shared.Protocol.ErrCode, global::Server.DataModel.Account> callback)
{
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
var protoCode = ProtocolCode.FIND_MATCH_REQ;
if (protoCode < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetPeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { uid, callback, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { uid, callback });
}
return;
}
Task.Run(() => {
var msg = new FindMatchReq()
{
uid = uid
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null?new FindMatchReq.Callback():RpcUtil.Deserialize <FindMatchReq.Callback>(cbData);
callback?.Invoke(cbMsg.code, cbMsg.user);
});
this.CallRemoteMethod(ProtocolCode.FIND_MATCH_REQ, msg, cb);
});
}
public void rpc_login(global::System.String username, global::System.String password, global::System.Action <global::Shared.Protocol.ErrCode, global::System.String, global::System.UInt64, global::System.String, global::System.String> callback)
{
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
var protoCode = ProtocolCode.LOGIN_REQ;
if (protoCode < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetPeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { username, password, callback, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { username, password, callback });
}
return;
}
Task.Run(() => {
var msg = new LoginReq()
{
username = username,
password = password
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null?new LoginReq.Callback():RpcUtil.Deserialize <LoginReq.Callback>(cbData);
callback?.Invoke(cbMsg.code, cbMsg.arg1, cbMsg.arg2, cbMsg.arg3, cbMsg.arg4);
});
this.CallRemoteMethod(ProtocolCode.LOGIN_REQ, msg, cb);
});
}
public void rpc_login(global::System.String username, global::System.String password, global::System.String extraData, global::System.Action <global::Shared.Protocol.ErrCode, global::System.String, global::System.UInt64, global::System.String, global::System.String> callback)
#endif
{
#if !FENIX_CODEGEN
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
var protoCode = ProtocolCode.__SERVERGMODULE__LOGINSERVICE__LOGIN_REQ;
if (Math.Abs(protoCode) < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetRemotePeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { username, password, extraData, callback, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { username, password, extraData, callback });
}
return;
}
Task.Run(() => {
var msg = new __ServerGModule__LoginService__LoginReq()
{
username = username,
password = password,
extraData = extraData
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null?new __ServerGModule__LoginService__LoginReq.Callback():global::Fenix.Common.Utils.RpcUtil.Deserialize <__ServerGModule__LoginService__LoginReq.Callback>(cbData);
callback?.Invoke(cbMsg.code, cbMsg.arg1, cbMsg.arg2, cbMsg.arg3, cbMsg.arg4);
});
this.CallRemoteMethod(ProtocolCode.__SERVERGMODULE__LOGINSERVICE__LOGIN_REQ, msg, cb);
});
#endif
}
public void rpc_change_name(global::System.String name, global::System.Action <global::Shared.Protocol.ErrCode> callback)
#endif
{
#if !FENIX_CODEGEN
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
var protoCode = ProtocolCode.__SERVERUMODULE__AVATAR__CHANGE_NAME_REQ;
if (Math.Abs(protoCode) < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetRemotePeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { name, callback, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { name, callback });
}
return;
}
Task.Run(() => {
var msg = new __ServerUModule__Avatar__ChangeNameReq()
{
name = name
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null?new __ServerUModule__Avatar__ChangeNameReq.Callback():global::Fenix.Common.Utils.RpcUtil.Deserialize <__ServerUModule__Avatar__ChangeNameReq.Callback>(cbData);
callback?.Invoke(cbMsg.code);
});
this.CallRemoteMethod(ProtocolCode.__SERVERUMODULE__AVATAR__CHANGE_NAME_REQ, msg, cb);
});
#endif
}
public void rpc_test_item_api(global::System.Action callback)
#endif
{
#if !FENIX_CODEGEN
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
var protoCode = ProtocolCode.__SERVERUMODULE__AVATAR__M__SERVERUMODULE__ITEMMODULE__TEST_ITEM_API_REQ;
if (Math.Abs(protoCode) < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetRemotePeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { callback, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { callback });
}
return;
}
Task.Run(() => {
var msg = new __ServerUModule__Avatar__M__ServerUModule__ItemModule__TestItemApiReq()
{
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null?new __ServerUModule__Avatar__M__ServerUModule__ItemModule__TestItemApiReq.Callback():global::Fenix.Common.Utils.RpcUtil.Deserialize <__ServerUModule__Avatar__M__ServerUModule__ItemModule__TestItemApiReq.Callback>(cbData);
callback?.Invoke();
});
this.CallRemoteMethod(ProtocolCode.__SERVERUMODULE__AVATAR__M__SERVERUMODULE__ITEMMODULE__TEST_ITEM_API_REQ, msg, cb);
});
#endif
}
public void rpc_change_name(global::System.String name, global::System.Action <global::Shared.Protocol.ErrCode> callback)
{
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
var protoCode = ProtocolCode.CHANGE_NAME_REQ;
if (protoCode < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetPeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { name, callback, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { name, callback });
}
return;
}
Task.Run(() => {
var msg = new ChangeNameReq()
{
name = name
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null?new ChangeNameReq.Callback():RpcUtil.Deserialize <ChangeNameReq.Callback>(cbData);
callback?.Invoke(cbMsg.code);
});
this.CallRemoteMethod(ProtocolCode.CHANGE_NAME_REQ, msg, cb);
});
}
public void client_on_api_test(global::System.String uid, global::System.Action <global::Shared.Protocol.ErrCode> callback)
{
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
var protoCode = ProtocolCode.API_TEST_NTF;
if (protoCode < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetPeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { uid, callback, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { uid, callback });
}
return;
}
Task.Run(() => {
var msg = new ApiTestNtf()
{
uid = uid
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null?new ApiTestNtf.Callback():RpcUtil.Deserialize <ApiTestNtf.Callback>(cbData);
callback?.Invoke(cbMsg.code);
});
this.CallRemoteMethod(ProtocolCode.API_TEST_NTF, msg, cb);
});
}
public void RegisterClient(global::System.UInt64 hostId, global::System.String hostName, global::System.Action <global::Fenix.Common.DefaultErrCode, global::Fenix.HostInfo> callback)
{
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
var protoCode = OpCode.REGISTER_CLIENT_REQ;
if (protoCode < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetPeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { hostId, hostName, callback, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { hostId, hostName, callback });
}
return;
}
Task.Run(() => {
var msg = new __Fenix__Host__RegisterClientReq()
{
hostId = hostId,
hostName = hostName
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null?new __Fenix__Host__RegisterClientReq.Callback():global::Fenix.Common.Utils.RpcUtil.Deserialize <__Fenix__Host__RegisterClientReq.Callback>(cbData);
callback?.Invoke(cbMsg.code, cbMsg.arg1);
});
this.CallRemoteMethod(OpCode.REGISTER_CLIENT_REQ, msg, cb);
});
}
public void client_api_test(global::System.String uid, global::System.Action <Shared.Protocol.ErrCode> callback)
#endif
{
#if !FENIX_CODEGEN
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
var protoCode = ProtocolCode.__CLIENT__AVATAR__API_TEST_NTF;
if (Math.Abs(protoCode) < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetRemotePeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { uid, callback, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { uid, callback });
}
return;
}
Task.Run(() => {
var msg = new __Client__Avatar__ApiTestNtf()
{
uid = uid
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null?new __Client__Avatar__ApiTestNtf.Callback():global::Fenix.Common.Utils.RpcUtil.Deserialize <__Client__Avatar__ApiTestNtf.Callback>(cbData);
callback?.Invoke(cbMsg.code);
});
this.CallRemoteMethod(ProtocolCode.__CLIENT__AVATAR__API_TEST_NTF, msg, cb);
});
#endif
}
public void rpc_find_match(global::System.String uid, global::System.Action <global::Shared.Protocol.ErrCode, global::Server.DataModel.Account> callback)
#endif
{
#if !FENIX_CODEGEN
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
var protoCode = ProtocolCode.__SERVERGMODULE__MATCHSERVICE__FIND_MATCH_REQ;
if (Math.Abs(protoCode) < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetRemotePeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { uid, callback, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { uid, callback });
}
return;
}
Task.Run(() => {
var msg = new __ServerGModule__MatchService__FindMatchReq()
{
uid = uid
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null?new __ServerGModule__MatchService__FindMatchReq.Callback():global::Fenix.Common.Utils.RpcUtil.Deserialize <__ServerGModule__MatchService__FindMatchReq.Callback>(cbData);
callback?.Invoke(cbMsg.code, cbMsg.user);
});
this.CallRemoteMethod(ProtocolCode.__SERVERGMODULE__MATCHSERVICE__FIND_MATCH_REQ, msg, cb);
});
#endif
}
public override void SwitchToMain()
{
onSwitchBack?.Invoke();
onSwitchBack = null;
DialogueSystem = MainDialogueSystem;
}
public void OnBeforeDisconnect(global::Fenix.Common.DisconnectReason reason, global::System.Action callback)
{
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
var protoCode = OpCode.ON_BEFORE_DISCONNECT_NTF;
if (protoCode < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetPeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { reason, callback, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { reason, callback });
}
return;
}
Task.Run(() => {
var msg = new OnBeforeDisconnectNtf()
{
reason = reason
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null?new OnBeforeDisconnectNtf.Callback():RpcUtil.Deserialize <OnBeforeDisconnectNtf.Callback>(cbData);
callback?.Invoke();
});
this.CallRemoteMethod(OpCode.ON_BEFORE_DISCONNECT_NTF, msg, cb);
});
}
public void BindClientActor(global::System.String actorName, global::System.Action <global::Fenix.Common.DefaultErrCode> callback)
{
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
var protoCode = OpCode.BIND_CLIENT_ACTOR_REQ;
if (protoCode < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetPeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { actorName, callback, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { actorName, callback });
}
return;
}
Task.Run(() => {
var msg = new BindClientActorReq()
{
actorName = actorName
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null?new BindClientActorReq.Callback():RpcUtil.Deserialize <BindClientActorReq.Callback>(cbData);
callback?.Invoke(cbMsg.code);
});
this.CallRemoteMethod(OpCode.BIND_CLIENT_ACTOR_REQ, msg, cb);
});
}
public void rpc_create_account(global::System.String username, global::System.String password, global::System.Action <global::Shared.Protocol.ErrCode> callback)
{
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
var protoCode = ProtocolCode.__SERVERGMODULE__LOGINSERVICE__CREATE_ACCOUNT_REQ;
if (protoCode < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetPeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { username, password, callback, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { username, password, callback });
}
return;
}
Task.Run(() => {
var msg = new __ServerGModule__LoginService__CreateAccountReq()
{
username = username,
password = password
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null?new __ServerGModule__LoginService__CreateAccountReq.Callback():global::Fenix.Common.Utils.RpcUtil.Deserialize <__ServerGModule__LoginService__CreateAccountReq.Callback>(cbData);
callback?.Invoke(cbMsg.code);
});
this.CallRemoteMethod(ProtocolCode.__SERVERGMODULE__LOGINSERVICE__CREATE_ACCOUNT_REQ, msg, cb);
});
}
public void SayHello(global::System.Action <global::Fenix.Common.DefaultErrCode, global::Fenix.HostInfo> callback)
#endif
{
#if !FENIX_CODEGEN
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
var protoCode = OpCode.SAY_HELLO_REQ;
if (Math.Abs(protoCode) < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetRemotePeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { callback, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { callback });
}
return;
}
Task.Run(() => {
var msg = new SayHelloReq()
{
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null?new SayHelloReq.Callback():global::Fenix.Common.Utils.RpcUtil.Deserialize <SayHelloReq.Callback>(cbData);
callback?.Invoke(cbMsg.code, cbMsg.arg1);
});
this.CallRemoteMethod(OpCode.SAY_HELLO_REQ, msg, cb);
});
#endif
}
public async Task <OnBeforeDisconnectNtf.Callback> OnBeforeDisconnectAsync(global::Fenix.Common.DisconnectReason reason, global::System.Action callback = null)
{
var t = new TaskCompletionSource <OnBeforeDisconnectNtf.Callback>();
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
global::System.Action _cb = () =>
{
var cbMsg = new OnBeforeDisconnectNtf.Callback();
callback?.Invoke();
t.TrySetResult(cbMsg);
};
var protoCode = OpCode.ON_BEFORE_DISCONNECT_NTF;
if (protoCode < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetPeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { reason, _cb, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { reason, _cb });
}
}
else
{
Action <OnBeforeDisconnectNtf.Callback> _cb = (cbMsg) =>
{
callback?.Invoke();
t.TrySetResult(cbMsg);
};
await Task.Run(() => {
var msg = new OnBeforeDisconnectNtf()
{
reason = reason
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null ? new OnBeforeDisconnectNtf.Callback() : RpcUtil.Deserialize <OnBeforeDisconnectNtf.Callback>(cbData);
_cb?.Invoke(cbMsg);
});
this.CallRemoteMethod(OpCode.ON_BEFORE_DISCONNECT_NTF, msg, cb);
});
}
return(await t.Task);
}
public async Task <ApiTestNtf.Callback> client_on_api_test_async(global::System.String uid, global::System.Action <global::Shared.Protocol.ErrCode> callback = null)
{
var t = new TaskCompletionSource <ApiTestNtf.Callback>();
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
global::System.Action <global::Shared.Protocol.ErrCode> _cb = (code) =>
{
var cbMsg = new ApiTestNtf.Callback();
cbMsg.code = code;
callback?.Invoke(cbMsg.code);
t.TrySetResult(cbMsg);
};
var protoCode = ProtocolCode.API_TEST_NTF;
if (protoCode < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetPeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { uid, _cb, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { uid, _cb });
}
}
else
{
Action <ApiTestNtf.Callback> _cb = (cbMsg) =>
{
callback?.Invoke(cbMsg.code);
t.TrySetResult(cbMsg);
};
await Task.Run(() => {
var msg = new ApiTestNtf()
{
uid = uid
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null ? new ApiTestNtf.Callback() : RpcUtil.Deserialize <ApiTestNtf.Callback>(cbData);
_cb?.Invoke(cbMsg);
});
this.CallRemoteMethod(ProtocolCode.API_TEST_NTF, msg, cb);
});
}
return(await t.Task);
}
// Token: 0x06000329 RID: 809 RVA: 0x00011724 File Offset: 0x0000F924
private void SafelyCall(global::System.Action action)
{
try
{
action.Invoke();
}
catch (global::System.Exception obj)
{
global::VRGIN.Core.VRLog.Error(obj);
}
}
// Token: 0x0600032C RID: 812 RVA: 0x000117F0 File Offset: 0x0000F9F0
private global::System.Collections.IEnumerator _Invoke(global::System.Action action, float delay)
{
yield return(new global::UnityEngine.WaitForSeconds(delay));
try
{
action.Invoke();
yield break;
}
catch (global::System.Exception ex)
{
global::System.Exception e = ex;
global::VRGIN.Core.VRLog.Error(e);
yield break;
}
yield break;
}
public void ReconnectServerActor(global::System.UInt64 hostId, global::System.String hostName, global::System.String hostIP, global::System.Int32 hostPort, global::System.UInt64 actorId, global::System.String actorName, global::System.String aTypeName, global::System.Action <global::Fenix.Common.DefaultErrCode> callback)
{
var toHostId = Global.IdManager.GetHostIdByActorId(this.toActorId, this.isClient);
if (this.FromHostId == toHostId)
{
var protoCode = OpCode.RECONNECT_SERVER_ACTOR_NTF;
if (protoCode < OpCode.CALL_ACTOR_METHOD)
{
var peer = Global.NetManager.GetPeerById(this.FromHostId, this.NetType);
var context = new RpcContext(null, peer);
Global.Host.CallMethodWithParams(protoCode, new object[] { hostId, hostName, hostIP, hostPort, actorId, actorName, aTypeName, callback, context });
}
else
{
Global.Host.GetActor(this.toActorId).CallMethodWithParams(protoCode, new object[] { hostId, hostName, hostIP, hostPort, actorId, actorName, aTypeName, callback });
}
return;
}
Task.Run(() => {
var msg = new __Fenix__Host__ReconnectServerActorNtf()
{
hostId = hostId,
hostName = hostName,
hostIP = hostIP,
hostPort = hostPort,
actorId = actorId,
actorName = actorName,
aTypeName = aTypeName
};
var cb = new Action <byte[]>((cbData) => {
var cbMsg = cbData == null?new __Fenix__Host__ReconnectServerActorNtf.Callback():global::Fenix.Common.Utils.RpcUtil.Deserialize <__Fenix__Host__ReconnectServerActorNtf.Callback>(cbData);
callback?.Invoke(cbMsg.code);
});
this.CallRemoteMethod(OpCode.RECONNECT_SERVER_ACTOR_NTF, msg, cb);
});
}