Page MenuHomePhabricator (Chris)
Files F631690

traits.as
No OneTemporary
Actions

Authored By
Unknown
Size
7 KB
Referenced Files
None
Subscribers
None

traits.as
View Options

#priority init 5500
#section game
import saving;
import hooks;
#section menu
class Hook {};
#section all
export Trait;
export getTrait, getTraitCount;
export TraitCategory;
export getTraitCategory, getTraitCategoryCount;
tidy final class Trait {
uint id;
const TraitCategory@ category;
string ident;
string name;
string description;
string unique;
Sprite icon;
Color color;
int order = 0;
int cost = 0;
int gives = 0;
bool defaultTrait = false;
bool available = true;
bool aiSupport = true;
string dlc;
array<ITraitEffect@> hooks;
array<string> hookDefs;
array<const Trait@> conflicts;
array<string> conflictDefs;
void preInit(Empire& emp, array<any>& data) const {
data.length = hooks.length;
for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
hooks[i].preInit(emp, data[i]);
}
void init(Empire& emp, array<any>& data) const {
for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
hooks[i].init(emp, data[i]);
}
void postInit(Empire& emp, array<any>& data) const {
data.length = hooks.length;
for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
hooks[i].postInit(emp, data[i]);
}
void tick(Empire& emp, array<any>& data, double time) const {
for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
hooks[i].tick(emp, data[i], time);
}
void save(array<any>& data, SaveFile& file) const {
for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
hooks[i].save(data[i], file);
}
void load(array<any>& data, SaveFile& file) const {
data.length = hooks.length;
for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
hooks[i].load(data[i], file);
}
void addConflict(const Trait@ other) {
if(conflicts.find(other) != -1)
return;
conflicts.insertLast(other);
}
bool get_hasDLC() const {
if(dlc.length == 0)
return true;
return hasDLC(dlc);
}
bool hasConflicts(const array<const Trait@>& list) const {
for(uint i = 0, cnt = list.length; i < cnt; ++i) {
auto@ other = list[i];
if(other is this)
continue;
if(conflicts.find(other) != -1)
return true;
if(unique.length != 0 && unique == other.unique)
return true;
}
return false;
}
int opCmp(const Trait@ other) const {
if(order < other.order)
return -1;
if(order > other.order)
return 1;
return 0;
}
bool opEquals(const Trait@ other) const {
return other.id == id;
}
};
interface ITraitEffect {
void preInit(Empire& emp, any@ data) const;
void init(Empire& emp, any@ data) const;
void postInit(Empire& emp, any@ data) const;
void tick(Empire& emp, any@ data, double time) const;
void save(any@ data, SaveFile& file) const;
void load(any@ data, SaveFile& file) const;
};
class TraitEffect : Hook, ITraitEffect {
void preInit(Empire& emp, any@ data) const {}
void init(Empire& emp, any@ data) const {}
void postInit(Empire& emp, any@ data) const {}
void tick(Empire& emp, any@ data, double time) const {}
void save(any@ data, SaveFile& file) const {}
void load(any@ data, SaveFile& file) const {}
};
array<Trait@> traits;
dictionary idents;
const Trait@ getTrait(uint id) {
if(id >= traits.length)
return null;
return traits[id];
}
const Trait@ getTrait(const string& ident) {
Trait@ def;
if(idents.get(ident, @def))
return def;
return null;
}
int getTraitID(const string& ident) {
auto@ type = getTrait(ident);
if(type is null)
return -1;
return int(type.id);
}
string getTraitIdent(int id) {
auto@ type = getTrait(id);
if(type is null)
return "";
return type.ident;
}
uint getTraitCount() {
return traits.length;
}
void addTrait(Trait@ type) {
type.id = traits.length;
traits.insertLast(type);
idents.set(type.ident, @type);
}
tidy final class TraitCategory {
uint id;
string ident;
string name;
TraitCategory(const string& ident) {
this.ident = ident;
name = localize("#TRAIT_CAT_"+ident);
if(name[0] == '#')
name = ident;
}
};
array<TraitCategory@> categories;
dictionary catIdents;
const TraitCategory@ getTraitCategory(uint id) {
if(id >= categories.length)
return null;
return categories[id];
}
const TraitCategory@ getTraitCategory(const string& ident, bool create = false) {
TraitCategory@ def;
if(catIdents.get(ident, @def))
return def;
if(create)
return addTraitCategory(TraitCategory(ident));
return null;
}
uint getTraitCategoryCount() {
return categories.length;
}
TraitCategory@ addTraitCategory(TraitCategory@ type) {
type.id = categories.length;
categories.insertLast(type);
catIdents.set(type.ident, @type);
return type;
}
void saveIdentifiers(SaveFile& file) {
#section game
for(uint i = 0, cnt = traits.length; i < cnt; ++i) {
auto type = traits[i];
file.addIdentifier(SI_Trait, type.id, type.ident);
}
#section all
}
void parseLine(string& line, Trait@ trait, ReadFile@ file) {
#section game
//Hook line
trait.hookDefs.insertLast(line);
#section all
}
void loadTraits(const string& filename) {
ReadFile file(filename, true);
string key, value;
Trait@ trait;
uint index = 0;
while(file++) {
key = file.key;
value = file.value;
if(file.fullLine) {
string line = file.line;
parseLine(line, trait, file);
}
else if(key.equals_nocase("Trait")) {
if(trait !is null)
addTrait(trait);
@trait = Trait();
trait.ident = value;
}
else if(trait is null) {
file.error("Missing trait ID' line");
}
else if(key.equals_nocase("Name")) {
trait.name = localize(value);
}
else if(key.equals_nocase("Description")) {
trait.description = localize(value);
}
else if(key.equals_nocase("Costs Points")) {
trait.cost = toInt(value);
}
else if(key.equals_nocase("Gives Points")) {
trait.gives = toInt(value);
}
else if(key.equals_nocase("Category")) {
@trait.category = getTraitCategory(value, create=true);
}
else if(key.equals_nocase("Icon")) {
trait.icon = getSprite(value);
}
else if(key.equals_nocase("Color")) {
trait.color = toColor(value);
}
else if(key.equals_nocase("Order")) {
trait.order = toInt(value);
}
else if(key.equals_nocase("Unique")) {
trait.unique = value;
}
else if(key.equals_nocase("Default")) {
trait.defaultTrait = toBool(value);
}
else if(key.equals_nocase("Available")) {
trait.available = toBool(value);
}
else if(key.equals_nocase("Conflict")) {
trait.conflictDefs.insertLast(value);
}
else if(key.equals_nocase("DLC")) {
trait.dlc = value;
}
else if(key.equals_nocase("AI Support")) {
trait.aiSupport = toBool(value);
}
else {
string line = file.line;
parseLine(line, trait, file);
}
}
if(trait !is null)
addTrait(trait);
}
export initTraits;
bool initialized = false;
void initTraits() {
if(initialized)
return;
initialized = true;
FileList list("data/traits", "*.txt", true);
for(uint i = 0, cnt = list.length; i < cnt; ++i)
loadTraits(list.path[i]);
}
void preInit() {
initTraits();
#section game
for(uint i = 0, cnt = traits.length; i < cnt; ++i) {
auto@ trait = traits[i];
for(uint n = 0, ncnt = trait.hookDefs.length; n < ncnt; ++n) {
auto@ hook = cast<ITraitEffect>(parseHook(trait.hookDefs[n], "trait_effects::", instantiate=false));
if(hook !is null)
trait.hooks.insertLast(hook);
}
}
#section all
}
void init() {
for(uint i = 0, cnt = traits.length; i < cnt; ++i) {
auto@ trait = traits[i];
#section game
for(uint n = 0, ncnt = trait.hooks.length; n < ncnt; ++n) {
if(!cast<Hook>(trait.hooks[n]).instantiate())
error("Could not instantiate hook "+addrstr(trait.hooks[n])+" on trait "+trait.ident);
}
#section all
for(uint n = 0, ncnt = trait.conflictDefs.length; n < ncnt; ++n) {
Trait@ other;
if(!idents.get(trait.conflictDefs[n], @other)) {
error("Could not find conflict trait "+trait.conflictDefs[n]+" in trait "+trait.ident);
continue;
}
trait.addConflict(other);
other.addConflict(trait);
}
}
}

File Metadata

Mime Type
text/x-c++
Expires
Sun, Nov 15, 12:32 PM (1 d, 15 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
130968
Default Alt Text
traits.as (7 KB)

Event Timeline