Quaternion ToQuaternion(const char* source)
{
unsigned elements = CountElements(source, ' ');
char* ptr = (char*)source;
if (elements < 3)
return Quaternion::IDENTITY;
else if (elements < 4)
{
// 3 coords specified: conversion from Euler angles
float x, y, z;
x = (float)strtod(ptr, &ptr);
y = (float)strtod(ptr, &ptr);
z = (float)strtod(ptr, &ptr);
return Quaternion(x, y, z);
}
else
{
// 4 coords specified: full quaternion
Quaternion ret;
ret.w_ = (float)strtod(ptr, &ptr);
ret.x_ = (float)strtod(ptr, &ptr);
ret.y_ = (float)strtod(ptr, &ptr);
ret.z_ = (float)strtod(ptr, &ptr);
return ret;
}
}
EXPORT_C TInt CTestConfig::GetElement(const TDesC8& aInput, TChar aDelimiter, TInt aIndex, TPtrC8& aOutput, TBool aTrimOutput)
{
TLex8 input(aInput);
TInt err = KErrNone;
TPtrC8 ptr;
for (TInt i = 0; i <= aIndex && err == KErrNone; i++)
{
err = GetNextElement(input, aDelimiter, ptr);
}
if (err == KErrNone)
{
if (aTrimOutput)
aOutput.Set(Trim(ptr));
else
aOutput.Set(ptr);
}
else
{
const TInt count = CountElements(aInput, aDelimiter);
const TInt len = aInput.Length();
if (len != 0 && count - 1 == aIndex && TChar(aInput[len-1]) == aDelimiter)
{
aOutput.Set(KNullDesC8);
err = KErrNone;
}
}
return err;
}
AAFRESULT STDMETHODCALLTYPE
ImplAAFTypeDefExtEnum::GetNameBufLenFromAUID (
const aafUID_t & value,
aafUInt32 * pLen)
{
if (! pLen)
return AAFRESULT_NULL_PARAM;
aafUInt32 i;
aafUInt32 count;
AAFRESULT hr;
hr = CountElements(&count);
if (AAFRESULT_FAILED(hr))
return hr;
for (i = 0; i < count; i++)
{
aafUID_t val;
hr = GetElementValue (i, &val);
if (AAFRESULT_FAILED(hr))
return hr;
if (EqualAUID (&val, &value))
{
aafUInt32 len;
hr = GetElementNameBufLen(i, &len);
if (AAFRESULT_FAILED(hr))
return hr;
ASSERTU (pLen);
*pLen = len;
return AAFRESULT_SUCCESS;
}
}
// fell out of for() loop, so we didn't find it.
return AAFRESULT_ILLEGAL_VALUE;
}
Vector4 ToVector4(const char* source, bool allowMissingCoords)
{
Vector4 ret(Vector4::ZERO);
unsigned elements = CountElements(source, ' ');
char* ptr = (char*)source;
if (!allowMissingCoords)
{
if (elements < 4)
return ret;
ret.x_ = (float)strtod(ptr, &ptr);
ret.y_ = (float)strtod(ptr, &ptr);
ret.z_ = (float)strtod(ptr, &ptr);
ret.w_ = (float)strtod(ptr, &ptr);
return ret;
}
else
{
if (elements > 0)
ret.x_ = (float)strtod(ptr, &ptr);
if (elements > 1)
ret.y_ = (float)strtod(ptr, &ptr);
if (elements > 2)
ret.z_ = (float)strtod(ptr, &ptr);
if (elements > 3)
ret.w_ = (float)strtod(ptr, &ptr);
return ret;
}
}
AAFRESULT ImplAAFTypeDefExtEnum::LookupValByName(aafUID_t *pVal, const aafCharacter *pName)
{
aafUInt32 i=0;
aafUInt32 count=0;
aafBoolean_t bFound = kAAFFalse;
aafCharacter Name_buf[256];
aafUInt32 bufSize = 256;
check_hr ( CountElements(&count) );
while ( (i<count) && !bFound)
{
check_hr ( GetElementName (i, Name_buf, bufSize) );
if ( wcscmp (Name_buf, pName) == 0 ) //matched
{
bFound = kAAFTrue;
check_hr (GetElementValue(i, pVal));
break;
}//if
i++;
}//while
if (!bFound)
return AAFRESULT_INVALID_PARAM;
return AAFRESULT_SUCCESS;
}
Matrix4 ToMatrix4(const char* source)
{
Matrix4 ret(Matrix4::ZERO);
unsigned elements = CountElements(source, ' ');
if (elements < 16)
return ret;
char* ptr = (char*)source;
ret.m00_ = (float)strtod(ptr, &ptr);
ret.m01_ = (float)strtod(ptr, &ptr);
ret.m02_ = (float)strtod(ptr, &ptr);
ret.m03_ = (float)strtod(ptr, &ptr);
ret.m10_ = (float)strtod(ptr, &ptr);
ret.m11_ = (float)strtod(ptr, &ptr);
ret.m12_ = (float)strtod(ptr, &ptr);
ret.m13_ = (float)strtod(ptr, &ptr);
ret.m20_ = (float)strtod(ptr, &ptr);
ret.m21_ = (float)strtod(ptr, &ptr);
ret.m22_ = (float)strtod(ptr, &ptr);
ret.m23_ = (float)strtod(ptr, &ptr);
ret.m30_ = (float)strtod(ptr, &ptr);
ret.m31_ = (float)strtod(ptr, &ptr);
ret.m32_ = (float)strtod(ptr, &ptr);
ret.m33_ = (float)strtod(ptr, &ptr);
return ret;
}
//
// private method
//
AAFRESULT STDMETHODCALLTYPE
ImplAAFTypeDefExtEnum::GetElementName (
aafUInt32 index,
wchar_t * pName,
aafUInt32 bufSize)
{
AAFRESULT hr;
aafUInt32 count;
aafUInt32 indexIntoProp;
aafUInt32 currentIndex;
if (!pName) return AAFRESULT_NULL_PARAM;
hr = CountElements(&count);
if (AAFRESULT_FAILED(hr)) return hr;
if (index >= count) return AAFRESULT_ILLEGAL_VALUE;
wchar_t c;
size_t numChars = _ElementNames.count();
indexIntoProp = 0;
currentIndex = 0;
if (0 != index)
{
for (OMUInt32 i = 0; i < numChars; i++)
{
indexIntoProp++;
_ElementNames.getValueAt(&c, i);
if (0 == c)
{
// We've found the null just before the string we want.
// We'll increment the indexIntoProp to the start of the
// string and break out of the loop, but first make sure
// there's more string there to index into.
ASSERTU (i < numChars);
currentIndex++;
if (index == currentIndex)
break;
}
}
// Make sure we didn't terminate the loop by dropping out before
// the correct index was found.
ASSERTU (indexIntoProp < numChars);
}
// indexIntoProp now indicates the starting char we want. Copy it
// into the client's buffer.
do
{
if (! bufSize) return AAFRESULT_SMALLBUF;
_ElementNames.getValueAt(&c, indexIntoProp++);
// BobT Note!!! We're cheating here, modifying client data
// before we're sure this method will succeed.
*pName++ = c;
bufSize--;
}
while (c);
return AAFRESULT_SUCCESS;
}
void
BTwoDimensionalLayout::LocalLayouter::AddConstraints(
CompoundLayouter* compoundLayouter, Layouter* layouter)
{
enum orientation orientation = compoundLayouter->Orientation();
int itemCount = fLayout->CountItems();
if (itemCount > 0) {
for (int i = 0; i < itemCount; i++) {
BLayoutItem* item = fLayout->ItemAt(i);
if (item->IsVisible()) {
Dimensions itemDimensions;
fLayout->GetItemDimensions(item, &itemDimensions);
BSize min = item->MinSize();
BSize max = item->MaxSize();
BSize preferred = item->PreferredSize();
if (orientation == B_HORIZONTAL) {
layouter->AddConstraints(
itemDimensions.x,
itemDimensions.width,
min.width,
max.width,
preferred.width);
if (item->HasHeightForWidth())
fHeightForWidthItems.AddItem(item);
} else {
layouter->AddConstraints(
itemDimensions.y,
itemDimensions.height,
min.height,
max.height,
preferred.height);
}
}
}
// add column/row constraints
ColumnRowConstraints constraints;
int elementCount = CountElements(compoundLayouter);
for (int element = 0; element < elementCount; element++) {
fLayout->GetColumnRowConstraints(orientation, element,
&constraints);
layouter->SetWeight(element, constraints.weight);
layouter->AddConstraints(element, 1, constraints.min,
constraints.max, constraints.min);
}
}
}
IntVector2 ToIntVector2(const char* source)
{
IntVector2 ret(IntVector2::ZERO);
unsigned elements = CountElements(source, ' ');
if (elements < 2)
return ret;
char* ptr = (char*)source;
ret.x_ = (int)strtol(ptr, &ptr, 10);
ret.y_ = (int)strtol(ptr, &ptr, 10);
return ret;
}
Vector2 ToVector2(const char* source)
{
Vector2 ret(Vector2::ZERO);
unsigned elements = CountElements(source, ' ');
if (elements < 2)
return ret;
char* ptr = (char*)source;
ret.x_ = (float)strtod(ptr, &ptr);
ret.y_ = (float)strtod(ptr, &ptr);
return ret;
}
Rect ToRect(const char* source)
{
Rect ret(Rect::ZERO);
unsigned elements = CountElements(source, ' ');
if (elements < 4)
return ret;
char* ptr = (char*)source;
ret.min_.x_ = (float)strtod(ptr, &ptr);
ret.min_.y_ = (float)strtod(ptr, &ptr);
ret.max_.x_ = (float)strtod(ptr, &ptr);
ret.max_.y_ = (float)strtod(ptr, &ptr);
return ret;
}
IntRect ToIntRect(const char* source)
{
IntRect ret(IntRect::ZERO);
unsigned elements = CountElements(source, ' ');
if (elements < 4)
return ret;
char* ptr = (char*)source;
ret.left_ = (int)strtol(ptr, &ptr, 10);
ret.top_ = (int)strtol(ptr, &ptr, 10);
ret.right_ = (int)strtol(ptr, &ptr, 10);
ret.bottom_ = (int)strtol(ptr, &ptr, 10);
return ret;
}
Color ToColor(const char* source)
{
Color ret;
unsigned elements = CountElements(source, ' ');
if (elements < 3)
return ret;
char* ptr = (char*)source;
ret.r_ = (float)strtod(ptr, &ptr);
ret.g_ = (float)strtod(ptr, &ptr);
ret.b_ = (float)strtod(ptr, &ptr);
if (elements > 3)
ret.a_ = (float)strtod(ptr, &ptr);
return ret;
}
AAFRESULT STDMETHODCALLTYPE
ImplAAFTypeDefExtEnum::GetNameFromAUID (
const aafUID_t & value,
wchar_t * pName,
aafUInt32 bufSize)
{
if (! pName)
return AAFRESULT_NULL_PARAM;
AAFRESULT hr;
aafUInt32 len;
// following call may return AAFRESULT_ILLEGAL_VALUE if value isn't
// recognized
hr = GetNameBufLenFromAUID (value, &len);
if (AAFRESULT_FAILED(hr))
return hr;
// len includes space for trailing null
if (bufSize < len)
return AAFRESULT_SMALLBUF;
aafUInt32 i;
aafUInt32 count;
hr = CountElements(&count);
if (AAFRESULT_FAILED(hr))
return hr;
for (i = 0; i < count; i++)
{
aafUID_t val;
hr = GetElementValue (i, &val);
if (AAFRESULT_FAILED(hr))
return hr;
if (EqualAUID (&val, &value))
{
// given integer value matches value of "i"th element.
hr = GetElementName(i, pName, bufSize);
if (AAFRESULT_FAILED(hr))
return hr;
return AAFRESULT_SUCCESS;
}
}
// fell out of for() loop, so we didn't find it.
// redundant, since GetNameBufLenFromInteger() should have already
// found it.
return AAFRESULT_ILLEGAL_VALUE;
}
void IniSpawn::ReadSpawnEntry(DataFileMgr *inifile, const char *entryname, SpawnEntry &entry) const
{
const char *s;
entry.interval = (unsigned int) inifile->GetKeyAsInt(entryname,"interval",0);
//don't default to NULL here, some entries may be missing in original game
//an empty default string here will create an empty but consistent entry
s = inifile->GetKeyAsString(entryname,"critters","");
int crittercount = CountElements(s,',');
entry.crittercount=crittercount;
entry.critters=new CritterEntry[crittercount];
ieVariable *critters = new ieVariable[crittercount];
GetElements(s, critters, crittercount);
while(crittercount--) {
ReadCreature(inifile, critters[crittercount], entry.critters[crittercount]);
}
delete[] critters;
}
Variant ToVectorVariant(const char* source)
{
Variant ret;
unsigned elements = CountElements(source, ' ');
switch (elements)
{
case 1:
ret.FromString(VAR_FLOAT, source);
break;
case 2:
ret.FromString(VAR_VECTOR2, source);
break;
case 3:
ret.FromString(VAR_VECTOR3, source);
break;
case 4:
ret.FromString(VAR_VECTOR4, source);
break;
case 9:
ret.FromString(VAR_MATRIX3, source);
break;
case 12:
ret.FromString(VAR_MATRIX3X4, source);
break;
case 16:
ret.FromString(VAR_MATRIX4, source);
break;
default:
// Illegal input. Return variant remains empty
break;
}
return ret;
}
void StringToBuffer(PODVector<unsigned char>& dest, const char* source)
{
if (!source)
{
dest.Clear();
return;
}
unsigned size = CountElements(source, ' ');
dest.Resize(size);
bool inSpace = true;
unsigned index = 0;
unsigned value = 0;
// Parse values
const char* ptr = source;
while (*ptr)
{
if (inSpace && *ptr != ' ')
{
inSpace = false;
value = (unsigned)(*ptr - '0');
}
else if (!inSpace && *ptr != ' ')
{
value *= 10;
value += *ptr - '0';
}
else if (!inSpace && *ptr == ' ')
{
dest[index++] = (unsigned char)value;
inSpace = true;
}
++ptr;
}
// Write the final value
if (!inSpace && index < size)
dest[index] = (unsigned char)value;
}
Variant ToVectorVariant(const char* source)
{
Variant ret;
unsigned elements = CountElements(source, ' ');
switch (elements)
{
case 1:
ret.FromString(VAR_FLOAT, source);
break;
case 2:
ret.FromString(VAR_VECTOR2, source);
break;
case 3:
ret.FromString(VAR_VECTOR3, source);
break;
case 4:
ret.FromString(VAR_VECTOR4, source);
break;
case 9:
ret.FromString(VAR_MATRIX3, source);
break;
case 12:
ret.FromString(VAR_MATRIX3X4, source);
break;
case 16:
ret.FromString(VAR_MATRIX4, source);
break;
default:
assert(false); // Should not get here
break;
}
return ret;
}
Matrix3 ToMatrix3(const char* source)
{
Matrix3 ret(Matrix3::ZERO);
unsigned elements = CountElements(source, ' ');
if (elements < 9)
return ret;
char* ptr = (char*)source;
ret.m00_ = (float)strtod(ptr, &ptr);
ret.m01_ = (float)strtod(ptr, &ptr);
ret.m02_ = (float)strtod(ptr, &ptr);
ret.m10_ = (float)strtod(ptr, &ptr);
ret.m11_ = (float)strtod(ptr, &ptr);
ret.m12_ = (float)strtod(ptr, &ptr);
ret.m20_ = (float)strtod(ptr, &ptr);
ret.m21_ = (float)strtod(ptr, &ptr);
ret.m22_ = (float)strtod(ptr, &ptr);
return ret;
}
AAFRESULT STDMETHODCALLTYPE
ImplAAFTypeDefExtEnum::GetElementValue (
aafUInt32 index,
aafUID_t * pOutValue)
{
if (! pOutValue)
return AAFRESULT_NULL_PARAM;
aafUInt32 count;
AAFRESULT hr;
hr = CountElements (&count);
if (AAFRESULT_FAILED(hr))
return hr;
if (index >= count)
return AAFRESULT_BADINDEX;
aafUID_t val;
_ElementValues.getValueAt (&val, index);
ASSERTU (pOutValue);
*pOutValue = val;
return AAFRESULT_SUCCESS;
}
//unimplemented tags (* marks partially implemented, # marks not working in original either):
//*check_crowd
// control_var
// spec_area
//*death_faction
//*death_team
// check_by_view_port
//*do_not_spawn
// hold_selected_point_key
// inc_spawn_point_index
//*find_safest_point
//#spawn_time_of_day
// exit - similar to enter[spawn], this is a spawn branch type (on exiting an area?)
// PST only
//*auto_buddy
//*detail_level
void IniSpawn::ReadCreature(DataFileMgr *inifile, const char *crittername, CritterEntry &critter) const
{
const char *s;
int ps;
memset(&critter,0,sizeof(critter));
//first assume it is a simple numeric value
critter.TimeOfDay = (ieDword) inifile->GetKeyAsInt(crittername,"time_of_day", 0xffffffff);
//at this point critter.TimeOfDay is usually 0xffffffff
s = inifile->GetKeyAsString(crittername,"time_of_day",NULL);
if (s && strlen(s)>=24) {
ieDword value = 0;
ieDword j = 1;
for(int i=0;i<24 && s[i];i++) {
if (s[i]=='0' || s[i]=='o') value |= j;
j<<=1;
}
//turn off individual bits marked by a 24 long string scheduling
//example: '0000xxxxxxxxxxxxxxxx00000000'
critter.TimeOfDay^=value;
}
if (inifile->GetKeyAsBool(crittername,"do_not_spawn",false)) {
//if the do not spawn flag is true, ignore this entry
return;
}
s = inifile->GetKeyAsString(crittername,"detail_level",NULL);
if (s) {
ieDword level;
switch(s[0]) {
case 'h': case 'H': level = 2; break;
case 'm': case 'M': level = 1; break;
default: level = 0; break;
}
//If the detail level is lower than this creature's detail level,
//skip this entry, creature_count is 0, so it will be ignored at evaluation of the spawn
if (level>detail_level) {
return;
}
}
//all specvars are using global, but sometimes it is explicitly given
s = inifile->GetKeyAsString(crittername,"spec_var",NULL);
if (s) {
if ((strlen(s)>9) && s[6]==':' && s[7]==':') {
strnuprcpy(critter.SpecContext, s, 6);
strnlwrcpy(critter.SpecVar, s+8, 32);
} else {
strnuprcpy(critter.SpecContext, "GLOBAL", 6);
strnlwrcpy(critter.SpecVar, s, 32);
}
}
//add this to specvar at each spawn
ps = inifile->GetKeyAsInt(crittername,"spec_var_inc", 0);
critter.SpecVarInc=ps;
//use this value with spec_var_operation to determine spawn
ps = inifile->GetKeyAsInt(crittername,"spec_var_value",0);
critter.SpecVarValue=ps;
//this operation uses DiffCore
s = inifile->GetKeyAsString(crittername,"spec_var_operation","");
critter.SpecVarOperator=GetDiffMode(s);
//the amount of critters to spawn
critter.TotalQuantity = inifile->GetKeyAsInt(crittername,"spec_qty",1);
critter.SpawnCount = inifile->GetKeyAsInt(crittername,"create_qty",critter.TotalQuantity);
//the creature resource(s)
s = inifile->GetKeyAsString(crittername,"cre_file",NULL);
if (s) {
critter.creaturecount = CountElements(s,',');
critter.CreFile=new ieResRef[critter.creaturecount];
GetElements(s, critter.CreFile, critter.creaturecount);
} else {
Log(ERROR, "IniSpawn", "Invalid spawn entry: %s", crittername);
}
s = inifile->GetKeyAsString(crittername,"point_select",NULL);
if (s) {
ps=s[0];
} else {
ps=0;
}
s = inifile->GetKeyAsString(crittername,"spawn_point",NULL);
if (s) {
//expect more than one spawnpoint
if (ps=='r') {
//select one of the spawnpoints randomly
int count = core->Roll(1,CountElements(s,']'),-1);
//go to the selected spawnpoint
while(count--) {
while(*s++!=']') ;
}
}
//parse the selected spawnpoint
int x,y,o;
if (sscanf(s,"[%d,%d:%d]", &x, &y, &o)==3) {
critter.SpawnPoint.x=(short) x;
critter.SpawnPoint.y=(short) y;
critter.Orientation=o;
} else
if (sscanf(s,"[%d.%d:%d]", &x, &y, &o)==3) {
critter.SpawnPoint.x=(short) x;
critter.SpawnPoint.y=(short) y;
critter.Orientation=o;
} else
if (sscanf(s,"[%d,%d]", &x, &y)==2) {
critter.SpawnPoint.x=(short) x;
critter.SpawnPoint.y=(short) y;
critter.Orientation=core->Roll(1,16,-1);
} else
if (sscanf(s,"[%d.%d]", &x, &y)==2) {
critter.SpawnPoint.x=(short) x;
critter.SpawnPoint.y=(short) y;
critter.Orientation=core->Roll(1,16,-1);
}
}
//store or retrieve spawn point
s = inifile->GetKeyAsString(crittername,"spawn_point_global", NULL);
if (s) {
switch (ps) {
case 'e':
critter.SpawnPoint.fromDword(CheckVariable(map, s+8,s));
break;
default:
//see save_selected_point
//SetVariable(map, s+8, s, critter.SpawnPoint.asDword());
break;
}
}
//take facing from variable
s = inifile->GetKeyAsString(crittername,"spawn_facing_global", NULL);
if (s) {
switch (ps) {
case 'e':
critter.Orientation=(int) CheckVariable(map, s+8,s);
break;
default:
//see save_selected_point
//SetVariable(map, s+8, s, (ieDword) critter.Orientation);
break;
}
}
s = inifile->GetKeyAsString(crittername,"save_selected_point",NULL);
if (s) {
if ((strlen(s)>9) && s[6]==':' && s[7]==':') {
SetVariable(map, s+8, s, critter.SpawnPoint.asDword());
} else {
SetVariable(map, s, "GLOBAL", critter.SpawnPoint.asDword());
}
}
s = inifile->GetKeyAsString(crittername,"save_selected_facing",NULL);
if (s) {
if ((strlen(s)>9) && s[6]==':' && s[7]==':') {
SetVariable(map, s+8, s, (ieDword) critter.Orientation);
} else {
SetVariable(map, s, "GLOBAL", (ieDword) critter.Orientation);
}
}
//sometimes only the orientation is given, the point is stored in a variable
ps = inifile->GetKeyAsInt(crittername,"facing",-1);
if (ps!=-1) critter.Orientation = ps;
ps = inifile->GetKeyAsInt(crittername, "ai_ea",-1);
if (ps!=-1) critter.SetSpec[AI_EA] = (ieByte) ps;
ps = inifile->GetKeyAsInt(crittername, "ai_team",-1);
if (ps!=-1) critter.SetSpec[AI_TEAM] = (ieByte) ps;
ps = inifile->GetKeyAsInt(crittername, "ai_general",-1);
if (ps!=-1) critter.SetSpec[AI_GENERAL] = (ieByte) ps;
ps = inifile->GetKeyAsInt(crittername, "ai_race",-1);
if (ps!=-1) critter.SetSpec[AI_RACE] = (ieByte) ps;
ps = inifile->GetKeyAsInt(crittername, "ai_class",-1);
if (ps!=-1) critter.SetSpec[AI_CLASS] = (ieByte) ps;
ps = inifile->GetKeyAsInt(crittername, "ai_specifics",-1);
if (ps!=-1) critter.SetSpec[AI_SPECIFICS] = (ieByte) ps;
ps = inifile->GetKeyAsInt(crittername, "ai_gender",-1);
if (ps!=-1) critter.SetSpec[AI_GENDER] = (ieByte) ps;
ps = inifile->GetKeyAsInt(crittername, "ai_alignment",-1);
if (ps!=-1) critter.SetSpec[AI_ALIGNMENT] = (ieByte) ps;
s = inifile->GetKeyAsString(crittername,"spec",NULL);
if (s) {
int x[9];
ps = sscanf(s,"[%d.%d.%d.%d.%d.%d.%d.%d.%d]", x, x+1, x+2, x+3, x+4, x+5,
x+6, x+7, x+8);
if (ps == 0) {
strnuprcpy(critter.ScriptName, s, 32);
critter.Flags|=CF_CHECK_NAME;
memset(critter.Spec,-1,sizeof(critter.Spec));
} else {
while(ps--) {
critter.Spec[ps]=(ieByte) x[ps];
}
}
}
s = inifile->GetKeyAsString(crittername,"script_name",NULL);
if (s) {
strnuprcpy(critter.ScriptName, s, 32);
}
//iwd2 script names (override remains the same)
//special 1 == area
s = inifile->GetKeyAsString(crittername,"script_special_1",NULL);
if (s) {
strnuprcpy(critter.AreaScript,s, 8);
}
//special 2 == class
s = inifile->GetKeyAsString(crittername,"script_special_2",NULL);
if (s) {
strnuprcpy(critter.ClassScript,s, 8);
}
//special 3 == general
s = inifile->GetKeyAsString(crittername,"script_special_3",NULL);
if (s) {
strnuprcpy(critter.GeneralScript,s, 8);
}
//team == specific
s = inifile->GetKeyAsString(crittername,"script_team",NULL);
if (s) {
strnuprcpy(critter.SpecificScript,s, 8);
}
//combat == race
s = inifile->GetKeyAsString(crittername,"script_combat",NULL);
if (s) {
strnuprcpy(critter.RaceScript,s, 8);
}
//movement == default
s = inifile->GetKeyAsString(crittername,"script_movement",NULL);
if (s) {
strnuprcpy(critter.DefaultScript,s, 8);
}
//pst script names
s = inifile->GetKeyAsString(crittername,"script_override",NULL);
if (s) {
strnuprcpy(critter.OverrideScript,s, 8);
}
s = inifile->GetKeyAsString(crittername,"script_class",NULL);
if (s) {
strnuprcpy(critter.ClassScript,s, 8);
}
s = inifile->GetKeyAsString(crittername,"script_race",NULL);
if (s) {
strnuprcpy(critter.RaceScript,s, 8);
}
s = inifile->GetKeyAsString(crittername,"script_general",NULL);
if (s) {
strnuprcpy(critter.GeneralScript,s, 8);
}
s = inifile->GetKeyAsString(crittername,"script_default",NULL);
if (s) {
strnuprcpy(critter.DefaultScript,s, 8);
}
s = inifile->GetKeyAsString(crittername,"script_area",NULL);
if (s) {
strnuprcpy(critter.AreaScript,s, 8);
}
s = inifile->GetKeyAsString(crittername,"script_specifics",NULL);
if (s) {
strnuprcpy(critter.SpecificScript,s, 8);
}
s = inifile->GetKeyAsString(crittername,"dialog",NULL);
if (s) {
strnuprcpy(critter.Dialog,s, 8);
}
//flags
if (inifile->GetKeyAsBool(crittername,"death_scriptname",false)) {
critter.Flags|=CF_DEATHVAR;
}
if (inifile->GetKeyAsBool(crittername,"death_faction",false)) {
critter.Flags|=CF_FACTION;
}
if (inifile->GetKeyAsBool(crittername,"death_team",false)) {
critter.Flags|=CF_TEAM;
}
ps = inifile->GetKeyAsInt(crittername,"good_mod",0);
if (ps) {
critter.Flags|=CF_GOOD;
critter.DeathCounters[DC_GOOD] = ps;
}
ps = inifile->GetKeyAsInt(crittername,"law_mod",0);
if (ps) {
critter.Flags|=CF_LAW;
critter.DeathCounters[DC_LAW] = ps;
}
ps = inifile->GetKeyAsInt(crittername,"lady_mod",0);
if (ps) {
critter.Flags|=CF_LADY;
critter.DeathCounters[DC_LADY] = ps;
}
ps = inifile->GetKeyAsInt(crittername,"murder_mod",0);
if (ps) {
critter.Flags|=CF_MURDER;
critter.DeathCounters[DC_MURDER] = ps;
}
if(inifile->GetKeyAsBool(crittername,"auto_buddy", false)) {
critter.Flags|=CF_BUDDY;
}
//don't spawn when spawnpoint is visible
if (inifile->GetKeyAsBool(crittername,"ignore_can_see",false)) {
critter.Flags|=CF_IGNORECANSEE;
}
//unsure, but could be similar to previous
if (inifile->GetKeyAsBool(crittername,"check_view_port", false)) {
critter.Flags|=CF_CHECKVIEWPORT;
}
//unknown, this is used only in pst
if (inifile->GetKeyAsBool(crittername,"check_crowd", false)) {
critter.Flags|=CF_CHECKCROWD;
}
//unknown, this is used only in pst
if (inifile->GetKeyAsBool(crittername,"find_safest_point", false)) {
critter.Flags|=CF_SAFESTPOINT;
}
//disable spawn based on game difficulty
if (inifile->GetKeyAsBool(crittername,"area_diff_1", false)) {
critter.Flags|=CF_NO_DIFF_1;
}
if (inifile->GetKeyAsBool(crittername,"area_diff_2", false)) {
critter.Flags|=CF_NO_DIFF_2;
}
if (inifile->GetKeyAsBool(crittername,"area_diff_3", false)) {
critter.Flags|=CF_NO_DIFF_3;
}
}
AAFRESULT STDMETHODCALLTYPE
ImplAAFTypeDefExtEnum::AppendElement (
const aafUID_t & value,
const aafCharacter * pName)
{
if (! pName)
return AAFRESULT_NULL_PARAM;
AAFRESULT hr;
aafUInt32 origNumElems = 0;
hr = CountElements(&origNumElems);
if (AAFRESULT_FAILED(hr))
return hr;
aafWChar * namesBuf = 0;
aafUID_t * valsBuf = 0;
AAFRESULT rReturned = AAFRESULT_SUCCESS;
try
{
//
// First, calculate new names
//
aafUInt32 origNameCharCount = 0;
aafUInt32 newNameCharCount = 0;
// _ElementNames.count() includes final trailing null
origNameCharCount = _ElementNames.count();
ASSERTU (pName);
aafUInt32 nvbc = (origNumElems+1)*sizeof (aafUID_t);
if (nvbc > OMPROPERTYSIZE_MAX)
return AAFRESULT_BAD_SIZE;
OMPropertySize newValueByteCount = static_cast<OMPropertySize>(nvbc);
aafUInt32 ovbc = origNumElems*sizeof (aafUID_t);
OMPropertySize origValueByteCount = static_cast<OMPropertySize>(ovbc);
// Add length for name to be appended. Don't forget to add one
// character for new name's trailing null
size_t mnl = wcslen (pName);
ASSERTU(mnl <= OMUINT32_MAX);
OMUInt32 memberNameLength = static_cast<OMUInt32>(mnl);
newNameCharCount = origNameCharCount + memberNameLength + 1;
aafUInt32 nnbc = newNameCharCount * sizeof(aafWChar);
if (nnbc > OMPROPERTYSIZE_MAX)
return AAFRESULT_BAD_SIZE;
OMPropertySize newNameByteCount = static_cast<OMPropertySize>(nnbc);
aafUInt32 onbc = origNameCharCount*sizeof(aafWChar);
OMPropertySize origNameByteCount = static_cast<OMPropertySize>(onbc);
namesBuf = new aafWChar[newNameCharCount];
if (origNameCharCount)
_ElementNames.getValue (namesBuf, origNameByteCount);
// Append new name to end of buffer. Don't forget that original
// buffer may have embedded nulls, so start copying at desired
// point immediately (don't use strcat or equiv).
wcscpy (namesBuf+origNameCharCount, pName);
//
// now, calculate the new value
//
// add one for new element to be appended
valsBuf = new aafUID_t[origNumElems+1];
if (origNumElems)
_ElementValues.getValue (valsBuf, origValueByteCount);
valsBuf[origNumElems] = value;
// Copy newly-appended name and value buffers out.
_ElementNames.setValue (namesBuf, newNameByteCount);
_ElementValues.setValue (valsBuf, newValueByteCount);
}
catch (AAFRESULT &rCaught)
{
rReturned = rCaught;
}
if (namesBuf) delete[] namesBuf;
if (valsBuf) delete[] valsBuf;
return rReturned;
}
//
// private method
//
AAFRESULT STDMETHODCALLTYPE
ImplAAFTypeDefExtEnum::GetElementNameBufLen (
aafUInt32 index,
aafUInt32 * pLen)
{
AAFRESULT hr;
aafUInt32 count;
aafUInt32 indexIntoProp;
aafUInt32 currentIndex;
if (!pLen) return AAFRESULT_NULL_PARAM;
hr = CountElements(&count);
if (AAFRESULT_FAILED(hr)) return hr;
if (index >= count) return AAFRESULT_ILLEGAL_VALUE;
wchar_t c;
size_t numChars = _ElementNames.count();
indexIntoProp = 0;
currentIndex = 0;
if (0 != index)
{
for (OMUInt32 i = 0; i < numChars; i++)
{
indexIntoProp++;
_ElementNames.getValueAt(&c, i);
if (0 == c)
{
// We've found the null just before the string we want.
// We'll increment the indexIntoProp to the start of the
// string and break out of the loop, but first make sure
// there's more string there to index into.
ASSERTU (i < numChars);
currentIndex++;
if (index == currentIndex)
break;
}
}
// Make sure we didn't terminate the loop by dropping out before
// the correct index was found.
ASSERTU (indexIntoProp < numChars);
}
// indexIntoProp now indicates the starting char we want. Start
// counting until we get to the next null.
aafUInt32 nameLength = 0;
do
{
_ElementNames.getValueAt(&c, indexIntoProp++);
if (c) nameLength += sizeof(wchar_t);
}
while (c);
// increment once more for trailing null
nameLength += sizeof (wchar_t);
ASSERTU (pLen);
*pLen = nameLength;
return AAFRESULT_SUCCESS;
}
unsigned InputDevice::GetNumDigitalElements() const {
if (num_digital_elements_ == -1) {
CountElements();
}
return num_digital_elements_;
}
unsigned InputDevice::GetNumAnalogueElements() const {
if (num_analogue_elements_ == -1) {
CountElements();
}
return num_analogue_elements_;
}
void IniSpawn::InitSpawn(const ieResRef DefaultArea)
{
const char *s;
Holder<DataFileMgr> inifile = GetIniFile(DefaultArea);
if (!inifile) {
strnuprcpy(NamelessSpawnArea, DefaultArea, 8);
return;
}
s = inifile->GetKeyAsString("nameless","destare",DefaultArea);
strnuprcpy(NamelessSpawnArea, s, 8);
s = inifile->GetKeyAsString("nameless","point","[0.0]");
int x,y;
if (sscanf(s,"[%d.%d]", &x, &y)!=2) {
x=0;
y=0;
}
NamelessSpawnPoint.x=x;
NamelessSpawnPoint.y=y;
s = inifile->GetKeyAsString("nameless", "partyarea", DefaultArea);
strnuprcpy(PartySpawnArea, s, 8);
s = inifile->GetKeyAsString("nameless", "partypoint", "[0.0]");
if (sscanf(s,"[%d.%d]", &x, &y) != 2) {
x = NamelessSpawnPoint.x;
y = NamelessSpawnPoint.y;
}
PartySpawnPoint.x = x;
PartySpawnPoint.y = y;
//35 - already standing
//36 - getting up
NamelessState = inifile->GetKeyAsInt("nameless","state",36);
namelessvarcount = inifile->GetKeysCount("namelessvar");
if (namelessvarcount) {
NamelessVar = new VariableSpec[namelessvarcount];
for (y=0;y<namelessvarcount;y++) {
const char* Key = inifile->GetKeyNameByIndex("namelessvar",y);
strnlwrcpy(NamelessVar[y].Name, Key, 32);
NamelessVar[y].Value = inifile->GetKeyAsInt("namelessvar",Key,0);
}
}
localscount = inifile->GetKeysCount("locals");
if (localscount) {
Locals = new VariableSpec[localscount];
for (y=0;y<localscount;y++) {
const char* Key = inifile->GetKeyNameByIndex("locals",y);
strnlwrcpy(Locals[y].Name, Key, 32);
Locals[y].Value = inifile->GetKeyAsInt("locals",Key,0);
}
}
s = inifile->GetKeyAsString("spawn_main","enter",NULL);
if (s) {
ReadSpawnEntry(inifile.get(), s, enterspawn);
}
s = inifile->GetKeyAsString("spawn_main","exit",NULL);
if (s) {
ReadSpawnEntry(inifile.get(), s, exitspawn);
}
s = inifile->GetKeyAsString("spawn_main","events",NULL);
if (s) {
eventcount = CountElements(s,',');
eventspawns = new SpawnEntry[eventcount];
ieVariable *events = new ieVariable[eventcount];
GetElements(s, events, eventcount);
int ec = eventcount;
while(ec--) {
ReadSpawnEntry(inifile.get(), events[ec], eventspawns[ec]);
}
delete[] events;
}
//maybe not correct
InitialSpawn();
}
