1
0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-10 09:50:17 +02:00
vcmi/lib/mapObjectConstructors/CommonConstructors.cpp

275 lines
7.3 KiB
C++
Raw Normal View History

/*
* CommonConstructors.cpp, part of VCMI engine
*
* Authors: listed in file AUTHORS in main folder
*
* License: GNU General Public License v2.0 or later
* Full text of license available in license.txt file, in main folder
*
*/
#include "StdInc.h"
#include "CommonConstructors.h"
#include "../CGeneralTextHandler.h"
#include "../CHeroHandler.h"
#include "../CTownHandler.h"
#include "../IGameCallback.h"
#include "../json/JsonRandom.h"
#include "../constants/StringConstants.h"
#include "../TerrainHandler.h"
#include "../VCMI_Lib.h"
#include "../mapObjects/CGHeroInstance.h"
#include "../mapObjects/CGMarket.h"
#include "../mapObjects/CGTownInstance.h"
#include "../mapObjects/MiscObjects.h"
#include "../mapObjects/ObjectTemplate.h"
#include "../modding/IdentifierStorage.h"
#include "../mapping/CMapDefines.h"
VCMI_LIB_NAMESPACE_BEGIN
bool CObstacleConstructor::isStaticObject()
{
return true;
}
2023-07-15 13:50:09 +02:00
bool CreatureInstanceConstructor::hasNameTextID() const
{
return true;
}
std::string CreatureInstanceConstructor::getNameTextID() const
{
return VLC->creatures()->getByIndex(getSubIndex())->getNamePluralTextID();
}
bool ResourceInstanceConstructor::hasNameTextID() const
{
return true;
}
std::string ResourceInstanceConstructor::getNameTextID() const
{
return TextIdentifier("core", "restypes", getSubIndex()).get();
}
void CTownInstanceConstructor::initTypeData(const JsonNode & input)
{
VLC->identifiers()->requestIdentifier("faction", input["faction"], [&](si32 index)
{
faction = (*VLC->townh)[index];
});
filtersJson = input["filters"];
2022-11-30 17:36:55 +02:00
// change scope of "filters" to scope of object that is being loaded
// since this filters require to resolve building ID's
filtersJson.setMeta(input["faction"].meta);
}
void CTownInstanceConstructor::afterLoadFinalization()
{
assert(faction);
2023-02-12 22:39:17 +02:00
for(const auto & entry : filtersJson.Struct())
{
filters[entry.first] = LogicalExpression<BuildingID>(entry.second, [this](const JsonNode & node)
{
return BuildingID(VLC->identifiers()->getIdentifier("building." + faction->getJsonKey(), node.Vector()[0]).value_or(-1));
});
}
}
bool CTownInstanceConstructor::objectFilter(const CGObjectInstance * object, std::shared_ptr<const ObjectTemplate> templ) const
{
2023-02-12 22:39:17 +02:00
const auto * town = dynamic_cast<const CGTownInstance *>(object);
auto buildTest = [&](const BuildingID & id)
{
return town->hasBuilt(id);
};
return filters.count(templ->stringID) != 0 && filters.at(templ->stringID).test(buildTest);
}
void CTownInstanceConstructor::initializeObject(CGTownInstance * obj) const
{
obj->town = faction->town;
obj->tempOwner = PlayerColor::NEUTRAL;
}
void CTownInstanceConstructor::randomizeObject(CGTownInstance * object, CRandomGenerator & rng) const
{
2024-01-01 16:37:48 +02:00
auto templ = getOverride(object->cb->getTile(object->pos)->terType->getId(), object);
if(templ)
object->appearance = templ;
}
2023-07-15 13:50:09 +02:00
bool CTownInstanceConstructor::hasNameTextID() const
{
return true;
}
std::string CTownInstanceConstructor::getNameTextID() const
{
return faction->getNameTextID();
}
void CHeroInstanceConstructor::initTypeData(const JsonNode & input)
{
VLC->identifiers()->requestIdentifier(
"heroClass",
input["heroClass"],
[&](si32 index) { heroClass = HeroClassID(index).toHeroClass(); });
filtersJson = input["filters"];
}
void CHeroInstanceConstructor::afterLoadFinalization()
{
2023-02-12 22:39:17 +02:00
for(const auto & entry : filtersJson.Struct())
{
filters[entry.first] = LogicalExpression<HeroTypeID>(entry.second, [](const JsonNode & node)
{
return HeroTypeID(VLC->identifiers()->getIdentifier("hero", node.Vector()[0]).value_or(-1));
});
}
}
bool CHeroInstanceConstructor::objectFilter(const CGObjectInstance * object, std::shared_ptr<const ObjectTemplate> templ) const
{
2023-02-12 22:39:17 +02:00
const auto * hero = dynamic_cast<const CGHeroInstance *>(object);
auto heroTest = [&](const HeroTypeID & id)
{
return hero->type->getId() == id;
};
if(filters.count(templ->stringID))
{
return filters.at(templ->stringID).test(heroTest);
}
return false;
}
void CHeroInstanceConstructor::initializeObject(CGHeroInstance * obj) const
{
obj->type = nullptr; //FIXME: set to valid value. somehow.
}
void CHeroInstanceConstructor::randomizeObject(CGHeroInstance * object, CRandomGenerator & rng) const
{
}
2023-07-15 13:50:09 +02:00
bool CHeroInstanceConstructor::hasNameTextID() const
{
return true;
}
std::string CHeroInstanceConstructor::getNameTextID() const
{
return heroClass->getNameTextID();
}
2023-04-18 15:27:39 +02:00
void BoatInstanceConstructor::initTypeData(const JsonNode & input)
{
2023-04-18 22:14:15 +02:00
layer = EPathfindingLayer::SAIL;
int pos = vstd::find_pos(NPathfindingLayer::names, input["layer"].String());
if(pos != -1)
layer = EPathfindingLayer(pos);
else
logMod->error("Unknown layer %s found in boat!", input["layer"].String());
2023-04-19 00:11:24 +02:00
onboardAssaultAllowed = input["onboardAssaultAllowed"].Bool();
onboardVisitAllowed = input["onboardVisitAllowed"].Bool();
actualAnimation = AnimationPath::fromJson(input["actualAnimation"]);
overlayAnimation = AnimationPath::fromJson(input["overlayAnimation"]);
2023-04-18 22:14:15 +02:00
for(int i = 0; i < flagAnimations.size() && i < input["flagAnimations"].Vector().size(); ++i)
flagAnimations[i] = AnimationPath::fromJson(input["flagAnimations"].Vector()[i]);
2023-04-18 23:11:51 +02:00
bonuses = JsonRandom::loadBonuses(input["bonuses"]);
2023-04-18 15:27:39 +02:00
}
void BoatInstanceConstructor::initializeObject(CGBoat * boat) const
2023-04-18 15:27:39 +02:00
{
boat->layer = layer;
2023-04-18 22:14:15 +02:00
boat->actualAnimation = actualAnimation;
boat->overlayAnimation = overlayAnimation;
boat->flagAnimations = flagAnimations;
2023-06-07 20:10:04 +02:00
boat->onboardAssaultAllowed = onboardAssaultAllowed;
boat->onboardVisitAllowed = onboardVisitAllowed;
2023-04-18 23:11:51 +02:00
for(auto & b : bonuses)
boat->addNewBonus(std::make_shared<Bonus>(b));
2023-04-18 15:27:39 +02:00
}
AnimationPath BoatInstanceConstructor::getBoatAnimationName() const
{
return actualAnimation;
}
2023-04-28 03:16:10 +02:00
void MarketInstanceConstructor::initTypeData(const JsonNode & input)
{
for(auto & element : input["modes"].Vector())
{
if(MappedKeys::MARKET_NAMES_TO_TYPES.count(element.String()))
marketModes.insert(MappedKeys::MARKET_NAMES_TO_TYPES.at(element.String()));
}
marketEfficiency = input["efficiency"].isNull() ? 5 : input["efficiency"].Integer();
2023-04-28 03:16:10 +02:00
predefinedOffer = input["offer"];
title = input["title"].String();
speech = input["speech"].String();
}
2024-01-01 16:37:48 +02:00
CGMarket * MarketInstanceConstructor::createObject(IGameCallback * cb) const
2023-04-28 03:16:10 +02:00
{
if(marketModes.size() == 1)
{
switch(*marketModes.begin())
{
case EMarketMode::ARTIFACT_RESOURCE:
case EMarketMode::RESOURCE_ARTIFACT:
2024-01-01 16:37:48 +02:00
return new CGBlackMarket(cb);
2023-04-28 03:16:10 +02:00
case EMarketMode::RESOURCE_SKILL:
2024-01-01 16:37:48 +02:00
return new CGUniversity(cb);
2023-04-28 03:16:10 +02:00
}
}
2024-01-12 23:57:19 +02:00
else if(marketModes.size() == 2)
{
if(vstd::contains(marketModes, EMarketMode::ARTIFACT_EXP))
return new CGArtifactsAltar(cb);
}
2024-01-01 16:37:48 +02:00
return new CGMarket(cb);
}
2023-04-28 03:16:10 +02:00
void MarketInstanceConstructor::initializeObject(CGMarket * market) const
{
2023-04-28 03:16:10 +02:00
market->marketModes = marketModes;
market->marketEfficiency = marketEfficiency;
2023-04-28 03:16:10 +02:00
2023-04-29 17:08:42 +02:00
market->title = market->getObjectName();
if(!title.empty())
market->title = VLC->generaltexth->translate(title);
2023-05-25 18:35:21 +02:00
if (!speech.empty())
market->speech = VLC->generaltexth->translate(speech);
2023-04-28 03:16:10 +02:00
}
void MarketInstanceConstructor::randomizeObject(CGMarket * object, CRandomGenerator & rng) const
2023-04-28 03:16:10 +02:00
{
2024-01-01 16:37:48 +02:00
JsonRandom randomizer(object->cb);
JsonRandom::Variables emptyVariables;
2023-04-28 03:16:10 +02:00
if(auto * university = dynamic_cast<CGUniversity *>(object))
{
2024-01-01 16:37:48 +02:00
for(auto skill : randomizer.loadSecondaries(predefinedOffer, rng, emptyVariables))
university->skills.push_back(skill.first);
2023-04-28 03:16:10 +02:00
}
}
VCMI_LIB_NAMESPACE_END