本文整理汇总了C++中Tile::addItem方法的典型用法代码示例。如果您正苦于以下问题:C++ Tile::addItem方法的具体用法?C++ Tile::addItem怎么用?C++ Tile::addItem使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类Tile
的用法示例。
在下文中一共展示了Tile::addItem方法的5个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: btnApplyTemplateClick
void InventoryState::btnApplyTemplateClick(Action *)
{
// don't accept clicks when moving items
// it's ok if the template is empty -- it will just result in clearing the
// unit's inventory
if (_inv->getSelectedItem() != 0)
{
return;
}
BattleUnit *unit = _battleGame->getSelectedUnit();
std::vector<BattleItem*> *unitInv = unit->getInventory();
Tile *groundTile = unit->getTile();
std::vector<BattleItem*> *groundInv = groundTile->getInventory();
RuleInventory *groundRuleInv = _game->getMod()->getInventory("STR_GROUND");
_clearInventory(_game, unitInv, groundTile);
// attempt to replicate inventory template by grabbing corresponding items
// from the ground. if any item is not found on the ground, display warning
// message, but continue attempting to fulfill the template as best we can
bool itemMissing = false;
std::vector<EquipmentLayoutItem*>::iterator templateIt;
for (templateIt = _curInventoryTemplate.begin(); templateIt != _curInventoryTemplate.end(); ++templateIt)
{
// search for template item in ground inventory
std::vector<BattleItem*>::iterator groundItem;
const bool needsAmmo = !_game->getMod()->getItem((*templateIt)->getItemType())->getCompatibleAmmo()->empty();
bool found = false;
bool rescan = true;
while (rescan)
{
rescan = false;
const std::string targetAmmo = (*templateIt)->getAmmoItem();
BattleItem *matchedWeapon = NULL;
BattleItem *matchedAmmo = NULL;
for (groundItem = groundInv->begin(); groundItem != groundInv->end(); ++groundItem)
{
// if we find the appropriate ammo, remember it for later for if we find
// the right weapon but with the wrong ammo
const std::string groundItemName = (*groundItem)->getRules()->getType();
if (needsAmmo && targetAmmo == groundItemName)
{
matchedAmmo = *groundItem;
}
if ((*templateIt)->getItemType() == groundItemName)
{
// if the loaded ammo doesn't match the template item's,
// remember the weapon for later and continue scanning
BattleItem *loadedAmmo = (*groundItem)->getAmmoItem();
if ((needsAmmo && loadedAmmo && targetAmmo != loadedAmmo->getRules()->getType())
|| (needsAmmo && !loadedAmmo))
{
// remember the last matched weapon for simplicity (but prefer empty weapons if any are found)
if (!matchedWeapon || matchedWeapon->getAmmoItem())
{
matchedWeapon = *groundItem;
}
continue;
}
// move matched item from ground to the appropriate inv slot
(*groundItem)->setOwner(unit);
(*groundItem)->setSlot(_game->getMod()->getInventory((*templateIt)->getSlot()));
(*groundItem)->setSlotX((*templateIt)->getSlotX());
(*groundItem)->setSlotY((*templateIt)->getSlotY());
(*groundItem)->setFuseTimer((*templateIt)->getFuseTimer());
unitInv->push_back(*groundItem);
groundInv->erase(groundItem);
found = true;
break;
}
}
// if we failed to find an exact match, but found unloaded ammo and
// the right weapon, unload the target weapon, load the right ammo, and use it
if (!found && matchedWeapon && (!needsAmmo || matchedAmmo))
{
// unload the existing ammo (if any) from the weapon
BattleItem *loadedAmmo = matchedWeapon->getAmmoItem();
if (loadedAmmo)
{
groundTile->addItem(loadedAmmo, groundRuleInv);
matchedWeapon->setAmmoItem(NULL);
}
// load the correct ammo into the weapon
if (matchedAmmo)
{
matchedWeapon->setAmmoItem(matchedAmmo);
groundTile->removeItem(matchedAmmo);
}
// rescan and pick up the newly-loaded/unloaded weapon
rescan = true;
}
}
//.........这里部分代码省略.........
示例2: FillDoodadPreviewBuffer
//.........这里部分代码省略.........
if(random(brush->getTotalChance(GetBrushVariation())) <= brush->getCompositeChance(GetBrushVariation())) {
// Composite
const CompositeTileList& composites = brush->getComposite(GetBrushVariation());
// Figure out if the placement is valid
for(CompositeTileList::const_iterator composite_iter = composites.begin();
composite_iter != composites.end();
++composite_iter)
{
Position pos = center_pos + composite_iter->first + Position(xpos, ypos, 0);
if(Tile* tile = doodad_buffer_map->getTile(pos)) {
if(tile->size() > 0) {
fail = true;
break;
}
}
}
if(fail) {
++retries;
break;
}
// Transfer items to the stack
for(CompositeTileList::const_iterator composite_iter = composites.begin();
composite_iter != composites.end();
++composite_iter)
{
Position pos = center_pos + composite_iter->first + Position(xpos, ypos, 0);
const ItemVector& items = composite_iter->second;
Tile* tile = doodad_buffer_map->getTile(pos);
if(!tile)
tile = doodad_buffer_map->allocator(doodad_buffer_map->createTileL(pos));
for(ItemVector::const_iterator item_iter = items.begin();
item_iter != items.end();
++item_iter)
{
tile->addItem((*item_iter)->deepCopy());
}
doodad_buffer_map->setTile(tile->getPosition(), tile);
}
exit = true;
} else if(brush->hasSingleObjects(GetBrushVariation())) {
Position pos = center_pos + Position(xpos, ypos, 0);
Tile* tile = doodad_buffer_map->getTile(pos);
if(tile) {
if(tile->size() > 0) {
fail = true;
break;
}
} else {
tile = doodad_buffer_map->allocator(doodad_buffer_map->createTileL(pos));
}
int variation = GetBrushVariation();
brush->draw(doodad_buffer_map, tile, &variation);
//std::cout << "\tpos: " << tile->getPosition() << std::endl;
doodad_buffer_map->setTile(tile->getPosition(), tile);
exit = true;
}
if(fail) {
++retries;
break;
}
}
++object_count;
}
} else {
if(brush->hasCompositeObjects(GetBrushVariation()) &&
random(brush->getTotalChance(GetBrushVariation())) <= brush->getCompositeChance(GetBrushVariation())) {
// Composite
const CompositeTileList& composites = brush->getComposite(GetBrushVariation());
// All placement is valid...
// Transfer items to the buffer
for(CompositeTileList::const_iterator composite_iter = composites.begin();
composite_iter != composites.end();
++composite_iter) {
Position pos = center_pos + composite_iter->first;
const ItemVector& items = composite_iter->second;
Tile* tile = doodad_buffer_map->allocator(doodad_buffer_map->createTileL(pos));
//std::cout << pos << " = " << center_pos << " + " << buffer_tile->getPosition() << std::endl;
for(ItemVector::const_iterator item_iter = items.begin();
item_iter != items.end();
++item_iter)
{
tile->addItem((*item_iter)->deepCopy());
}
doodad_buffer_map->setTile(tile->getPosition(), tile);
}
} else if(brush->hasSingleObjects(GetBrushVariation())) {
Tile* tile = doodad_buffer_map->allocator(doodad_buffer_map->createTileL(center_pos));
int variation = GetBrushVariation();
brush->draw(doodad_buffer_map, tile, &variation);
doodad_buffer_map->setTile(center_pos, tile);
}
}
}
示例3: convert
bool Map::convert(const ConversionMap& rm, bool showdialog)
{
if(showdialog)
gui.CreateLoadBar(wxT("Converting map ..."));
uint64_t tiles_done = 0;
std::vector<uint16_t> id_list;
//std::ofstream conversions("converted_items.txt");
for(MapIterator miter = begin(); miter != end(); ++miter) {
Tile* tile = (*miter)->get();
ASSERT(tile);
if(tile->size() == 0)
continue;
// id_list try MTM conversion
id_list.clear();
if(tile->ground)
id_list.push_back(tile->ground->getID());
for(ItemVector::const_iterator item_iter = tile->items.begin(); item_iter != tile->items.end(); ++item_iter)
if((*item_iter)->isBorder())
id_list.push_back((*item_iter)->getID());
std::sort(id_list.begin(), id_list.end());
ConversionMap::MTM::const_iterator cfmtm = rm.mtm.end();
while(id_list.size()) {
cfmtm = rm.mtm.find(id_list);
if(cfmtm != rm.mtm.end())
break;
id_list.pop_back();
}
// Keep track of how many items have been inserted at the bottom
size_t inserted_items = 0;
if(cfmtm != rm.mtm.end()) {
const std::vector<uint16_t>& v = cfmtm->first;
if(tile->ground && std::find(v.begin(), v.end(), tile->ground->getID()) != v.end()) {
delete tile->ground;
tile->ground = nullptr;
}
for(ItemVector::iterator item_iter = tile->items.begin(); item_iter != tile->items.end(); ) {
if(std::find(v.begin(), v.end(), (*item_iter)->getID()) != v.end()) {
delete *item_iter;
item_iter = tile->items.erase(item_iter);
}
else
++item_iter;
}
const std::vector<uint16_t>& new_items = cfmtm->second;
for(std::vector<uint16_t>::const_iterator iit = new_items.begin(); iit != new_items.end(); ++iit) {
Item* item = Item::Create(*iit);
if(item->isGroundTile())
tile->ground = item;
else {
tile->items.insert(tile->items.begin(), item);
++inserted_items;
}
}
}
if(tile->ground) {
ConversionMap::STM::const_iterator cfstm = rm.stm.find(tile->ground->getID());
if(cfstm != rm.stm.end()) {
uint16_t aid = tile->ground->getActionID();
uint16_t uid = tile->ground->getUniqueID();
delete tile->ground;
tile->ground = nullptr;
const std::vector<uint16_t>& v = cfstm->second;
//conversions << "Converted " << tile->getX() << ":" << tile->getY() << ":" << tile->getZ() << " " << id << " -> ";
for(std::vector<uint16_t>::const_iterator iit = v.begin(); iit != v.end(); ++iit) {
Item* item = Item::Create(*iit);
//conversions << *iit << " ";
if(item->isGroundTile()) {
item->setActionID(aid);
item->setUniqueID(uid);
tile->addItem(item);
} else {
tile->items.insert(tile->items.begin(), item);
++inserted_items;
}
}
//conversions << std::endl;
}
}
for(ItemVector::iterator replace_item_iter = tile->items.begin() + inserted_items; replace_item_iter != tile->items.end(); ) {
uint16_t id = (*replace_item_iter)->getID();
ConversionMap::STM::const_iterator cf = rm.stm.find(id);
if(cf != rm.stm.end()) {
//uint16_t aid = (*replace_item_iter)->getActionID();
//.........这里部分代码省略.........
示例4: readTile
Tile* LiveSocket::readTile(BinaryNode* node, Editor& editor, const Position* position)
{
ASSERT(node != nullptr);
Map& map = editor.map;
uint8_t tileType;
node->getByte(tileType);
if(tileType != OTBM_TILE && tileType != OTBM_HOUSETILE) {
return nullptr;
}
Position pos;
if(position) {
pos = *position;
} else {
uint16_t x; node->getU16(x); pos.x = x;
uint16_t y; node->getU16(y); pos.y = y;
uint8_t z; node->getU8(z); pos.z = z;
}
Tile* tile = map.allocator(
map.createTileL(pos)
);
if(tileType == OTBM_HOUSETILE) {
uint32_t houseId;
if(!node->getU32(houseId)) {
//warning(wxT("House tile without house data, discarding tile"));
delete tile;
return nullptr;
}
if(houseId) {
House* house = map.houses.getHouse(houseId);
if(house) {
tile->setHouse(house);
}
} else {
//warning(wxT("Invalid house id from tile %d:%d:%d"), pos.x, pos.y, pos.z);
}
}
uint8_t attribute;
while(node->getU8(attribute)) {
switch (attribute) {
case OTBM_ATTR_TILE_FLAGS: {
uint32_t flags = 0;
if(!node->getU32(flags)) {
//warning(wxT("Invalid tile flags of tile on %d:%d:%d"), pos.x, pos.y, pos.z);
}
tile->setMapFlags(flags);
break;
}
case OTBM_ATTR_ITEM: {
Item* item = Item::Create_OTBM(mapVersion, node);
if(!item) {
//warning(wxT("Invalid item at tile %d:%d:%d"), pos.x, pos.y, pos.z);
}
tile->addItem(item);
break;
}
default:
//warning(wxT("Unknown tile attribute at %d:%d:%d"), pos.x, pos.y, pos.z);
break;
}
}
//for(BinaryNode* itemNode = node->getChild(); itemNode; itemNode->advance()) {
BinaryNode* itemNode = node->getChild();
if(itemNode) do {
uint8_t itemType;
if(!itemNode->getByte(itemType)) {
//warning(wxT("Unknown item type %d:%d:%d"), pos.x, pos.y, pos.z);
delete tile;
return nullptr;
}
if(itemType == OTBM_ITEM) {
Item* item = Item::Create_OTBM(mapVersion, itemNode);
if(item) {
if(!item->unserializeItemNode_OTBM(mapVersion, itemNode)) {
//warning(wxT("Couldn't unserialize item attributes at %d:%d:%d"), pos.x, pos.y, pos.z);
}
tile->addItem(item);
}
} else {
//warning(wxT("Unknown type of tile child node"));
}
//}
} while(itemNode->advance());
return tile;
}
示例5: loadMap
//.........这里部分代码省略.........
warning(wxT("Could not read position of tile"));
continue;
}
const Position pos(x_offset, y_offset, z_offset);
if(map.getTile(pos)) {
warning(wxT("Duplicate tile at %d:%d:%d, discarding duplicate"), pos.x, pos.y, pos.z);
continue;
}
tile = map.allocator(pos);
House* house = NULL;
if(tile_type == OTMM_HOUSETILE) {
uint32_t house_id;
if(!tileNode->getU32(house_id)) {
warning(wxT("House tile without house data, discarding tile"));
continue;
}
if(house_id) {
house = map.houses.getHouse(house_id);
if(!house) {
house = newd House(map);
house->id = house_id;
map.houses.addHouse(house);
}
} else {
warning(wxT("Invalid house id from tile %d:%d:%d"), pos.x, pos.y, pos.z);
}
}
uint16_t ground_id;
tileNode->getU16(ground_id);
if(ground_id != 0) {
tile->addItem(Item::Create(ground_id));
}
uint8_t attribute;
while(tileNode->getU8(attribute)) {
switch(attribute) {
case OTMM_ATTR_TILE_FLAGS: {
uint32_t flags = 0;
if(!tileNode->getU32(flags)) {
warning(wxT("Invalid tile flags of tile on %d:%d:%d"), pos.x, pos.y, pos.z);
}
tile->setMapFlags(flags);
} break;
default: {
warning(wxT("Unknown tile attribute at %d:%d:%d"), pos.x, pos.y, pos.z);
} break;
}
}
BinaryNode* itemNode = tileNode->getChild();
if(itemNode) do {
Item* item = NULL;
uint8_t item_type;
if(!itemNode->getByte(item_type)) {
warning(wxT("Unknown item type %d:%d:%d"), pos.x, pos.y, pos.z);
continue;
}
if(item_type == OTMM_ITEM) {
item = Item::Create_OTMM(*this, itemNode);
if(item) {
if(item->unserializeItemNode_OTMM(*this, itemNode) == false) {
warning(wxT("Couldn't unserialize item attributes at %d:%d:%d"), pos.x, pos.y, pos.z);
}