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;
}
