void TreasuryManager::bankTipOnline(uint32 amount, PlayerObject* playerObject, PlayerObject* targetObject ) { //check if we have enough money uint32 surcharge = (uint32)((amount/100)*5); auto equip_service = gWorldManager->getKernel()->GetServiceManager()->GetService<swganh::equipment::EquipmentService>("EquipmentService"); auto inventory = dynamic_cast<Inventory*>(equip_service->GetEquippedObject(playerObject->GetCreature(), "inventory")); auto playerBank = dynamic_cast<Bank*>(equip_service->GetEquippedObject(playerObject->GetCreature(), "bank")); auto targetBank = dynamic_cast<Bank*>(equip_service->GetEquippedObject(targetObject->GetCreature(), "bank")); if(!playerBank) { LOG (error) << "TreasuryManager::bankTipOnline No bank for " << playerObject->getId(); return; } if(!inventory) { LOG (error) << "TreasuryManager::bankTipOnline No Inventory Object for " << playerObject->getId(); return; } if((amount+surcharge) > inventory->getCredits()) { std::string s; s = targetObject->GetCreature()->getFirstName(); std::wstring s_w(s.begin(), s.end()); gMessageLib->SendSystemMessage(::common::OutOfBand("base_player", "prose_tip_nsf_cash", L"", s_w, L"", amount), playerObject); return; } playerBank->updateCredits(-(amount+surcharge)); targetBank->updateCredits(amount); gMessageLib->SendSystemMessage(::common::OutOfBand("base_player", "prose_tip_pass_self", 0, targetObject->getId(), 0, amount), playerObject); gMessageLib->SendSystemMessage(::common::OutOfBand("base_player", "prose_tip_pass_target", 0, playerObject->getId(), 0, amount), targetObject); gMessageLib->sendBanktipMail(playerObject,targetObject,amount); }
void TreasuryManager::bankDepositAll(PlayerObject* player) { auto equip_service = gWorldManager->getKernel()->GetServiceManager()->GetService<swganh::equipment::EquipmentService>("EquipmentService"); auto inventory = dynamic_cast<Inventory*>(equip_service->GetEquippedObject(player->GetCreature(), "inventory")); auto bank = dynamic_cast<Bank*>(equip_service->GetEquippedObject(player->GetCreature(), "bank")); if(!inventory) { LOG(error) << "TreasuryManager::bankDepositAll no Inventory"; return; } if(!bank) { LOG(error) << "TreasuryManager::bankDepositAll no bank"; return; } int32 credits = inventory->getCredits(); if(credits > 0) { // bank credits = bank + inventory. // inventory = 0 bank->updateCredits(credits); inventory->setCredits(0); gMessageLib->SendSystemMessage(::common::OutOfBand("base_player", "prose_deposit_success", 0, 0, 0, credits), player); } else { //There has been an error during an attempt to deposit funds to your bank account. Verify you have sufficient funds for the desired transaction. gMessageLib->SendSystemMessage(::common::OutOfBand("error_message", "bank_deposit"), player); } }
void TreasuryManager::bankWithdrawAll(PlayerObject* player) { auto equip_service = gWorldManager->getKernel()->GetServiceManager()->GetService<swganh::equipment::EquipmentService>("EquipmentService"); auto inventory = dynamic_cast<Inventory*>(equip_service->GetEquippedObject(player->GetCreature(), "inventory")); auto bank = dynamic_cast<Bank*>(equip_service->GetEquippedObject(player->GetCreature(), "bank")); if(! bank) { LOG (error) << "TreasuryManager::bankWithdrawAll No Bank Object for " << player->getId(); return; } if(!inventory) { LOG (error) << "TreasuryManager::bankWithdrawAll No Inventory Object for " << player->getId(); return; } if(!bank->getCredits()) { //There has been an error during an attempt to withdraw funds from your bank account. Verify you have sufficient funds for the desired transaction. gMessageLib->SendSystemMessage(::common::OutOfBand("error_message", "bank_withdraw"), player); return; } gMessageLib->SendSystemMessage(::common::OutOfBand("base_player", "prose_withdraw_success", 0, 0, 0, bank->getCredits()), player); inventory->updateCredits(bank->getCredits()); bank->setCredits(0); }
void TreasuryManager::bankTransfer(int32 inventoryMoneyDelta, int32 bankMoneyDelta, PlayerObject* player) { auto equip_service = gWorldManager->getKernel()->GetServiceManager()->GetService<swganh::equipment::EquipmentService>("EquipmentService"); auto inventory = dynamic_cast<Inventory*>(equip_service->GetEquippedObject(player->GetCreature(), "inventory")); auto bank = dynamic_cast<Bank*>(equip_service->GetEquippedObject(player->GetCreature(), "bank")); if(! bank) { LOG (error) << "TreasuryManager::bankWithdrawAll No Bank Object for " << player->getId(); return; } if(!inventory) { LOG (error) << "TreasuryManager::bankWithdrawAll No Inventory Object for " << player->getId(); return; } // do we deposit or withdraw? if(bankMoneyDelta > 0) { // we deposit // update the deposit amount // in case our inventory cash // changed since the window popped bankMoneyDelta -= (bankMoneyDelta + inventoryMoneyDelta); // do we still have enough money? if(bankMoneyDelta < 1) { // transaction error // - we dont have enough money // - deposit equals zero return; } // ok, update the treasury inventory->setCredits(inventory->getCredits() - bankMoneyDelta); bank->updateCredits(bankMoneyDelta); // system message gMessageLib->SendSystemMessage(::common::OutOfBand("base_player", "prose_deposit_success", 0, 0, 0, bankMoneyDelta), player); } else { // we withdraw // update the withdraw amount // in case our bank cash // changed since the window popped inventoryMoneyDelta -= (bankMoneyDelta + inventoryMoneyDelta); // do we still have enough money? if(inventoryMoneyDelta < 1) { // transaction error // - we dont have enough money // - withdraw equals zero return; } // ok, update the treasury bank->updateCredits(-inventoryMoneyDelta); inventory->updateCredits(inventoryMoneyDelta); // system message gMessageLib->SendSystemMessage(::common::OutOfBand("base_player", "prose_withdraw_success", 0, 0, 0, inventoryMoneyDelta), player); } }
size_t FlashCacheLruk::proc(const request* r, bool warmup) { if (!warmup) {stat.accesses++;} counter++; double currTime = r->time; updateCredits(currTime); bool updateWrites = true; uint32_t mfuKid=0; //#ifdef COMPARE_TIME // updateDramFlashiness(currTime); //#else // updateDramFlashiness(); //#endif auto searchRKId = allObjects.find(r->kid); if (searchRKId != allObjects.end()) { /* * The object exists in flashCache system. If the sizes of the * current request and previous request differ then the previous * request is removed from the flashcache system. Otherwise, one * needs to update the hitrate and its place in the globalLru. * If it is in the cache, one needs as well to update the * 'flashiness' value and its place in the dram MFU and dram LRU */ FlashCacheLruk::Item& item = searchRKId->second; if (r->size() == item.size) { if (!warmup) {stat.hits++;} globalLru.erase(item.globalLruIt); globalLru.emplace_front(item.kId); item.globalLruIt = globalLru.begin(); if (item.isInDram) { if (!warmup) {stat.hits_dram++;} size_t qN = item.queueNumber; // std::pair<uint32_t, double> p = *(item.dramLocation); //#ifdef COMPARE_TIME // p.second += hitCredit(item, currTime); //#else // p.second += hitCredit(item); //#endif dram[qN].erase(item.dramLocation); kLruSizes[qN] -= item.size; dramSize -= item.size; if ((qN + 1) != FC_K_LRU) { qN++; } else { updateWrites = false; } std::vector<uint32_t> objects{r->kid}; dramAddandReorder(objects, r->size(),qN, updateWrites, warmup); } else { if (!warmup) {stat.hits_flash++;} } item.lastAccessInTrace = counter; item.last_accessed = currTime; lastCreditUpdate = r->time; return 1; } else {// Size changed globalLru.erase(item.globalLruIt); if(item.isInDram) { size_t qN = item.queueNumber; dram[qN].erase(item.dramLocation); kLruSizes[qN] -= item.size; dramSize -= item.size; } else {// in flash flash.erase(item.flashIt); flashSize -= item.size; } allObjects.erase(item.kId); } } /* * The request doesn't exist in the system. We always insert new requests * to the DRAM at the beginning of the last queue. * * 2. While (object not inserted to the DRAM) * 2.1 if (item.size() + dramSize <= DRAM_SIZE_FC_KLRU) - * insert item to the dram and return * 2.2 if (not enough credits) - remove the least recently used item * in the dram until there is a place. return to 2 * 2.3 if (possible to move from DRAM to flash) - * move items from DRAM to flash. back to 2. * 2.4 remove from global lru. back to 2 */ FlashCacheLruk::Item newItem; newItem.kId = r->kid; newItem.size = r->size(); newItem.isInDram = true; newItem.last_accessed = r->time; newItem.lastAccessInTrace = counter; assert(((unsigned int) newItem.size) <= DRAM_SIZE_FC_KLRU); while (true) { if (newItem.size + dramSize <= DRAM_SIZE_FC_KLRU) { // If we have place in the dram insert the new item to the beginning of the last queue. globalLru.emplace_front(newItem.kId); newItem.globalLruIt = globalLru.begin(); allObjects[newItem.kId] = newItem; lastCreditUpdate = r->time; std::vector<uint32_t> objects{r->kid}; dramAdd(objects, r->size(),0, true, warmup); return PROC_MISS; } // If we don't have enough space in the dram, we can move MRU items to the flash // or to delete LRU items for (int i=FC_K_LRU-1; i >=0 ; i--) {// Find the MRU item if (kLruSizes[i] > 0){ mfuKid = ((dram[i]).front()).first; break; } } FlashCacheLruk::Item& mfuItem = allObjects[mfuKid]; size_t qN = mfuItem.queueNumber; assert(mfuItem.size > 0); // if (credits < (double) mfuItem.size) { // // If we can't write into the flash we need to make room in the dram // if (!warmup) {stat.credit_limit++;} // // while (newItem.size + dramSize > DRAM_SIZE_FC_KLRU ) { // // ------------- // // Need to extract the last items from the last queue until // // there will be enough space. Then to insert the new item at the // // beginning of the last queue // // ------------ // // uint32_t lruKid = ((dram[0]).back()).first; // FlashCacheLruk::Item& lruItem = allObjects[lruKid]; // // assert(lruItem.size > 0); // dram[0].erase(lruItem.dramLocation); // globalLru.erase(lruItem.globalLruIt); // kLruSizes[0] -= lruItem.size; // dramSize -= lruItem.size; // allObjects.erase(lruKid); // } // continue; // } else { // We can write items to the flash if (flashSize + mfuItem.size <= FLASH_SIZE_FC_KLRU) { // If we have enough space in the flash, we will insert the MRU item // to the flash mfuItem.isInDram = false; dram[qN].erase(mfuItem.dramLocation); flash.emplace_front(mfuKid); mfuItem.dramLocation = ((dram[0]).end()); dramSize -= mfuItem.size; mfuItem.flashIt = flash.begin(); credits -= mfuItem.size; kLruSizes[qN] -= mfuItem.size; flashSize += mfuItem.size; if (!warmup) { stat.writes_flash++; stat.flash_bytes_written += mfuItem.size; } } else { // If we don't have space in the flash, we will delete the GLRU item // and make room for the new item uint32_t globalLruKid = globalLru.back(); FlashCacheLruk::Item& globalLruItem = allObjects[globalLruKid]; globalLru.erase(globalLruItem.globalLruIt); if (globalLruItem.isInDram) { size_t dGqN = globalLruItem.queueNumber; dram[dGqN].erase(globalLruItem.dramLocation); kLruSizes[dGqN] -= globalLruItem.size; dramSize -= globalLruItem.size; } else { flash.erase(globalLruItem.flashIt); flashSize -= globalLruItem.size; } allObjects.erase(globalLruKid); } // } } assert(false); return PROC_MISS; }