static bool loadResourceFunction(const char *pData)
{
RESOURCE_FUNCTION *psFunction;
char functionName[MAX_STR_LENGTH];
int dummy;
//allocate storage
psFunction = (RESOURCE_FUNCTION *)malloc(sizeof(RESOURCE_FUNCTION));
memset(psFunction, 0, sizeof(RESOURCE_FUNCTION));
//store the pointer in the Function Array
*asFunctions = (FUNCTION *)psFunction;
psFunction->ref = REF_FUNCTION_START + numFunctions;
numFunctions++;
asFunctions++;
//set the type of function
psFunction->type = RESOURCE_TYPE;
//no data to read in
functionName[0] = '\0';
sscanf(pData, "%255[^,'\r\n],%d", functionName, &dummy);
//allocate storage for the name
storeName((FUNCTION *)psFunction, functionName);
return true;
}
static bool loadRepairDroidFunction(const char *pData)
{
REPAIR_DROID_FUNCTION *psFunction;
char functionName[MAX_STR_LENGTH];
//allocate storage
psFunction = (REPAIR_DROID_FUNCTION *)malloc(sizeof(REPAIR_DROID_FUNCTION));
memset(psFunction, 0, sizeof(REPAIR_DROID_FUNCTION));
//store the pointer in the Function Array
*asFunctions = (FUNCTION *)psFunction;
psFunction->ref = REF_FUNCTION_START + numFunctions;
numFunctions++;
asFunctions++;
//set the type of function
psFunction->type = REPAIR_DROID_TYPE;
//read the data in
functionName[0] = '\0';
sscanf(pData, "%255[^,'\r\n],%d", functionName, &psFunction->repairPoints);
//allocate storage for the name
storeName((FUNCTION *)psFunction, functionName);
return true;
}
static bool loadDroidBodyUpgradeFunction(const char *pData)
{
DROIDBODY_UPGRADE_FUNCTION *psFunction;
char functionName[MAX_STR_LENGTH];
UDWORD modifier, armourKinetic, armourHeat, body, droid, cyborg;
//allocate storage
psFunction = (DROIDBODY_UPGRADE_FUNCTION *)malloc(sizeof(DROIDBODY_UPGRADE_FUNCTION));
memset(psFunction, 0, sizeof(DROIDBODY_UPGRADE_FUNCTION));
//store the pointer in the Function Array
*asFunctions = (FUNCTION *)psFunction;
psFunction->ref = REF_FUNCTION_START + numFunctions;
numFunctions++;
asFunctions++;
//set the type of function
psFunction->type = DROIDBODY_UPGRADE_TYPE;
//read the data in
functionName[0] = '\0';
sscanf(pData, "%255[^,'\r\n],%d,%d,%d,%d,%d,%d", functionName, &modifier,
&body, &armourKinetic, &armourHeat, &droid, &cyborg);
//allocate storage for the name
storeName((FUNCTION *)psFunction, functionName);
if (modifier > UWORD_MAX || armourKinetic > UWORD_MAX ||
armourHeat > UWORD_MAX || body > UWORD_MAX)
{
ASSERT(false,
"loadUnitBodyUpgradeFunction: one or more modifiers too great");
return false;
}
//store the % upgrades
psFunction->upgradePoints = (UWORD)modifier;
psFunction->body = (UWORD)body;
psFunction->armourValue[WC_KINETIC] = (UWORD)armourKinetic;
psFunction->armourValue[WC_HEAT] = (UWORD)armourHeat;
if (droid)
{
psFunction->droid = true;
}
else
{
psFunction->droid = false;
}
if (cyborg)
{
psFunction->cyborg = true;
}
else
{
psFunction->cyborg = false;
}
return true;
}
static bool loadProductionUpgradeFunction(const char *pData)
{
PRODUCTION_UPGRADE_FUNCTION *psFunction;
char functionName[MAX_STR_LENGTH];
UDWORD factory, cyborg, vtol;
UDWORD outputModifier;
//allocate storage
psFunction = (PRODUCTION_UPGRADE_FUNCTION *)malloc(sizeof
(PRODUCTION_UPGRADE_FUNCTION));
memset(psFunction, 0, sizeof(PRODUCTION_UPGRADE_FUNCTION));
//store the pointer in the Function Array
*asFunctions = (FUNCTION *)psFunction;
psFunction->ref = REF_FUNCTION_START + numFunctions;
numFunctions++;
asFunctions++;
//set the type of function
psFunction->type = PRODUCTION_UPGRADE_TYPE;
//read the data in
functionName[0] = '\0';
sscanf(pData, "%255[^,'\r\n],%d,%d,%d,%d", functionName, &factory,
&cyborg, &vtol, &outputModifier);
psFunction->outputModifier = (UBYTE)outputModifier;
//allocate storage for the name
storeName((FUNCTION *)psFunction, functionName);
//set the factory flags
if (factory)
{
psFunction->factory = true;
}
else
{
psFunction->factory = false;
}
if (cyborg)
{
psFunction->cyborgFactory = true;
}
else
{
psFunction->cyborgFactory = false;
}
if (vtol)
{
psFunction->vtolFactory = true;
}
else
{
psFunction->vtolFactory = false;
}
return true;
}
static bool loadWeaponUpgradeFunction(const char *pData)
{
WEAPON_UPGRADE_FUNCTION *psFunction;
char functionName[MAX_STR_LENGTH], weaponSubClass[MAX_STR_LENGTH];
UDWORD firePause, dummyVal, longHit, damage, radiusDamage, periodicalDamage, radiusHit;
//allocate storage
psFunction = (WEAPON_UPGRADE_FUNCTION *)malloc(sizeof(WEAPON_UPGRADE_FUNCTION));
memset(psFunction, 0, sizeof(WEAPON_UPGRADE_FUNCTION));
//store the pointer in the Function Array
*asFunctions = (FUNCTION *)psFunction;
psFunction->ref = REF_FUNCTION_START + numFunctions;
numFunctions++;
asFunctions++;
//set the type of function
psFunction->type = WEAPON_UPGRADE_TYPE;
//read the data in
functionName[0] = '\0';
weaponSubClass[0] = '\0';
sscanf(pData, "%255[^,'\r\n],%255[^,'\r\n],%d,%d,%d,%d,%d,%d,%d", functionName,
weaponSubClass, &firePause, &dummyVal, &longHit, &damage, &radiusDamage,
&periodicalDamage, &radiusHit);
//allocate storage for the name
storeName((FUNCTION *)psFunction, functionName);
if (!getWeaponSubClass(weaponSubClass, &psFunction->subClass))
{
return false;
}
//check none of the %increases are over UBYTE max
if (firePause > UBYTE_MAX ||
longHit > UWORD_MAX ||
damage > UWORD_MAX ||
radiusDamage > UWORD_MAX ||
periodicalDamage > UWORD_MAX ||
radiusHit > UWORD_MAX)
{
debug(LOG_ERROR, "A percentage increase for Weapon Upgrade function is too large");
return false;
}
//copy the data across
psFunction->firePause = (UBYTE)firePause;
psFunction->longHit = (UWORD)longHit;
psFunction->damage = (UWORD)damage;
psFunction->radiusDamage = (UWORD)radiusDamage;
psFunction->periodicalDamage = (UWORD)periodicalDamage;
psFunction->radiusHit = (UWORD)radiusHit;
return true;
}
static bool loadPowerGenFunction(const char *pData)
{
POWER_GEN_FUNCTION *psFunction;
char functionName[MAX_STR_LENGTH];
//allocate storage
psFunction = (POWER_GEN_FUNCTION *)malloc(sizeof(POWER_GEN_FUNCTION));
memset(psFunction, 0, sizeof(POWER_GEN_FUNCTION));
//store the pointer in the Function Array
*asFunctions = (FUNCTION *)psFunction;
psFunction->ref = REF_FUNCTION_START + numFunctions;
numFunctions++;
asFunctions++;
//set the type of function
psFunction->type = POWER_GEN_TYPE;
//read the data in
functionName[0] = '\0';
sscanf(pData, "%255[^,'\r\n],%d,%d,%d,%d,%d,%d", functionName,
&psFunction->powerOutput, &psFunction->powerMultiplier,
&psFunction->criticalMassChance, &psFunction->criticalMassRadius,
&psFunction->criticalMassDamage, &psFunction->radiationDecayTime);
if (bMultiPlayer)
{
switch (game.power)
{
// Multiply by 3/4
case LEV_LOW:
psFunction->powerMultiplier *= 3;
psFunction->powerMultiplier /= 4;
break;
// No change
case LEV_MED:
break;
// Multiply by 5/4
case LEV_HI:
psFunction->powerMultiplier *= 5;
psFunction->powerMultiplier /= 4;
break;
default:
break;
}
}
//allocate storage for the name
storeName((FUNCTION *)psFunction, functionName);
return true;
}
static bool loadProduction(const char *pData)
{
PRODUCTION_FUNCTION *psFunction;
char functionName[MAX_STR_LENGTH], bodySize[MAX_STR_LENGTH];
UDWORD productionOutput;
psFunction = (PRODUCTION_FUNCTION *)malloc(sizeof(PRODUCTION_FUNCTION));
memset(psFunction, 0, sizeof(PRODUCTION_FUNCTION));
//store the pointer in the Function Array
*asFunctions = (FUNCTION *)psFunction;
psFunction->ref = REF_FUNCTION_START + numFunctions;
numFunctions++;
asFunctions++;
//set the type of function
psFunction->type = PRODUCTION_TYPE;
//read the data in
functionName[0] = '\0';
bodySize[0] = '\0';
sscanf(pData, "%255[^,'\r\n],%255[^,'\r\n],%d", functionName, bodySize,
&productionOutput);
//allocate storage for the name
storeName((FUNCTION *)psFunction, functionName);
if (!getBodySize(bodySize, &psFunction->capacity))
{
ASSERT(false, "loadProduction: unknown body size for %s", psFunction->pName);
return false;
}
//check prod output < UWORD_MAX
if (productionOutput < UWORD_MAX)
{
psFunction->productionOutput = (UWORD)productionOutput;
}
else
{
ASSERT(false, "loadProduction: production Output too big for %s", psFunction->pName);
psFunction->productionOutput = 0;
}
return true;
}
static bool loadStructureUpgradeFunction(const char *pData)
{
STRUCTURE_UPGRADE_FUNCTION *psFunction;
char functionName[MAX_STR_LENGTH];
UDWORD armour, body, resistance;
//allocate storage
psFunction = (STRUCTURE_UPGRADE_FUNCTION *)malloc(sizeof
(STRUCTURE_UPGRADE_FUNCTION));
memset(psFunction, 0, sizeof(STRUCTURE_UPGRADE_FUNCTION));
//store the pointer in the Function Array
*asFunctions = (FUNCTION *)psFunction;
psFunction->ref = REF_FUNCTION_START + numFunctions;
numFunctions++;
asFunctions++;
//set the type of function
psFunction->type = STRUCTURE_UPGRADE_TYPE;
//read the data in
functionName[0] = '\0';
sscanf(pData, "%255[^,'\r\n],%d,%d,%d", functionName, &armour, &body, &resistance);
//allocate storage for the name
storeName((FUNCTION *)psFunction, functionName);
//check none of the %increases are over UWORD max
if (armour > UWORD_MAX ||
body > UWORD_MAX ||
resistance > UWORD_MAX)
{
debug(LOG_ERROR, "A percentage increase for Structure Upgrade function is too large");
return false;
}
//copy the data across
psFunction->armour = (UWORD)armour;
psFunction->body = (UWORD)body;
psFunction->resistance = (UWORD)resistance;
return true;
}
/*loads the corner stat to use for a particular wall stat */
static bool loadWallFunction(const char *pData)
{
WALL_FUNCTION *psFunction;
char functionName[MAX_STR_LENGTH];
char structureName[MAX_STR_LENGTH];
//allocate storage
psFunction = (WALL_FUNCTION *)malloc(sizeof(WALL_FUNCTION));
memset(psFunction, 0, sizeof(WALL_FUNCTION));
//store the pointer in the Function Array
*asFunctions = (FUNCTION *)psFunction;
psFunction->ref = REF_FUNCTION_START + numFunctions;
numFunctions++;
asFunctions++;
//set the type of function
psFunction->type = WALL_TYPE;
//read the data in
functionName[0] = '\0';
structureName[0] = '\0';
sscanf(pData, "%255[^,'\r\n],%255[^,'\r\n],%*d", functionName, structureName);
//allocate storage for the name
storeName((FUNCTION *)psFunction, functionName);
//store the structure name - cannot set the stat pointer here because structures
//haven't been loaded in yet!
psFunction->pStructName = allocateName(structureName);
if (!psFunction->pStructName)
{
debug(LOG_ERROR, "Structure Stats Invalid for function - %s", functionName);
return false;
}
psFunction->pCornerStat = NULL;
return true;
}
static bool loadDroidSensorUpgradeFunction(const char *pData)
{
DROIDSENSOR_UPGRADE_FUNCTION *psFunction;
char functionName[MAX_STR_LENGTH];
UDWORD modifier, range;
//allocate storage
psFunction = (DROIDSENSOR_UPGRADE_FUNCTION *)malloc(sizeof(DROIDSENSOR_UPGRADE_FUNCTION));
memset(psFunction, 0, sizeof(DROIDSENSOR_UPGRADE_FUNCTION));
//store the pointer in the Function Array
*asFunctions = (FUNCTION *)psFunction;
psFunction->ref = REF_FUNCTION_START + numFunctions;
numFunctions++;
asFunctions++;
//set the type of function
psFunction->type = DROIDSENSOR_UPGRADE_TYPE;
//read the data in
functionName[0] = '\0';
sscanf(pData, "%255[^,'\r\n],%d,%d", functionName, &modifier, &range);
//allocate storage for the name
storeName((FUNCTION *)psFunction, functionName);
if (modifier > UWORD_MAX || range > UWORD_MAX)
{
ASSERT(false,
"loadUnitSensorUpgradeFunction: one or more modifiers too great");
return false;
}
//store the % upgrades
psFunction->upgradePoints = (UWORD)modifier;
psFunction->range = (UWORD)range;
return true;
}
//generic load function for upgrade type
static bool loadUpgradeFunction(const char *pData, FUNCTION_TYPE type)
{
char functionName[MAX_STR_LENGTH];
UDWORD modifier;
UPGRADE_FUNCTION *psFunction;
//allocate storage
psFunction = (UPGRADE_FUNCTION *)malloc(sizeof(UPGRADE_FUNCTION));
memset(psFunction, 0, sizeof(UPGRADE_FUNCTION));
//store the pointer in the Function Array
*asFunctions = (FUNCTION *)psFunction;
psFunction->ref = REF_FUNCTION_START + numFunctions;
numFunctions++;
asFunctions++;
//set the type of function
psFunction->type = type;
//read the data in
functionName[0] = '\0';
sscanf(pData, "%255[^,'\r\n],%d", functionName, &modifier);
//allocate storage for the name
storeName((FUNCTION *)psFunction, functionName);
if (modifier > UWORD_MAX)
{
ASSERT(false, "Modifier too great for %s", functionName);
return false;
}
//store the % upgrade
psFunction->upgradePoints = (UWORD)modifier;
return true;
}
