square.c

手机8032的完整代码。吐血推荐。小做改动就可以生产。

          // bfgTotal[bSquareData[bSquareType][j].y + rNowSquarePos.y]| = 1 << (bSquareData[bSquareType][j].x + rNowSquarePos.x);
        }

        //judge full
        vJudgeFull();

        if (_wSqScore >= rGameLevel[_bGameGrade].wScoreThreshold)
        {
          //Timer1 - > Enabled = FALSE;
          _fgGameStart = FALSE;
          _fgGmTmEnb = FALSE;
          vChgGameState(SQ_DIALOG_STATE);
          vChgGameSubState(SQ_DIALOG_NEXT_STATE);
          vSquareShowDialog();
        #ifdef OSD_GAME_SOUND
          vGameDelayMs(10);
          vSendUopCmd(UOP_AUDIO_CLIP, SV_ACLIP_FLASH, CLIP_WIN, 0);
          _bGameSndId = 0xFF;
          _bGameSndTimer = 75;
        #endif
          return;
        }

        for (j = 0; j < MAX_WIDTH; j++)
        {
          if (bReadSQMap(j, 0) != SHP_EMPTY)
          {
            _fgGameStart = FALSE;
            _fgGmTmEnb = FALSE;
            vChgGameState(SQ_DIALOG_STATE);
            vChgGameSubState(SQ_DIALOG_AGAIN_STATE);
            vSquareShowDialog();
          #ifdef OSD_GAME_SOUND
            vGameDelayMs(10);
            vSendUopCmd(UOP_AUDIO_CLIP, SV_ACLIP_FLASH, CLIP_LOSE, 0);
            _bGameSndId = 0xFF;
            _bGameSndTimer = 75;
          #endif
            return;
          }
        }

        return;
      }
    }
  }
}


static void vSquareDrop(void) large
{
  vJudgeY();

  //when press down key please ignore the step??
  if (_fgGameStart && _fgGmTmEnb)
  {
    vOsdClrWorkSquare();
    if (!_fgSquareInit)
    {
      _rNowSquarePos.y++;
    }
    if (!_fgDownKey || _fgSquareInit)
    {
      vOsdDrawSquare(_bSquareType);
    }
  }
}


static BOOL  fgJudgeLeft(void) large
{
  BOOL fgLeftEnable = FALSE;
  BYTE i;

  for (i = 0; i < 4; i++)
  {
    if ( (_rNowSquarePos.x <= 0)
      || (bReadSQMap(rSquareData[_bSquareType][i].x + _rNowSquarePos.x - 1,
                     rSquareData[_bSquareType][i].y + _rNowSquarePos.y) != SHP_EMPTY) )
    {
      fgLeftEnable = FALSE;
      return fgLeftEnable;
    }
  }

  fgLeftEnable = TRUE;
  return  fgLeftEnable;
}


static BOOL fgJudgeRight(void) large
{
  BOOL fgRightEnable = FALSE;
  BYTE i;

  for (i = 0; i < 4; i++)
  {
    if ( (_rNowSquarePos.x + rSquareSize[_bSquareType].Width == MAX_WIDTH)
      || (bReadSQMap(rSquareData[_bSquareType][i].x + _rNowSquarePos.x + 1,
                     rSquareData[_bSquareType][i].y + _rNowSquarePos.y) != SHP_EMPTY) )
    {
      fgRightEnable = FALSE;
      return fgRightEnable;
    }
  }

  fgRightEnable = TRUE;
  return  fgRightEnable;
}


static BOOL fgSQMenuState(void) large
{
  BOOL fgRet = TRUE;

  switch (_bIRKey)
  {
    case IR_UP:
    {
      if (_bGameItem < SQ_MENU_MAX)
      {
        vHiliSquareMenuItem(_bGameItem, FALSE);
        _bGameItem++;
        vHiliSquareMenuItem(_bGameItem, ITEM_HILI);
      }
      break;
    }
    case IR_DOWN:
    {
      if (_bGameItem > 0)
      {
        vHiliSquareMenuItem(_bGameItem, FALSE);
        _bGameItem--;
        vHiliSquareMenuItem(_bGameItem, ITEM_HILI);
      }
      break;
    }
    case IR_LEFT:
    case IR_PREV:
    {
      if ((SQ_MENU_GRADE == _bGameItem) && (_bGameGrade > 0))
      {
        _bGameGrade--;
        vHiliSquareMenuItem(_bGameItem, TRUE);
      }
      break;
    }
    case IR_RIGHT:
    case IR_NEXT:
    {
      if ((SQ_MENU_GRADE == _bGameItem) && (_bGameGrade < GAME_SQ_GRADE_MAX))
      {
        _bGameGrade++;
        vHiliSquareMenuItem(_bGameItem, TRUE);
      }
      break;
    }
    case IR_PLAY:
    case IR_ENTER:
    case IR_PLAY_ENTER:
    {
      switch (_bGameItem)
      {
        case SQ_MENU_START:
        {
          vChgGameState(SQ_PLAY_STATE);
          vGameSQNewTurnInit();
          vInitSquare();
          _fgGameStart = TRUE;
          _fgGmTmEnb = TRUE;
          vGameSQOsdRecover();
          vSquareShowInfo(SQ_INFO_PLAYING);
        #ifdef OSD_GAME_SOUND
          vGameDelayMs(10);
          vSendUopCmd(UOP_AUDIO_CLIP, SV_ACLIP_FLASH, CLIP_START, 0);
          _bGameSndId = 0xFF;
          _bGameSndTimer = 75;
        #endif
          break;
        }
        case SQ_MENU_GRADE:
        {
          break;
        }
        default:
        {
          break;
        }
      }
      break;
    }
    case IR_TITLE_MENU:
    case IR_ROOT_MENU:
    {
    #ifdef OSD_GAME_MAIN_MENU
      vChangeInputState(INPUT_STATE_OSD_GAME_MAIN_MENU, FALSE);
    #endif
      break;
    }
    default:
    {
      break;
    }
  }

  return fgRet;
}


static BOOL fgSQPlayState(void) large
{
  BOOL fgRet = TRUE;

  switch (_bIRKey)
  {
    case IR_LEFT:
    {
      if (_fgGameStart && _fgGmTmEnb)
      {
        if (fgJudgeLeft())
        {
          vOsdClrWorkSquare();
          _rNowSquarePos.x--;
          vOsdDrawSquare(_bSquareType);
        }
      }
      break;
    }
    case IR_RIGHT:
    {
      if (_fgGameStart && _fgGmTmEnb)
      {
        if (fgJudgeRight())
        {
          vOsdClrWorkSquare();
          _rNowSquarePos.x++;
          vOsdDrawSquare(_bSquareType);
        }
      }
      break;
    }
    case IR_UP:
    {
      if (_fgGameStart && _fgGmTmEnb)
      {
        vOsdClrWorkSquare();
        if (fgJudgeRotate())
        {
          _bRotate++;
        #if  0 // #ifdef OSD_GAME_SOUND
          if (_bGameSndTimer == 0)
          {
            _bGameSndId = CLIP_ROTATE;
          }
        #endif
        }
        _bSquareType = bGetSquareType(_bRotate, _bNowShape);
        vOsdDrawSquare(_bSquareType);
        // The rotate operation is too busy! the sound need so much time, so disable it!
        #if  0  // #ifdef OSD_GAME_SOUND
        if (_bGameSndId < CLIP_NS)
        {
          if (_bGameSndTimer == 0)
          {
            vGameDelayMs(10);
            vSendUopCmd(UOP_AUDIO_CLIP, SV_ACLIP_FLASH, CLIP_ROTATE, 0);
            _bGameSndTimer = 15;
            _bGameSndId = 0xFF;
          }
        }
        #endif
      }
      break;
    }
    case IR_DOWN:
    {
      if (_fgGameStart && _fgGmTmEnb && !_fgDownKey && !_fgSquareInit)
      {
      #ifdef OSD_GAME_SOUND
        if (_bGameSndTimer == 0)
        {
          vSendUopCmd(UOP_AUDIO_CLIP, SV_ACLIP_FLASH, CLIP_FAST, 0);
          _bGameSndId = 0xFF;
          _bGameSndTimer = 15;
        }
      #endif
        _fgDownKey = TRUE;
        while(_fgDownKey)
        {
          vSquareDrop();  //force the timer is interrupt;
        }
      }
      break;
    }
    case IR_PAUSE:
    case IR_PLAY_PAUSE:
    {
      if(_fgGmTmEnb)
      {
        _fgGmTmEnb = FALSE;
        vSquareShowInfo(SQ_INFO_PAUSE);
      }
      else
      {
        _fgGmTmEnb = TRUE;
        vSquareShowInfo(SQ_INFO_PLAYING);
      }
      break;
    }
    case IR_PLAY:
    case IR_ENTER:
    case IR_PLAY_ENTER:
    {
      if(!_fgGmTmEnb)
      {
        _fgGmTmEnb = TRUE;
        vSquareShowInfo(SQ_INFO_PLAYING);
      }
      break;
    }
    case IR_TITLE_MENU:
    {
      _fgGameStart = FALSE;
      _fgGmTmEnb = FALSE;
      vChgGameState(SQ_MENU_STATE);
      vGameSQNewTurnInit();
      vGameSQOsdRecover();
      vHiliSquareMenuItem(_bGameItem, ITEM_HILI);
      break;
    }
    case IR_ROOT_MENU:
    {
    #ifdef OSD_GAME_MAIN_MENU
      vChangeInputState(INPUT_STATE_OSD_GAME_MAIN_MENU, FALSE);
    #endif
      break;
    } 
  }

  return fgRet;
}


static BOOL fgSQDialogState(void) large
{
  BOOL fgRet = TRUE;

  switch (_bIRKey)
  {
    case IR_LEFT:
    {
      if (_bGameItem > 0)
      {
        vHiliSquareDialogItem(_bGameItem, FALSE);
        _bGameItem--;
        vHiliSquareDialogItem(_bGameItem, TRUE);
      }
      break;
    }
    case IR_RIGHT:
    {
      if (_bGameItem < 1)
      {
        vHiliSquareDialogItem(_bGameItem, FALSE);
        _bGameItem++;
        vHiliSquareDialogItem(_bGameItem, TRUE);
      }
      break;
    }
    case IR_PLAY:
    case IR_ENTER:
    case IR_PLAY_ENTER:
    {
      if (0 == _bGameItem)
      {
        if(SQ_DIALOG_NEXT_STATE == _bGameSubState)
        {
          if (_bGameGrade < GAME_SQ_GRADE_MAX)
          {
            _bGameGrade++;
          }
          else
          {
            _bGameGrade = 0;
          }
        }
        vChgGameState(SQ_PLAY_STATE);
        vSquareShowInfo(SQ_INFO_ALL2);
        vGameSQNewTurnInit();
        vInitSquare();
        _fgGameStart = TRUE;
        _fgGmTmEnb = TRUE;
        vGameSQOsdRecover();
        vSquareShowInfo(SQ_INFO_PLAYING);
      }
      else
      {
        _fgGameStart = FALSE;
        _fgGmTmEnb = FALSE;
        vChgGameState(SQ_MENU_STATE);
        vGameSQNewTurnInit();
        vGameSQOsdRecover();
        vHiliSquareMenuItem(_bGameItem, ITEM_HILI);
      }
    }
    default:
    {
      break;
    }
  }

  return fgRet;
}

///////////////////////////////////////////////////////////////////////////////

void vSetSQMap(BYTE bx, BYTE by, BYTE bValue) large
{
  vSetSharedInfo((SI_GAME_SQ_MAP_START + (WORD)bx + (WORD)by * MAX_WIDTH), bValue);
}


BYTE bReadSQMap(BYTE bx, BYTE by) large
{
  return bSharedInfo(SI_GAME_SQ_MAP_START + (WORD)bx + (WORD)by * MAX_WIDTH);
}


BYTE bGetSquareType(BYTE bRotate, BYTE bShape) large
{
  BYTE bSquareType;

  switch (bShape)
  {
    case SHP_LONG_BAR:
      bSquareType = (bRotate % 2) + SHP_BAR_SA;
      break;
    case SHP_TWO:
      bSquareType = (bRotate % 2) + SHP_TWO_SA;
      break;
    case SHP_SEVEN:
      bSquareType = (bRotate % 4) + SHP_SEVEN_SA;
      break;
    case SHP_T:
      bSquareType = (bRotate % 4) + SHP_T_SA;
      break;
    case SHP_RE_SEVEN:
      bSquareType = (bRotate % 4) + SHP_RE_SEVEN_SA;
      break;
    case SHP_RE_TWO:
      bSquareType = (bRotate % 2) + SHP_RE_TWO_SA;
      break;
    case SHP_SQUARE:
      bSquareType = SHP_SQUARE_SA;
      break;
  }

  return bSquareType;
}


void vGameSQTimer(void) large
{
  if ( (_bInputState == INPUT_STATE_OSD_GAME_TETRIS) 
    && (_bGameState == SQ_PLAY_STATE) 
  #ifdef OSD_GAME_SOUND
    && (_bGameSndTimer == 0)
  #endif
    && _fgGameStart 
    && _fgGmTmEnb )
  {
    _bGameSqTimer++;
    if (_bGameSqTimer >= rGameLevel[_bGameGrade].bTimerInterval)
    {
      _bGameSqTimer = 0;
      if (!_fgDownKey)
      {
        vSquareDrop();
      }
    }
  }
}

///////////////////////////////////////////////////////////////////////////////

void vGameSQStateInit(void) large
{
  vGameSQVarInit();
  vGameSQNewTurnInit();
  vGameSQShowInit();
}


BOOL fgGameSQState(void) large
{
  BOOL fgRet = TRUE;

#ifdef OSD_GAME_SOUND
  if (_bGameSndTimer != 0)
  {
    _bIRKey = IR_NONE;
    return fgRet;
  }
#endif

  switch (_bIRKey)
  {
    case IR_GAME:
    {
      vGameClose();
      return TRUE;
    }
    default:
    {
      break;
    }
  }

  switch (_bGameState)
  {
    case SQ_MENU_STATE:
    {
      fgRet = fgSQMenuState();
      break;
    }
    case SQ_PLAY_STATE:
    {
      fgRet = fgSQPlayState();
      break;
    }
    case SQ_DIALOG_STATE:
    {
      fgRet = fgSQDialogState();
      break;
    }
    default:
    {
      break;
    }
  }

  _bIRKey = IR_NONE;
  return fgRet;
}


void vGameSQExit(void) large
{
  vDeleteWB(WB_OSD_GAME);
  vOsdSetSt(OSD_ST_NML);
}

///////////////////////////////////////////////////////////////////////////////
#endif