void ActionMeassureBattery::OnComplete( PlayerBase player, PlayerBase target, ItemBase item )
{
//float energy = item.GetEnergy;
item.TransferModifiers(player);
//if(energy > 0) m_MessageSuccess = "Theres still some juice.";
//if(energy == 0) m_MessageSuccess = "Theres nothing.";
}
int Player::GetVenderBuyPrice(int ItemID)
{
VendorItemList *ItemL = 0;
ItemBase * Item = 0;
if (!m_CurrentNPC)
{
Item = g_ItemBaseMgr->GetItem(ItemID);
if (Item)
{
return Item->Cost();
}
else
{
return 0;
}
}
for(vecItemList::const_iterator v_item = m_CurrentNPC->Vendor.Items.begin(); v_item < m_CurrentNPC->Vendor.Items.end(); ++v_item)
{
ItemL = g_ServerMgr->m_StationMgr.GetVendorItem(*v_item);
if (ItemL && ItemL->ItemID == ItemID && (Item = g_ItemBaseMgr->GetItem(ItemL->ItemID)) )
{
if (ItemL->BuyPrice > 0)
{
return ItemL->BuyPrice;
}
else if (ItemL->BuyPrice == -1)
{
return 0;
}
else //panic! NPC buys for low cost
{
return (int)(Item->Cost() * 0.50f);
}
}
}
Item = g_ItemBaseMgr->GetItem(ItemID);
if (Item)
{
return Item->Cost();
}
return 0;
}
void PartsBinListView::loadImage(ModelPart * modelPart, QListWidgetItem * lwi, const QString & moduleID)
{
ItemBase * itemBase = ItemBaseHash.value(moduleID);
if (itemBase == NULL) {
itemBase = PartFactory::createPart(modelPart, ViewLayer::NewTop, ViewLayer::IconView, ViewGeometry(), ItemBase::getNextID(), NULL, NULL, false);
ItemBaseHash.insert(moduleID, itemBase);
LayerAttributes layerAttributes;
itemBase->initLayerAttributes(layerAttributes, ViewLayer::IconView, ViewLayer::Icon, itemBase->viewLayerPlacement(), false, false);
FSvgRenderer * renderer = itemBase->setUpImage(modelPart, layerAttributes);
if (renderer != NULL) {
if (itemBase) {
itemBase->setFilename(renderer->filename());
}
itemBase->setSharedRendererEx(renderer);
}
}
lwi->setData(Qt::UserRole, qVariantFromValue( itemBase ) );
QSize size(HtmlInfoView::STANDARD_ICON_IMG_WIDTH, HtmlInfoView::STANDARD_ICON_IMG_HEIGHT);
QPixmap * pixmap = FSvgRenderer::getPixmap(itemBase->renderer(), size);
lwi->setIcon(QIcon(*pixmap));
delete pixmap;
lwi->setData(Qt::UserRole + 1, itemBase->renderer()->defaultSize());
m_itemBaseHash.insert(moduleID, itemBase);
}
/* We are out of ammo, reload the launcher */
bool Equipable::Reload()
{
ItemBase * Ammo = 0;
for(u32 i=0; i<m_Player->ShipIndex()->Inventory.GetCargoSpace(); i++)
{
Ammo = g_ItemBaseMgr->GetItem(m_Player->ShipIndex()->Inventory.CargoInv.Item[i].GetItemTemplateID());
/* If this is ammo that matches the launcher */
if (Ammo && strstr(Ammo->Name(), m_ItemInstance.WeaponAmmo))
{
m_AuxAmmoItem->SetData(m_Player->ShipIndex()->Inventory.CargoInv.Item[i].GetData());
m_Player->ShipIndex()->Inventory.CargoInv.Item[i].Empty();
return true;
}
}
return false;
}
bool ActionOnConsciousSelfContinuousQuantity::CanDo( PlayerBase player, Object target, ItemBase item )
{
if ( player && player.IsAlive() && item.GetDamage() < 1 ) //&& IsConscious && IsNotCaptured
{
return true;
}
else
{
return false;
}
}
ItemBase * ItemBaseManager::GetOreTemplate(short level, short obj_type, long sector_id, Field *f)
{
ItemBase * Template[60];
int TemplateCount = 0;
int ItemIndex = 0;
SectorData *sector_data = g_ServerMgr->m_SectorContent.GetSectorData(sector_id);
AsteroidSubcatVec *subcat_vec = g_ServerMgr->m_SectorContent.GetAsteroidContentSelection(obj_type);
//scan through to see how many ores there are for this level and type
if (subcat_vec)
{
//find out what we've got to choose from
//base sector ores
for (int i = 0; i < sector_data->ore_list_size; i++)
{
//now get item
ItemBase * myItem = GetItem(sector_data->OreList[i]->item_id);
//now check to see if it's in the categories, if so, add as choice
for (AsteroidSubcatVec::iterator subcatItr = subcat_vec->begin(); subcatItr != subcat_vec->end(); ++subcatItr)
{
if (myItem->SubCategory() == (*subcatItr) && myItem->TechLevel() == level)
{
Template[TemplateCount++] = myItem; //add to ore choice
if (TemplateCount == 60) break;
}
}
}
//Additional field ores
ItemIDList *orelist = f->GetAdditionalItemIDs();
for (ItemIDList::iterator itrI = orelist->begin(); itrI != orelist->end(); ++itrI)
{
//now get item
ItemBase * myItem = GetItem((*itrI)->item_id);
//now check to see if it's in the categories, if so, add as choice
for (AsteroidSubcatVec::iterator subcatItr = subcat_vec->begin(); subcatItr != subcat_vec->end(); ++subcatItr)
{
if (myItem->SubCategory() == (*subcatItr) && myItem->TechLevel() == level)
{
Template[TemplateCount++] = myItem; //add to ore choice
if (TemplateCount == 60) break;
}
}
}
}
if (TemplateCount > 0)
{
return Template[rand() % TemplateCount]; //randomly choose from ore choice - TODO: add frequency weightings
}
else
{
//didn't find anything to go here - issue error from resource class
return 0;// m_ItemList[rand() % m_ItemCount];
}
}
//This is for the various effects associated with the item
void Equipable::AddEffects()
{
ItemBase * myItemBase = g_ItemBaseMgr->GetItem(m_AuxEquipItem->GetItemTemplateID());
if (myItemBase && myItemBase->EquipEffect() > 0)
{
// Add Equip Effect
ObjectEffect Effect;
Effect.Bitmask = 0x07;
Effect.EffectDescID = myItemBase->EquipEffect();
Effect.GameID = m_Player->GameID();
Effect.Duration = 0;
Effect.TimeStamp = GetNet7TickCount();
m_EEffectID = m_Player->m_Effects.AddEffect(&Effect);
// ----
}
/*
if (m_ItemBase->m_EffectsEquip > 0)
{
// Display Equip Effect
ObjectEffect OBTOBE;
OBTOBE.Bitmask = 0x07;
OBTOBE.GameID = m_Player->GameID();
OBTOBE.EffectDescID = m_ItemBase->m_EffectsEquip;
OBTOBE.EffectID = GetNet7TickCount();
OBTOBE.TimeStamp = GetNet7TickCount();
OBTOBE.Duration = 1750;
if (m_Player->ConnectionAvailable())
{
m_Player->Connection()->SendObjectEffect(m_Player->GameID(), &OBTOBE, TRUE); // Sector Wide
}
}
*/
}
bool Equipable::CheckForItem(const char *description, const char *search)
{
long skill_count = 0;
bool no_duplicate = true;
bool retval = false;
if (strstr(description, search))
{
retval = true;
//check to see if there's already an item like this installed
for(int i=0;i<6;i++)
{
_Item *item = m_Player->ShipIndex()->Inventory.EquipInv.EquipItem[9+i].GetItemData();
if (item->ItemTemplateID > 0)
{
ItemBase *itembase = g_ItemBaseMgr->GetItem(item->ItemTemplateID);
//protect against equipping a null item, but how can that happen?
if(itembase)
{
//what have we here?
char *item_desc = itembase->Description();
if (strstr(item_desc, search))
{
//already equipped this item, don't allow it to affect stats again
skill_count++;
if (skill_count > 1)
{
no_duplicate = false;
break;
}
}
}
}
}
}
return (retval && no_duplicate);
}
int PartsBinListView::setItemAux(ModelPart * modelPart, int position) {
if (modelPart->modelPartShared() == NULL) return position;
if (modelPart->itemType() == ModelPart::Unknown) {
// don't want the empty root to appear in the view
return position;
}
emit settingItem();
QString moduleID = modelPart->moduleID();
if(contains(moduleID)) {
m_partHash[moduleID]->copy(modelPart); // copies into the cached modelPart, but I don't know why
return position;
}
QListWidgetItem * lwi = new QListWidgetItem(modelPart->title());
if (modelPart->itemType() == ModelPart::Space) {
lwi->setBackground(QBrush(SectionHeaderBackgroundColor));
lwi->setForeground(QBrush(SectionHeaderForegroundColor));
lwi->setData(Qt::UserRole, 0);
lwi->setFlags(0);
lwi->setText(" " + TranslatedCategoryNames.value(modelPart->instanceText(), modelPart->instanceText()));
}
else {
ItemBase * itemBase = ItemBaseHash.value(moduleID);
if (itemBase == NULL) {
itemBase = PartFactory::createPart(modelPart, ViewLayer::ThroughHoleThroughTop_OneLayer, ViewLayer::IconView, ViewGeometry(), ItemBase::getNextID(), NULL, NULL, false);
ItemBaseHash.insert(moduleID, itemBase);
QString error;
LayerAttributes layerAttributes;
FSvgRenderer * renderer = itemBase->setUpImage(modelPart, ViewLayer::IconView, ViewLayer::Icon, itemBase->viewLayerSpec(), layerAttributes, error);
if (renderer != NULL) {
if (itemBase) {
itemBase->setFilename(renderer->filename());
}
itemBase->setSharedRendererEx(renderer);
}
}
lwi->setData(Qt::UserRole, qVariantFromValue( itemBase ) );
QSize size(HtmlInfoView::STANDARD_ICON_IMG_WIDTH, HtmlInfoView::STANDARD_ICON_IMG_HEIGHT);
QPixmap * pixmap = FSvgRenderer::getPixmap(itemBase->renderer(), size);
lwi->setIcon(QIcon(*pixmap));
delete pixmap;
lwi->setData(Qt::UserRole + 1, itemBase->renderer()->defaultSize());
m_partHash[moduleID] = modelPart;
}
if(position > -1 && position < count()) {
insertItem(position, lwi);
} else {
addItem(lwi);
position = this->count();
}
return position;
}
void ActionForceConsumeSingle::OnComplete( PlayerBase player, PlayerBase target, ItemBase item )
{
float quantity = item.GetQuantity();
if ( quantity <= 0 )
{
m_MessageSuccess = m_MessageStartFail ;
}
else
{
quantity--;
item.CalculateNutritions(target, m_GramsConsumedPerUse);
item.TransferModifiers(player);
item.SetQuantity(quantity, false);
if ( quantity <= 0 )
{
bool destroy = g_Game.ConfigGetInt("cfgVehicles " + item.GetType() + " destroyOnEmpty");
if ( destroy == 1 ) item.Delete();
}
}
}
ModelPart *PartsBinListView::itemModelPart(const QListWidgetItem *item) const {
ItemBase * itemBase = itemItemBase(item);
if (itemBase == NULL) return NULL;
return itemBase->modelPart();
}
void operator()(const ItemBase& item){
called = true;
frame = item.getFrame();
}
/* Checks if an item can be equiped in this slot */
bool Equipable::CanEquip(_Item * NewItem)
{
/* If this is a weapon/device then we can unequip it */
if (m_Slot >= 3 && m_Slot <= 14 && NewItem->ItemTemplateID == -1)
{
return true;
}
ItemBase * myItemBase = g_ItemBaseMgr->GetItem(NewItem->ItemTemplateID);
/* If we fail to find an itembase - exit */
if (!myItemBase)
{
return false;
}
int SubCat = myItemBase->SubCategory();
/* Now check to see if this is ammo for current item */
if (SubCat == 103 && m_UsesAmmo && !CorrectAmmo(NewItem))
{
m_Player->SendPriorityMessageString("The ammo does not fit here","MessageLine",2000,4);
//printf("CanEquip - Wrong ammo\n");
return false;
}
/* Cannot equip ammo without a launcher */
if (SubCat == 103 && !m_UsesAmmo)
{
m_Player->SendPriorityMessageString("Weapon doesn't require ammo","MessageLine",2000,4);
//m_Player->SendVaMessage("Weapon doesn't use ammo");
//printf("CanEquip - Ammo with no launcher\n");
return false;
}
/* Now check that the item matches the slot type */
if ((m_Slot == 0 && SubCat != 122) || // Shield
(m_Slot == 1 && SubCat != 120) || // Reactor
(m_Slot == 2 && SubCat != 121) || // Engine
(m_Slot >= 3 && m_Slot <= 8 && SubCat != 100 && SubCat != 101 && SubCat != 102 && SubCat != 103) || //Weapon/Ammo
(m_Slot >= 9 && m_Slot <= 15 && SubCat != 110)) //Device
{
m_Player->SendPriorityMessageString("Item does not fit here","MessageLine",2000,4);
//printf("CanEquip - Wrong item for slot\n");
return false;
}
AuxSkill * Skills = &m_Player->PlayerIndex()->RPGInfo.Skills.Skill[0];
/* Now check skill requirements */
if ((SubCat == 100 && Skills[SKILL_BEAM_WEAPON].GetLevel() < myItemBase->TechLevel()) ||
(SubCat == 101 && Skills[SKILL_PROJECTILE_WEAPON].GetLevel() < myItemBase->TechLevel()) ||
(SubCat == 102 && Skills[SKILL_MISSILE_WEAPON].GetLevel() < myItemBase->TechLevel()) ||
(SubCat == 110 && Skills[SKILL_DEVICE_TECH].GetLevel() < myItemBase->TechLevel()) ||
(SubCat == 120 && Skills[SKILL_REACTOR_TECH].GetLevel() < myItemBase->TechLevel()) ||
(SubCat == 121 && Skills[SKILL_ENGINE_TECH].GetLevel() < myItemBase->TechLevel()) ||
(SubCat == 122 && Skills[SKILL_SHIELD_TECH].GetLevel() < myItemBase->TechLevel()))
{
m_Player->SendPriorityMessageString("You need more skill to equip this item","MessageLine",2000,4);
//printf("CanEquip - bad skill\n");
return false;
}
ItemRequirements Req = myItemBase->GetItemRequirements();
/* Now check for race restrictions */
if (Req.RaceRestriction & (0x01 << m_Player->Race()))
{
//printf("CanEquip - Race restriction\n");
m_Player->SendPriorityMessageString("Your Race can not equip this item","MessageLine",2000,4);
return false;
}
/* Also check for race lore restrictions */
if ((m_Player->Race() == 1 && Req.LoreRestriction == 0x02) ||
(m_Player->Race() == 2 && Req.LoreRestriction == 0x01))
{
//printf("CanEquip - Lore restriction\n");
m_Player->SendPriorityMessageString("Your Lore can not equip this item","MessageLine",2000,4);
return false;
}
/* Now check for profession restrictions */
if (Req.ProfessionRestriction & (0x01 << m_Player->Profession()))
{
m_Player->SendPriorityMessageString("Your profession can not equip this item","MessageLine",2000,4);
//printf("CanEquip - Profession restriction\n");
return false;
}
/* Now check for level requirements */
if ((Req.CombatRequirement > m_Player->CombatLevel()) ||
(Req.ExploreRequirement > m_Player->ExploreLevel()) ||
(Req.TradeRequirement > m_Player->TradeLevel()) ||
(Req.OverallRequirement > m_Player->TotalLevel()))
{
m_Player->SendPriorityMessageString("You can not equip this item","MessageLine",2000,4);
//printf("CanEquip - level restriction\n");
//printf("Combat Req %d Act %d\n",Req.CombatRequirement,m_Player->CombatLevel());
//printf("Explore Req %d Act %d\n",Req.CombatRequirement,m_Player->ExploreLevel());
//printf("Trade Req %d Act %d\n",Req.CombatRequirement,m_Player->TradeLevel());
//printf("Overall Req %d Act %d\n",Req.CombatRequirement,m_Player->TotalLevel());
return false;
}
return true;
}
bool Player::QualityCalculator(_Item * myItem)
{
char InstanceInfo[64];
char IInstanceInfo[64];
int QArraySize = 7;
QualityArray QArray[] = {{14, 5, 0, 1.55f, 0.01f }, // Beams
{15,21, 1, 1.55f, 0.01f }, // ML
{16,21, 1, 1.55f, 0.01f }, // Projectiles
{ 2,26, 0, 1.55f, 0.01f }, // Shields
{ 6,31, 0, 1.35f, 0.01f }, // Engines Thrust
{ 6,34, 1, 1.55f, 0.01f }, // Engines Warp Drain
{ 7,20, 0, 1.55f, 0.01f } // Reactors
};
ItemBase * myItemBase = g_ItemBaseMgr->GetItem(myItem->ItemTemplateID);
memset(InstanceInfo, 0, sizeof(InstanceInfo));
if (!myItemBase) return false; // early return if item invalid
for(int x=0;x<QArraySize;x++)
{
if (QArray[x].ItemType == myItemBase->ItemType())
{
int FieldID = QArray[x].ItemField;
// Get Field Type
int FieldType = myItemBase->FieldType(FieldID);
float FieldData = 0;
// Read in Data
switch(FieldType)
{
// Float
case 1:
FieldData = myItemBase->Fields(FieldID)->fData;
break;
// Int
case 2:
FieldData = (float) myItemBase->Fields(FieldID)->iData;
break;
}
// Calculate Real Quality Percent
float RealPercent;
float ChangeRate;
float ItemQuality = myItem->Quality;
float NewFieldValue = 0;
// Calculate real percent from numbers
if (ItemQuality < 1.0f)
{
ChangeRate = ((1.0f - QArray[x].MinQuality)/1.0f);
RealPercent = ItemQuality * ChangeRate + QArray[x].MinQuality;
}
else
{
ChangeRate = ((QArray[x].MaxQuality - 1.0f)/1.0f);
RealPercent = (ItemQuality - 1.0f)* ChangeRate + 1.0f;
}
// Calculate the field data
if (QArray[x].Direction == 1)
{
NewFieldValue = (1.0f + (1.0f - RealPercent)) * FieldData;
}
else
{
NewFieldValue = RealPercent * FieldData;
}
// Client does not read below 1
if (NewFieldValue < 1.0f)
NewFieldValue = 1.0f;
sprintf(IInstanceInfo, "%d:%4.2f^", FieldID,NewFieldValue);
strcat(InstanceInfo, IInstanceInfo);
}
}
if (InstanceInfo[0] != 0)
{
memcpy(myItem->InstanceInfo, InstanceInfo, sizeof(InstanceInfo));
return true;
}
return false;
}
/* This currently does not check quality */
void Player::CheckStack(int MoveNum, _Item * Source, _Item * Destination)
{
/* If the items have the same ID they can stack */
if (Source->ItemTemplateID == Destination->ItemTemplateID)
{
ItemBase * myItemBase = g_ItemBaseMgr->GetItem(Source->ItemTemplateID);
if (!myItemBase)
{
return;
}
/* If the MoveNum has enough items to make a full stack at Destination */
if (Destination->StackCount + MoveNum > myItemBase->MaxStack())
{
int moved = myItemBase->MaxStack() - Destination->StackCount;
Source->StackCount -= moved;
Destination->StackCount = myItemBase->MaxStack();
/* Now update the trade stacks */
Destination->TradeStack += (Source->TradeStack < moved ? Source->TradeStack : moved);
Source->TradeStack -= moved;
}
/* Otherwise the Destination can store the entire MoveNum ammount */
else
{
Destination->StackCount += MoveNum;
Source->StackCount -= MoveNum;
/* Now update the trade stacks */
Destination->TradeStack += (Source->TradeStack < MoveNum ? Source->TradeStack : MoveNum);
Source->TradeStack -= MoveNum;
}
/* Switch the Source and Destination stack counts */
u32 tmpStack = Destination->StackCount;
Destination->StackCount = Source->StackCount;
Source->StackCount = tmpStack;
/* Now switch their trade stacks aswell */
tmpStack = Destination->TradeStack;
Destination->TradeStack = Source->TradeStack;
Source->TradeStack = tmpStack;
/* If weve moved all of the items out of the source, set it to an empty item */
if (Destination->StackCount == 0)
{
memcpy(Destination, &g_ItemBaseMgr->EmptyItem, sizeof(_Item));
}
}
/* If the destination is am empty item and we are moving a substack*/
else if (Destination->ItemTemplateID == -1 && (u32)MoveNum < Source->StackCount)
{
/* Copy the source item to the destination */
memcpy(Destination, Source, sizeof(_Item));
Destination->StackCount = MoveNum;
Source->StackCount -= MoveNum;
/* Now update the trade stacks */
Destination->TradeStack += (Source->TradeStack < MoveNum ? Source->TradeStack : MoveNum);
Source->TradeStack -= MoveNum;
/* Switch the Source and Destination stack counts */
u32 tmpStack = Destination->StackCount;
Destination->StackCount = Source->StackCount;
Source->StackCount = tmpStack;
/* Now switch their trade stacks aswell */
tmpStack = Destination->TradeStack;
Destination->TradeStack = Source->TradeStack;
Source->TradeStack = tmpStack;
/* If weve moved all of the items out of the source, set it to an empty item */
if (Destination->StackCount == 0)
{
memcpy(Destination, &g_ItemBaseMgr->EmptyItem, sizeof(_Item));
}
}
}
int Player::CargoAddItem(_Item * myItem)
{
if (myItem->ItemTemplateID < 0)
{
return -1;
}
ItemBase * myItemBase = g_ItemBaseMgr->GetItem(myItem->ItemTemplateID);
if (!myItemBase)
{
return -2;
}
u32 curTrade = myItem->TradeStack;
u32 curStack = myItem->StackCount;
u32 maxStack = myItemBase->MaxStack();
u32 curPrice = (u32)myItem->Price;
SendItemBase(myItem->ItemTemplateID);
// Update the instance information
QualityCalculator(myItem);
// If this is a stackable item, check stacks
if (maxStack > 1)
{
for(u32 i=0; i<ShipIndex()->Inventory.GetCargoSpace(); i++)
{
if (ShipIndex()->Inventory.CargoInv.Item[i].GetItemTemplateID() == myItem->ItemTemplateID)
{
if (ShipIndex()->Inventory.CargoInv.Item[i].GetStackCount() + curStack > maxStack)
{
// There is SOME room in this slot
u32 oldstack = ShipIndex()->Inventory.CargoInv.Item[i].GetStackCount();
u32 moved = maxStack - ShipIndex()->Inventory.CargoInv.Item[i].GetStackCount();
curStack -= moved;
ShipIndex()->Inventory.CargoInv.Item[i].AddTradeStack(curTrade < moved ? curTrade : moved);
curTrade -= moved;
ShipIndex()->Inventory.CargoInv.Item[i].SetStackCount(maxStack);
//set average cost
float average = ( (ShipIndex()->Inventory.CargoInv.Item[i].GetAveCost() * oldstack) + (float)(moved * curPrice) ) / (float)maxStack;
ShipIndex()->Inventory.CargoInv.Item[i].SetAveCost(average);
if (myItem->Price != 0)
{
ShipIndex()->Inventory.CargoInv.Item[i].SetPrice(myItem->Price);
}
SaveInventoryChange(i);
}
else
{
// Enough room here for the rest of the stack
u32 oldstack = ShipIndex()->Inventory.CargoInv.Item[i].GetStackCount();
//set average cost
float average = ( (ShipIndex()->Inventory.CargoInv.Item[i].GetAveCost() * oldstack) + (float)(curStack * curPrice) ) / (float)(curStack + oldstack);
ShipIndex()->Inventory.CargoInv.Item[i].SetAveCost(average);
if (myItem->Price != 0)
{
ShipIndex()->Inventory.CargoInv.Item[i].SetPrice(myItem->Price);
}
curStack += oldstack;
curTrade += ShipIndex()->Inventory.CargoInv.Item[i].GetTradeStack();
ShipIndex()->Inventory.CargoInv.Item[i].SetStackCount(curStack);
ShipIndex()->Inventory.CargoInv.Item[i].SetTradeStack(curTrade);
SaveInventoryChange(i);
return 0;
}
}
}
}
// At this point, we need to fill empty slots with the item
for(u32 i=0; i<ShipIndex()->Inventory.GetCargoSpace(); i++)
{
if (ShipIndex()->Inventory.CargoInv.Item[i].GetItemTemplateID() == -1)
{
if (curStack > maxStack)
{
// We have more than a full stack
curStack -= maxStack;
ShipIndex()->Inventory.CargoInv.Item[i].SetData(myItem);
ShipIndex()->Inventory.CargoInv.Item[i].SetStackCount(maxStack);
// The tradable count is the smaller amount of whats left tradable and max stack
ShipIndex()->Inventory.CargoInv.Item[i].SetTradeStack(curTrade < maxStack ? curTrade : maxStack);
ShipIndex()->Inventory.CargoInv.Item[i].SetAveCost((float)curPrice);
// The SetTradeStack method converts negative numbers to zero so this is allowerd
curTrade -= maxStack;
SaveInventoryChange(i);
}
else
{
// Enough room here to finish adding this item
ShipIndex()->Inventory.CargoInv.Item[i].SetData(myItem);
ShipIndex()->Inventory.CargoInv.Item[i].SetStackCount(curStack);
ShipIndex()->Inventory.CargoInv.Item[i].SetTradeStack(curTrade);
ShipIndex()->Inventory.CargoInv.Item[i].SetAveCost((float)curPrice);
SaveInventoryChange(i);
return 0;
}
}
}
return -3;
}
void cb(const ItemBase& item){
called = true;
frame = item.getFrame();
}
//
// Callbacks from brow
//
static int tblnav_brow_cb( FlowCtx *ctx, flow_tEvent event)
{
TblNav *tblnav;
ItemBase *item;
if ( event->event == flow_eEvent_ObjectDeleted) {
brow_GetUserData( event->object.object, (void **)&item);
delete item;
return 1;
}
brow_GetCtxUserData( (BrowCtx *)ctx, (void **) &tblnav);
if ( !tblnav->is_authorized())
return 1;
tblnav->message( ' ', "");
switch ( event->event) {
case flow_eEvent_Key_PageDown: {
brow_Page( tblnav->brow->ctx, 0.8);
break;
}
case flow_eEvent_Key_PageUp: {
brow_Page( tblnav->brow->ctx, -0.8);
break;
}
case flow_eEvent_ScrollDown: {
brow_Page( tblnav->brow->ctx, 0.1);
break;
}
case flow_eEvent_ScrollUp: {
brow_Page( tblnav->brow->ctx, -0.1);
break;
}
case flow_eEvent_Key_Up: {
brow_tNode *node_list;
int node_count;
brow_tObject object;
int sts;
brow_GetSelectedNodes( tblnav->brow->ctx, &node_list, &node_count);
if ( !node_count) {
sts = brow_GetLastVisible( tblnav->brow->ctx, &object);
if ( EVEN(sts)) return 1;
}
else {
if ( !brow_IsVisible( tblnav->brow->ctx, node_list[0], flow_eVisible_Partial)) {
sts = brow_GetLastVisible( tblnav->brow->ctx, &object);
if ( EVEN(sts)) return 1;
}
else {
sts = brow_GetPrevious( tblnav->brow->ctx, node_list[0], &object);
if ( EVEN(sts)) {
if ( node_count)
free( node_list);
return 1;
}
}
}
brow_SelectClear( tblnav->brow->ctx);
brow_SetInverse( object, 1);
brow_SelectInsert( tblnav->brow->ctx, object);
if ( !brow_IsVisible( tblnav->brow->ctx, object, flow_eVisible_Full))
brow_CenterObject( tblnav->brow->ctx, object, 0.25);
if ( node_count)
free( node_list);
break;
}
case flow_eEvent_Key_Down: {
brow_tNode *node_list;
int node_count;
brow_tObject object;
int sts;
brow_GetSelectedNodes( tblnav->brow->ctx, &node_list, &node_count);
if ( !node_count) {
sts = brow_GetFirstVisible( tblnav->brow->ctx, &object);
if ( EVEN(sts)) return 1;
}
else {
if ( !brow_IsVisible( tblnav->brow->ctx, node_list[0], flow_eVisible_Partial)) {
sts = brow_GetFirstVisible( tblnav->brow->ctx, &object);
if ( EVEN(sts)) return 1;
}
else {
sts = brow_GetNext( tblnav->brow->ctx, node_list[0], &object);
if ( EVEN(sts)) {
if ( node_count)
free( node_list);
return 1;
}
}
}
brow_SelectClear( tblnav->brow->ctx);
brow_SetInverse( object, 1);
brow_SelectInsert( tblnav->brow->ctx, object);
if ( !brow_IsVisible( tblnav->brow->ctx, object, flow_eVisible_Full))
brow_CenterObject( tblnav->brow->ctx, object, 0.75);
if ( node_count)
free( node_list);
break;
}
case flow_eEvent_SelectClear:
brow_ResetSelectInverse( tblnav->brow->ctx);
break;
case flow_eEvent_MB1Click: {
// Select
double ll_x, ll_y, ur_x, ur_y;
int sts;
switch ( event->object.object_type) {
case flow_eObjectType_Node:
brow_MeasureNode( event->object.object, &ll_x, &ll_y,
&ur_x, &ur_y);
if ( event->object.x < ll_x + 1.0) {
// Simulate doubleclick
flow_tEvent doubleclick_event;
doubleclick_event = (flow_tEvent) calloc( 1, sizeof(*doubleclick_event));
memcpy( doubleclick_event, event, sizeof(*doubleclick_event));
doubleclick_event->event = flow_eEvent_MB1DoubleClick;
sts = tblnav_brow_cb( ctx, doubleclick_event);
free( (char *) doubleclick_event);
return sts;
}
if ( brow_FindSelectedObject( tblnav->brow->ctx, event->object.object)) {
brow_SelectClear( tblnav->brow->ctx);
}
else {
brow_SelectClear( tblnav->brow->ctx);
brow_SetInverse( event->object.object, 1);
brow_SelectInsert( tblnav->brow->ctx, event->object.object);
}
break;
default:
brow_SelectClear( tblnav->brow->ctx);
}
break;
}
case flow_eEvent_Key_Left: {
brow_tNode *node_list;
int node_count;
brow_tObject object;
int sts;
brow_GetSelectedNodes( tblnav->brow->ctx, &node_list, &node_count);
if ( !node_count)
return 1;
if ( brow_IsOpen( node_list[0]))
// Close this node
object = node_list[0];
else {
// Close parent
sts = brow_GetParent( tblnav->brow->ctx, node_list[0], &object);
if ( EVEN(sts)) {
free( node_list);
return 1;
}
}
brow_GetUserData( object, (void **)&item);
item->close( tblnav, 0, 0);
brow_SelectClear( tblnav->brow->ctx);
brow_SetInverse( object, 1);
brow_SelectInsert( tblnav->brow->ctx, object);
if ( !brow_IsVisible( tblnav->brow->ctx, object, flow_eVisible_Full))
brow_CenterObject( tblnav->brow->ctx, object, 0.25);
free( node_list);
break;
}
case flow_eEvent_Key_Right: {
brow_tNode *node_list;
int node_count;
brow_GetSelectedNodes( tblnav->brow->ctx, &node_list, &node_count);
if ( !node_count)
return 1;
brow_GetUserData( node_list[0], (void **)&item);
switch( item->type) {
case tblnav_eItemType_Local:
case tblnav_eItemType_TreeLocal:
((ItemLocal *)item)->open_attributes( tblnav, 0, 0);
break;
case tblnav_eItemType_TreeNode:
((ItemTreeNode *)item)->open_children( tblnav, 0, 0);
break;
default:
;
}
}
case flow_eEvent_MB1DoubleClick:
switch ( event->object.object_type) {
case flow_eObjectType_Node:
brow_GetUserData( event->object.object, (void **)&item);
switch( item->type) {
case tblnav_eItemType_Local:
case tblnav_eItemType_TreeLocal:
((ItemLocal *)item)->open_attributes( tblnav,
event->object.x, event->object.y);
break;
case tblnav_eItemType_TreeNode:
((ItemTreeNode *)item)->open_children( tblnav,
event->object.x, event->object.y);
break;
default:
;
}
break;
default:
;
}
break;
default:
;
}
return 1;
}
void Inventory::Update(float deltaTime) {
mDragSprite.Update(deltaTime);
int x = Input_GetMouseScreenX();
int y = Input_GetMouseScreenY();
int dragSpriteX = mDragSprite.GetPosition().x;
int dragSpriteY = mDragSprite.GetPosition().y;
int width = mDragSprite.GetSpriteWidth();
int height = mDragSprite.GetSpriteHeight();
// Check for item use
if (((x > dragSpriteX) && x < dragSpriteX + width)
&& (y > dragSpriteY && y < dragSpriteY + height)
&& mDragSprite.GetVisible()) {
bool mouseDown = Input_IsMousePressed(Mouse::LBUTTON);
SVector2 position = mDragSprite.GetPosition();
float x = Input_GetMouseScreenX() - position.x;
float y = Input_GetMouseScreenY() - position.y - 32;
// Exit Button
if (mouseDown && x > 264 && x < 286 && y < 0) {
mDragSprite.ToggleVisible();
}
int itemSlot = -1;
// Figure out what item we are selecting
int xSlot = -1;
if (x > 27 && x < 70)
xSlot = 0;
if (x > 78 && x < 120)
xSlot = 1;
if (x > 127 && x < 170)
xSlot = 2;
if (x > 178 && x < 218)
xSlot = 3;
if (x > 226 && x < 270)
xSlot = 4;
int ySlot = -1;
if (y > -4 && y < 34)
ySlot = 0;
if (y > 46 && y < 85)
ySlot = 1;
if (y > 93 && y < 135)
ySlot = 2;
if (y > 143 && y < 183)
ySlot = 3;
if (y > 192 && y < 234)
ySlot = 4;
if (y > 242 && y < 282)
ySlot = 5;
if (xSlot >= 0 && ySlot >= 0) {
itemSlot = xSlot + ySlot * 5;
}
if (mouseDown) {
if (itemSlot >= 0 && itemSlot < mItems.size()) {
mItems[itemSlot]->UseItem(mPlayerInfo, mRaknet);
mItems.erase(mItems.begin() + itemSlot);
}
}
if (Input_IsMousePressed(Mouse::RBUTTON)) {
// Delete Item in slot
if (itemSlot >= 0 && itemSlot < mItems.size()) {
ItemBase* item = mItems[itemSlot];
int imageNumber = item->GetImageNumber();
mItems.erase(mItems.begin() + itemSlot);
// Let the server know we droped a item
RakNet::BitStream bsOut;
bsOut.Write((RakNet::MessageID) ID_DROP_ITEM);
bsOut.Write(mPlayerInfo.GetMap());
bsOut.Write(imageNumber);
bsOut.Write(item->GetItemNumber());
bsOut.Write(mCharacter.GetTileIndex());
mRaknet.mPeer->Send(&bsOut, HIGH_PRIORITY, RELIABLE_ORDERED, 0,
mRaknet.mServerAddress, false);
}
}
}
}
void Inventory::UpdateRaknet() {
switch (mRaknet.mPacket->data[0]) {
case ID_PICKUP_ITEM: {
ItemBase* item;
int itemType = 0;
char itemName[CHAR_MAX];
int value = 0;
bool questItem = 0;
int imageNumber = 0;
char description[1000];
int itemNumber = 0;
RakNet::BitStream bsIn(mRaknet.mPacket->data, mRaknet.mPacket->length,
false);
bsIn.IgnoreBytes(sizeof(RakNet::MessageID));
bsIn.Read(itemType);
bsIn.Read(itemName);
bsIn.Read(value);
bsIn.Read(questItem);
bsIn.Read(imageNumber);
bsIn.Read(description);
bsIn.Read(itemNumber);
switch (itemType) {
case potion: {
item = new Potion;
break;
}
case weapon: {
item = new Weapon;
break;
}
case shield: {
item = new Shield;
break;
}
case helmet: {
item = new Helmet;
break;
}
case armor: {
item = new Armor;
break;
}
case boots: {
item = new Boots;
break;
}
case necklace: {
item = new Necklace;
break;
}
case ring: {
item = new Ring;
break;
}
}
SetValues(item, itemName, value, questItem, imageNumber, description,
itemNumber);
item->GetData(bsIn);
AddItem(item);
break;
}
}
}
// Major hack until we get good item information
// TODO: we have got good item info now, we can do this properly
void ItemBaseManager::SetRefineInfo()
{
ItemBase * item = 0;
ItemBase * refines_into = 0;
char name_buffer[128];
char * name_end;
for (int i=0; i<MAX_ITEMBASE_ITEMS; i++)
{
if (item = GetItem(i))
{
if (strstr(item->Description(), "Refines to: ") != 0)
{
if (name_end = strchr(item->Description(), '\\'))
{
memcpy(name_buffer, item->Description() + 12, name_end - item->Description() - 12);
name_buffer[name_end - item->Description() - 12] = '\0';
}
else if(name_end = strchr(item->Description(), '\n'))
{
memcpy(name_buffer, item->Description() + 12, name_end - item->Description() - 12);
name_buffer[name_end - item->Description() - 12] = '\0';
}
else
{
strcpy(name_buffer, item->Description() + 12);
}
//printf("SetRefineInfo - Refines Into: %s\n",name_buffer);
if (refines_into = GetItem(name_buffer))
{
item->SetRefinesInto(refines_into->ItemTemplateID());
refines_into->SetComponent(0, item->ItemTemplateID());
refines_into->SetComponent(1, item->ItemTemplateID());
refines_into->SetComponent(2, -2);
refines_into->SetComponent(3, -2);
refines_into->SetComponent(4, -2);
refines_into->SetComponent(5, -2);
}
}
}
}
printf("Refining information parsed\n");
}
//----------------------------- updateVision ----------------------------------
//
// this method iterates through all the bots in the game world to test if
// they are in the field of view. Each bot's memory record is updated
// accordingly
//-----------------------------------------------------------------------------
void SensoryMemory::updateVision()
{
const auto& elist = _owner->getGame()->getNeighborsOnMove(_owner->getWorldPosition(), _viewRange);
for (auto iter = std::begin(elist); iter != std::end(elist); iter++)
{
if (_owner->getTag() != (*iter)->getTag())
{
if (isMasked((*iter)->getFamilyMask(), FamilyMask::HUMAN_BASE))
{
HumanBase* human = static_cast<HumanBase*>(*iter);
//make sure it is part of the memory map
makeNewRecordIfNotAlreadyPresent(human);
//get a reference to this bot's data
MemoryRecord& info = _memory[human];
Vec2 ownerPos = _owner->getWorldPosition();
Vec2 humanPos = human->getWorldPosition();
if (ownerPos.getDistance(humanPos) < _viewRange)
{
info.isLosOkay = _owner->getGame()->isLOSOkay(ownerPos, humanPos);
if (info.isLosOkay)
{
if (ownerPos.getDistance(humanPos) < _attackRange)
info.attackable = true;
else
info.attackable = false;
info.viewable = true;
info.timeBecameVisible = info.timeLastSensed;
info.timeLastSensed =
system_clock::now().time_since_epoch();
info.timeLastVisible =
system_clock::now().time_since_epoch();
info.lastSensedPos = humanPos;
}
else
{
info.attackable = false;
info.viewable = false;
}
}
else
{
info.attackable = false;
info.viewable = false;
}
}
else if (isMasked((*iter)->getFamilyMask(), FamilyMask::ITEM_BASE))
{
ItemBase* item = static_cast<ItemBase*>(*iter);
if (_owner->getWorldPosition().getDistance(item->getWorldPosition()) < _viewRange)
{
auto finded = std::find(std::begin(_sensedItems), std::end(_sensedItems), item);
if (finded == std::end(_sensedItems))
_sensedItems.push_back(item);
}
}
}
}
}
