brewhall.cpp

象棋框架

/*===========================================================================
FILE: BrewHall.c
===========================================================================*/
#include "BrewHall.h"
#include "brewhallcanvas2.h"
#include "brewlogincanvasbase.h"

CBrewHall::CBrewHall(){
  m_nHallRunFlag = FALSE;
  frame = NULL;
  m_pIShell = NULL;
  m_pIDi = NULL;
  m_pIHallCanvas = CreateHallCanvas();

  m_nCurCv = Canvas1;

  if (m_pIHallCanvas != NULL)
	m_pIHallCanvas->setFrame(this);
  m_pRList = NULL;
  m_pCList = NULL;
  m_pUList = NULL;
  m_nRCount = 0;
  m_nCCount = 0;
  m_nUCount = 0;
  m_pIMenu = NULL;
  m_nHallState = HALL_INIT;
  m_pCurrentRoom = NULL;
  m_nCurrentTableId = 0;
  m_nCurrentSeatId = 0;
  m_nWaitSitdownTime = 0;
  m_nWaitQueryTime = 0;
}

void CBrewHall::freeData(){
	m_pIShell = NULL;
	m_pIDi = NULL;
	
	if (m_pIMenu != NULL){
		IMENUCTL_Release(m_pIMenu);
		m_pIMenu = NULL;
	}
	if (m_pCurrentRoom != NULL){
		FREE(m_pCurrentRoom);
		m_pCurrentRoom = NULL;
	}
	if (m_pIHallCanvas != NULL){
		m_pIHallCanvas->Release();
		m_pIHallCanvas = NULL;
	}
	clearRoomList();
	clearSeatList();
	clearUserList();
}

void CBrewHall::clearUserList(){
  struct UserItemStruct *uItem;
  UINT16 i;

  for (i = 0; i < m_nUCount; i ++){
    if (m_pUList == NULL)
	  break;
	uItem = m_pUList;
	m_pUList = m_pUList->userNext;
	FREE(uItem);
  }
  m_nUCount = 0;
}

void CBrewHall::clearRoomList(){
	struct RoomItemStruct *rItem;
	UINT16 i;
	
	for (i = 0; i < m_nRCount; i ++){
		if (m_pRList == NULL)
			break;
		rItem = m_pRList;
		m_pRList = m_pRList->roomNext;
		FREE(rItem);
	}
	m_nRCount = 0;
}

void CBrewHall::clearSeatList(){
	struct SeatItemStruct *cItem;
	UINT16 i;
	
	for (i = 0; i < m_nCCount; i ++){
		if (m_pCList == NULL)
			break;
		cItem = m_pCList;
		m_pCList = m_pCList->seatNext;
		FREE(cItem);
	}
	m_nCCount = 0;
}

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

void CBrewHall::setHallFrame(IBrewHallFrame *f){
  frame = f;
  if (frame != NULL){
    m_pIShell = frame->getCurrentShell();
	m_pIDi = frame->getDeviceInfo();
  }
  if (m_pIShell != NULL){
    m_nWaitSitdownTime = ISHELL_GetUpTimeMS(m_pIShell);
	m_nWaitQueryTime = m_nWaitSitdownTime;
  }
}

void CBrewHall::onGetRoomList(UINT16 gameId, UINT16 serverId, UINT16 num, struct RoomItemStruct *rItem){
  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;
  }
}

void CBrewHall::onEnterRoom(UINT16 gameId, UINT16 serverId, UINT8 roomId, UINT8 retCode){
	
	frame->showHint(NULL,0,HINT_TOP);
	frame->showHint(NULL,0,HINT_BOTTOM);
	if(m_nHallRunFlag != false)
	{	
		
		if(m_nCurCv == Canvas2)
		{
			CBrewHallCanvas2 *p = (CBrewHallCanvas2*)m_pIHallCanvas;
			p->OnReconnect();
		}
	}
  UINT16 i;
  struct RoomItemStruct *rItem;

  rItem = m_pRList;
  for (i = 0; i < m_nRCount; i ++){
	if (rItem == NULL)
	  break;
	if (rItem->roomItem.roomId == roomId){
	  if (m_pCurrentRoom == NULL)
        m_pCurrentRoom = (struct RoomItemStruct *)MALLOC(sizeof(struct RoomItemStruct));
      if (m_pCurrentRoom == NULL)
	    break;
	  MEMCPY(&(m_pCurrentRoom->roomItem), &(rItem->roomItem), sizeof(struct RoomStruct));
	  m_pCurrentRoom->roomNext = NULL;
	  break;
	}
	rItem = rItem->roomNext;
  }
}

void CBrewHall::onSeatInfo(UINT16 gameId, UINT16 serverId, UINT8 roomId, UINT16 num, struct SeatItemStruct *cItem){
	if(m_nHallRunFlag == false)
		return;
	
  UINT16 i;
  struct SeatItemStruct *cFromItem;
  struct SeatItemStruct *cToItem;
  struct SeatItemStruct *cLastItem;

  if(m_nCurCv == Canvas2)
  {
	  CBrewHallCanvas2 *p = (CBrewHallCanvas2*)m_pIHallCanvas;
	  p->Invalidate();
  }

  for (i = 0; i < m_nCCount; i ++){
    cToItem = m_pCList;
	if (cToItem == NULL)
	  break;
	m_pCList = m_pCList->seatNext;
	FREE(cToItem);
  }
  m_nCCount = 0;

  cLastItem = NULL;
  cFromItem = cItem;
  for (i = 0; i < num; i ++){
	if (cFromItem == NULL)
	  break;
    cToItem = (struct SeatItemStruct *)MALLOC(sizeof(struct SeatItemStruct));
    if (cToItem == NULL)
	  break;
	m_nCCount ++;
	if (cLastItem == NULL){
	  cToItem->seatNext = NULL;
	  m_pCList = cToItem;
	}else{
	  cToItem->seatNext = cLastItem->seatNext;
	  cLastItem->seatNext = cToItem;
	}
	MEMCPY(&(cToItem->seatItem), &(cFromItem->seatItem), sizeof(struct SeatInfoStruct));
	cLastItem = cToItem;
	cFromItem = cFromItem->seatNext;
  }
  if (m_nHallState == HALL_CHOOSE_SEAT)
	m_nHallState = HALL_UPDATE_SEAT_LIST;
}

void CBrewHall::onSitDown(UINT8 tableId, UINT8 seatId, UINT8 action, UINT8 retCode){
	if(m_nHallRunFlag == false)
		return;
	
  if (frame == NULL){
    m_nHallState = HALL_WAIT_SEAT_LIST;
	if(m_nCurCv == Canvas2)
	{
		CBrewHallCanvas2 *p = (CBrewHallCanvas2*)m_pIHallCanvas;
		p->OnFailed();
	}
	return;
  }


  
  switch (retCode){
    case 0:
	case 1:
		frame->queryTable(tableId,0);
	  m_nHallRunFlag = FALSE;
	  frame->showHint(NULL,0,HINT_BOTTOM);
	  frame->postUserEvent(GAME, SWITCH_INTO, 0);
	  SetCanvas(Canvas1);
	  break;
	default:
	  m_nHallState = HALL_WAIT_SEAT_LIST;
	  if(m_nCurCv == Canvas2)
	  {
		  CBrewHallCanvas2 *p = (CBrewHallCanvas2*)m_pIHallCanvas;
		  p->OnFailed();
	  }
	  break;
  }
}

void CBrewHall::onInviteUser(UINT16 num, struct InviteItemStruct *inviteItem){
}

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

void CBrewHall::onUserInfo(UINT8 ret, UINT16 num, struct UserItemStruct *uItem){
  UINT16 i;
  UINT16 j;
  struct UserItemStruct *uFromItem;
  struct UserItemStruct *uToItem;
  struct UserItemStruct *uLastItem;

  //总是保存个人信息，第一项是个人信息
  if(m_pUList != NULL)
  {
	  struct UserItemStruct *tmp = (struct UserItemStruct *)MALLOC(sizeof(struct UserItemStruct));
	  MEMCPY(tmp,m_pUList,sizeof(struct UserItemStruct));
	  tmp->userNext = NULL;
	  clearUserList();
	  m_pUList = tmp;
	  m_nUCount = 1;
  }
  ////////////////////////////////////


  uLastItem = NULL;
  uFromItem = uItem;
  for (i = 0; i < num; i ++){
	if (uFromItem == NULL)
	  break;
	uToItem = m_pUList;
	uLastItem = NULL;
	for (j = 0; j < m_nUCount; j ++){
	  if (uToItem == NULL)
		break;
	  if ((uToItem->userItem.userNameLength == uItem->userItem.userNameLength)
	  && (MEMCMP(uToItem->userItem.userName, uItem->userItem.userName, uItem->userItem.userNameLength) == 0))
		break;
	  uLastItem = uToItem;
	  uToItem = uToItem->userNext;
	}
	if (uToItem == NULL){
      uToItem = (struct UserItemStruct *)MALLOC(sizeof(struct UserItemStruct));
      if (uToItem == NULL)
	    break;
	  m_nUCount ++;
	  if (uLastItem == NULL){
	    uToItem->userNext = NULL;
	    m_pUList = uToItem;
	  }else{
	    uToItem->userNext = uLastItem->userNext;
	    uLastItem->userNext = uToItem;
	  }
	}
	MEMCPY(&(uToItem->userItem), &(uFromItem->userItem), sizeof(struct UserInfoStruct));
	uFromItem = uFromItem->userNext;
  }

  if ((m_nHallState == HALL_TEST_QUERY) || (m_nHallState == HALL_GET_QUERY) || (m_nHallState == HALL_WAIT_QUERY))
	m_nHallState = HALL_READY_QUERY;
  else if (m_nHallState == HALL_CHOOSE_QUERY)
	  m_nHallState = HALL_UPDATE_QUERY;
}

void CBrewHall::onDisconnectGameServer(UINT8 retCode){
	if(m_nHallRunFlag == false)
		return;
	
	//clearUserList();
	//clearSeatList();
	if(m_nCurCv == Canvas2)
	{
		CBrewHallCanvas2 *p = (CBrewHallCanvas2*)m_pIHallCanvas;
		p->onDisconnectGameServer(retCode);
	}
}

void CBrewHall::onYouBack(UINT8 roomId, UINT8 tableId, UINT8 seatId){
	if(m_nCurCv == Canvas2)
	{
		CBrewHallCanvas2 *p = (CBrewHallCanvas2*)m_pIHallCanvas;
		p->OnReconnect();
	}
}

void CBrewHall::onTableUp(UINT8 tableId, UINT8 action){
}

void CBrewHall::onEvent(AEEEvent eCode, UINT16 wParam, UINT32 dwParam){
  if (frame == NULL)
	return;

  switch (eCode){
    case EVT_COMMAND:
	  if (m_nHallRunFlag == FALSE)
		break;
	  if(m_nCurCv == Canvas2)
	  {
		  //frame->showHint(STRTOWSTR("onevent in hall",szText,20),0,HINT_TOP);
		  CBrewHallCanvas2 *p = (CBrewHallCanvas2*)m_pIHallCanvas;

		  boolean b = p->onEvent(eCode,wParam,dwParam);
		  if(b)
			  break;
	  }
      switch (m_nHallState){
        case HALL_CHOOSE_SEAT:
		  m_nCurrentTableId = (wParam >> 8) & 0xFF;
		  m_nCurrentSeatId = wParam & 0xFF;
		  m_nHallState = HALL_READY_ACTION_LIST;
		  if(m_pIMenu)
			IMENUCTL_SetActive(m_pIMenu, FALSE);
	      break;
        case HALL_CHOOSE_ACTION:
		  switch (wParam){
		    case ACTION_SITDOWN:
		      m_nHallState = HALL_TEST_SITDOWN;
			  break;
			case ACTION_QUERY_USER:
		      m_nHallState = HALL_TEST_QUERY;
			  break;
			case ACTION_QUERY_TABLE:
		      m_nHallState = HALL_TEST_QUERY;
			  break;
			default:
			  break;
		  }
	      IMENUCTL_SetActive(m_pIMenu, FALSE);
	      break;
		case HALL_CHOOSE_QUERY:
		  m_nHallState = HALL_READY_SEAT_LIST;
	      IMENUCTL_SetActive(m_pIMenu, FALSE);
		  break;
	    default:
	      break;
	  }
	  break;
    case EVT_USER:
	  switch (wParam){
	    case SWITCH_INTO:
	      //frame->setCanvas(m_pIHallCanvas);
			SetCanvas(Canvas2);			

		  m_nHallState = HALL_WAIT_SEAT_LIST;
		  m_nHallRunFlag = TRUE;
		  break;
		default:
		  break;
	  }
	  break;
	default:
	  break;
  }
  return;
}

void CBrewHall::onStart(){
}

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

void CBrewHall::onSuspend(){
	if (m_pIMenu != NULL){
		IMENUCTL_Release(m_pIMenu);
		m_pIMenu = NULL;
	}
	if(m_nCurCv != Canvas1)
		((CBrewLoginCanvasBase*)m_pIHallCanvas)->onSuspend();
}

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

void CBrewHall::onPlay(){
  UINT32 timeMS;
  //UINT16 i;
  //UINT16 j;
  //struct SeatItemStruct *cItem;
 // struct UserItemStruct *uItem;
  //AEERect r;
//  UINT16 mId;

  if (m_nHallRunFlag == FALSE)
	return;

  if (frame == NULL)
	return;

  timeMS = ISHELL_GetUpTimeMS(pApp->m_pApp->m_pIShell);
  switch (m_nHallState){
    case HALL_INIT:
	  m_nHallState = HALL_WAIT_SEAT_LIST;
	  break;
	case HALL_WAIT_SEAT_LIST:
	  if ((m_pCList != NULL) && (m_nCCount > 0))
		m_nHallState = HALL_READY_SEAT_LIST;
	  break;
    case HALL_READY_SEAT_LIST:
    case HALL_UPDATE_SEAT_LIST:
		if(m_nCurCv == Canvas1)
		{
			SetCanvas(Canvas2);			
		}
		break;	  
	  break;
    case HALL_CHOOSE_SEAT:
	  break;
	case HALL_READY_ACTION_LIST:	  
	  break;
    case HALL_CHOOSE_ACTION:
	  break;
	case HALL_TEST_SITDOWN:
	  if (frame->sitDown((UINT8)m_nCurrentTableId, (UINT8)m_nCurrentSeatId, 0) == OK)
		m_nHallState = HALL_GET_SITDOWN;
	  break;
	case HALL_GET_SITDOWN:
	  m_nHallState = HALL_WAIT_SITDOWN;
	  m_nWaitSitdownTime = timeMS;
	  break;
    case HALL_WAIT_SITDOWN:
	  if (timeMS > m_nWaitSitdownTime + TIMEOUT)
		//m_nHallState = HALL_GET_SITDOWN;
	  {
		  if(m_nCurCv == Canvas2)
		  {
			  CBrewHallCanvas2 *p = (CBrewHallCanvas2*)m_pIHallCanvas;
			  p->TimeOut();
		  }
		  m_nHallState = HALL_CHOOSE_SEAT;
	  }
	  break;
	case HALL_TEST_QUERY:
	  if (m_nCurrentTableId == 0){
		m_nHallState = HALL_WAIT_SEAT_LIST;
	  }else{
		if (frame->queryTable((UINT8)m_nCurrentTableId, (UINT8)m_nCurrentSeatId) == OK){
		  //clearUserList();
		  m_nHallState = HALL_GET_QUERY;
		}
	  }
	  break;
	case HALL_GET_QUERY:
	  m_nHallState = HALL_WAIT_QUERY;
	  m_nWaitQueryTime = timeMS;
	  break;
    case HALL_WAIT_QUERY:
	  if (timeMS > m_nWaitQueryTime + TIMEOUT)
		//m_nHallState = HALL_GET_QUERY;
	  {
		  if(m_nCurCv == Canvas2)
		  {
			  CBrewHallCanvas2 *p = (CBrewHallCanvas2*)m_pIHallCanvas;
			  p->TimeOut();
		  }
		  m_nHallState = HALL_CHOOSE_SEAT;
	  }
	  break;
	case HALL_READY_QUERY:
		break;	  
	  break;
    case HALL_CHOOSE_QUERY:
	  break;
	default:
	  break;
  }
}

struct SeatItemStruct *CBrewHall::findSeatItem(UINT16 tableId, UINT16 seatId){
  UINT16 i;
  struct SeatItemStruct *cItem;

  cItem = m_pCList;
  for (i = 0; i < m_nCCount; i ++){
	if (cItem == NULL)
	  return NULL;
	if ((cItem->seatItem.tableId == tableId) && (cItem->seatItem.seatId == seatId))
	  return cItem;
	cItem = cItem->seatNext;
  }
  return NULL;
}

void CBrewHall::Release(){
  delete this;
}

IBrewHall *CreateBrewHall(){
  return (IBrewHall *)new CBrewHall();
}

void CBrewHall::SetCanvas(CURRENTCANVAS ci)
{
	if (m_pIHallCanvas != NULL)
	{
		m_pIHallCanvas->Release();
		m_pIHallCanvas = NULL;
	}
	switch(ci)
	{
	case Canvas1:
		m_pIHallCanvas = CreateHallCanvas();
		break;
	case Canvas2:
		m_pIHallCanvas = CreateHallCanvas2();
		break;
	//case WaitCanvas:
	//		m_pIHallCanvas = CreateWaitingCanvas();
	//		break;	
	
	}		
	
	if (m_pIHallCanvas != NULL)
	{
		m_pIHallCanvas->setFrame(this);
		frame->setCanvas(m_pIHallCanvas);
		m_nCurCv = ci;
	}
}