void CEffectCreator::InitPainterParameters (CCreatePainterCtx &Ctx, IEffectPainter *pPainter)
// InitPainterParameters
//
// Initialize painter parameters
{
SEventHandlerDesc Event;
if (FindEventHandlerEffectType(evtGetParameters, &Event))
{
CCodeChainCtx CCCtx;
CCCtx.SaveAndDefineDataVar(Ctx.GetData());
ICCItem *pResult = CCCtx.Run(Event);
if (pResult->IsError())
::kernelDebugLogMessage(CONSTLIT("EffectType %x GetParameters: %s"), GetUNID(), (LPSTR)pResult->GetStringValue());
else if (pResult->IsSymbolTable())
{
int i;
CCSymbolTable *pTable = (CCSymbolTable *)pResult;
for (i = 0; i < pTable->GetCount(); i++)
{
CString sParam = pTable->GetKey(i);
ICCItem *pValue = pTable->GetElement(i);
CEffectParamDesc Value;
if (pValue->IsNil())
Value.InitNull();
else if (pValue->IsInteger())
Value.InitInteger(pValue->GetIntegerValue());
else if (pValue->IsIdentifier())
{
CString sValue = pValue->GetStringValue();
char *pPos = sValue.GetASCIIZPointer();
// If this is a color, parse it
if (*pPos == '#')
Value.InitColor(::LoadRGBColor(sValue));
// Otherwise, a string
else
Value.InitString(sValue);
}
pPainter->SetParam(Ctx, sParam, Value);
}
}
else
::kernelDebugLogMessage(CONSTLIT("EffectType %x GetParameters: Expected struct result."), GetUNID());
CCCtx.Discard(pResult);
}
}
void CArmorClass::FireOnArmorDamage (CItemCtx &ItemCtx, SDamageCtx &Ctx)
// FireOnArmorDamage
//
// Fires OnArmorDamage event
{
SEventHandlerDesc Event;
if (FindEventHandlerArmorClass(evtOnArmorDamage, &Event))
{
// Setup arguments
CCodeChainCtx CCCtx;
CCCtx.SaveAndDefineSourceVar(ItemCtx.GetSource());
CCCtx.SaveAndDefineItemVar(ItemCtx);
CCCtx.DefineInteger(CONSTLIT("aArmorHP"), Ctx.iHPLeft);
CCCtx.DefineInteger(CONSTLIT("aArmorSeg"), Ctx.iSectHit);
CCCtx.DefineSpaceObject(CONSTLIT("aAttacker"), Ctx.Attacker.GetObj());
CCCtx.DefineSpaceObject(CONSTLIT("aCause"), Ctx.pCause);
CCCtx.DefineDamageEffects(CONSTLIT("aDamageEffects"), Ctx);
CCCtx.DefineInteger(CONSTLIT("aDamageHP"), Ctx.iDamage);
CCCtx.DefineString(CONSTLIT("aDamageType"), GetDamageShortName(Ctx.Damage.GetDamageType()));
CCCtx.DefineInteger(CONSTLIT("aHitDir"), Ctx.iDirection);
CCCtx.DefineVector(CONSTLIT("aHitPos"), Ctx.vHitPos);
CCCtx.DefineSpaceObject(CONSTLIT("aOrderGiver"), (Ctx.Attacker.GetObj() ? Ctx.Attacker.GetObj()->GetOrderGiver(Ctx.Attacker.GetCause()) : NULL));
CCCtx.DefineItemType(CONSTLIT("aWeaponType"), Ctx.pDesc->GetWeaponType());
ICCItem *pResult = CCCtx.Run(Event);
// If we return Nil, then nothing
if (pResult->IsNil())
NULL;
// If we return an integer, then this is the damage that armor should take
else if (pResult->IsInteger())
Ctx.iDamage = pResult->GetIntegerValue();
// If we return a list, then we it to be a DamageEffects list (modifications to
// aDamageEffects)
else if (pResult->IsList())
LoadDamageEffectsFromItem(pResult, Ctx);
CCCtx.Discard(pResult);
}
}
bool CWeaponFireDesc::FireOnDamageShields (SDamageCtx &Ctx, int iDevice)
// FireOnDamageShields
//
// Fire OnDamageShields event. Returns TRUE if we should skip further shields damage
{
SEventHandlerDesc Event;
if (FindEventHandler(evtOnDamageShields, &Event))
{
// Setup arguments
CCodeChainCtx CCCtx;
CItemListManipulator ItemList(Ctx.pObj->GetItemList());
CShip *pShip = Ctx.pObj->AsShip();
if (pShip)
pShip->SetCursorAtDevice(ItemList, iDevice);
CCCtx.SaveAndDefineSourceVar(Ctx.pObj);
CCCtx.DefineInteger(CONSTLIT("aArmorSeg"), Ctx.iSectHit);
CCCtx.DefineInteger(CONSTLIT("aDevice"), iDevice);
CCCtx.DefineItem(CONSTLIT("aDeviceItem"), ItemList.GetItemAtCursor());
CCCtx.DefineSpaceObject(CONSTLIT("aCause"), Ctx.pCause);
CCCtx.DefineSpaceObject(CONSTLIT("aAttacker"), Ctx.Attacker.GetObj());
CCCtx.DefineSpaceObject(CONSTLIT("aOrderGiver"), (Ctx.Attacker.GetObj() ? Ctx.Attacker.GetObj()->GetOrderGiver(Ctx.Attacker.GetCause()) : NULL));
CCCtx.DefineVector(CONSTLIT("aHitPos"), Ctx.vHitPos);
CCCtx.DefineInteger(CONSTLIT("aHitDir"), Ctx.iDirection);
CCCtx.DefineInteger(CONSTLIT("aDamageHP"), Ctx.iDamage);
CCCtx.DefineString(CONSTLIT("aDamageType"), GetDamageShortName(Ctx.Damage.GetDamageType()));
CCCtx.DefineItemType(CONSTLIT("aWeaponType"), Ctx.pDesc->GetWeaponType());
CCCtx.DefineInteger(CONSTLIT("aShieldHP"), Ctx.iHPLeft);
CCCtx.DefineInteger(CONSTLIT("aShieldDamageHP"), Ctx.iShieldDamage);
CCCtx.DefineInteger(CONSTLIT("aArmorDamageHP"), Ctx.iDamage - Ctx.iAbsorb);
if (Ctx.bReflect)
{
CCCtx.DefineString(CONSTLIT("aShieldReflect"), STR_SHIELD_REFLECT);
CCCtx.DefineInteger(CONSTLIT("aOriginalShieldDamageHP"), Ctx.iOriginalShieldDamage);
CCCtx.DefineInteger(CONSTLIT("aOriginalArmorDamageHP"), Ctx.iDamage - Ctx.iOriginalAbsorb);
}
else
{
CCCtx.DefineNil(CONSTLIT("aShieldReflect"));
CCCtx.DefineInteger(CONSTLIT("aOriginalShieldDamageHP"), Ctx.iShieldDamage);
CCCtx.DefineInteger(CONSTLIT("aOriginalArmorDamageHP"), Ctx.iDamage - Ctx.iAbsorb);
}
ICCItem *pResult = CCCtx.Run(Event);
// If we return Nil, then we continue processing
bool bResult;
if (pResult->IsNil())
bResult = false;
// If this is an integer, we pass damage to armor
else if (pResult->IsInteger())
{
Ctx.iDamage = pResult->GetIntegerValue();
bResult = true;
}
// If we return a list, then modify variables
else if (pResult->IsList())
{
// A single value means we modified the damage to armor
if (pResult->GetCount() == 1)
{
if (strEquals(pResult->GetElement(0)->GetStringValue(), STR_SHIELD_REFLECT))
{
Ctx.bReflect = true;
Ctx.iAbsorb = Ctx.iDamage;
Ctx.iShieldDamage = 0;
}
else
{
Ctx.iShieldDamage = Max(0, Min(pResult->GetElement(0)->GetIntegerValue(), Ctx.iHPLeft));
if (Ctx.bReflect)
{
Ctx.bReflect = false;
Ctx.iAbsorb = Ctx.iOriginalAbsorb;
}
}
}
// Two values mean we modified both damage to armor and shield damage
else if (pResult->GetCount() == 2)
{
Ctx.bReflect = false;
Ctx.iShieldDamage = Max(0, Min(pResult->GetElement(0)->GetIntegerValue(), Ctx.iHPLeft));
Ctx.iAbsorb = Max(0, Ctx.iDamage - Max(0, pResult->GetElement(1)->GetIntegerValue()));
}
// Otherwise, we deal with reflection
else
{
Ctx.bReflect = strEquals(pResult->GetElement(0)->GetStringValue(), STR_SHIELD_REFLECT);
Ctx.iShieldDamage = Max(0, Min(pResult->GetElement(1)->GetIntegerValue(), Ctx.iHPLeft));
Ctx.iAbsorb = Max(0, Ctx.iDamage - Max(0, pResult->GetElement(2)->GetIntegerValue()));
}
// Proceed with processing
bResult = false;
}
// If this is the string "reflect" then we reflect
else if (strEquals(pResult->GetStringValue(), STR_SHIELD_REFLECT))
{
Ctx.bReflect = true;
Ctx.iAbsorb = Ctx.iDamage;
Ctx.iShieldDamage = 0;
bResult = false;
}
// Otherwise, error
else
{
Ctx.pObj->ReportEventError(ON_DAMAGE_OVERLAY_EVENT, pResult);
bResult = true;
}
CCCtx.Discard(pResult);
return bResult;
}
else
return false;
}
bool IDockScreenDisplay::ParseBackgrounDesc (ICCItem *pDesc, SBackgroundDesc *retDesc)
// ParseBackroundDesc
//
// Parses a descriptor. Returns TRUE if successful.
{
CCodeChain &CC = g_pUniverse->GetCC();
// Nil means no default value
if (pDesc->IsNil())
retDesc->iType = backgroundDefault;
// If we have a struct, we expect a certain format
else if (pDesc->IsSymbolTable())
{
CString sType = pDesc->GetStringAt(FIELD_TYPE);
if (sType.IsBlank() || strEquals(sType, TYPE_NONE))
retDesc->iType = backgroundNone;
else if (strEquals(sType, TYPE_HERO))
{
retDesc->iType = backgroundObjHeroImage;
retDesc->pObj = CreateObjFromItem(CC, pDesc->GetElement(FIELD_OBJ));
if (retDesc->pObj == NULL)
return false;
}
else if (strEquals(sType, TYPE_IMAGE))
{
retDesc->iType = backgroundImage;
ICCItem *pImage = pDesc->GetElement(FIELD_IMAGE);
if (pImage == NULL)
return false;
else if (pImage->IsInteger())
retDesc->dwImageID = pImage->GetIntegerValue();
else
return false;
}
else if (strEquals(sType, TYPE_OBJECT))
{
retDesc->pObj = CreateObjFromItem(CC, pDesc->GetElement(FIELD_OBJ));
if (retDesc->pObj == NULL)
return false;
if (retDesc->pObj->IsPlayer())
retDesc->iType = backgroundObjSchematicImage;
else
retDesc->iType = backgroundObjHeroImage;
}
else if (strEquals(sType, TYPE_SCHEMATIC))
{
retDesc->iType = backgroundObjSchematicImage;
retDesc->pObj = CreateObjFromItem(CC, pDesc->GetElement(FIELD_OBJ));
if (retDesc->pObj == NULL)
return false;
}
else
return false;
}
// Otherwise, we can't parse.
//
// LATER: We should eventually handle a list-based image descriptor, but we
// would need to enhance SBackgroundDesc for that.
else
return false;
// Success
return true;
}
ICCItem *CCodeChain::EvaluateArgs (CEvalContext *pCtx, ICCItem *pArgs, const CString &sArgValidation)
// EvaluateArgs
//
// Evaluate arguments and validate their types
{
ICCItem *pArg;
ICCItem *pNew;
ICCItem *pError;
CCLinkedList *pEvalList;
char *pValidation;
int i;
BOOL bNoEval;
// If the argument list if quoted, then it means that the arguments
// have already been evaluated. This happens if we've been called by
// (apply).
bNoEval = pArgs->IsQuoted();
// Create a list to hold the results
pNew = CreateLinkedList();
if (pNew->IsError())
return pNew;
pEvalList = dynamic_cast<CCLinkedList *>(pNew);
// Start parsing at the beginning
pValidation = sArgValidation.GetPointer();
// If there is a '*' in the validation, figure out
// how many arguments it represents
int iVarArgs = Max(0, pArgs->GetCount() - (sArgValidation.GetLength() - 1));
// Loop over each argument
for (i = 0; i < pArgs->GetCount(); i++)
{
ICCItem *pResult;
pArg = pArgs->GetElement(i);
// If we're processing variable args, see if we're done
if (*pValidation == '*')
{
if (iVarArgs == 0)
pValidation++;
else
iVarArgs--;
}
// Evaluate the item. If the arg is 'q' or 'u' then we
// don't evaluate it.
if (bNoEval || *pValidation == 'q' || *pValidation == 'u')
pResult = pArg->Reference();
// If the arg is 'c' then we don't evaluate unless it is
// a lambda expression (or an identifier)
else if (*pValidation == 'c' && !pArg->IsLambdaExpression() && !pArg->IsIdentifier())
pResult = pArg->Reference();
// Evaluate
else
{
pResult = Eval(pCtx, pArg);
// We don't want to return on error because some functions
// might want to pass errors around
if (*pValidation != 'v' && *pValidation != '*')
{
if (pResult->IsError())
{
pEvalList->Discard(this);
return pResult;
}
}
}
// Check to see if the item is valid
switch (*pValidation)
{
// We expect a function...
case 'f':
{
if (!pResult->IsFunction())
{
pError = CreateError(LITERAL("Function expected"), pResult);
pResult->Discard(this);
pEvalList->Discard(this);
return pError;
}
break;
}
// We expect a numeral...
//
// NOTE: We treat integer the same a numeral because it's not always
// clear to the user when they've created a double or an integer.
// It is up to the actual function to use the integer or double
// value appropriately.
case 'i':
case 'n':
{
if (!pResult->IsDouble() && !pResult->IsInteger())
{
pError = CreateError(LITERAL("Numeral expected"), pResult);
pResult->Discard(this);
pEvalList->Discard(this);
return pError;
}
break;
}
// We expect a double...
case 'd':
{
if (!pResult->IsDouble())
{
pError = CreateError(LITERAL("Double expected"), pResult);
pResult->Discard(this);
pEvalList->Discard(this);
return pError;
}
break;
}
// We expect a vEctor...
case 'e':
{
if (!(pResult->GetValueType() == ICCItem::Vector))
{
pError = CreateError(LITERAL("Vector expected"), pResult);
pResult->Discard(this);
pEvalList->Discard(this);
return pError;
}
break;
}
// We expect a linked list
case 'k':
{
if (pResult->GetClass()->GetObjID() != OBJID_CCLINKEDLIST)
{
pError = CreateError(LITERAL("Linked-list expected"), pResult);
pResult->Discard(this);
pEvalList->Discard(this);
return pError;
}
break;
}
// We expect a list
case 'l':
{
if (!pResult->IsList())
{
pError = CreateError(LITERAL("List expected"), pResult);
pResult->Discard(this);
pEvalList->Discard(this);
return pError;
}
break;
}
// We expect an identifier
case 's':
case 'q':
{
if (!pResult->IsIdentifier())
{
pError = CreateError(LITERAL("Identifier expected"), pResult);
pResult->Discard(this);
pEvalList->Discard(this);
return pError;
}
break;
}
// We expect an atom table
case 'x':
{
if (!pResult->IsAtomTable())
{
pError = CreateError(LITERAL("Atom table expected"), pResult);
pResult->Discard(this);
pEvalList->Discard(this);
return pError;
}
break;
}
// We expect a symbol table
case 'y':
{
if (!pResult->IsSymbolTable())
{
pError = CreateError(LITERAL("Symbol table expected"), pResult);
pResult->Discard(this);
pEvalList->Discard(this);
return pError;
}
break;
}
// We expect anything
case 'c':
case 'u':
case 'v':
break;
// We expect any number of anythings...
case '*':
break;
// Too many arguments
case '\0':
{
pError = CreateError(LITERAL("Too many arguments"), NULL);
pResult->Discard(this);
pEvalList->Discard(this);
return pError;
}
default:
ASSERT(FALSE);
}
// Add the result to the list
pEvalList->Append(*this, pResult);
pResult->Discard(this);
// Next validation sequence (note that *pValidation can never
// be '\0' because we return above if we find it)
if (*pValidation != '*')
pValidation++;
}
// Make sure we have enough arguments
if (*pValidation != '\0' && *pValidation != '*')
{
pError = CreateError(LITERAL("Insufficient arguments"), NULL);
pEvalList->Discard(this);
return pError;
}
// Return the evaluation list
return pEvalList;
}