bool CGameServer::InitLoadShare(void)
{
assert(m_pConfig == nullptr);
m_pUIHandler->OnHandle(CServerConfig::CFG_CONFIG_PTR, reinterpret_cast<uintptr_t>(&m_pConfig), DATA_INDEX_GAME);
if (m_pConfig == nullptr) {
LOG_ERROR(m_FileLog, TF("[游戏服务器]从界面回调接口获取配置对象指针无效"));
return false;
}
LOG_INFO(m_FileLog, TF("[游戏服务器]从界面回调接口获取配置对象指针完成!"));
m_pConfig->Dump(m_FileLog); // 配置信息输出到日志文件
// 从动态变量表获取网络层智能指针
assert(m_NetworkPtr == nullptr);
CKeyValue::VALUE xValue = { 0 };
m_pConfig->GetKeyValue()->GetValue(CServerConfig::NetworkPtr, xValue);
if (xValue.pValue == nullptr) {
LOG_ERROR(m_FileLog, TF("[游戏服务器]从动态变量表获取网络层智能指针无效"));
return false;
}
LOG_INFO(m_FileLog, TF("[游戏服务器]从动态变量表获取网络层智能指针完成!"));
m_NetworkPtr = *(reinterpret_cast<CNetworkPtr*>(xValue.pValue));
// 保存游戏服务器指针到动态变量表
LOGV_INFO(m_FileLog, TF("[游戏服务器]保存游戏服务器指针到动态变量表完成[key=%s]!"), CServerConfig::GameServer);
m_pConfig->GetKeyValue()->AddItem(CServerConfig::GameServer, this);
return true;
}
bool CGameServer::OnShareUpdate(CEventBase& EventRef, LLong llParam)
{
CPAKUpdate* pUpdate = static_cast<CPAKUpdate*>(&EventRef);
if (pUpdate->GetType() == PAK_TYPE_ZONE) {
if (m_pShareZoneSvr != nullptr) {
DEV_INFO(TF("[游戏服务器]同进程地图服务器[%p]更新"), m_pShareZoneSvr);
assert(m_pShareZoneSvr == reinterpret_cast<ICommonServer*>(llParam));
return ServerUpdate<SVR_ZONE_INDEX_MAP, DATA_INDEX_ZONE, INFOI_ZONE>(pUpdate, (DataRef)llParam, m_ZoneSvrMap);
}
else {
LOGV_WARN(m_FileLog, TF("[游戏服务器]同进程地图服务器对象未注册"));
}
}
else if (pUpdate->GetType() == PAK_TYPE_GATE) {
if (m_pShareGateSvr != nullptr) {
DEV_INFO(TF("[游戏服务器]同进程网关服务器[%p]更新"), m_pShareGateSvr);
assert(m_pShareGateSvr == reinterpret_cast<ICommonServer*>(llParam));
return ServerUpdate<SVR_GATE_MAP, DATA_INDEX_GATE, INFOI_GATE>(pUpdate, (DataRef)llParam, m_GateSvrMap);
}
else {
LOGV_WARN(m_FileLog, TF("[游戏服务器]同进程网关服务器对象未注册"));
}
}
return false;
}
bool CGameServer::OnServerUpdate(CPAKUpdate* pUpdate, KeyRef krSocket)
{
bool bRet = false;
switch (pUpdate->GetType()) {
case PAK_TYPE_ZONE:
{
DEV_INFO(TF("[游戏服务器]地图服务器[%p]更新"), krSocket);
bRet = ServerUpdate<SVR_ZONE_INDEX_MAP, DATA_INDEX_ZONE, INFOI_ZONE>(pUpdate, (DataRef)krSocket, m_ZoneSvrMap);
}
break;
case PAK_TYPE_GATE:
{
DEV_INFO(TF("[游戏服务器]网关服务器[%p]更新"), krSocket);
bRet = ServerUpdate<SVR_GATE_MAP, DATA_INDEX_GATE, INFOI_GATE>(pUpdate, (DataRef)krSocket, m_GateSvrMap);
}
break;
default:
{
LOGV_WARN(m_FileLog, TF("[游戏服务器]%p无法识别的%X服务器信令包数据"), krSocket, pUpdate->GetType());
}
}
if (bRet) {
// 发送更新回执包
CPAKSimple<PAK_EVENT_UPDATEACK, PAK_TYPE_GAME> UpdateAck;
UpdateAck.AdjustSize();
m_NetworkPtr->Send(krSocket, UpdateAck);
}
return bRet;
}
bool CGameServer::DispatchGameDBServer(const PacketPtr& PktPtr, KeyRef krSocket)
{
switch (PktPtr->GetEvent()) {
case PAK_EVENT_LINKACK:
{
m_bGameDBLinked = true;
NET_ADDR NetAddr;
m_NetworkPtr->GetAddr(krSocket, NetAddr, false);
m_pUIHandler->OnHandle(PAK_EVENT_LINK, reinterpret_cast<uintptr_t>(&NetAddr), DATA_INDEX_GAMEDB);
LOG_INFO(m_FileLog, TF("[游戏服务器]收到游戏DB服务器注册回复包"));
}
break;
case PAK_EVENT_UPDATEACK:
{
DEV_INFO(TF("[游戏服务器]收到游戏DB服务器更新回复包"));
}
break;
case PAK_EVENT_UNLINKACK:
{
m_bGameDBLinked = false;
LOG_INFO(m_FileLog, TF("[游戏服务器]收到游戏DB服务器注销回复包"));
}
break;
case PAK_EVENT_LIVEACK:
{
}
break;
default:
{
LOGV_WARN(m_FileLog, TF("[游戏服务器]%p无法识别的游戏DB服务器信令包数据[event=%d]"), krSocket, PktPtr->GetEvent());
}
}
return true;
}
bool CGameServer::OnServerUnlink(CPAKHead* pUnlink, KeyRef krSocket)
{
bool bRet = false;
switch (pUnlink->GetType()) {
case PAK_TYPE_ZONE:
{
LOGV_INFO(m_FileLog, TF("[游戏服务器]地图服务器[%p]注销"), krSocket);
bRet = ServerUnlink<SVR_ZONE_INDEX_MAP, DATA_INDEX_ZONE, INFOI_ZONE>(krSocket, m_ZoneSvrMap);
}
break;
case PAK_TYPE_GATE:
{
LOGV_INFO(m_FileLog, TF("[游戏服务器]网关服务器[%p]注销"), krSocket);
bRet = ServerUnlink<SVR_GATE_MAP, DATA_INDEX_GATE, INFOI_GATE>(krSocket, m_GateSvrMap);
}
break;
default:
{
LOGV_WARN(m_FileLog, TF("[游戏服务器]%p无法识别的%X服务器信令包数据"), krSocket, pUnlink->GetType());
}
}
if (bRet) {
// 3.设置为无效服务器类型
m_NetworkPtr->SetAttr(krSocket, PAK_TYPE_NONE);
// 4.发送注销回执包
CPAKSimple<PAK_EVENT_UNLINKACK, PAK_TYPE_GAME> UnlinkAck;
UnlinkAck.AdjustSize();
m_NetworkPtr->Send(krSocket, UnlinkAck);
}
return bRet;
}
bool CGameServer::OnShareLink(CEventBase& EventRef, LLong llParam)
{
CPAKLink* pLink = static_cast<CPAKLink*>(&EventRef);
if (pLink->GetType() == PAK_TYPE_ZONE) {
if (m_pShareZoneSvr == nullptr) {
// 0.获得共享指针
m_pShareZoneSvr = reinterpret_cast<ICommonServer*>(llParam);
LOGV_INFO(m_FileLog, TF("[游戏服务器]同进程地图服务器[%p]注册"), m_pShareZoneSvr);
return ServerLink<SVR_ZONE_INDEX_MAP, DATA_INDEX_ZONE, INFOI_ZONE>(pLink, (DataRef)llParam, m_ZoneSvrMap);
}
else {
LOGV_WARN(m_FileLog, TF("[游戏服务器]同进程地图服务器对象已经存在[%p-%p]"), m_pShareZoneSvr, llParam);
}
}
else if (pLink->GetType() == PAK_TYPE_GATE) {
if (m_pShareGateSvr == nullptr) {
// 0.获得共享指针
m_pShareGateSvr = reinterpret_cast<ICommonServer*>(llParam);
LOGV_INFO(m_FileLog, TF("[游戏服务器]同进程网关服务器[%p]注册"), m_pShareGateSvr);
return ServerLink<SVR_GATE_MAP, DATA_INDEX_GATE, INFOI_GATE>(pLink, (DataRef)llParam, m_GateSvrMap);
}
else {
LOGV_WARN(m_FileLog, TF("[游戏服务器]同进程网关服务器对象已经存在[%p-%p]"), m_pShareGateSvr, llParam);
}
}
return false;
}
/*
When printing a line from the pipe, it could look like this:
01:8006 f4 fb 86 iwt r4,#$86fb
The values are:
program bank: 01
adress: 8006
values at memory address 8006: f4 fb 86
instruction in the pipe: iwt r4,#$86fb
Note! If the instruction has more than one byte (like in 'iwt')
and the instruction is in a delay slot, the second and third
byte displayed will not be the same as those used.
Since the instrction is in a delay slot, the first byte
of the instruction will be taken from the pipe at the address
after the branch instruction, and the next one or two bytes
will be taken from the address that the branch points to.
This is a bit complicated, but I've taken this into account,
in this debug function. (See the diffrence of how the values
vPipe1 and vPipe2 are read, compared to the values vByte1 and
vByte2)
*/
void FxPipeString(char * pvString)
{
char *p;
uint32 vOpcode = (GSU.vStatusReg & 0x300) | ((uint32)PIPE);
const char *m = fx_apvMnemonicTable[vOpcode];
uint8 vPipe1,vPipe2,vByte1,vByte2;
uint8 vPipeBank = GSU.vPipeAdr >> 16;
/* The next two bytes after the pipe's address */
vPipe1 = GSU.apvRomBank[vPipeBank][USEX16(GSU.vPipeAdr+1)];
vPipe2 = GSU.apvRomBank[vPipeBank][USEX16(GSU.vPipeAdr+2)];
/* The actual next two bytes to be read */
vByte1 = PRGBANK(USEX16(R15));
vByte2 = PRGBANK(USEX16(R15+1));
/* Print ROM address of the pipe */
sprintf(pvString, "%02x:%04x %02x ",
USEX8(vPipeBank), USEX16(GSU.vPipeAdr), USEX8(PIPE));
p = &pvString[strlen(pvString)];
/* Check if it's a branch instruction */
if( PIPE >= 0x05 && PIPE <= 0x0f )
{
sprintf(&pvString[11], "%02x ", USEX8(vPipe1));
#ifdef BRANCH_DELAY_RELATIVE
sprintf(p, m, USEX16(R15 + SEX8(vByte1) + 1 ) );
#else
sprintf(p, m, USEX16(R15 + SEX8(vByte1) - 1 ) );
#endif
}
/* Check for 'move' instruction */
else if( PIPE >= 0x10 && PIPE <= 0x1f && TF(B) )
sprintf(p, "move r%d,r%d", (int)USEX8(PIPE & 0x0f), (int)(GSU.pvSreg - GSU.avReg));
/* Check for 'ibt', 'lms' or 'sms' */
else if( PIPE >= 0xa0 && PIPE <= 0xaf )
{
sprintf(&pvString[11], "%02x ", USEX8(vPipe1));
if( (GSU.vStatusReg & 0x300) == 0x100 || (GSU.vStatusReg & 0x300) == 0x200 )
sprintf(p, m, USEX16(vByte1) << 1 );
else
sprintf(p, m, USEX16(vByte1) );
}
/* Check for 'moves' */
else if( PIPE >= 0xb0 && PIPE <= 0xbf && TF(B) )
sprintf(p, "moves r%d,r%d", (int)(GSU.pvDreg - GSU.avReg), (int)USEX8(PIPE & 0x0f) );
/* Check for 'iwt', 'lm' or 'sm' */
else if( PIPE >= 0xf0 )
{
sprintf(&pvString[11], "%02x %02x ", USEX8(vPipe1), USEX8(vPipe2));
sprintf(p, m, USEX8(vByte1) | (USEX16(vByte2)<<8) );
}
/* Normal instruction */
else
strcpy(p, m);
}
//--------------------------------------
void CGameServer::Exit(void)
{
if (m_nStatus != STATUSC_NONE) {
LOG_INFO(m_FileLog, TF("[游戏服务器]游戏服务退出处理开始!"));
m_pUIHandler = nullptr;
ExitUnloadConfig();
ExitUnloadShare();
m_nStatus = STATUSC_NONE;
LOG_INFO(m_FileLog, TF("[游戏服务器]游戏服务退出处理完成!"));
}
}
//--------------------------------------
bool CGameServer::Pause(bool bPause)
{
if (bPause && (m_nStatus == STATUSC_RUN)) {
m_nStatus = STATUSC_PAUSE;
LOG_INFO(m_FileLog, TF("[游戏服务器]暂停服务"));
return true;
}
else if ((bPause == false) && (m_nStatus == STATUSC_PAUSE)) {
m_nStatus = STATUSC_RUN;
LOG_INFO(m_FileLog, TF("[游戏服务器]允许服务"));
return true;
}
return false;
}
static void free_xft_color(Widget w, XftColor *col)
{
Display *dpy = XtDisplay(w);
TF();
XftColorFree(dpy, DefaultVisual(dpy, DefaultScreen(dpy)),
None, col );
}
static void notify_act(Widget w, XEvent *event, String *params, Cardinal *n)
{
CtrlWidget cw = (CtrlWidget)w;
CtrlPart *c = & cw->ctrl;
TF();
if( ! c->isflip ) {
c->msg.cmd = MSG_FIRE;
XtCallCallbacks( w, XtNcallback, (XtPointer) & c->msg );
}
else {
if( c->msg.state == STATE_ARMED ) {
c->msg.state = STATE_SELECTED;
c->msg.cmd = MSG_FIRE;
XtCallCallbacks( w, XtNcallback, (XtPointer) & c->msg );
}
else {
c->msg.state = STATE_ARMED;
/* make virtual keyboard visible */
vis_setup_slider_t msg;
msg.min = c->msg.min_value;
msg.max = c->msg.max_value;
msg.cur = c->msg.value;
sig_send( w, VIS_SETUP_SLIDER, &msg );
}
}
expose(w, NULL, 0);
}
bool CGameServer::DispatchZoneServer(const PacketPtr& PktPtr, KeyRef krSocket)
{
bool bRet = false;
switch (PktPtr->GetEvent()) {
case PAK_EVENT_LINK:
{
bRet = OnServerLink(static_cast<CPAKLink*>(PktPtr.Get()), krSocket);
}
break;
case PAK_EVENT_UPDATE:
{
bRet = OnServerUpdate(static_cast<CPAKUpdate*>(PktPtr.Get()), krSocket);
}
break;
case PAK_EVENT_UNLINK:
{
bRet = OnServerUnlink(PktPtr.Get(), krSocket);
}
break;
default:
{
LOGV_WARN(m_FileLog, TF("[游戏服务器]%p无法识别的地图服务器信令包数据[event=%d]"), krSocket, PktPtr->GetEvent());
}
}
return bRet;
}
bool CGameServer::DispatchGateServer(const PacketPtr& PktPtr, KeyRef krSocket)
{
bool bRet = false;
switch (PktPtr->GetEvent()) {
case PAK_EVENT_LINK:
{
bRet = OnServerLink(static_cast<CPAKLink*>(PktPtr.Get()), krSocket);
}
break;
case PAK_EVENT_UPDATE:
{
bRet = OnServerUpdate(static_cast<CPAKUpdate*>(PktPtr.Get()), krSocket);
}
break;
case PAK_EVENT_UNLINK:
{
bRet = OnServerUnlink(PktPtr.Get(), krSocket);
}
break;
case PAK_EVENT_GAME_ID:
{
CPAKGameIdAck GameIdAck;
GameIdAck.SetId((Int)m_ServerInfo.usId);
GameIdAck.AdjustSize();
m_NetworkPtr->Send(krSocket, GameIdAck);
}
break;
default:
{
LOGV_WARN(m_FileLog, TF("[游戏服务器]%p无法识别的网关服务器信令包数据[event=%d]"), krSocket, PktPtr->GetEvent());
}
}
return bRet;
}
//--------------------------------------
bool CGameServer::OnTcpAccept(KeyRef krAccept, KeyRef)
{
if (m_nStatus == STATUSC_RUN) {
UShort usPort = 0;
CStringKey strAddr;
m_NetworkPtr->GetAddr(krAccept, strAddr, usPort);
DEV_INFO(TF("[游戏服务器]服务器[%s]:%d连接完成!"), *strAddr, usPort);
m_ServerInfo.Incr();
return true;
}
else {
LOGV_WARN(m_FileLog, TF("[游戏服务器]游戏服务器处于暂停状态!"));
}
return false;
}
//--------------------------------------
UInt CGameServer::Init(CEventHandler& EventHandlerRef)
{
if (m_nStatus == STATUSC_NONE) {
LOG_INFO(m_FileLog, TF("[游戏服务器]游戏服务初始化开始!"));
m_pUIHandler = &EventHandlerRef;
if ((InitLoadShare() == false) ||
(InitLoadConfig() == false)) {
return (UInt)RET_FAIL;
}
m_nStatus = STATUSC_INIT;
LOG_INFO(m_FileLog, TF("[游戏服务器]游戏服务初始化完成!"));
return (UInt)RET_OKAY;
}
return (UInt)RET_FAIL;
}
//--------------------------------------
bool CGameServer::OnUdpClose(KeyRef krSocket, LLong)
{
if (krSocket == m_krUDPService){
m_krUDPService = nullptr;
DEV_INFO(TF("[游戏服务器]UDP监听登陆服务器关闭"));
}
return true;
}
static void resize(Widget w)
{
TF();
// layout based on the new width and height of the widget's
// window.
do_layout(w);
TRACE(2, "%s %u %u", ((CtrlWidget)w)->core.name, XtWidth(w), XtHeight(w));
}
void CGameServer::StopUDPService(void)
{
if (m_krUDPService != nullptr) {
m_NetworkPtr->Destroy(m_krUDPService, false);
m_krUDPService = nullptr;
LOG_INFO(m_FileLog, TF("[游戏服务器]销毁UDP服务对象成功"));
}
}
static void do_layout(Widget w)
{
CtrlWidget cw = (CtrlWidget)w;
CtrlPart *c = & cw->ctrl;
Display *dpy = XtDisplay(w);
clabel_t *cl,*cu,*ct;
char *s;
Dimension total_w=0, total_h=0, stretch=0;
TF();
total_w = XtWidth(w);
total_h = XtHeight(w);
// top-left
cl = c->clabel+LABEL;
s=cl->str;
if( IsEmpty(s) || !cl->font ) {
cl->width=0; cl->height=0;
cl->x=0; cl->y=0;
}
else {
cl->x=0; cl->y = 0;
cl->height = cl->font->height;
cl->width = cl->extents.xOff;
}
// top-right
cu = c->clabel+UNIT;
s=cu->str;
if( IsEmpty(s) || !cu->font ) {
cu->width=0; cu->height=0;
cu->x=0; cu->y=0;
}
else {
cu->width = cu->extents.xOff;
cu->x = total_w - cu->width;
cu->y = 0;
cu->height = cu->font->height;
}
int top_h = Max(cl->height, cu->height );
// center bottom
ct = c->clabel+TEXT;
s=ct->str;
if( ct->font && !IsEmpty(s)) {
ct->width = total_w;
ct->height = total_h - top_h;
ct->x = 0;
ct->y = top_h;
calc_str_position( ct );
}
else {
ct->width = ct->height = ct->x=ct->y=0;
}
}
static void highlight_act(Widget w, XEvent* e, String* s, Cardinal* n)
{
CtrlWidget cw = (CtrlWidget)w;
CtrlPart *c = & cw->ctrl;
TF();
if( c->msg.state == STATE_SELECTED ) return;
c->msg.state = STATE_SELECTED;
expose(w, NULL, 0);
}
//--------------------------------------
bool CGameServer::Start(void)
{
if (m_nStatus == STATUSC_INIT) {
LOG_INFO(m_FileLog, TF("[游戏服务器]游戏服务启动开始!"));
if ((StartUDPService() == false) || // 提前开启获取地址信息
(StartConnectCenterServer() == false) ||
(StartConnectGameDBServer() == false) ||
(StartListenZoneServer() == false) ||
(StartListenGateServer() == false)) {
return false;
}
m_nStatus = STATUSC_RUN;
LOG_INFO(m_FileLog, TF("[游戏服务器]游戏服务启动完成!"));
}
return true;
}
bool CGameServer::StartUDPService(void)
{
if (m_krUDPService == nullptr) {
m_krUDPService = m_NetworkPtr->Create(*this, m_ServerInfo.NetAddr[GAMEI_UDP], SOCKET_UDP);
if (m_krUDPService != nullptr) {
LOGV_INFO(m_FileLog, TF("[游戏服务器]创建UDP监听登陆服务器成功"));
if (m_ServerInfo.NetAddr[GAMEI_UDP].usPort == 0) {
m_NetworkPtr->GetAddr(m_krUDPService, m_ServerInfo.NetAddr[GAMEI_UDP], false);
}
m_pUIHandler->OnHandle(PAK_EVENT_LINK, reinterpret_cast<uintptr_t>(m_ServerInfo.NetAddr + GAMEI_UDP), DATA_INDEX_GAME);
}
else {
LOGV_ERROR(m_FileLog, TF("[游戏服务器]创建UDP监听登陆服务器失败"));
return false;
}
}
return true;
}
void CGameServer::StopListenZoneServer(void)
{
if (m_krListenZone != nullptr) {
m_NetworkPtr->Destroy(m_krListenZone, false);
m_krListenZone = nullptr;
LOG_INFO(m_FileLog, TF("[游戏服务器]销毁监听地图服务器对象成功"));
}
m_pShareZoneSvr = nullptr;
}
void CGameServer::StopConnectCenterServer(void)
{
if (m_krConnectCenter != nullptr) {
m_NetworkPtr->Destroy(m_krConnectCenter, false);
m_krConnectCenter = nullptr;
LOG_INFO(m_FileLog, TF("[游戏服务器]销毁连接中心服务器对象成功"));
}
m_bCenterCnnted = false;
m_bCenterLinked = false;
m_pShareCenterSvr = nullptr;
}
static void reset_act(Widget w, XEvent* e, String* s, Cardinal* n)
{
CtrlWidget cw = (CtrlWidget)w;
CtrlPart *c = & cw->ctrl;
TF();
if( c->msg.state == STATE_NORMAL ) return;
c->msg.state = STATE_NORMAL;
expose(w, NULL, 0);
/* disable virtual keyboard */
sig_send( w, VIS_REMOVE_SLIDER, NULL );
}
void CGameServer::StopConnectGameDBServer(void)
{
if (m_krConnectGameDB != nullptr) {
m_NetworkPtr->Destroy(m_krConnectGameDB, false);
m_krConnectGameDB = nullptr;
LOG_INFO(m_FileLog, TF("[游戏服务器]销毁连接游戏DB服务器对象成功"));
}
m_bGameDBCnnted = false;
m_bGameDBLinked = false;
m_pShareGameDBSvr = nullptr;
}
void CGameServer::StopListenGateServer(void)
{
if (m_krListenGate != nullptr) {
if (m_krListenGate != (KeyRef)this) {
m_NetworkPtr->Destroy(m_krListenGate, false);
}
m_krListenGate = nullptr;
LOG_INFO(m_FileLog, TF("[游戏服务器]销毁监听网关服务器对象成功"));
}
m_pShareGateSvr = nullptr;
}
bool CGameServer::StartListenGateServer(void)
{
if (m_krListenGate != nullptr) {
LOGV_INFO(m_FileLog, TF("[游戏服务器]创建监听网关服务器对象已经存在"));
return true;
}
if (m_ServerInfo.NetAddr[GAMEI_GATE].usPort == 0) {
m_krListenGate = (KeyRef)this;
LOG_INFO(m_FileLog, TF("[游戏服务器]监听网关服务器地址和监听地图服务器地址一样"));
return true;
}
m_krListenGate = m_NetworkPtr->Create(*this, m_ServerInfo.NetAddr[GAMEI_GATE]);
if (m_krListenGate != nullptr) {
LOGV_INFO(m_FileLog, TF("[游戏服务器]创建监听网关服务器对象成功"));
if (m_NetworkPtr->Listen(m_krListenGate) == false) {
LOG_ERROR(m_FileLog, TF("[游戏服务器]监听网关服务器失败"));
return false;
}
else {
LOG_INFO(m_FileLog, TF("[游戏服务器]监听网关服务器成功"));
}
}
else {
LOGV_ERROR(m_FileLog, TF("[游戏服务器]创建监听网关服务器对象失败"));
return false;
}
return true;
}
//--------------------------------------
bool CGameServer::OnShareRoutine(Int nEvent, CEventBase& EventRef, LLong llParam, CEventQueue::EVENT_TYPE)
{
assert((m_pConfig->GetLoadServers() & (CServerConfig::CFG_DEFAULT_CENTER|CServerConfig::CFG_DEFAULT_GAMEDB|CServerConfig::CFG_DEFAULT_ZONE|CServerConfig::CFG_DEFAULT_GATE)) != 0);
switch (nEvent) {
case PAK_EVENT_LINK:
{
return OnShareLink(EventRef, llParam);
}
break;
case PAK_EVENT_UPDATE:
{
return OnShareUpdate(EventRef, llParam);
}
break;
//case PAK_EVENT_UNLINK: // 同进程服务器注销, 说明服务停止, 不需要处理
// break;
case PAK_EVENT_GAME_ID:
{
PInt pId = reinterpret_cast<PInt>(llParam);
*pId = (Int)m_ServerInfo.usId;
}
break;
case PAK_EVENT_LOGIN_SELECT_GAME:
{
CPAKLoginSelectGame* pSelect = static_cast<CPAKLoginSelectGame*>(&EventRef);
if (SelectGame(pSelect, llParam) == false) {
pSelect->SetAck(LOGIN_ERROR_NONE_GATE);
reinterpret_cast<ICommonServer*>(llParam)->OnShareRoutine(PAK_EVENT_LOGIN_SELECT_GAME, *pSelect);
DEV_INFO(TF("[游戏服务器]同进程游戏服务器收到客户端选择游戏服务器请求, 但是没有网关服务器"));
}
}
break;
default:
{
LOGV_WARN(m_FileLog, TF("[游戏服务器]同进程服务器无法识别的信令包数据[event=%d]"), nEvent);
assert(0);
}
}
return true;
}
static void calc_widget_size(Widget w, Dimension *width, Dimension *height )
{
CtrlWidget cw = (CtrlWidget)w;
CtrlPart *c = & cw->ctrl;
Display *dpy = XtDisplay(w);
clabel_t *cl,*cu,*ct;
char *s;
Dimension total_w=0, total_h=0, stretch=0;
TF();
total_w = total_h = 0;
// top-left
cl = c->clabel+LABEL;
s=cl->str;
if( ! IsEmpty(s) && cl->font ) {
XftTextExtentsUtf8(dpy, cl->font, (FcChar8*)s,
strlen(s), & cl->extents );
total_h = cl->font->height;
total_w = cl->extents.xOff;
}
total_w += c->hspace +1;
// top-right
cu = c->clabel+UNIT;
s=cu->str;
if(! IsEmpty(s) && cu->font ) {
XftTextExtentsUtf8(dpy, cu->font, (FcChar8*)s,
strlen(s), & cu->extents );
total_w += cu->extents.xOff;
total_h = Max( cu->font->height, total_h );
}
total_h += c->vspace;
// center bottom
ct = c->clabel+TEXT;
s=ct->str;
if(! IsEmpty(s) && ct->font ) {
XftTextExtentsUtf8(dpy, ct->font, (FcChar8*)s,
strlen(s), & ct->extents );
total_w = Max( total_w,ct->extents.xOff );
total_h += ct->font->height;
}
*width = total_w;
*height = total_h;
TRACE(2,"%s %u %u", cw->core.name, total_w, total_h );
}
