message.cpp

分布式坦克游戏

    return m_MsgSizeArr[ADD_BONUS];
}

void            
CMessage::DecodeAddBonus (PBYTE pData)
{
    m_UnionData.BonusParam = *((BonusParamTag *)pData);
    ASSERT (BonusType(m_UnionData.BonusParam.Type) < NUM_BONUSES);
}


DWORD            
CMessage::EncodeAddTank (PBYTE pData) const
{
    ASSERT (m_UnionData.TankParam.ShieldLevel < 101);
    ASSERT (m_UnionData.TankParam.Direction < 24);

    *((TankParamTag*)pData) = m_UnionData.TankParam;
    return m_MsgSizeArr[ADD_TANK];
}

void            
CMessage::DecodeAddTank (PBYTE pData)
{
    m_UnionData.TankParam = *((TankParamTag*)pData);
    ASSERT (m_UnionData.TankParam.ShieldLevel < 101);
    ASSERT (m_UnionData.TankParam.Direction < 24);
}

DWORD            
CMessage::EncodeAddBoard (PBYTE pData) const
{
    ASSERT (m_UnionData.BoardParam.Seed < 0xFFFF);
    ASSERT (m_UnionData.BoardParam.Complexity < 0x001F);

    *((BoardParamTag *)pData) = m_UnionData.BoardParam;
    return m_MsgSizeArr[ADD_BOARD];
}

void            
CMessage::DecodeAddBoard (PBYTE pData)
{
    m_UnionData.BoardParam = *((BoardParamTag *)pData);
}

DWORD            
CMessage::EncodeRemoveTank (PBYTE pData) const
{
    *((TankRemoveParamTag *)pData) = m_UnionData.TankRemoveParam;
    return m_MsgSizeArr[REMOVE_TANK];
}

void            
CMessage::DecodeRemoveTank (PBYTE pData)
{
    m_UnionData.TankRemoveParam = *((TankRemoveParamTag *)pData);
}


DWORD           
CMessage::EncodeSetTankStatus (PBYTE pBuffer) const
{
    *(TankStatusParamTag*)pBuffer = m_UnionData.TankStatusParam;
    return m_MsgSizeArr[SET_TANK_STATUS];
}

void
CMessage::DecodeSetTankStatus (PBYTE pBuffer)
{
    m_UnionData.TankStatusParam = *((TankStatusParamTag *)pBuffer);
}

DWORD
CMessage::EncodeSetTankPos (PBYTE pBuffer) const
{
    *(TankPosParamTag*)pBuffer = m_UnionData.TankPosParam;
    return m_MsgSizeArr[SET_TANK_POS];
}

void
CMessage::DecodeSetTankPos (PBYTE pBuffer)
{
    m_UnionData.TankPosParam = *(TankPosParamTag*)pBuffer;
}

DWORD
CMessage::EncodeSetTankZombie (PBYTE pBuffer) const
{
    *(TankZombieParamTag*)pBuffer = m_UnionData.TankZombieParam;
    return m_MsgSizeArr[SET_TANK_ZOMBIE];
}

void
CMessage::DecodeSetTankZombie (PBYTE pBuffer)
{
    m_UnionData.TankZombieParam = *(TankZombieParamTag*)pBuffer;
}

DWORD            
CMessage::EncodeCheckSum (PBYTE pData) const
{
    ASSERT (m_UnionData.CheckSumParam.NumberOfTanks <= 4);
    ASSERT ((m_UnionData.CheckSumParam.ActiveBonusType >= BONUS_NONE) &&
            (m_UnionData.CheckSumParam.ActiveBonusType < NUM_BONUSES));

    PBYTE pb = pData;
    // First, do fixed part:
    FixedSizeChkSumType *p = (FixedSizeChkSumType *)pb;
    p->Header.NumberOfTanks     = m_UnionData.CheckSumParam.NumberOfTanks;
    p->Header.DeadHostReport    = BYTE(m_UnionData.CheckSumParam.DeadHostReport ? 1 : 0);
    p->Header.ActiveBonusType   = BYTE(m_UnionData.CheckSumParam.ActiveBonusType);
    p->Header.XPos              = m_UnionData.CheckSumParam.XPos;
    p->Header.YPos              = m_UnionData.CheckSumParam.YPos;
        // Encode sector mines checksums:
    int sect = 0;
    for (int i=0; i<8; i++)
    {
        p->MinesSectorsChkSum[i].LoNibble = BYTE((m_UnionData.CheckSumParam.MinesSectorsChkSum[sect++]) & 0x0F);
        p->MinesSectorsChkSum[i].HiNibble = BYTE((m_UnionData.CheckSumParam.MinesSectorsChkSum[sect++]) & 0x0F);
    }

    // Encode tanks - variable part:

    pb += sizeof (FixedSizeChkSumType);
    for (i=0; i<4; i++)
        if (m_UnionData.CheckSumParam.TanksChkSums[i].TankExists)
        {   // i'th tank exists
            // Tank's encoding includes tank's ID
            SingleTankChkSumType *p = (SingleTankChkSumType *)pb;

            p->TankID   = i;
            p->Zombie   = m_UnionData.CheckSumParam.TanksChkSums[i].Zombie;
            p->Shells   = m_UnionData.CheckSumParam.TanksChkSums[i].Shells;
            p->Bullets  = m_UnionData.CheckSumParam.TanksChkSums[i].Bullets;
            p->Mines    = m_UnionData.CheckSumParam.TanksChkSums[i].Mines;
            p->FastFire = m_UnionData.CheckSumParam.TanksChkSums[i].FastFire;
            pb += sizeof (SingleTankChkSumType);
        }

    // Return true (varaible) message size    
    DWORD dwMsgSize = sizeof (FixedSizeChkSumType) + 
                      m_UnionData.CheckSumParam.NumberOfTanks * sizeof (SingleTankChkSumType);
    ASSERT (pb == pData+dwMsgSize);
    return dwMsgSize + 5;   // Including message header
}

void            
CMessage::DecodeCheckSum (PBYTE pData)
{
    FixedSizeChkSumType *p = (FixedSizeChkSumType *)pData;
    m_UnionData.CheckSumParam.NumberOfTanks     = p->Header.NumberOfTanks;
    m_UnionData.CheckSumParam.DeadHostReport    = p->Header.DeadHostReport;
    m_UnionData.CheckSumParam.ActiveBonusType   = BonusType(p->Header.ActiveBonusType);
    m_UnionData.CheckSumParam.XPos = p->Header.XPos;
    m_UnionData.CheckSumParam.YPos = p->Header.YPos;
        // Decode sector mines checksums:
    int sect = 0;
    for (int i=0; i<8; i++)
    {
        m_UnionData.CheckSumParam.MinesSectorsChkSum[sect++] = p->MinesSectorsChkSum[i].LoNibble;
        m_UnionData.CheckSumParam.MinesSectorsChkSum[sect++] = p->MinesSectorsChkSum[i].HiNibble;
    }

    ASSERT (m_UnionData.CheckSumParam.NumberOfTanks <= 4);
    ASSERT ((m_UnionData.CheckSumParam.ActiveBonusType >= BONUS_NONE) &&
            (m_UnionData.CheckSumParam.ActiveBonusType < NUM_BONUSES));

    // Decode tanks - variable part:
    // Clear all tanks data
    memset (m_UnionData.CheckSumParam.TanksChkSums,
            0,
            sizeof (CheckSumParamTag::TankCheckSumParamTag) * MAX_TANKS);

    pData += sizeof (FixedSizeChkSumType);
    for (i=0; i<m_UnionData.CheckSumParam.NumberOfTanks; i++)
    {
        SingleTankChkSumType *p = (SingleTankChkSumType *)pData;
        BYTE bTankID = BYTE(p->TankID);  // Get tank ID
        ASSERT (bTankID < 4);
        m_UnionData.CheckSumParam.TanksChkSums[bTankID].TankExists  = TRUE;
        m_UnionData.CheckSumParam.TanksChkSums[bTankID].Zombie      = p->Zombie;
        m_UnionData.CheckSumParam.TanksChkSums[bTankID].Shells      = WORD(p->Shells);
        m_UnionData.CheckSumParam.TanksChkSums[bTankID].Bullets     = WORD(p->Bullets);
        m_UnionData.CheckSumParam.TanksChkSums[bTankID].Mines       = WORD(p->Mines);
        m_UnionData.CheckSumParam.TanksChkSums[bTankID].FastFire    = p->FastFire;
        pData += sizeof (SingleTankChkSumType);
    }
}

DWORD
CMessage::EncodeChat (PBYTE pData) const
{
    *pData++ = m_UnionData.ChatParam.TankID;
    PDWORD pdw = (PDWORD)pData;
    *pdw++ = m_UnionData.ChatParam.idFrom;
    pData = (PBYTE)pdw;
    strcpy ((char *)pData, m_UnionData.ChatParam.Msg);
    return DWORD(sizeof (m_UnionData.ChatParam) -           // Entire message
                 sizeof (m_UnionData.ChatParam.Msg) +       // Leave const size
                 strlen(m_UnionData.ChatParam.Msg) + 1 +    // Variable string 
                 MSG_HEADER_SIZE);                          // Msg header
}
 
void
CMessage::DecodeChat (PBYTE pData)
{
    m_UnionData.ChatParam.TankID = *pData++;
    m_UnionData.ChatParam.idFrom = *((PDWORD)(pData));
    pData+=sizeof(DWORD);

    // Assert msg length :
    int len = strlen ((char *)pData);

    ASSERT (len <= MAX_CHAT_MSG_LEN);
    if (len > MAX_CHAT_MSG_LEN) 
    {   // Chop string at last available char:
        pData[MAX_CHAT_MSG_LEN] = '\0';
        len = MAX_CHAT_MSG_LEN;
    }
    strcpy (m_UnionData.ChatParam.Msg, (char *)pData);
}

/* Special case - static mines per sector encoding / decoding functions : */

DWORD 
CMessage::EncodeSectorMines (PBYTE pData, int iSector, DWORD dwMinesFound, DWORD *pAllMinesInSector)
{
    pData[0] = BYTE(iSector);
    pData[1] = BYTE(dwMinesFound);
    DWORD dwDataSize = dwMinesFound * sizeof (DWORD);
    memcpy (&pData[2], pAllMinesInSector, dwDataSize);
    return dwDataSize + 2;
}

DWORD 
CMessage::DecodeSectorMines (PBYTE pData, DWORD dwBufferSize, int &iSector, DWORD *pAllMinesInSector)
{
    ASSERT (dwBufferSize >= 2);
    iSector = int(pData[0]);

    DWORD dwMinesFound = DWORD(pData[1]);
    DWORD dwDataSize = dwMinesFound * sizeof (DWORD);
    ASSERT (dwBufferSize == dwDataSize + 2);
    memcpy (pAllMinesInSector, &pData[2], dwDataSize);
    return dwMinesFound;

    UNREFERENCED_PARAMETER(dwBufferSize);
}

/* End of special case - static mines per sector encoding / decoding functions */


#ifdef NET_MON_GAME
char *
CMessage::GetName()
{   // Get message name
    return CMessage::GetName (BYTE(m_Type));
}
char *
CMessage::GetName(BYTE bID)
{   // Get message name (static)
    switch (bID)
    {
        case ADD_BONUS:
            return "ADD_BONUS";
        case ADD_TANK:
            return "ADD_TANK";
        case ADD_BOARD:
            return "ADD_BOARD";
        case ADD_BOMBER:
            return "ADD_BOMBER";
        case REMOVE_TANK:
            return "REMOVE_TANK";
        case MANOUVER_SET:
            return "MANOUVER_SET";
        case SET_TANK_STATUS:
            return "SET_TANK_STATUS";
        case SET_TANK_POS:
            return "SET_TANK_POS";
        case REQUEST_TANK:
            return "REQUEST_TANK";
        case CHECK_SUM:
            return "CHECK_SUM";
        case ADD_OBJECT:
            return "ADD_OBJECT";
        case ADD_SHELL:
            return "ADD_SHELL";
        case ADD_BULLET:
            return "ADD_BULLET";
        case ADD_GAME_OVER:
            return "ADD_GAME_OVER";
        case 0xff:
            return "PING";
        default:
            return "unknown";
    }
}

#endif  NET_MON_GAME



#pragma pack (pop)