Traits* PoolObject::resolveParameterizedType(const Toplevel* toplevel, Traits* base, Traits* param_traits ) const
{
Traits* r = NULL;
if( base == core->traits.vector_itraits)
{
// Only vector is parameterizable for now...
if(!param_traits) // Vector.<*>
r = core->traits.vectorobj_itraits;
else if( param_traits == core->traits.int_itraits)
r = core->traits.vectorint_itraits;
else if (param_traits == core->traits.uint_itraits)
r = core->traits.vectoruint_itraits;
else if (param_traits == core->traits.number_itraits)
r = core->traits.vectordouble_itraits;
else
{
Stringp fullname = core->internString( core->concatStrings(core->newString("Vector.<"),
core->concatStrings(param_traits->formatClassName(), core->newString(">")))->atom());
Multiname newname;
newname.setName(fullname);
newname.setNamespace(base->ns);
r = getTraits(newname, toplevel);
if( !r )
{
r = core->traits.vectorobj_itraits->newParameterizedITraits(fullname, base->ns);
core->traits.vector_itraits->pool->domain->addNamedTrait(fullname, base->ns, r);
}
}
}
return r;
}
// -----------------------------------------------------------------
// Name : computeObjectiveAttraction
// -----------------------------------------------------------------
float AI::computeObjectiveAttraction(Character * pOther)
{
float attraction = 0.0f;
long_hash * pThisTraits = getTraits();
long_hash * pOtherTraits = pOther->getTraits();
for (pair<string, long> from : *pThisTraits) {
for (pair<string, long> to : *pOtherTraits) {
// fRelation [-1,1]
float fRelation = (float)from.second/*[0,5]*/ * (float)to.second/*[0,5]*/ * getTraitsRelation(from.first, to.first)/*[0,1]*/ / (float)(TRAIT_MAX_VALUE * TRAIT_MAX_VALUE);
// Square it so that an "extreme" relation counts for more than a neutral one
attraction += (fRelation * abs(fRelation));
}
}
// "Friendly" traits automatically improves attraction
float friendly = ((float)(*pThisTraits)[TRAITS_FRIENDLY]) / (float)(TRAIT_MAX_VALUE);
attraction += friendly / 2;
friendly = ((float)(*pOtherTraits)[TRAITS_FRIENDLY]) / (float)(TRAIT_MAX_VALUE);
attraction += friendly;
// charismatic, charmer, cold
return attraction;
}
Traits* PoolObject::getTraits(const Multiname& mname, const Toplevel* toplevel, bool recursive/*=true*/) const
{
// do full lookup of multiname, error if more than 1 match
// return Traits if 1 match, NULL if 0 match, throw ambiguity error if >1 match
Traits* match = NULL;
if (mname.isBinding())
{
// multiname must not be an attr name, have wildcards, or have runtime parts.
for (int i=0, n=mname.namespaceCount(); i < n; i++)
{
Traits* t = getTraits(mname.getName(), mname.getNamespace(i), recursive);
if (t != NULL)
{
if (match == NULL)
{
match = t;
}
else if (match != t)
{
// ambiguity
if (toplevel)
toplevel->throwReferenceError(kAmbiguousBindingError, mname);
AvmAssert(!"unhandled ambiguous binding");
}
}
}
}
return match;
}
bool DomainObject::isDynamic (Atom a)
{
Traits *traits = getTraits(a);
if (traits->itraits != NULL) {
traits = traits->itraits;
}
return traits->needsHashtable();
}
bool DomainObject::isAssignableAs (ClassClosure *asClass, Atom a)
{
Traits *traits = getTraits(a);
if (traits->itraits != NULL) {
traits = traits->itraits;
}
return traits->containsInterface(asClass->traits()->itraits) != 0;
}
/** Add uniform matrix child. */
Fullscreen::Fullscreen(const Tag &tag) : Shape(tag,getTraits()) {
Node *node;
string text;
text = "uniform type='mat4' name='MVPMatrix' as='identity'";
node = Factory::create(text);
addChild(node);
}
Traits* PoolObject::resolveTypeName(uint32 index, const Toplevel* toplevel, bool allowVoid/*=false*/) const
{
// only save the type name for now. verifier will resolve to traits
if (index == 0)
{
return NULL;
}
// check contents is a multiname. in the cpool, and type system, kObjectType means multiname.
if (index >= constantMnCount)
{
if (toplevel)
toplevel->throwVerifyError(kCpoolIndexRangeError, core->toErrorString(index), core->toErrorString(constantMnCount));
AvmAssert(!"unhandled verify error");
}
Multiname m;
parseMultiname(cpool_mn[index], m);
Traits* t = getTraits(m, toplevel);
if(m.isParameterizedType())
{
Traits* param_traits = resolveTypeName(m.getTypeParameter(), toplevel);
t = resolveParameterizedType(toplevel, t, param_traits);
}
if (!t)
{
#ifdef AVMPLUS_VERBOSE
if (!toplevel || !toplevel->verifyErrorClass())
core->console << "class not found: " << m << " index=" << index << "\n";
#endif
if (toplevel)
toplevel->throwVerifyError(kClassNotFoundError, core->toErrorString(&m));
AvmAssert(!"unhandled verify error");
}
if (!allowVoid && t == VOID_TYPE)
{
if (toplevel)
toplevel->throwVerifyError(kIllegalVoidError);
AvmAssert(!"unhandled verify error");
}
return t;
}
ArrayObject *DomainObject::getVariables (Atom a)
{
ArrayObject *result = toplevel()->arrayClass->newArray(0);
TraitsBindingsp traits = getTraits(a)->getTraitsBindings();
int i = 0;
while ((i = traits->next(i)) != 0) {
Namespace *ns = traits->nsAt(i);
Stringp name = traits->keyAt(i);
Binding b = traits->valueAt(i);
if (core()->isVarBinding(b) && ns->getType() == Namespace::NS_Public) {
Atom nameAtom = core()->internString(name)->atom();
result->push(&nameAtom, 1);
}
}
return result;
}
Stringp DomainObject::getClassName (Atom a)
{
return getTraits(a)->formatClassName();
}
Traits* PoolObject::getTraits(Stringp name, bool recursive/*=true*/) const
{
return getTraits(name, core->publicNamespace, recursive);
}
