Example #1
0
BOOL KGym::DirectEndUseEquipRequest(DWORD dwHeroTemplateID)
{
	BOOL bResult  = false;
	BOOL bRetCode = false;
    int  nCoin    = 0;
    KUSING_EQUIP_INFO* pEquipInfo = NULL;

    pEquipInfo = GetHeroUsingEquipInfo(dwHeroTemplateID);
    KGLOG_PROCESS_ERROR(pEquipInfo);

    KGLOG_PROCESS_ERROR(pEquipInfo->nEndTime > g_pSO3World->m_nCurrentTime);

    nCoin =  ((pEquipInfo->nEndTime - g_pSO3World->m_nCurrentTime + SECONDS_PER_MINUTE) / SECONDS_PER_MINUTE) * 
        g_pSO3World->m_Settings.m_ConstList.nGymCoinPerMinute;

    // request to paysys
	{
	    KCUSTOM_CONSUME_INFO CCInfo;
	    memset(&CCInfo, 0, sizeof(KCUSTOM_CONSUME_INFO));

	    CCInfo.nValue1 = (int)dwHeroTemplateID;
	    bRetCode = g_pSO3World->m_ShopMgr.DoCustomConsumeRequest(m_pPlayer, uctDirectEndUseEquip, nCoin, &CCInfo);
	    KGLOG_PROCESS_ERROR(bRetCode);
	}

    PLAYER_LOG(m_pPlayer, "clearcd,herogym,%d,%d,%d", m_nEquipLevel, (pEquipInfo->nEndTime - g_pSO3World->m_nCurrentTime), nCoin);

	bResult = true;
Exit0:
	return bResult;
}
void KCollisionMgr::OnGoldCollisionHero(KSceneObject* pSource, KSceneObject* pDest)
{
    BOOL            bRetCode        = false;
    KGold*          pGold           = NULL;
    KHero*          pHero           = NULL;
    KMission*       pMission        = NULL;    
    KPlayer*        pPlayer         = NULL;
    int             nMoney          = 0;
    std::vector<KHero*> vecAllTeammate;
    std::vector<KPlayer*> vecPlayer;
    
    KG_PROCESS_ERROR(!pSource->IsToBeDelete());
    assert(pSource->GetType() == sotGold);
    pGold = (KGold*)pSource;
    nMoney = pGold->GetMoney(); 
    assert(nMoney > 0);

    KG_PROCESS_ERROR(pGold->CanGetAward());

    assert(pDest->GetType() == sotHero);
    pHero = (KHero*)pDest;

    KG_PROCESS_ERROR(pHero->IsMainHero());

    vecPlayer.push_back(pHero->GetOwner());

    m_pScene->GetAllTeammate(pHero, vecAllTeammate);

    for (size_t i = 0; i < vecAllTeammate.size(); ++i)
    {
        pHero = vecAllTeammate[i];
        KGLOG_PROCESS_ERROR(pHero);
        if (pHero->IsMainHero())
            vecPlayer.push_back(pHero->GetOwner());
    }

    for (size_t i = 0; i < vecPlayer.size(); ++i)
    {
        pPlayer = vecPlayer[i];
        pPlayer->m_MoneyMgr.AddMoney(emotMoney,nMoney);
        PLAYER_LOG(pPlayer, "money,addmoney,%d,%s,%d-%d,%d,%d", emotMoney, "PickGold", 0, 0, 0, nMoney);
    }

    m_pScene->RemoveSceneObject(pGold);

Exit0:
    return;
}
Example #3
0
KAWARD_ITEM*  KAwardMgr::AwardRandomOne(KPlayer* pPlayer, DWORD dwAwardTableID)
{
    BOOL            bRetCode        = false;
    IItem*          pItem           = NULL;
    KAwardTable*    pAwardTable     = NULL;
    KAWARD_ITEM*    pAwardItem      = NULL;
    int             nValuePoint = 0;

    assert(pPlayer);

    bRetCode = HasEnoughBagToAwardRandomOne(pPlayer, dwAwardTableID);
    KGLOG_PROCESS_ERROR(bRetCode);

    pAwardTable = GetAwardTable(dwAwardTableID);
    KGLOG_PROCESS_ERROR(pAwardTable);

    pAwardItem = pAwardTable->GetRandomAward();
    if (pAwardItem)
    {
        if (pAwardItem->dwTabType == ittOther || pAwardItem->dwTabType == ittEquip)
        {
            bRetCode = GetAwardItemValuePoint(pAwardItem, nValuePoint);
            KGLOG_PROCESS_ERROR(bRetCode);

            pItem = pPlayer->AddItem(pAwardItem->dwTabType, pAwardItem->dwIndex, pAwardItem->nStackNum, nValuePoint);
            if (pItem)
            {
                PLAYER_LOG(
                    pPlayer, "item,additem,%u-%u,%d,%d,%d,%s,%d",
                    pAwardItem->dwTabType, pAwardItem->dwIndex, pAwardItem->nStackNum, nValuePoint, pItem->GetQuality(),
                    "useitem", pPlayer->m_dwMapID
                );
            }
        }
        else if (pAwardItem->dwTabType == ittFashion)
        {
            bRetCode = pPlayer->m_Wardrobe.AddFashion(pAwardItem->dwIndex);
            KGLOG_CHECK_ERROR(bRetCode);
        }
        else if (pAwardItem->dwTabType == ittCheerleading)
        {
            KGCheerleadingInfo* pCheerleadingInfo = g_pSO3World->m_ItemHouse.GetCheerleadingInfo(pAwardItem->dwIndex);
            KGLOG_PROCESS_ERROR(pCheerleadingInfo);

            bRetCode = pPlayer->m_CheerleadingMgr.AddCheerleading(pCheerleadingInfo->dwID);
            KGLOG_PROCESS_ERROR(bRetCode);
        }
        else if (pAwardItem->dwTabType == ittTeamLogo)
        {
            KTEAM_LOGO_INFO*    pTeamLogoInfo = NULL;

            pTeamLogoInfo = g_pSO3World->m_ItemHouse.GetTeamLogoInfo(pAwardItem->dwIndex);
            KGLOG_PROCESS_ERROR(pTeamLogoInfo);

            bRetCode = pPlayer->AddTeamLogo((WORD)pTeamLogoInfo->nID);
            KGLOG_PROCESS_ERROR(bRetCode);
        }
        else if (pAwardItem->nMoney > 0)
        {
            bRetCode = pPlayer->m_MoneyMgr.AddMoney(pAwardItem->eMoneyType, pAwardItem->nMoney);
            KGLOG_PROCESS_ERROR(bRetCode);
            PLAYER_LOG(pPlayer, "money,addmoney,%d,%s,%d-%d,%d,%d", pAwardItem->eMoneyType, "useitem", 0, 0, 0, pAwardItem->nMoney);
        }
    }

Exit0:
    return pAwardItem;
}
Example #4
0
BOOL KAwardMgr::AwardAll(KPlayer* pPlayer, DWORD dwAwardTableID, const char szWayID[])
{
    BOOL bResult = false;
    BOOL bRetCode = false;
    KAwardTable* pAwardTable = NULL;
    int nValuePoint = 0;

    assert(szWayID);

    KGLOG_PROCESS_ERROR(pPlayer);
    KGLOG_PROCESS_ERROR(dwAwardTableID);

    pAwardTable = GetAwardTable(dwAwardTableID);
    KGLOG_PROCESS_ERROR(pAwardTable);

    bRetCode = HasEnoughBagToAwardAll(pPlayer, dwAwardTableID);
    KGLOG_PROCESS_ERROR(bRetCode);

    for (KAWARD_ITEM_MAP::iterator it = pAwardTable->m_mapAwardItem.begin(); it != pAwardTable->m_mapAwardItem.end(); ++it)
    {
        KAWARD_ITEM* pAwardItem = &it->second;
        if (pAwardItem->dwTabType == ittOther || pAwardItem->dwTabType == ittEquip)
        {
			IItem* pItem = NULL;

            bRetCode = GetAwardItemValuePoint(pAwardItem, nValuePoint);
            KGLOG_PROCESS_ERROR(bRetCode);

            pItem = pPlayer->AddItem(pAwardItem->dwTabType, pAwardItem->dwIndex, pAwardItem->nStackNum, nValuePoint);
            if (pItem)
            {
                PLAYER_LOG(
                    pPlayer, "item,additem,%u-%u,%d,%d,%d,%s,%d",
                    pAwardItem->dwTabType, pAwardItem->dwIndex, pAwardItem->nStackNum, nValuePoint, pItem->GetQuality(),
                    szWayID, pPlayer->m_dwMapID
                );
            }
        }
        else if (pAwardItem->dwTabType == ittFashion)
        {
            bRetCode = pPlayer->m_Wardrobe.AddFashion(pAwardItem->dwIndex);
            KGLOG_CHECK_ERROR(bRetCode);
        }
        else if (pAwardItem->dwTabType == ittCheerleading)
        {
            KGCheerleadingInfo* pCheerleadingInfo = g_pSO3World->m_ItemHouse.GetCheerleadingInfo(pAwardItem->dwIndex);
            KGLOG_PROCESS_ERROR(pCheerleadingInfo);

            bRetCode = pPlayer->m_CheerleadingMgr.AddCheerleading(pCheerleadingInfo->dwID);
            KGLOG_PROCESS_ERROR(bRetCode);
        }
        else if (pAwardItem->dwTabType == ittTeamLogo)
        {
            KTEAM_LOGO_INFO*    pTeamLogoInfo = NULL;

            pTeamLogoInfo = g_pSO3World->m_ItemHouse.GetTeamLogoInfo(pAwardItem->dwIndex);
            KGLOG_PROCESS_ERROR(pTeamLogoInfo);

            bRetCode = pPlayer->AddTeamLogo((WORD)pTeamLogoInfo->nID);
            KGLOG_PROCESS_ERROR(bRetCode);
        }
        else if (pAwardItem->nMoney > 0)
        {
            bRetCode = pPlayer->m_MoneyMgr.AddMoney(pAwardItem->eMoneyType, pAwardItem->nMoney);
            KGLOG_PROCESS_ERROR(bRetCode);

            PLAYER_LOG(pPlayer, "money,addmoney,%d,%s,%d-%d,%d,%d", pAwardItem->eMoneyType, szWayID, 0, 0, 0, pAwardItem->nMoney);
        }
    }

    bResult = true;
Exit0:
    return bResult;
}
Example #5
0
BOOL KAwardMgr::Award(KPlayer* pPlayer, KAWARD_CARD_TYPE eType, DWORD dwAwardID, unsigned uChooseIndex, BOOL bEndChoose)
{
    BOOL            bResult         = false;
    BOOL            bRetCode        = false;
    IItem*          pItem           = NULL;
    KAwardTable*    pAwardTable     = NULL;
    KAWARD_ITEM*    pAwardItem      = NULL;
    KS2C_Award_Item arrAwardList[cdVipCardCount] = {0};
    IItem*          pLookItem = NULL;
    KSystemMailTxt* pSysMailTxt = NULL;
    KAWARD_ITEM*    pTempItem = NULL;
    KS2C_Award_Item* pAwardItemInfo = NULL;
    KS2C_Award_Item AwardItem;
    DWORD           dwRandSeed = 0;
    int nValuePoint = 0;

    assert(pPlayer);

    KGLOG_PROCESS_ERROR(uChooseIndex < countof(arrAwardList));

    pAwardTable = GetAwardTable(dwAwardID);
    KGLOG_PROCESS_ERROR(pAwardTable);

    pAwardItem = pAwardTable->GetRandomAward();
    if (pAwardItem)
    {
        if (pAwardItem->dwTabType == ittOther || pAwardItem->dwTabType == ittEquip)
        { 
            pSysMailTxt = g_pSO3World->m_Settings.m_SystemMailMgr.GetSystemMailTxt(KMAIL_CHOOSE);
            KGLOG_PROCESS_ERROR(pSysMailTxt);

            bRetCode = GetAwardItemValuePoint(pAwardItem, nValuePoint);
            KGLOG_PROCESS_ERROR(bRetCode);
            
            dwRandSeed = KG_GetTickCount();

            bRetCode = pPlayer->SafeAddItem(pAwardItem->dwTabType, pAwardItem->dwIndex, pAwardItem->nStackNum, nValuePoint, 
                pSysMailTxt->m_szMailTitl, pSysMailTxt->m_szSendName, pSysMailTxt->m_szMailTxt, dwRandSeed
            );

            pItem = g_pSO3World->m_ItemHouse.CreateItem(pAwardItem->dwTabType, pAwardItem->dwIndex, 0, dwRandSeed, nValuePoint);

            if (bRetCode)
            {
                BroadCastAwardItem(pPlayer, pAwardItem);
 
                if (eType == KAWARD_CARD_TYPE_NORMAL)
                {
                    PLAYER_LOG(
                        pPlayer, "item,additem,%u-%u,%d,%d,%s,%d",
                        pAwardItem->dwTabType, pAwardItem->dwIndex, pAwardItem->nStackNum, nValuePoint, 
                        "missionaward", pPlayer->m_dwMapID
                        );
                }
                else if (eType == KAWARD_CARD_TYPE_GOLD)
                {
                    PLAYER_LOG(
                        pPlayer, "item,additem,%u-%u,%d,%d,%s,%d",
                        pAwardItem->dwTabType, pAwardItem->dwIndex, pAwardItem->nStackNum, nValuePoint,
                        "goldaward", pPlayer->m_dwMapID
                        );
                }
                else if (eType == KAWARD_CARD_TYPE_VIP)
                {
                    PLAYER_LOG(
                        pPlayer, "item,additem,%u-%u,%d,%d,%s,%d",
                        pAwardItem->dwTabType, pAwardItem->dwIndex, pAwardItem->nStackNum, nValuePoint,
                        "vipaward", pPlayer->m_dwMapID
                    );
                }
            }
        }
        else if (pAwardItem->dwTabType == ittFashion)
        {
            bRetCode = pPlayer->m_Wardrobe.AddFashion(pAwardItem->dwIndex);
            KGLOG_CHECK_ERROR(bRetCode);
        }
        else if (pAwardItem->dwTabType == ittCheerleading)
        {
            KGCheerleadingInfo* pCheerleadingInfo = g_pSO3World->m_ItemHouse.GetCheerleadingInfo(pAwardItem->dwIndex);
            KGLOG_PROCESS_ERROR(pCheerleadingInfo);

            bRetCode = pPlayer->m_CheerleadingMgr.AddCheerleading(pCheerleadingInfo->dwID);
            KGLOG_PROCESS_ERROR(bRetCode);
        }
        else if (pAwardItem->dwTabType == ittTeamLogo)
        {
            KTEAM_LOGO_INFO*    pTeamLogoInfo = NULL;

            pTeamLogoInfo = g_pSO3World->m_ItemHouse.GetTeamLogoInfo(pAwardItem->dwIndex);
            KGLOG_PROCESS_ERROR(pTeamLogoInfo);

            bRetCode = pPlayer->AddTeamLogo((WORD)pTeamLogoInfo->nID);
            KGLOG_PROCESS_ERROR(bRetCode);
        }
        else if (pAwardItem->nMoney > 0)
        {
            bRetCode = pPlayer->m_MoneyMgr.AddMoney(pAwardItem->eMoneyType, pAwardItem->nMoney);
            KGLOG_PROCESS_ERROR(bRetCode);
            PLAYER_LOG(pPlayer, "money,addmoney,%d,%s,%d-%d,%d,%d", pAwardItem->eMoneyType, "awardtable", 0, 0, 0, pAwardItem->nMoney);


            BroadCastAwardMoney(pPlayer, pAwardItem);
        }

        memset(&AwardItem, 0, sizeof(AwardItem));

        pAwardItemInfo = &AwardItem;

        memset(pAwardItemInfo->RandomAttr, 0, sizeof(pAwardItemInfo->RandomAttr));

        bRetCode = GetAwardItemValuePoint(pAwardItem, nValuePoint);
        KGLOG_PROCESS_ERROR(bRetCode);

        pAwardItemInfo->itemType    = (unsigned char)pAwardItem->dwTabType;
        pAwardItemInfo->itemIndex   = pAwardItem->dwIndex;
        pAwardItemInfo->nCount      = (short)pAwardItem->nStackNum;
        pAwardItemInfo->byMoneyType = (BYTE)pAwardItem->eMoneyType;
        pAwardItemInfo->nMoney      = (short)pAwardItem->nMoney;
        pAwardItemInfo->nValuePoint = nValuePoint;

        if (pItem)
        {
            const KItemProperty*    pProperty   = pItem->GetProperty();
            KAttribute*			    pExtAttr    = pProperty->pExtAttr;  

            for (int j = 0; j < countof(pAwardItemInfo->RandomAttr); ++j)
            {
                if (pExtAttr == NULL)
                    break;

                pAwardItemInfo->RandomAttr[j].wKey = (unsigned short)pExtAttr->nKey;
                pAwardItemInfo->RandomAttr[j].wValue = (unsigned short)pExtAttr->nValue1;
                pExtAttr = pExtAttr->pNext;
            }
        }

        g_PlayerServer.DoAwardItemNotify(pPlayer, eType, AwardItem, uChooseIndex);
    }

    KG_PROCESS_SUCCESS(!bEndChoose);

    memset(arrAwardList, 0, sizeof(arrAwardList));
    for (unsigned i = 0; i < countof(arrAwardList); ++i)
    {
        pTempItem = NULL;
        pAwardItemInfo = &arrAwardList[i];

        memset(pAwardItemInfo->RandomAttr, 0, sizeof(pAwardItemInfo->RandomAttr));

        if (i != uChooseIndex)
        {
            const KItemProperty*    pProperty = NULL;
            KAttribute*			    pExtAttr  = NULL;

            pTempItem = pAwardTable->GetOneAwardItemByEqualRate();
            if (pTempItem == NULL)
                continue;

            bRetCode = GetAwardItemValuePoint(pTempItem, nValuePoint);
			KGLOG_PROCESS_ERROR(bRetCode);

            pAwardItemInfo->itemType    = (unsigned char)pTempItem->dwTabType;
            pAwardItemInfo->itemIndex   = pTempItem->dwIndex;
            pAwardItemInfo->nCount      = (short)pTempItem->nStackNum;
            pAwardItemInfo->byMoneyType = (BYTE)pTempItem->eMoneyType;
            pAwardItemInfo->nMoney      = (short)pTempItem->nMoney;
            pAwardItemInfo->nValuePoint = nValuePoint;

            if (pTempItem->dwTabType > 0 && pTempItem->dwIndex > 0)
            {
                pLookItem = g_pSO3World->m_ItemHouse.CreateItem(pTempItem->dwTabType, pTempItem->dwIndex, 0, 0, nValuePoint);
                KGLOG_CHECK_ERROR(pLookItem);
                if (pLookItem)
                {
                    pProperty   = pLookItem->GetProperty();
                    pExtAttr    = pProperty->pExtAttr;  

                    for (int j = 0; j < countof(pAwardItemInfo->RandomAttr); ++j)
                    {
                        if (pExtAttr == NULL)
                            break;

                        pAwardItemInfo->RandomAttr[j].wKey = (unsigned short)pExtAttr->nKey;
                        pAwardItemInfo->RandomAttr[j].wValue = (unsigned short)pExtAttr->nValue1;
                        pExtAttr = pExtAttr->pNext;
                    }

                    g_pSO3World->m_ItemHouse.DestroyItem(pLookItem);
                    pLookItem = NULL;
                }

            }
        }
    }

    g_PlayerServer.DoAwardItemListNotify(pPlayer, eType, arrAwardList, countof(arrAwardList));

Exit1:
    bResult = true;
Exit0:
    if (pLookItem)
    {
        g_pSO3World->m_ItemHouse.DestroyItem(pLookItem);
        pLookItem = NULL;
    }

    if (pItem)
    {
        g_pSO3World->m_ItemHouse.DestroyItem(pItem);
        pItem = NULL;
    }
    return bResult;
}
Example #6
0
BOOL KAwardMgr::ScenenItemAward(std::vector<KPlayer*>& vecPlayer, DWORD dwAwardID)
{
    BOOL            bResult         = false;
    BOOL            bRetCode        = false;
    KAwardTable*    pAwardTable     = NULL;
    KAWARD_ITEM*    pAwardItem      = NULL;
    KPlayer*        pPlayer         = NULL; 
    KSystemMailTxt* pSysMailTxt     = NULL;
    int             nValuePoint     = 0;

    pAwardTable = g_pSO3World->m_AwardMgr.GetAwardTable(dwAwardID);
    KGLOG_PROCESS_ERROR(pAwardTable);

    pAwardItem = pAwardTable->GetRandomAward();
    KGLOG_PROCESS_ERROR(pAwardItem);
    KGLOG_PROCESS_ERROR(pAwardItem->dwTabType);

    pSysMailTxt = g_pSO3World->m_Settings.m_SystemMailMgr.GetSystemMailTxt(KMAIL_BATTLE_AWARD);
    KGLOG_PROCESS_ERROR(pSysMailTxt);

    for (size_t i = 0; i < vecPlayer.size(); ++i)
    {
        pPlayer = vecPlayer[i];

        KGLOG_PROCESS_ERROR(pPlayer);

        if (pAwardItem->dwTabType == ittOther || pAwardItem->dwTabType == ittEquip)
        {
            bRetCode = GetAwardItemValuePoint(pAwardItem, nValuePoint);
            KGLOG_PROCESS_ERROR(bRetCode);

            bRetCode = pPlayer->SafeAddItem(pAwardItem->dwTabType, pAwardItem->dwIndex, pAwardItem->nStackNum, nValuePoint, 
                pSysMailTxt->m_szMailTitl, pSysMailTxt->m_szSendName, pSysMailTxt->m_szMailTxt
            );
            KGLOG_PROCESS_ERROR(bRetCode);

            PLAYER_LOG(
                pPlayer, "item,additem,%u-%u,%d,%d,%s,%d",
                pAwardItem->dwTabType, pAwardItem->dwIndex, pAwardItem->nStackNum, nValuePoint, 
                "SceneAward", pPlayer->m_dwMapID
            );
        }
        else if (pAwardItem->dwTabType == ittFashion)
        {
            bRetCode = pPlayer->m_Wardrobe.AddFashion(pAwardItem->dwIndex);
            KGLOG_CHECK_ERROR(bRetCode);
        }
        else if (pAwardItem->dwTabType == ittCheerleading)
        {
            KGCheerleadingInfo* pCheerleadingInfo = g_pSO3World->m_ItemHouse.GetCheerleadingInfo(pAwardItem->dwIndex);
            KGLOG_PROCESS_ERROR(pCheerleadingInfo);

            bRetCode = pPlayer->m_CheerleadingMgr.AddCheerleading(pCheerleadingInfo->dwID);
            KGLOG_PROCESS_ERROR(bRetCode);
        }
        else if (pAwardItem->dwTabType == ittTeamLogo)
        {
            KTEAM_LOGO_INFO*    pTeamLogoInfo = NULL;

            pTeamLogoInfo = g_pSO3World->m_ItemHouse.GetTeamLogoInfo(pAwardItem->dwIndex);
            KGLOG_PROCESS_ERROR(pTeamLogoInfo);

            bRetCode = pPlayer->AddTeamLogo((WORD)pTeamLogoInfo->nID);
            KGLOG_PROCESS_ERROR(bRetCode);
        }
    }

    bResult = true;
Exit0:
    return bResult;
}