//
// E_ProcessInventoryDeltas
//
// Does processing for inventorydelta sections, which allow cascading editing
// of existing inventory items. The inventorydelta shares most of its fields
// and processing code with the thingtype section.
//
void E_ProcessInventoryDeltas(cfg_t *cfg)
{
int i, numdeltas;
E_EDFLogPuts("\t* Processing inventory deltas\n");
numdeltas = cfg_size(cfg, EDF_SEC_INVDELTA);
E_EDFLogPrintf("\t\t%d inventorydelta(s) defined\n", numdeltas);
for(i = 0; i < numdeltas; i++)
{
cfg_t *deltasec = cfg_getnsec(cfg, EDF_SEC_INVDELTA, i);
inventory_t *inv;
// get thingtype to edit
if(!cfg_size(deltasec, ITEM_DELTA_NAME))
E_EDFLoggedErr(2, "E_ProcessInventoryDeltas: inventorydelta requires name field\n");
inv = E_GetInventoryForName(cfg_getstr(deltasec, ITEM_DELTA_NAME));
E_ProcessInventory(inv, deltasec, cfg, false);
E_EDFLogPrintf("\t\tApplied inventorydelta #%d to %s(#%d)\n",
i, inv->name, inv->numkey);
}
}
//
// E_ProcessInventoryDefs
//
// Resolves and loads all information for the inventory structures.
//
void E_ProcessInventoryDefs(cfg_t *cfg)
{
unsigned int i, numInventory;
E_EDFLogPuts("\t* Processing inventory data\n");
if(!(numInventory = cfg_size(cfg, EDF_SEC_INVENTORY)))
return;
// allocate inheritance stack and hitlist
inv_pstack = ecalloc(inventory_t **, numInventoryDefs, sizeof(inventory_t *));
// TODO: any first-time-only processing?
for(i = 0; i < numInventory; i++)
{
cfg_t *invsec = cfg_getnsec(cfg, EDF_SEC_INVENTORY, i);
const char *name = cfg_title(invsec);
inventory_t *inv = E_InventoryForName(name);
// reset the inheritance stack
E_ResetInventoryPStack();
// add this def to the stack
E_AddInventoryToPStack(inv);
E_ProcessInventory(inv, invsec, cfg, true);
E_EDFLogPrintf("\t\tFinished inventory %s(#%d)\n", inv->name, inv->numkey);
}
// free tables
efree(inv_pstack);
}
//
// E_ProcessInventory
//
// Generalized code to process the data for a single inventory definition
// structure. Doubles as code for inventory and inventorydelta.
//
static void E_ProcessInventory(inventory_t *inv, cfg_t *invsec, cfg_t *pcfg, bool def)
{
//int tempint;
const char *tempstr;
bool inherits = false;
// possible when inheriting from an inventory def of a previous EDF generation
if(!invsec)
return;
// Process inheritance (not in deltas)
if(def)
{
// if this inventory is already processed via recursion due to
// inheritance, don't process it again
if(inv->processed)
return;
if(cfg_size(invsec, ITEM_INVENTORY_INHERITS) > 0)
{
cfg_t *parent_invsec;
// resolve parent inventory def
inventory_t *parent = E_GetInventoryForName(cfg_getstr(invsec, ITEM_INVENTORY_INHERITS));
// check against cyclic inheritance
if(!E_CheckInventoryInherit(parent))
{
E_EDFLoggedErr(2,
"E_ProcessInventory: cyclic inheritance detected in inventory '%s'\n",
inv->name);
}
// add to inheritance stack
E_AddInventoryToPStack(parent);
// process parent recursively
parent_invsec = cfg_gettsec(pcfg, EDF_SEC_INVENTORY, parent->name);
E_ProcessInventory(parent, parent_invsec, pcfg, true);
// copy parent to this thing
E_CopyInventory(inv, parent);
// keep track of parent explicitly
inv->parent = parent;
// we inherit, so treat defaults as no value
inherits = true;
}
else
inv->parent = NULL; // no parent.
// mark this inventory def as processed
inv->processed = true;
}
// field processing
if(IS_SET(ITEM_INVENTORY_CLASS))
{
const char *classname = cfg_getstr(invsec, ITEM_INVENTORY_CLASS);
int classtype = E_StrToNumLinear(inventoryClassNames, INV_CLASS_NUMCLASSES, classname);
if(classtype == INV_CLASS_NUMCLASSES)
{
E_EDFLoggedWarning(2, "Warning: unknown inventory class %s\n", classname);
classtype = INV_CLASS_NONE;
}
inv->classtype = classtype;
}
#ifdef RANGECHECK
if(inv->classtype < 0 || inv->classtype >= INV_CLASS_NUMCLASSES)
E_EDFLoggedErr(2, "E_ProcessInventory: internal error - bad classtype %d\n", inv->classtype);
#endif
// process subclass fields
inventorySubClasses[inv->classtype](inv, invsec, def, inherits);
if(IS_SET(ITEM_INVENTORY_AMOUNT))
inv->amount = cfg_getint(invsec, ITEM_INVENTORY_AMOUNT);
if(IS_SET(ITEM_INVENTORY_MAXAMOUNT))
inv->maxAmount = cfg_getint(invsec, ITEM_INVENTORY_MAXAMOUNT);
if(IS_SET(ITEM_INVENTORY_INTERHUBAMOUNT))
inv->interHubAmount = cfg_getint(invsec, ITEM_INVENTORY_INTERHUBAMOUNT);
if(IS_SET(ITEM_INVENTORY_ICON))
E_ReplaceString(inv->icon, cfg_getstrdup(invsec, ITEM_INVENTORY_ICON));
if(IS_SET(ITEM_INVENTORY_PICKUPMESSAGE))
E_ReplaceString(inv->pickUpMessage, cfg_getstrdup(invsec, ITEM_INVENTORY_PICKUPMESSAGE));
if(IS_SET(ITEM_INVENTORY_PICKUPSOUND))
E_ReplaceString(inv->pickUpSound, cfg_getstrdup(invsec, ITEM_INVENTORY_PICKUPSOUND));
if(IS_SET(ITEM_INVENTORY_PICKUPFLASH))
E_ReplaceString(inv->pickUpFlash, cfg_getstrdup(invsec, ITEM_INVENTORY_PICKUPFLASH));
if(IS_SET(ITEM_INVENTORY_USESOUND))
E_ReplaceString(inv->useSound, cfg_getstrdup(invsec, ITEM_INVENTORY_USESOUND));
if(IS_SET(ITEM_INVENTORY_RESPAWNTICS))
inv->respawnTics = cfg_getint(invsec, ITEM_INVENTORY_RESPAWNTICS);
if(IS_SET(ITEM_INVENTORY_GIVEQUEST))
inv->giveQuest = cfg_getint(invsec, ITEM_INVENTORY_GIVEQUEST);
if(IS_SET(ITEM_INVENTORY_FLAGS))
{
tempstr = cfg_getstr(invsec, ITEM_INVENTORY_FLAGS);
if(*tempstr == '\0')
inv->flags = 0;
else
inv->flags = E_ParseFlags(tempstr, &inventory_flagset);
}
// TODO: addflags/remflags
}
//
// E_DoEDFProcessing
//
// haleyjd 11/21/11: Shared processing phase code, now that all EDF sections
// are fully dynamic with repeatable processing.
//
static void E_DoEDFProcessing(cfg_t *cfg, bool firsttime)
{
E_EDFLogPuts("\n=================== Processing Phase ====================\n");
// Echo final enable values to the log file for reference.
if(firsttime)
E_EchoEnables();
// NOTE: The order of most of the following calls is extremely
// important and must be preserved, unless the static routines
// above and in other files are rewritten accordingly.
// process strings
E_ProcessStrings(cfg);
// process sprites
E_ProcessSprites(cfg);
// process sounds
E_ProcessSounds(cfg);
// process ambience information
E_ProcessAmbience(cfg);
// process sound sequences
E_ProcessSndSeqs(cfg);
// process reverb definitions (12/22/13)
E_ProcessReverbs(cfg);
// process damage types
E_ProcessDamageTypes(cfg);
// process frame and thing definitions (made dynamic 11/06/11)
E_ProcessStatesAndThings(cfg);
// process sprite-related variables (made dynamic 11/21/11)
E_ProcessSpriteVars(cfg);
// process inventory
E_ProcessInventory(cfg);
// process player sections
E_ProcessPlayerData(cfg);
// process cast call (made dynamic 11/21/11)
E_ProcessCast(cfg);
// process boss spawn types (made dynamic 11/21/11)
E_ProcessBossTypes(cfg);
// process TerrainTypes
E_ProcessTerrainTypes(cfg);
// process dynamic menus
MN_ProcessMenus(cfg);
// process fonts
E_ProcessFonts(cfg);
// process misc vars (made dynamic 11/21/11)
E_ProcessMiscVars(cfg);
// 08/30/03: apply deltas
E_ProcessSoundDeltas(cfg, true); // see e_sound.cpp
E_ProcessStateDeltas(cfg); // see e_states.cpp
E_ProcessThingDeltas(cfg); // see e_things.cpp
// 07/19/12: game properties
E_ProcessGameProperties(cfg); // see e_gameprops.cpp
// post-processing routines
E_SetThingDefaultSprites();
}
