void
CodeVisitor::visitConst(const ConstPtr& p)
{
string name = getName(p);
string type = getTypeVar(p);
string abs = getAbsolute(p, _ns);
startNamespace(p);
_out << sp << nl << "if(!defined('" << escapeName(abs) << "'))";
_out << sb;
if(_ns)
{
_out << sp << nl << "define(__NAMESPACE__ . '\\\\" << name << "', ";
}
else
{
_out << sp << nl << "define('" << name << "', ";
}
writeConstantValue(p->type(), p->valueType(), p->value());
_out << ");";
_out << eb;
endNamespace();
}
std::shared_ptr<RoadPatch::PatchArray> RoadPatch::loadPatches(const std::string& filename)
{
XMLDocument doc;
doc.LoadFile(filename.c_str());
if (doc.Error())
return nullptr;
std::shared_ptr<PatchArray> arr = std::make_shared<PatchArray>();
for (XMLElement* titleElement = doc.FirstChildElement(XML_TITLE_ELEMENT);
titleElement != nullptr;
titleElement = titleElement->NextSiblingElement(XML_TITLE_ELEMENT))
{
// Create new
ConstPtr tmp = std::make_shared<RoadPatch>(titleElement);
// Check for XML/Read error
if (!tmp->good())
return nullptr;
// Save according to ID
(*arr)[tmp->getPatchTypeInt()] = tmp;
}
return arr;
}
void
Slice::Ruby::CodeVisitor::visitConst(const ConstPtr& p)
{
Slice::TypePtr type = p->type();
string name = fixIdent(p->name(), IdentToUpper);
_out << sp << nl << name << " = ";
writeConstantValue(type, p->valueType(), p->value());
}
void ProjectileManager::launchProjectile(Ptr actor, ConstPtr projectile, const osg::Vec3f &pos, const osg::Quat &orient, Ptr bow, float speed, float attackStrength)
{
ProjectileState state;
state.mActorId = actor.getClass().getCreatureStats(actor).getActorId();
state.mBowId = bow.getCellRef().getRefId();
state.mVelocity = orient * osg::Vec3f(0,1,0) * speed;
state.mId = projectile.getCellRef().getRefId();
state.mCasterHandle = actor;
state.mAttackStrength = attackStrength;
MWWorld::ManualRef ref(MWBase::Environment::get().getWorld()->getStore(), projectile.getCellRef().getRefId());
MWWorld::Ptr ptr = ref.getPtr();
createModel(state, ptr.getClass().getModel(ptr), pos, orient, false);
mProjectiles.push_back(state);
}
void
Slice::Ruby::CodeVisitor::writeConstantValue(const TypePtr& type, const SyntaxTreeBasePtr& valueType,
const string& value)
{
ConstPtr constant = ConstPtr::dynamicCast(valueType);
if(constant)
{
_out << fixIdent(constant->scoped(), IdentToUpper);
}
else
{
Slice::BuiltinPtr b = Slice::BuiltinPtr::dynamicCast(type);
Slice::EnumPtr en = Slice::EnumPtr::dynamicCast(type);
if(b)
{
switch(b->kind())
{
case Slice::Builtin::KindBool:
case Slice::Builtin::KindByte:
case Slice::Builtin::KindShort:
case Slice::Builtin::KindInt:
case Slice::Builtin::KindFloat:
case Slice::Builtin::KindDouble:
{
_out << value;
break;
}
case Slice::Builtin::KindLong:
{
IceUtil::Int64 l;
IceUtilInternal::stringToInt64(value, l);
_out << value;
break;
}
case Slice::Builtin::KindString:
{
//
// Expand strings into the basic source character set. We can't use isalpha() and the like
// here because they are sensitive to the current locale.
//
static const string basicSourceChars = "abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"0123456789"
"_{}[]#()<>%:;.?*+-/^&|~!=, '";
static const set<char> charSet(basicSourceChars.begin(), basicSourceChars.end());
_out << "\""; // Opening "
for(string::const_iterator c = value.begin(); c != value.end(); ++c)
{
switch(*c)
{
case '"':
{
_out << "\\\"";
break;
}
case '\\':
{
_out << "\\\\";
break;
}
case '\r':
{
_out << "\\r";
break;
}
case '\n':
{
_out << "\\n";
break;
}
case '\t':
{
_out << "\\t";
break;
}
case '\b':
{
_out << "\\b";
break;
}
case '\f':
{
_out << "\\f";
break;
}
default:
{
if(charSet.find(*c) == charSet.end())
{
unsigned char uc = *c; // Char may be signed, so make it positive.
stringstream s;
s << "\\"; // Print as octal if not in basic source character set.
s.flags(ios_base::oct);
s.width(3);
s.fill('0');
s << static_cast<unsigned>(uc);
_out << s.str();
}
else
{
_out << *c; // Print normally if in basic source character set.
}
break;
}
}
}
_out << "\""; // Closing "
break;
}
case Slice::Builtin::KindObject:
case Slice::Builtin::KindObjectProxy:
case Slice::Builtin::KindLocalObject:
assert(false);
}
}
else if(en)
{
_out << getAbsolute(en, IdentToUpper) << "::";
string::size_type colon = value.rfind(':');
if(colon != string::npos)
{
_out << fixIdent(value.substr(colon + 1), IdentToUpper);
}
else
{
_out << fixIdent(value, IdentToUpper);
}
}
else
{
assert(false); // Unknown const type.
}
}
}
int MWWorld::ContainerStore::getType (const ConstPtr& ptr)
{
if (ptr.isEmpty())
throw std::runtime_error ("can't put a non-existent object into a container");
if (ptr.getTypeName()==typeid (ESM::Potion).name())
return Type_Potion;
if (ptr.getTypeName()==typeid (ESM::Apparatus).name())
return Type_Apparatus;
if (ptr.getTypeName()==typeid (ESM::Armor).name())
return Type_Armor;
if (ptr.getTypeName()==typeid (ESM::Book).name())
return Type_Book;
if (ptr.getTypeName()==typeid (ESM::Clothing).name())
return Type_Clothing;
if (ptr.getTypeName()==typeid (ESM::Ingredient).name())
return Type_Ingredient;
if (ptr.getTypeName()==typeid (ESM::Light).name())
return Type_Light;
if (ptr.getTypeName()==typeid (ESM::Lockpick).name())
return Type_Lockpick;
if (ptr.getTypeName()==typeid (ESM::Miscellaneous).name())
return Type_Miscellaneous;
if (ptr.getTypeName()==typeid (ESM::Probe).name())
return Type_Probe;
if (ptr.getTypeName()==typeid (ESM::Repair).name())
return Type_Repair;
if (ptr.getTypeName()==typeid (ESM::Weapon).name())
return Type_Weapon;
throw std::runtime_error (
"Object '" + ptr.getCellRef().getRefId() + "' of type " + ptr.getTypeName() + " can not be placed into a container");
}
bool MWWorld::ContainerStore::stacks(const ConstPtr& ptr1, const ConstPtr& ptr2) const
{
const MWWorld::Class& cls1 = ptr1.getClass();
const MWWorld::Class& cls2 = ptr2.getClass();
if (!Misc::StringUtils::ciEqual(ptr1.getCellRef().getRefId(), ptr2.getCellRef().getRefId()))
return false;
// If it has an enchantment, don't stack when some of the charge is already used
if (!ptr1.getClass().getEnchantment(ptr1).empty())
{
const ESM::Enchantment* enchantment = MWBase::Environment::get().getWorld()->getStore().get<ESM::Enchantment>().find(
ptr1.getClass().getEnchantment(ptr1));
float maxCharge = static_cast<float>(enchantment->mData.mCharge);
float enchantCharge1 = ptr1.getCellRef().getEnchantmentCharge() == -1 ? maxCharge : ptr1.getCellRef().getEnchantmentCharge();
float enchantCharge2 = ptr2.getCellRef().getEnchantmentCharge() == -1 ? maxCharge : ptr2.getCellRef().getEnchantmentCharge();
if (enchantCharge1 != maxCharge || enchantCharge2 != maxCharge)
return false;
}
return ptr1 != ptr2 // an item never stacks onto itself
&& ptr1.getCellRef().getOwner() == ptr2.getCellRef().getOwner()
&& ptr1.getCellRef().getSoul() == ptr2.getCellRef().getSoul()
&& ptr1.getClass().getRemainingUsageTime(ptr1) == ptr2.getClass().getRemainingUsageTime(ptr2)
&& cls1.getScript(ptr1) == cls2.getScript(ptr2)
// item that is already partly used up never stacks
&& (!cls1.hasItemHealth(ptr1) || (
cls1.getItemHealth(ptr1) == cls1.getItemMaxHealth(ptr1)
&& cls2.getItemHealth(ptr2) == cls2.getItemMaxHealth(ptr2)));
}
inline void setNull() { curr.setNull(); data = 0; ind = pos = RNIL;}
inline bool isNull() const { return curr.isNull();}
void Slice::ChecksumVisitor::visitConst(const ConstPtr& p)
{
ostringstream ostr;
ostr << "const " << typeToString(p->type()) << ' ' << p->name() << " = " << p->value() << endl;
updateMap(p->scoped(), ostr.str());
}
