Exemplo n.º 1
0
void InventoryItem::onHandDragStop(Event::Mouse* event, HAND hand)
{
    // Check if mouse is over this item
    if (!Rect::inRect(event->position(), position(), size()))
    {
        return;
    }

    if (ItemsList* itemsList = dynamic_cast<ItemsList*>(event->target()))
    {
        InventoryItem* itemUi = itemsList->draggedItem();
        auto item = itemUi->item();
        itemsList->removeItem(itemUi, 1);
        // place current weapon back to inventory
        if (_item)
        {
            itemsList->addItem(this, 1);
        }
        this->setItem(item);
        auto player = Game::getInstance()->player();
        if (hand == HAND::LEFT)
        {
            player->setLeftHandSlot(item);
        }
        else
        {
            player->setRightHandSlot(item);
        }
    }
}
void InventoryItem::onArmorDragStop(Event::Mouse* event)
{
    // Check if mouse is over this item
    if (!Rect::inRect(event->position(), position(), size()))
    {
        return;
    }

    if (ItemsList* itemsList = dynamic_cast<ItemsList*>(event->target()))
    {
        InventoryItem* draggedItem = itemsList->draggedItem();
        auto itemObject = draggedItem->item();
        if(itemObject->subtype() != Game::ItemObject::Subtype::ARMOR) return;
        itemsList->removeItem(draggedItem, 1);
        // place current armor back to inventory
        if (_item)
        {
            itemsList->addItem(this, 1);
        }
        this->setItem(itemObject);
        if (auto armor = dynamic_cast<Game::ArmorItemObject*>(itemObject))
        {
            Game::getInstance()->player()->setArmorSlot(armor);
        }
    }
}
Exemplo n.º 3
0
bool AICurrentItemCondition::fireCondition() {
	InventoryItem *item = ((PegasusEngine *)g_engine)->getCurrentInventoryItem();

	if (_item == kNoItemID)
		return item == 0;

	return item != 0 && item->getObjectID() == _item;
}
Exemplo n.º 4
0
/********************************************************
 *                       showValues                     *
 * This function displays the member data stored in the *
 * InventoryItem object passed to it by value.          *
 ********************************************************/
void showValues(InventoryItem item)
{
	cout << fixed << showpoint << setprecision(2) << endl;;
	cout << "Part Number  : "  << item.getPartNum() << endl;
	cout << "Description  : "  << item.getDescription() << endl;
	cout << "Units On Hand: "  << item.getOnHand() << endl;
	cout << "Price        : $" << item.getPrice() << endl;
}
void Client::clickActiveObject(u8 button, u16 id, u16 item_i)
{
	if(connectedAndInitialized() == false){
		infostream<<"Client::clickActiveObject() "
				"cancelled (not connected)"
				<<std::endl;
		return;
	}

	Player *player = m_env.getLocalPlayer();
	if(player == NULL)
		return;

	ClientActiveObject *obj = m_env.getActiveObject(id);
	if(obj){
		if(button == 0){
			ToolItem *titem = NULL;
			std::string toolname = "";

			InventoryList *mlist = player->inventory.getList("main");
			if(mlist != NULL)
			{
				InventoryItem *item = mlist->getItem(item_i);
				if(item && (std::string)item->getName() == "ToolItem")
				{
					titem = (ToolItem*)item;
					toolname = titem->getToolName();
				}
			}

			v3f playerpos = player->getPosition();
			v3f objpos = obj->getPosition();
			v3f dir = (objpos - playerpos).normalize();

			bool disable_send = obj->directReportPunch(toolname, dir);

			if(disable_send)
				return;
		}
	}

	/*
		length: 7
		[0] u16 command
		[2] u8 button (0=left, 1=right)
		[3] u16 id
		[5] u16 item
	*/
	u8 datasize = 2 + 1 + 6 + 2 + 2;
	SharedBuffer<u8> data(datasize);
	writeU16(&data[0], TOSERVER_CLICK_ACTIVEOBJECT);
	writeU8(&data[2], button);
	writeU16(&data[3], id);
	writeU16(&data[5], item_i);
	Send(0, data, true);
}
//----------------------------------------------------------------------------//
void InventoryModel::updateItemName(const ModelIndex& index, const String& newName)
{
    ModelIndex parent_index = getParentIndex(index);

    notifyChildrenDataWillChange(parent_index, 0, 1);

    InventoryItem* item = static_cast<InventoryItem*>(index.d_modelData);
    item->setText(newName);

    notifyChildrenDataChanged(parent_index, 0, 1);
}
Exemplo n.º 7
0
//------------------------------------------------------------------------------//
void InventoryReceiver::removeItem(InventoryItem& item)
{
    if (item.getParent() != this ||
        item.locationOnReceiverX() == -1 ||
        item.locationOnReceiverY() == -1)
            return;

    eraseItemFromContentMap(item);
    item.setLocationOnReceiver(-1, -1);
    removeChild(&item);
}
Exemplo n.º 8
0
video::ITexture * ItemObject::getItemImage()
{
	/*
		Create an inventory item to see what is its image
	*/
	video::ITexture *texture = NULL;
	InventoryItem *item = createInventoryItem();
	if(item)
		texture = item->getImage();
	if(item)
		delete item;
	return texture;
}
Exemplo n.º 9
0
 void restoreItemInBackpack( Item* item,
                             int inventoryPosX,
                             int inventoryPosY,
                             size_t stackSize )
 {
   InventoryItem* invItem = new InventoryItem( item,
                                               inventoryPosX,
                                               inventoryPosY,
                                               Globals::getPlayer() );
   invItem->setCurrentStackSize( stackSize );
   Globals::getPlayer()->getInventory()->insertItemWithExchangeAt( invItem,
                                                                   inventoryPosX,
                                                                   inventoryPosY );
 }
//------------------------------------------------------------------------------//
void InventoryItemRenderer::render()
{
    const WidgetLookFeel& wlf = getLookNFeel();

    InventoryItem* item = dynamic_cast<InventoryItem*>(d_window);

    if (!item)
        // render basic imagery
        wlf.getStateImagery(d_window->isDisabled() ? "Disabled" : "Enabled").render(*d_window);

    if (item->isBeingDragged())
        wlf.getStateImagery(item->currentDropTargetIsValid() ? "DraggingValidTarget" : "DraggingInvalidTarget").render(*item);
    else
        wlf.getStateImagery("Normal").render(*item);
}
Exemplo n.º 11
0
	void GenericPlayerCharacter::EquipCharacter(int choosenObject)
	{
		for(Vector<InventoryItem*>::iterator playerObject = playerInventory.begin(); playerObject < playerInventory.end(); playerObject++)
		{
			InventoryItem* currentItem = *playerObject;
			if(currentItem->getObjectWorldID() == choosenObject)
			{
				playerAttackPoints = playerAttackPoints - currentEquipedObject->getAttackBoost();
				playerDefencePoints = playerDefencePoints - currentEquipedObject->getDefenceBoost();
				playerAttackPoints = playerAttackPoints - currentItem->getAttackBoost();
				playerDefencePoints = playerDefencePoints - currentItem->getDefenceBoost();
				break;
			}
		}
	}
Exemplo n.º 12
0
InventoryItem* Item::AddLootItem(InventoryItem* pItem, int slotX, int slotY)
{
	if(pItem != NULL)
	{
		InventoryItem* pAddedLootItem = AddLootItem(pItem->m_filename.c_str(), pItem->m_Iconfilename.c_str(), pItem->m_itemType, pItem->m_item, pItem->m_status, pItem->m_equipSlot, pItem->m_itemQuality, pItem->m_title.c_str(), pItem->m_description.c_str(), pItem->m_left, pItem->m_right, pItem->m_placementR, pItem->m_placementG, pItem->m_placementB, pItem->m_quantity, slotX, slotY);

		for(int i = 0; i < (int)pItem->m_vpStatAttributes.size(); i++)
		{
			pAddedLootItem->AddStatAttribute(pItem->m_vpStatAttributes[i]->GetType(), pItem->m_vpStatAttributes[i]->GetModifyAmount());
		}

		return pAddedLootItem;
	}

	return NULL;
}
Exemplo n.º 13
0
//------------------------------------------------------------------------------//
void InventoryReceiver::onDragDropItemDropped(DragDropEventArgs &e)
{
    InventoryItem* item = dynamic_cast<InventoryItem*>(e.dragDropItem);

    if (!item)
        return;

    const Sizef square_size(squarePixelSize());

    Rectf item_area(item->getUnclippedOuterRect().get());
    item_area.offset(Vector2f(square_size.d_width / 2, square_size.d_height / 2));

    const int drop_x = gridXLocationFromPixelPosition(item_area.left());
    const int drop_y = gridYLocationFromPixelPosition(item_area.top());

    addItemAtLocation(*item, drop_x, drop_y);
}
Exemplo n.º 14
0
//------------------------------------------------------------------------------//
bool InventoryReceiver::itemWillFitAtLocation(const InventoryItem& item,
                                              int x, int y)
{
    if (x < 0 || y < 0)
        return false;

    if (x + item.contentWidth() > d_content.width() ||
        y + item.contentHeight() > d_content.height())
            return false;

    const bool already_attached = this == item.getParent();
    // if item is already attatched erase its data from the content map so the
    // test result is reliable.
    if (already_attached)
        eraseItemFromContentMap(item);

    bool result = true;
    for (int item_y = 0; item_y < item.contentHeight() && result; ++item_y)
    {
        for (int item_x = 0; item_x < item.contentWidth() && result; ++item_x)
        {
            if (d_content.elementAtLocation(item_x + x, item_y + y) &&
                item.isSolidAtLocation(item_x, item_y))
                    result = false;
        }
    }

    // re-write item into content map if we erased it earlier.
    if (already_attached)
        writeItemToContentMap(item);

    return result;
}
Exemplo n.º 15
0
//------------------------------------------------------------------------------//
bool InventoryReceiver::addItemAtLocation(InventoryItem& item, int x, int y)
{
    if (itemWillFitAtLocation(item, x, y))
    {
        InventoryReceiver* old_receiver =
            dynamic_cast<InventoryReceiver*>(item.getParent());

        if (old_receiver)
            old_receiver->removeItem(item);

        item.setLocationOnReceiver(x, y);
        writeItemToContentMap(item);
        addChild(&item);

        // set position and size.  This ensures the items visually match the
        // logical content map.


        item.setPosition(UVector2(UDim(static_cast<float>(x) / contentWidth(), 0),
                                  UDim(static_cast<float>(y) / contentHeight(), 0)));
        item.setSize(USize(
            UDim(static_cast<float>(item.contentWidth()) / contentWidth(), 0),
            UDim(static_cast<float>(item.contentHeight()) / contentHeight(), 0)));

        return true;
    }

    return false;
}
Exemplo n.º 16
0
std::string Inventory::getReloadText()
{
  std::ostringstream oss;
  oss << "-- Player's inventory" << std::endl;
  oss << "-- Items in Backpack" << std::endl;

  for( size_t backpackNr=0; backpackNr<backpackItems.size(); ++backpackNr )
  {
    InventoryItem* curBackpackItem = backpackItems[ backpackNr ];
    Item* curItem = curBackpackItem->getItem();
    oss << "DawnInterface.restoreItemInBackpack( itemDatabase[\""
        << curItem->getID() << "\"], "
        << curBackpackItem->getInventoryPosX()
        << ", " << curBackpackItem->getInventoryPosY() << ", "
        << curBackpackItem->getCurrentStackSize() << " );"
        << std::endl;
  }

  oss << "-- equipped Items" << std::endl;
  size_t numEquippable = static_cast<size_t>( ItemSlot::COUNT );
  for( size_t curEquippable=0; curEquippable<numEquippable; ++curEquippable )
  {
    if( equippedItems[ curEquippable ] != NULL )
    {
      Item* curItem = equippedItems[ curEquippable ]->getItem();
      /* if the item is two-handed and we're inspecting the off-hand slot
         don't output it. */
      if( !( curItem->isTwoHandedWeapon() == true &&
             curEquippable == static_cast<size_t>( ItemSlot::OFF_HAND ) ) )
      {
        oss << "DawnInterface.restoreWieldItem( " << curEquippable << ", "
            << "itemDatabase[\"" << curItem->getID() << "\"] " << ");"
            << std::endl;
      }
    }
  }

  return oss.str();
}
Exemplo n.º 17
0
InventoryItem* Inventory::getItemAt( size_t invPosX, size_t invPosY )
{
  assert( !isPositionFree( invPosX, invPosY ) );

  size_t numBackItems = backpackItems.size();
  for( size_t curBackItemNr=0; curBackItemNr<numBackItems; ++curBackItemNr )
  {
    InventoryItem* curItem = backpackItems[ curBackItemNr ];
    size_t itemPosX = curItem->getInventoryPosX();
    size_t itemPosY = curItem->getInventoryPosY();
    size_t itemSizeX = curItem->getItem()->getSizeX();
    size_t itemSizeY = curItem->getItem()->getSizeY();

    if( itemPosX <= invPosX && itemPosX + itemSizeX > invPosX &&
        itemPosY <= invPosY && itemPosY + itemSizeY > invPosY )
    {
      return curItem;
    }
  }

  // should have found an item so should never reach here
  abort();
}
Exemplo n.º 18
0
//-----------------------------------------------------------------------------------------
void InventoryList::render(bool eggTransparency)
{
    InventoryItem *draggedItem = nullptr;

    for(auto& item: _slotItems)
    {
        if(item.second->type() != InventoryItem::Type::DRAG)
        {
            item.second->render();
        }
        else
        {
            draggedItem = item.second.get();
        }
    }

    ItemsList::render(eggTransparency);

    if(draggedItem)
    {
        draggedItem->render();
    }
}
Exemplo n.º 19
0
//------------------------------------------------------------------------------//
void InventoryReceiver::writeItemToContentMap(const InventoryItem& item)
{
    if (item.locationOnReceiverX() == -1 || item.locationOnReceiverY() == -1)
        return;

    for (int y = 0; y < item.contentHeight(); ++y)
    {
        const int map_y = item.locationOnReceiverY() + y;

        for (int x = 0; x < item.contentWidth(); ++x)
        {
            const int map_x = item.locationOnReceiverX() + x;

            bool val = d_content.elementAtLocation(map_x, map_y) |
                       item.isSolidAtLocation(x, y);
            d_content.setElementAtLocation(map_x, map_y, val);
        }
    }

    invalidate();
}
Exemplo n.º 20
0
/**********************************************************
 *                        storeValues                     *
 * This function stores user input data in the members of *
 * an InventoryItem object passed to it by reference.     *
 * ********************************************************/
void storeValues(InventoryItem &item)   
{
	int partNum;                   // Local variables to hold user input    
	string description;   
	int qty;           
	double price; 

	// Get the data from the user
	cout << "Enter data for the new part number \n";
	cout << "Part number: ";
	cin  >> partNum;
	cout << "Description: ";
	cin.get();                     // Move past the '\n' left in the
	                               // input buffer by the last input 
	getline(cin, description);
	cout << "Quantity on hand: ";
	cin  >> qty;
	cout << "Unit price: ";
	cin  >> price;

	// Store the data in the InventoryItem object
	item.storeInfo(partNum, description, qty, price);
}
Exemplo n.º 21
0
string Inventory::getInventoryString()
{
	stringstream result;
	result << "{";
	vector<Entity*> inventoryItems = getVectorItems();
	for (vector<Entity*>::iterator i = inventoryItems.begin(); i != inventoryItems.end(); i++)
	{
		Entity* theItem = *i;
		InventoryItem* theInventoryItem = theItem->getInventoryItem();
		if (theInventoryItem->getType() == "INVENTORYFOOD")
		{
			result << "F";
			result << theInventoryItem->getItem()->getID() << ":";
			result << theInventoryItem->getCurrentStackCount() << ":";
			result << ((InventoryFood*)theInventoryItem)->getFoodState();
		}
		else if (theInventoryItem->getType() == "INVENTORYEQUIPMENT")
		{
			result << "E";
			result << theInventoryItem->getItem()->getID() << ":";
			result << theInventoryItem->getCurrentStackCount() << ":";
			result << ((InventoryEquipment*)theInventoryItem)->getSmithingMaterial()->getID();
		}
		else if (theInventoryItem->getType() == "INVENTORYBOOST")
		{
			result << "B";
			result << theInventoryItem->getItem()->getID() << ":";
			result << theInventoryItem->getCurrentStackCount() << ":";
		}
		else
		{
			result << theInventoryItem->getItem()->getID() << ":";
			result << theInventoryItem->getCurrentStackCount() << ":";
		}
		result << ",";
	}
	result << "}";
	return result.str();
}
Exemplo n.º 22
0
void game_create_pickup(const ScriptArguments& args)
{
	glm::vec3 pos (args[2].real, args[3].real, args[4].real);
	int id;
	int type = args[1].integer;
	
	switch(args[0].type) {
		case TInt8:
			id = (std::int8_t)args[0].integer;
			break;
		case TInt16:
			id = (std::int16_t)args[0].integer;
			break;
		default:
			RW_ERROR("Unhandled integer type");
			*args[5].globalInteger = 0;
			return;
	}
	
	if ( id < 0 )
	{
		id = -id;
		
		auto model = args.getVM()->getFile()->getModels()[id];
		std::transform(model.begin(), model.end(), model.begin(), ::tolower);
	
		id = args.getWorld()->data->findModelObject(model);
		args.getWorld()->data->loadDFF(model+".dff");
		args.getWorld()->data->loadTXD("icons.txd");
	}
	else
	{
		auto data = args.getWorld()->data->findObjectType<ObjectData>(id);
		
		if ( ! ( id >= 170 && id <= 184 ) )
		{
			args.getWorld()->data->loadDFF(data->modelName+".dff");
		}
		args.getWorld()->data->loadTXD(data->textureName+".txd");
	}
	
	PickupObject* pickup = nullptr;

	if ( id >= 170 && id <= 184 )
	{
		// Find the item for this model ID
		auto world = args.getWorld();
		InventoryItem *item = nullptr;
		for (auto i = 0; i < maxInventorySlots; ++i)
		{
			item = world->getInventoryItem(i);
			if (item->getModelID() == id) {
				auto pickuptype = (PickupObject::PickupType)type;
				pickup = new ItemPickup(args.getWorld(), pos, pickuptype, item);
				world->pickupPool.insert( pickup );
				world->allObjects.push_back(pickup);
				*args[5].globalInteger = pickup->getGameObjectID();
			}
		}
	}
	else
	{
		RW_UNIMPLEMENTED("non-item pickups");
		*args[5].globalInteger = 0;
	}
	
}
Exemplo n.º 23
0
void Player::update(float frameTime, LevelController* lc) {
	// 1-Press NoClip
	if (noClipButtonReleased && input->isKeyDown(VK_F2)) {
		noClip = !noClip;
		noClipButtonReleased = false;
	} else {
		noClipButtonReleased = true;
	}
	velocityX = getVelocity().x;
	velocityY = getVelocity().y;
	// Handle NoClip
	if (noClip) {
		if (input->isKeyDown(PLAYER_RIGHT)) {
			velocityX = playerNS::NOCLIP_SPEED * frameTime;
			orientation = Right;
		} else if (input->isKeyDown(PLAYER_LEFT)) {
			velocityX = -playerNS::NOCLIP_SPEED * frameTime;
			orientation = Left;
		} else {
			velocityX = 0;
		}
		if (input->isKeyDown(PLAYER_UP)) {
			velocityY = -playerNS::NOCLIP_SPEED * frameTime;
			orientation = Up;
		} else if (input->isKeyDown(PLAYER_DOWN)) {
			velocityY = playerNS::NOCLIP_SPEED * frameTime;
			orientation = Down;
		} else {
			velocityY = 0;
		}
		velocity = VECTOR2(velocityX, velocityY);
		frameDelay = 1000000;
		Item* activeItem = inventory->getActiveItem()->getItem();
		if (inventory->getActiveItem()->getItem()->getItemType() == Item::Equipable) {
			Gun* gun = dynamic_cast<Gun*>(activeItem);
			if (gun != 0) {
				gun->update(frameTime, orientation, getX(), getY(), input, lc);
			}
		}
		Entity::update(frameTime);
		return;
	}
	// Set Obj Vars
	levelController = lc;
	// Debug Messages
	OSD::instance()->addLine("Jump Distance: " + std::to_string(jumpdistance) + " / " + std::to_string(playerNS::JUMP_HEIGHT));
	OSD::instance()->addLine("Can | Left: " + std::to_string(canMoveLeft(true)) + " | Right: " + std::to_string(canMoveRight(true)) + " | Up: " + std::to_string(canMoveUp(true)) + " | Down: " + std::to_string(canMoveDown(true)));
	// Stuck Hotfix
	if (!canMoveLeft() && !canMoveRight() && !canMoveUp() && !canMoveDown()) {
		setX(spawnPos.x);
		setY(spawnPos.y);
	}
	// Update Guns
	inventory->update(frameTime, input);
	// Boss Audio
	if (lc->getMapX() * -1.0 > 1900) {
		audio->stopCue(BK_MUSIC);
		audio->playCue(BOSS_MUSIC);
	}

	// Start of Player Movement
	if (healthStatus != Dead) {
		if (!canMoveDown()) {
			if (!input->isKeyDown(PLAYER_UP) && !input->isKeyDown(PLAYER_JUMP))
				canJump = true;
			canFall = false;
			falling = false;
		} else {
			canFall = true;
			falling = true;
		}
		// Move Left and Right
		if (input->isKeyDown(PLAYER_RIGHT) && canMoveRight()) {
			velocityX = playerNS::SPEED * frameTime;
			while (!canMoveRight()) {
				spriteData.x -= 0.1;
				velocityX = 0;
			}
			orientation = Right;
		} else if (input->isKeyDown(PLAYER_LEFT) && canMoveLeft()) {
			velocityX = -playerNS::SPEED * frameTime;
			while (!canMoveLeft()) {
				spriteData.x += 0.1;
				velocityX = 0;
			}
			orientation = Left;
		} else {
			velocityX = 0;
			if (input->isKeyDown(PLAYER_UP)) {
				orientation = Up;
			}

			if (input->isKeyDown(PLAYER_DOWN)) {
				orientation = Down;
			}
		}
		// Handle Jumping
		if (jumping || (((input->isKeyDown(PLAYER_JUMP) || input->isKeyDown(PLAYER_UP)) && canMoveUp() && canJump))) {
			jumpdistance = jumpOriginY - getY();
			if (canJump && !jumping)
				jumpOriginY = getY();
			if (jumpdistance > playerNS::JUMP_HEIGHT || !canMoveUp()) {
				jumping = false;
				canJump = false;
				falling = true;
			} else {
				if (!jumping)
					velocityY = -playerNS::JUMP_SPEED * frameTime;
				else
					velocityY += 0.5 * frameTime;
				jumping = true;
				canJump = false;
			}
		}
		if (!jumping)
			jumpOriginY = getY();
		if (falling && !jumping) {
			if (canMoveDown()) {
				velocityY = playerNS::FALLING_SPEED * frameTime;
			} else {
				velocityY = 0;
			}
		}
		// Handle Stuck
		while (canMoveUp() && !canMoveDown() && !canMoveLeft() && !canMoveRight()) {
			spriteData.y -= 0.1;
		}
		while (!canMoveUp() && !canMoveDown() && !canMoveLeft() && canMoveRight()) {
			spriteData.x += 0.1;
		}
		while (!canMoveUp() && !canMoveDown() && canMoveLeft() && !canMoveRight()) {
			spriteData.x -= 0.1;
		}
		// Final Sanity Check
		if (!canMoveLeft() && velocityX < 0 || !canMoveRight() && velocityX > 0)
			velocityX = 0;
		if (!canMoveUp() && velocityY < 0 || !canMoveDown() && velocityY > 0)
			velocityY = 0;
		setVelocity(VECTOR2(velocityX, velocityY));

		// Handle Orientations
		if (input->isKeyDown(PLAYER_UP))
			orientation = Up;
		else if (input->isKeyDown(PLAYER_DOWN))
			orientation = Down;
		switch (orientation) {
		case Right:
			currentFrame = 953;
			spriteData.flipHorizontal = true;
			break;
		case Down:
			currentFrame = 954;
			break;
		case Left:
			currentFrame = 953;
			spriteData.flipHorizontal = false;
			break;
		case Up:
			currentFrame = 952;
			break;
		}

		// Draw Items
		Item* activeItem = inventory->getActiveItem()->getItem();
		if (inventory->getActiveItem()->getItem()->getItemType() == Item::Equipable) {
			Gun* gun = dynamic_cast<Gun*>(activeItem);
			if (gun != 0) {
				gun->update(frameTime, orientation, getX(), getY(), input, lc);
			}
		}
		// Crate Collision
		if (lc->collidedWithCrate() == 1 && lc->getCrateItem() != -1) {
			audio->playCue(RELOAD);
			if (lc->collidedWithCrate() == 1 && lc->getCrateItem() != -1) {
				int itemid = lc->getCrateItem();
				InventoryItem *invItem;
				std::vector<InventoryItem*>* itemList = inventory->getItems();
				switch (itemid) {
				case playerNS::ItemType::shotGun:
					shotgun = new Shotgun();
					shotgun->initialize(gameptr, 136, 41, 2, gunTexture);
					shotgun->setCurrentFrame(6);
					invItem = new InventoryItem(shotgun);
					break;
				case playerNS::ItemType::machineGun:
					machineGun = new MachineGun();
					machineGun->initialize(gameptr, 136, 41, 2, gunTexture);
					machineGun->setCurrentFrame(0);
					invItem = new InventoryItem(machineGun);
					break;
				case 3:
					break;
				}
				for (int i = 0; i < itemList->size(); i++) {
					InventoryItem *iItem = itemList->at(i);
					Item* item = iItem->getItem();
					Item* newItem = invItem->getItem();
					if (item->getItemType() == Item::Equipable && newItem->getItemType() == Item::Equipable) {
						Gun* gunInvItem = dynamic_cast<Gun*>(item);
						Gun* gunNewItem = dynamic_cast<Gun*>(newItem);
						if (gunInvItem->getGunId() == gunNewItem->getGunId()) {
							gunInvItem->addAmmo();
							lc->setCrateCollided(0);
							return; // Should this be return or break?
						}
					} else if (item->getItemType() == Item::Usable && newItem->getItemType() == Item::Usable) {
						lc->setCrateCollided(0);
						return;
					} // Should this be return or break?
				}
				inventory->addItem(invItem);
				lc->setCrateCollided(0);
				lc->setCrateItem(-1);
			}
		}
		Entity::update(frameTime);
	}
}
Exemplo n.º 24
0
Command *Command::opItemSelectInInventory(const ResourceReference &itemRef) {
	InventoryItem *item = itemRef.resolve<InventoryItem>();
	StarkUserInterface->selectInventoryItem(item->getIndex());

	return nextCommand();
}
//----------------------------------------------------------------------------//
void InventoryModel::load()
{
    InventoryItem* backpack = InventoryItem::make("Trip backpack", 2.0f, d_root);
    InventoryItem* prev_matryoshka = 0;

    // matryoshka Z to A
    for (char chr = 'Z'; chr >= 'A'; --chr)
    {
        InventoryItem* matryoshka = InventoryItem::make("Matryoshka " + String(1, chr), 1.0f, backpack);

        matryoshka->setIcon("DriveIcons/DriveStack");

        if (prev_matryoshka != 0)
        {
            prev_matryoshka->setParent(matryoshka);
            matryoshka->addItem(prev_matryoshka);
        }

        prev_matryoshka = matryoshka;
    }

    backpack->addItem(InventoryItem::make("Gepäckaufbewahrungsschein: Wiener Neustadt", 1.0f, backpack));
    backpack->addItem(InventoryItem::make("Gepäckaufbewahrungsschein: Frankfurt am Main", 1.0f, backpack));
    backpack->addItem(InventoryItem::make("Gepäckaufbewahrungsschein: Sankt Johann im Pongau", 1.0f, backpack));
    backpack->addItem(InventoryItem::make("Gepäckaufbewahrungsschein: Seekirchen am Wallersee", 1.0f, backpack));

    InventoryItem* beans_can = InventoryItem::make("Beans can", 1.0f, backpack);
    beans_can->setIcon("DriveIcons/GlobalDrive");
    InventoryItem* beans = InventoryItem::make("Beans!", 0.1f, beans_can);
    beans_can->addItem(beans);

    backpack->addItem(prev_matryoshka);
    backpack->addItem(beans_can);

    d_root->addItem(backpack);

    InventoryItem* bow = InventoryItem::make("Bow", 23.451f, d_root);
    for (int i = 25; i >= 0; --i)
    {
        InventoryItem* arrow = InventoryItem::make(
            "arrow " + PropertyHelper<int>::toString(i), 0.2f, bow);
        bow->addItem(arrow);
    }
    d_root->addItem(bow);

    // generate *many* items :D
    for (int i = 2000; i >= 1960; i -= 2)
    {
        InventoryItem* almanach = InventoryItem::make(
            "Almanach " + PropertyHelper<int>::toString(i), 0.34f, d_root);

        if (i % 2 == 0)
            almanach->setIcon("DriveIcons/Lime");

        d_root->addItem(almanach);
    }
}
Exemplo n.º 26
0
void drawPlayerInfo(PlayerController* player, GameWorld* world, GameRenderer* render)
{
	float infoTextX = render->getRenderer()->getViewport().x -
			(ui_outerMargin + ui_weaponSize + ui_infoMargin);
	float infoTextY = 0.f + ui_outerMargin;
	float iconX = render->getRenderer()->getViewport().x -
			(ui_outerMargin + ui_weaponSize);
	float iconY = ui_outerMargin;
	float wantedX = render->getRenderer()->getViewport().x -
			(ui_outerMargin);
	float wantedY = ui_outerMargin + ui_weaponSize + 3.f;

	TextRenderer::TextInfo ti;
	ti.font = 1;
	ti.size = ui_textSize;
	ti.align = TextRenderer::TextInfo::Right;

	{
		std::stringstream ss;
		ss << std::setw(2) << std::setfill('0') << world->getHour()
		   << std::setw(0) << ":"
		   << std::setw(2) << world->getMinute();

		ti.text = ss.str();
	}
	ti.baseColour = ui_shadowColour;
	ti.screenPosition = glm::vec2(infoTextX + 1.f, infoTextY+1.f);
	render->text.renderText(ti);

	ti.baseColour = ui_timeColour;
	ti.screenPosition = glm::vec2(infoTextX, infoTextY);
	render->text.renderText(ti);

	infoTextY += ui_textHeight;

	ti.text = "$" + std::to_string(world->state->playerInfo.money);
	ti.baseColour = ui_shadowColour;
	ti.screenPosition = glm::vec2(infoTextX + 1.f, infoTextY+1.f);
	render->text.renderText(ti);

	ti.baseColour = ui_moneyColour;
	ti.screenPosition = glm::vec2(infoTextX, infoTextY);
	render->text.renderText(ti);

	infoTextY += ui_textHeight;

	{
		std::stringstream ss;
		ss << "@" << std::setw(3) << std::setfill('0')
		   << (int)player->getCharacter()->getCurrentState().health;
		ti.text = ss.str();
	}
	ti.baseColour = ui_shadowColour;
	ti.screenPosition = glm::vec2(infoTextX + 1.f, infoTextY+1.f);
	render->text.renderText(ti);

	ti.baseColour = ui_healthColour;
	ti.screenPosition = glm::vec2(infoTextX, infoTextY);
	render->text.renderText(ti);

	if (player->getCharacter()->getCurrentState().armour > 0)
	{
		std::stringstream ss;
		ss << "[" << std::setw(3) << std::setfill('0')
		   << (int)player->getCharacter()->getCurrentState().armour;
		ti.text = ss.str();
		ti.baseColour = ui_shadowColour;
		ti.screenPosition = glm::vec2(infoTextX + 1.f - ui_armourOffset, infoTextY+1.f);
		render->text.renderText(ti);

		ti.baseColour = ui_armourColour;
		ti.screenPosition = glm::vec2(infoTextX - ui_armourOffset, infoTextY);
		render->text.renderText(ti);
	}

	std::string s;
	for (int i = 0; i < ui_maxWantedLevel; ++i) {
		s += "]";
	}
	ti.text = s;
	ti.baseColour = ui_shadowColour;
	ti.screenPosition = glm::vec2(wantedX + 1.f, wantedY + 1.f);
	render->text.renderText(ti);

#if 0 // Useful for debugging
	ti.text = "ABCDEFGHIJKLMANOQRTSWXYZ\nM0123456789";
	ti.size = 30;
	ti.align = TextRenderer::TextInfo::Left;
	ti.baseColour = glm::vec3(0.f, 0.f, 0.f);
	ti.screenPosition = glm::vec2(101.f, 202.f);
	render->text.renderText(ti);
	ti.baseColour = glm::vec3(1.f, 1.f, 1.f);
	ti.screenPosition = glm::vec2(100.f, 200.f);
	render->text.renderText(ti);
#endif

	InventoryItem *current = player->getCharacter()->getActiveItem();
	std::string itemTextureName = "fist";
	if (current) {
		uint16_t model = current->getModelID();
		if (model > 0) {
			ObjectDataPtr weaponData = world
					->data
					->findObjectType<ObjectData>(model);
			if (weaponData != nullptr) {
				itemTextureName = weaponData->modelName;
			}
		}
	}
	// Urgh
	if (itemTextureName == "colt45") {
		itemTextureName = "pistol";
	}

	TextureData::Handle itemTexture = render->getData()->findTexture(itemTextureName);
	RW_CHECK(itemTexture != nullptr, "Item has 0 texture");
	if (itemTexture != nullptr) {
		RW_CHECK(itemTexture->getName() != 0, "Item has 0 texture");
		render->drawTexture(itemTexture.get(),
							glm::vec4(iconX,
									  iconY,
									  ui_weaponSize,
									  ui_weaponSize));
	}

	if (current) {
		WeaponItem* wep = static_cast<WeaponItem*>(current);
		if (wep->getWeaponData()->fireType != WeaponData::MELEE) {
			const CharacterState& cs = player->getCharacter()->getCurrentState();
			const CharacterWeaponSlot& slotInfo = cs.weapons[cs.currentWeapon];
			ti.text = std::to_string(slotInfo.bulletsClip) + "-"
					+ std::to_string(slotInfo.bulletsTotal);

			ti.baseColour = ui_shadowColour;
			ti.font = 2;
			ti.size = ui_ammoSize;
			ti.align = TextRenderer::TextInfo::Center;
			ti.screenPosition = glm::vec2(iconX + ui_weaponSize / 2.f,
										  iconY + ui_weaponSize - ui_ammoHeight);
			render->text.renderText(ti);
		}
	}
}