void House::removePlayers(bool ignoreInvites)
{
PlayerVector kickList;
for(HouseTileList::iterator it = houseTiles.begin(); it != houseTiles.end(); ++it)
{
CreatureVector* creatures = (*it)->getCreatures();
if(!creatures)
continue;
Player* player = nullptr;
for(CreatureVector::iterator cit = creatures->begin(); cit != creatures->end(); ++cit)
{
if((player = (*cit)->getPlayer()) && !player->isRemoved()
&& (ignoreInvites || !isInvited(player)))
kickList.push_back(player);
}
}
if(kickList.empty())
return;
for(PlayerVector::iterator it = kickList.begin(); it != kickList.end(); ++it)
removePlayer((*it), false);
}
void Tile::removeThing(Thing* thing, uint32_t count)
{
Creature* creature = thing->getCreature();
if (creature) {
CreatureVector* creatures = getCreatures();
if (creatures) {
CreatureVector::iterator it = std::find(creatures->begin(), creatures->end(), thing);
if (it != creatures->end()) {
g_game.map.clearSpectatorCache();
creatures->erase(it);
}
}
return;
}
Item* item = thing->getItem();
if (!item) {
return;
}
int32_t index = getThingIndex(item);
if (index == -1) {
return;
}
if (item == ground) {
ground->setParent(nullptr);
ground = nullptr;
SpectatorVec list;
g_game.map.getSpectators(list, getPosition(), true);
onRemoveTileItem(list, std::vector<int32_t>(list.size(), 0), item);
return;
}
TileItemVector* items = getItemList();
if (!items) {
return;
}
const ItemType& itemType = Item::items[item->getID()];
if (itemType.alwaysOnTop) {
auto it = std::find(items->getBeginTopItem(), items->getEndTopItem(), item);
if (it == items->getEndTopItem()) {
return;
}
std::vector<int32_t> oldStackPosVector;
SpectatorVec list;
g_game.map.getSpectators(list, getPosition(), true);
for (Creature* spectator : list) {
if (Player* tmpPlayer = spectator->getPlayer()) {
oldStackPosVector.push_back(getStackposOfItem(tmpPlayer, item));
}
}
item->setParent(nullptr);
items->erase(it);
onRemoveTileItem(list, oldStackPosVector, item);
} else {
auto it = std::find(items->getBeginDownItem(), items->getEndDownItem(), item);
if (it == items->getEndDownItem()) {
return;
}
if (itemType.stackable && count != item->getItemCount()) {
uint8_t newCount = static_cast<uint8_t>(std::max<int32_t>(0, static_cast<int32_t>(item->getItemCount() - count)));
item->setItemCount(newCount);
onUpdateTileItem(item, itemType, item, itemType);
} else {
std::vector<int32_t> oldStackPosVector;
SpectatorVec list;
g_game.map.getSpectators(list, getPosition(), true);
for (Creature* spectator : list) {
if (Player* tmpPlayer = spectator->getPlayer()) {
oldStackPosVector.push_back(getStackposOfItem(tmpPlayer, item));
}
}
item->setParent(nullptr);
items->erase(it);
items->addDownItemCount(-1);
onRemoveTileItem(list, oldStackPosVector, item);
}
}
}
bool Creature::onDeath()
{
DeathList deathList = getKillers();
bool deny = false;
CreatureEventList prepareDeathEvents = getCreatureEvents(CREATURE_EVENT_PREPAREDEATH);
for(CreatureEventList::iterator it = prepareDeathEvents.begin(); it != prepareDeathEvents.end(); ++it)
{
if(!(*it)->executePrepareDeath(this, deathList) && !deny)
deny = true;
}
if(deny)
return false;
int32_t i = 0, size = deathList.size(), limit = g_config.getNumber(ConfigManager::DEATH_ASSISTS) + 1;
if(limit > 0 && size > limit)
size = limit;
Creature* tmp = NULL;
CreatureVector justifyVec;
for(DeathList::iterator it = deathList.begin(); it != deathList.end(); ++it, ++i)
{
if(it->isNameKill())
continue;
if(it == deathList.begin())
it->setLast();
if(i < size)
{
if(it->getKillerCreature()->getPlayer())
tmp = it->getKillerCreature();
else if(it->getKillerCreature()->getPlayerMaster())
tmp = it->getKillerCreature()->getMaster();
}
if(tmp)
{
if(std::find(justifyVec.begin(), justifyVec.end(), tmp) == justifyVec.end())
{
it->setJustify();
justifyVec.push_back(tmp);
}
tmp = NULL;
}
if(!it->getKillerCreature()->onKilledCreature(this, (*it)) && it->isLast())
return false;
}
for(CountMap::iterator it = damageMap.begin(); it != damageMap.end(); ++it)
{
if((tmp = g_game.getCreatureByID(it->first)))
tmp->onTargetKilled(this);
}
dropCorpse(deathList);
if(master)
master->removeSummon(this);
return true;
}
void Tile::__addThing(int32_t index, Thing* thing)
{
Creature* creature = thing->getCreature();
if(creature){
g_game.clearSpectatorCache();
creature->setParent(this);
CreatureVector* creatures = makeCreatures();
creatures->insert(creatures->end(), creature);
++thingCount;
}
else{
Item* item = thing->getItem();
if(item == NULL){
#ifdef __DEBUG__MOVESYS__
std::cout << "Failure: [Tile::__addThing] item == NULL" << std::endl;
DEBUG_REPORT
#endif
return /*RET_NOTPOSSIBLE*/;
}
TileItemVector* items = getItemList();
if(items && items->size() > 0xFFFF){
return /*RET_NOTPOSSIBLE*/;
}
item->setParent(this);
if(item->isGroundTile()){
if(ground == NULL){
ground = item;
++thingCount;
onAddTileItem(item);
}
else{
const ItemType& oldType = Item::items[ground->getID()];
const ItemType& newType = Item::items[item->getID()];
int32_t oldGroundIndex = __getIndexOfThing(ground);
Item* oldGround = ground;
ground->setParent(NULL);
g_game.FreeThing(ground);
ground = item;
updateTileFlags(oldGround, true);
updateTileFlags(item, false);
onUpdateTileItem(oldGround, oldType, item, newType);
postRemoveNotification(oldGround, NULL, oldGroundIndex, true);
}
}
else if(item->isAlwaysOnTop()){
if(item->isSplash()){
//remove old splash if exists
if(items){
for(ItemVector::iterator it = items->getBeginTopItem(); it != items->getEndTopItem(); ++it){
if((*it)->isSplash()){
int32_t oldSplashIndex = __getIndexOfThing(*it);
Item* oldSplash = *it;
__removeThing(oldSplash, 1);
oldSplash->setParent(NULL);
g_game.FreeThing(oldSplash);
postRemoveNotification(oldSplash, NULL, oldSplashIndex, true);
break;
}
}
}
}
bool isInserted = false;
if(items){
for(ItemVector::iterator it = items->getBeginTopItem(); it != items->getEndTopItem(); ++it){
//Note: this is different from internalAddThing
if(Item::items[item->getID()].alwaysOnTopOrder <= Item::items[(*it)->getID()].alwaysOnTopOrder){
items->insert(it, item);
++thingCount;
isInserted = true;
break;
}
}
}
else{
items = makeItemList();
}
if(!isInserted){
items->push_back(item);
++thingCount;
}
onAddTileItem(item);
}
else{
if(item->isMagicField()){
//remove old field item if exists
if(items){
MagicField* oldField = NULL;
for(ItemVector::iterator it = items->getBeginDownItem(); it != items->getEndDownItem(); ++it){
if((oldField = (*it)->getMagicField())){
if(oldField->isReplaceable()){
int32_t oldFieldIndex = __getIndexOfThing(*it);
__removeThing(oldField, 1);
oldField->setParent(NULL);
g_game.FreeThing(oldField);
postRemoveNotification(oldField, NULL, oldFieldIndex, true);
break;
}
else{
//This magic field cannot be replaced.
item->setParent(NULL);
g_game.FreeThing(item);
return;
}
}
}
}
}
items = makeItemList();
items->insert(items->getBeginDownItem(), item);
++items->downItemCount;
++thingCount;
onAddTileItem(item);
}
}
void Tile::__removeThing(Thing* thing, uint32_t count)
{
Creature* creature = thing->getCreature();
if (creature) {
CreatureVector* creatures = getCreatures();
if (creatures) {
CreatureVector::iterator it = std::find(creatures->begin(), creatures->end(), thing);
if (it != creatures->end()) {
g_game.clearSpectatorCache();
creatures->erase(it);
}
}
return;
}
Item* item = thing->getItem();
if (item) {
int32_t index = __getIndexOfThing(item);
if (index == -1) {
return;
}
if (item == ground) {
const SpectatorVec& list = g_game.getSpectators(getPosition());
std::vector<uint32_t> oldStackPosVector;
for (SpectatorVec::const_iterator it = list.begin(), end = list.end(); it != end; ++it) {
if (Player* tmpPlayer = (*it)->getPlayer()) {
oldStackPosVector.push_back(getClientIndexOfThing(tmpPlayer, ground));
}
}
ground->setParent(NULL);
ground = NULL;
onRemoveTileItem(list, oldStackPosVector, item);
return;
}
if (item->isAlwaysOnTop()) {
TileItemVector* items = getItemList();
if (items) {
for (ItemVector::iterator it = items->getBeginTopItem(); it != items->getEndTopItem(); ++it) {
if (*it == item) {
const SpectatorVec& list = g_game.getSpectators(getPosition());
std::vector<uint32_t> oldStackPosVector;
for (SpectatorVec::const_iterator iit = list.begin(), iend = list.end(); iit != iend; ++iit) {
if (Player* tmpPlayer = (*iit)->getPlayer()) {
oldStackPosVector.push_back(getClientIndexOfThing(tmpPlayer, *it));
}
}
(*it)->setParent(NULL);
items->erase(it);
onRemoveTileItem(list, oldStackPosVector, item);
return;
}
}
}
} else {
TileItemVector* items = getItemList();
if (items) {
for (ItemVector::iterator it = items->getBeginDownItem(); it != items->getEndDownItem(); ++it) {
if (*it == item) {
if (item->isStackable() && count != item->getItemCount()) {
uint8_t newCount = (uint8_t)std::max<int32_t>(0, (int32_t)(item->getItemCount() - count));
updateTileFlags(item, true);
item->setItemCount(newCount);
updateTileFlags(item, false);
const ItemType& it = Item::items[item->getID()];
onUpdateTileItem(item, it, item, it);
} else {
const SpectatorVec& list = g_game.getSpectators(getPosition());
std::vector<uint32_t> oldStackPosVector;
for (SpectatorVec::const_iterator iit = list.begin(), iend = list.end(); iit != iend; ++iit) {
if (Player* tmpPlayer = (*iit)->getPlayer()) {
oldStackPosVector.push_back(getClientIndexOfThing(tmpPlayer, *it));
}
}
(*it)->setParent(NULL);
items->erase(it);
--items->downItemCount;
onRemoveTileItem(list, oldStackPosVector, item);
}
return;
}
}
}
}
}
}
