brewlogin.cpp

象棋框架

/*===========================================================================
FILE: BrewLogin.c
===========================================================================*/
#include "BrewLogin.h"
#include "waitingcanvas.h"
#include "BrewMainMenu.h"
#include "BrewLoginCanvas42.h"
#include "usermng.h"
#include "BrewLoginCanvas2.h"
#include "BrewLoginCanvas3.h"
#include "brewlogincanvasbase.h"


CBrewLogin::CBrewLogin(){
	m_bUserMng = true;
	MEMSET(&m_userMng,0,sizeof(m_userMng));
	m_userMng.urs.userinfo = 0x10;
	m_broom = false;
  m_nLoginRunFlag = TRUE;
  frame = NULL;
  m_nLoginState = LOGIN_INIT;
  m_bLoginFlag = FALSE;
  m_nWaitGameListTime = 0;
  m_nWaitServerListTime = m_nWaitGameListTime;
  m_nWaitRoomListTime = m_nWaitGameListTime;
  m_nWaitLoginTime = m_nWaitGameListTime;
  m_nWaitEnterTime = m_nWaitGameListTime;
  m_pILoginCanvas = CreateLoginCanvas();
  if (m_pILoginCanvas != NULL)
	m_pILoginCanvas->setFrame(this);
  m_pGList = NULL;
  m_pSList = NULL;
  m_pRList = NULL;
  m_nGCount = 0;
  m_nSCount = 0;
  m_nRCount = 0;
  m_pIShell = NULL;
  m_pIMenu = NULL;
  m_pIText1 = NULL;
  m_pIText2 = NULL;
  m_nCurrentGameId = 0x1007;
  m_nCurrentServerId = 0;
  m_nCurrentRoomId = 0;
  m_pIDi = NULL;
  MEMSET(m_nUserName, '\0', sizeof(m_nUserName));
  MEMSET(m_nUserPass, '\0', sizeof(m_nUserPass));


}

void CBrewLogin::freeData(){
  UINT16 i;
  struct GameItemStruct *gItem;
  struct ServerItemStruct *sItem;
  struct RoomItemStruct *rItem;

  m_pIShell = NULL;
  m_pIDi = NULL;

  if (m_pIText1 != NULL){
	ITEXTCTL_Release(m_pIText1);
	m_pIText1 = NULL;
  }

  if (m_pIText2 != NULL){
	ITEXTCTL_Release(m_pIText2);
	m_pIText2 = NULL;
  }

  if (m_pIMenu != NULL){
    IMENUCTL_Release(m_pIMenu);
    m_pIMenu = NULL;
  }

  if (m_pILoginCanvas != NULL){
	m_pILoginCanvas->Release();
	m_pILoginCanvas = NULL;
  }

  for (i = 0; i < m_nGCount; i ++){
    gItem = m_pGList;
	if (gItem == NULL)
	  break;
	m_pGList = m_pGList->gameNext;
	FREE(gItem);
  }
  m_nGCount = 0;

  for (i = 0; i < m_nSCount; i ++){
    sItem = m_pSList;
	if (sItem == NULL)
	  break;
	m_pSList = m_pSList->serverNext;
	FREE(sItem);
  }
  m_nSCount = 0;

  for (i = 0; i < m_nRCount; i ++){
    rItem = m_pRList;
	if (rItem == NULL)
	  break;
	m_pRList = m_pRList->roomNext;
	FREE(rItem);
  }
  m_nRCount = 0;
}

CBrewLogin::~CBrewLogin(){
  freeData();
}

void CBrewLogin::setLoginFrame(IBrewLoginFrame *f){
  frame = f;
  if (frame != NULL){
	frame->setCanvas(m_pILoginCanvas);
    m_pIShell = frame->getCurrentShell();
    m_pIDi = frame->getDeviceInfo();
	m_nCurrentGameId = frame->getCurrentGameId();
  }
  if (m_pIShell != NULL){
    m_nWaitGameListTime = ISHELL_GetUpTimeMS(m_pIShell);
    m_nWaitServerListTime = m_nWaitGameListTime;
    m_nWaitRoomListTime = m_nWaitGameListTime;
    m_nWaitLoginTime = m_nWaitGameListTime;
    m_nWaitEnterTime = m_nWaitGameListTime;
  }
}

void CBrewLogin::onGetGameList(UINT16 num, struct GameItemStruct *gItem){
	if(!m_nLoginRunFlag)
		return;
  UINT16 i;
  struct GameItemStruct *gFromItem;
  struct GameItemStruct *gToItem;
  struct GameItemStruct *gLastItem;

  for (i = 0; i < m_nGCount; i ++){
    gToItem = m_pGList;
	if (gToItem == NULL)
	  break;
	m_pGList = m_pGList->gameNext;
	FREE(gToItem);
  }
  m_nGCount = 0;

  gLastItem = NULL;
  gFromItem = gItem;
  for (i = 0; i < num; i ++){
	if (gFromItem == NULL)
	  break;
    gToItem = (struct GameItemStruct *)MALLOC(sizeof(struct GameItemStruct));
    if (gToItem == NULL)
	  break;
	gToItem->serverCount = 0;
	gToItem->serverNext = NULL;
	m_nGCount ++;
	if (gLastItem == NULL){
	  gToItem->gameNext = NULL;
	  m_pGList = gToItem;
	}else{
	  gToItem->gameNext = gLastItem->gameNext;
	  gLastItem->gameNext = gToItem;
	}
	MEMCPY(&(gToItem->gameItem), &(gFromItem->gameItem), sizeof(struct GameStruct));
	gLastItem = gToItem;
	gFromItem = gFromItem->gameNext;
  }

  if ((m_nLoginState == LOGIN_TEST_GAME_LIST) || (m_nLoginState == LOGIN_GET_GAME_LIST) || (m_nLoginState == LOGIN_WAIT_GAME_LIST))
	m_nLoginState = LOGIN_READY_GAME;
}

void CBrewLogin::onGetServerList(UINT16 gameId, UINT16 num, struct ServerItemStruct *sItem){
	if(!m_nLoginRunFlag)
		return;
  UINT16 i;
  struct ServerItemStruct *sFromItem;
  struct ServerItemStruct *sToItem;
  struct ServerItemStruct *sLastItem;

  for (i = 0; i < m_nSCount; i ++){
    sToItem = m_pSList;
	if (sToItem == NULL)
	  break;
	m_pSList = m_pSList->serverNext;
	FREE(sToItem);
  }
  m_nSCount = 0;

  sLastItem = NULL;
  sFromItem = sItem;
  for (i = 0; i < num; i ++){
	if (sFromItem == NULL)
	  break;
    sToItem = (struct ServerItemStruct *)MALLOC(sizeof(struct ServerItemStruct));
    if (sToItem == NULL)
	  break;
	m_nSCount ++;
	if (sLastItem == NULL){
	  sToItem->serverNext = NULL;
	  m_pSList = sToItem;
	}else{
	  sToItem->serverNext = sLastItem->serverNext;
	  sLastItem->serverNext = sToItem;
	}
	MEMCPY(&(sToItem->serverItem), &(sFromItem->serverItem), sizeof(struct ServerStruct));
	sLastItem = sToItem;
	sFromItem = sFromItem->serverNext;
  }

  if ((m_nLoginState == LOGIN_TEST_SERVER_LIST) || (m_nLoginState == LOGIN_GET_SERVER_LIST) || (m_nLoginState == LOGIN_WAIT_SERVER_LIST))
	m_nLoginState = LOGIN_READY_SERVER;
}

void CBrewLogin::onGetRoomList(UINT16 gameId, UINT16 serverId, UINT16 num, struct RoomItemStruct *rItem){
	if(!m_nLoginRunFlag)
		return;
  UINT16 i;
  struct RoomItemStruct *rFromItem;
  struct RoomItemStruct *rToItem;
  struct RoomItemStruct *rLastItem;

  for (i = 0; i < m_nRCount; i ++){
    rToItem = m_pRList;
	if (rToItem == NULL)
	  break;
	m_pRList = m_pRList->roomNext;
	FREE(rToItem);
  }
  m_nRCount = 0;

  rLastItem = NULL;
  rFromItem = rItem;
  for (i = 0; i < num; i ++){
	if (rFromItem == NULL)
	  break;
    rToItem = (struct RoomItemStruct *)MALLOC(sizeof(struct RoomItemStruct));
    if (rToItem == NULL)
	  break;
	m_nRCount ++;
	if (rLastItem == NULL){
	  rToItem->roomNext = NULL;
	  m_pRList = rToItem;
	}else{
	  rToItem->roomNext = rLastItem->roomNext;
	  rLastItem->roomNext = rToItem;
	}
	MEMCPY(&(rToItem->roomItem), &(rFromItem->roomItem), sizeof(struct RoomStruct));
	rLastItem = rToItem;
	rFromItem = rFromItem->roomNext;
  }

  if ((m_nLoginState == LOGIN_TEST_ROOM_LIST) || (m_nLoginState == LOGIN_GET_ROOM_LIST) || (m_nLoginState == LOGIN_WAIT_ROOM_LIST))
	m_nLoginState = LOGIN_READY_ROOM;
  else if(m_nLoginState == LOGIN_WAIT_LOGIN)
	  m_nLoginState = LOGIN_TEST_LOGIN;
}

void CBrewLogin::onEnterRoom(UINT16 gameId, UINT16 serverId, UINT8 roomId, UINT8 retCode){
	if(m_nLoginRunFlag == false)
		return;
  if (frame == NULL){
    m_nLoginState = LOGIN_READY_ROOM;
	return;
  }

  switch (retCode){
    case 0:
	case 4:
	  m_nLoginRunFlag = FALSE;
	  frame->postUserEvent(HALL, SWITCH_INTO, 0);
	  
	  m_nLoginState = LOGIN_READY_ROOM; //为了可以回来
	  SetCanvas(Canvas1);
	  //m_bLoginFlag = false;
	  
	  break;
	default:
	  m_nLoginState = LOGIN_READY_ROOM;
	  break;
  }
}

void CBrewLogin::onInviteUser(UINT16 num, struct InviteItemStruct *inviteItem){
	if(!m_nLoginRunFlag)
		return;
}

void CBrewLogin::onChat(UINT16 num, struct ChatItemStruct *chatItem){
}

void CBrewLogin::onLoginUser(UINT8 retCode){
	if(!m_nLoginRunFlag)
		return;
  switch (retCode){
    case 0:
	  m_nLoginState = LOGIN_TEST_ENTER;
	  m_bLoginFlag = TRUE;
	  break;
	default:
		{
			//m_nLoginState = LOGIN_READY_LOGIN;
			if(m_nCurCv == WaitCanvas)	//等待界面的话显示出错信息
			{
				SetCanvas(WaitCanvas);
				CDispInfo di;			
				di.bErr = true;
				di.pInfo[0] = 0;
				di.nPreState = LOGIN_READY_LOGIN;
				WSTRCPY(di.pErrmsg,((CBrewLoginCanvasBase*)m_pILoginCanvas)->GetDispText(IDS_LOGIN_FAILED));
				if(m_nCurCv == WaitCanvas)
					((CWaitingCanvas*)m_pILoginCanvas)->SetDispMsg(&di);				
			}
			else
				m_nLoginState = LOGIN_READY_LOGIN;
		}
	  break;
  }
}

void CBrewLogin::onRegisterUser(UINT8 retCode){
	if(!m_bReg)
	{
		onModifyUser(retCode);
		return;
	}
	switch (retCode){
    case 0:
		{
			SetCanvas(WaitCanvas);			
			if(m_nCurCv == WaitCanvas)
			SetWaitingMsg(m_nCurCv,m_pILoginCanvas,
				((CBrewLoginCanvasBase*)m_pILoginCanvas)->GetDispText(IDS_UMG_REGSUC),
				true,LOGIN_READY_LOGIN);			
			break;
		}
	default:
		{
			//m_nLoginState = LOGIN_READY_REGISTER;
			//break;
			SetCanvas(WaitCanvas);			
			if(m_nCurCv == WaitCanvas)
			SetWaitingMsg(m_nCurCv,m_pILoginCanvas,
				((CBrewLoginCanvasBase*)m_pILoginCanvas)->GetDispText(IDS_UMG_REGFAIL),
				true,LOGIN_READY_REGISTER);
			break;
		}
	}
}

void CBrewLogin::onModifyUser(UINT8 retCode){
	switch (retCode){
    case 0:
		{
			SetCanvas(WaitCanvas);			
			if(m_nCurCv == WaitCanvas)
			SetWaitingMsg(m_nCurCv,m_pILoginCanvas,
				((CBrewLoginCanvasBase*)m_pILoginCanvas)->GetDispText(IDS_UMG_MODSUC),
				true,LOGIN_READY_LOGIN);
			break;
		}
	default:
		{
			//m_nLoginState = LOGIN_READY_REGISTER;
			//break;
			SetCanvas(WaitCanvas);
			if(m_nCurCv == WaitCanvas)
			SetWaitingMsg(m_nCurCv,m_pILoginCanvas,
				((CBrewLoginCanvasBase*)m_pILoginCanvas)->GetDispText(IDS_UMG_MODFAIL),
				true,LOGIN_READY_MODIFY);
			break;
		}
	}
}

void CBrewLogin::onConnectGameServer(boolean retFlag){
}

void CBrewLogin::onDisconnectGameServer(UINT8 retCode){
}

void CBrewLogin::onYouBack(UINT8 roomId, UINT8 tableId, UINT8 seatId){
}

void CBrewLogin::onStart(){
}

void CBrewLogin::onStop(){
  freeData();
}

void CBrewLogin::onSuspend(){
	if (m_pIText1 != NULL){
		ITEXTCTL_Release(m_pIText1);
		m_pIText1 = NULL;
	}
	
	if (m_pIText2 != NULL){
		ITEXTCTL_Release(m_pIText2);
		m_pIText2 = NULL;
	}
	
	if (m_pIMenu != NULL){
		IMENUCTL_Release(m_pIMenu);
		m_pIMenu = NULL;
	}
	if(m_nCurCv != Canvas1)
		((CBrewLoginCanvasBase*)m_pILoginCanvas)->onSuspend();
}

void CBrewLogin::onResume(){
	if(m_nCurCv != Canvas1)
		((CBrewLoginCanvasBase*)m_pILoginCanvas)->onResume();
}

void CBrewLogin::onPlay(){
	boolean bTimeOut = false;
	UINT32 timeMS;
	UINT16 i;
	UINT16 j;
	struct ServerItemStruct *sItem;
	struct RoomItemStruct *rItem;
	AEERect r;
	
	if (m_nLoginRunFlag == FALSE)
		return;
	
	if (frame == NULL)
		return;
	
	timeMS = ISHELL_GetUpTimeMS(pApp->m_pApp->m_pIShell);
	switch (m_nLoginState){
    case LOGIN_INIT:
		//m_nLoginState = LOGIN_TEST_GAME_LIST;
		//break;
		{
			if(m_nCurCv == InitCanvas)
				break;
			SetCanvas(InitCanvas);			
			//break;
		}