You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
789 lines
34 KiB
C++
789 lines
34 KiB
C++
#include <OgreSceneNode.h>
|
|
|
|
#include <components/esm/loadcell.hpp>
|
|
|
|
#include <components/compiler/extensions.hpp>
|
|
#include <components/compiler/opcodes.hpp>
|
|
|
|
#include <components/interpreter/interpreter.hpp>
|
|
#include <components/interpreter/runtime.hpp>
|
|
#include <components/interpreter/opcodes.hpp>
|
|
|
|
#include "../mwbase/environment.hpp"
|
|
#include "../mwbase/world.hpp"
|
|
|
|
#include "../mwworld/cellstore.hpp"
|
|
#include "../mwworld/class.hpp"
|
|
#include "../mwworld/manualref.hpp"
|
|
#include "../mwworld/player.hpp"
|
|
#include "../mwworld/esmstore.hpp"
|
|
|
|
#include "interpretercontext.hpp"
|
|
#include "ref.hpp"
|
|
|
|
namespace MWScript
|
|
{
|
|
namespace Transformation
|
|
{
|
|
template<class R>
|
|
class OpSetScale : public Interpreter::Opcode0
|
|
{
|
|
public:
|
|
|
|
virtual void execute (Interpreter::Runtime& runtime)
|
|
{
|
|
MWWorld::Ptr ptr = R()(runtime);
|
|
|
|
Interpreter::Type_Float scale = runtime[0].mFloat;
|
|
runtime.pop();
|
|
|
|
MWBase::Environment::get().getWorld()->scaleObject(ptr,scale);
|
|
}
|
|
};
|
|
|
|
template<class R>
|
|
class OpGetScale : public Interpreter::Opcode0
|
|
{
|
|
public:
|
|
|
|
virtual void execute (Interpreter::Runtime& runtime)
|
|
{
|
|
MWWorld::Ptr ptr = R()(runtime);
|
|
runtime.push(ptr.getCellRef().getScale());
|
|
}
|
|
};
|
|
|
|
template<class R>
|
|
class OpModScale : public Interpreter::Opcode0
|
|
{
|
|
public:
|
|
|
|
virtual void execute (Interpreter::Runtime& runtime)
|
|
{
|
|
MWWorld::Ptr ptr = R()(runtime);
|
|
|
|
Interpreter::Type_Float scale = runtime[0].mFloat;
|
|
runtime.pop();
|
|
|
|
// add the parameter to the object's scale.
|
|
MWBase::Environment::get().getWorld()->scaleObject(ptr,ptr.getCellRef().getScale() + scale);
|
|
}
|
|
};
|
|
|
|
template<class R>
|
|
class OpSetAngle : public Interpreter::Opcode0
|
|
{
|
|
public:
|
|
|
|
virtual void execute (Interpreter::Runtime& runtime)
|
|
{
|
|
MWWorld::Ptr ptr = R()(runtime);
|
|
|
|
std::string axis = runtime.getStringLiteral (runtime[0].mInteger);
|
|
runtime.pop();
|
|
Interpreter::Type_Float angle = runtime[0].mFloat;
|
|
runtime.pop();
|
|
|
|
float ax = Ogre::Radian(ptr.getRefData().getPosition().rot[0]).valueDegrees();
|
|
float ay = Ogre::Radian(ptr.getRefData().getPosition().rot[1]).valueDegrees();
|
|
float az = Ogre::Radian(ptr.getRefData().getPosition().rot[2]).valueDegrees();
|
|
|
|
MWWorld::LocalRotation localRot = ptr.getRefData().getLocalRotation();
|
|
|
|
if (axis == "x")
|
|
{
|
|
localRot.rot[0] = 0;
|
|
ptr.getRefData().setLocalRotation(localRot);
|
|
MWBase::Environment::get().getWorld()->rotateObject(ptr,angle,ay,az);
|
|
}
|
|
else if (axis == "y")
|
|
{
|
|
localRot.rot[1] = 0;
|
|
ptr.getRefData().setLocalRotation(localRot);
|
|
MWBase::Environment::get().getWorld()->rotateObject(ptr,ax,angle,az);
|
|
}
|
|
else if (axis == "z")
|
|
{
|
|
localRot.rot[2] = 0;
|
|
ptr.getRefData().setLocalRotation(localRot);
|
|
MWBase::Environment::get().getWorld()->rotateObject(ptr,ax,ay,angle);
|
|
}
|
|
else
|
|
throw std::runtime_error ("invalid rotation axis: " + axis);
|
|
}
|
|
};
|
|
|
|
template<class R>
|
|
class OpGetStartingAngle : public Interpreter::Opcode0
|
|
{
|
|
public:
|
|
|
|
virtual void execute (Interpreter::Runtime& runtime)
|
|
{
|
|
MWWorld::Ptr ptr = R()(runtime);
|
|
|
|
std::string axis = runtime.getStringLiteral (runtime[0].mInteger);
|
|
runtime.pop();
|
|
|
|
if (axis == "x")
|
|
{
|
|
runtime.push(Ogre::Radian(ptr.getCellRef().getPosition().rot[0]).valueDegrees());
|
|
}
|
|
else if (axis == "y")
|
|
{
|
|
runtime.push(Ogre::Radian(ptr.getCellRef().getPosition().rot[1]).valueDegrees());
|
|
}
|
|
else if (axis == "z")
|
|
{
|
|
runtime.push(Ogre::Radian(ptr.getCellRef().getPosition().rot[2]).valueDegrees());
|
|
}
|
|
else
|
|
throw std::runtime_error ("invalid rotation axis: " + axis);
|
|
}
|
|
};
|
|
|
|
template<class R>
|
|
class OpGetAngle : public Interpreter::Opcode0
|
|
{
|
|
public:
|
|
|
|
virtual void execute (Interpreter::Runtime& runtime)
|
|
{
|
|
MWWorld::Ptr ptr = R()(runtime);
|
|
|
|
std::string axis = runtime.getStringLiteral (runtime[0].mInteger);
|
|
runtime.pop();
|
|
|
|
if (axis=="x")
|
|
{
|
|
runtime.push(Ogre::Radian(ptr.getRefData().getPosition().rot[0]).valueDegrees());
|
|
}
|
|
else if (axis=="y")
|
|
{
|
|
runtime.push(Ogre::Radian(ptr.getRefData().getPosition().rot[1]).valueDegrees());
|
|
}
|
|
else if (axis=="z")
|
|
{
|
|
runtime.push(Ogre::Radian(ptr.getRefData().getPosition().rot[2]).valueDegrees());
|
|
}
|
|
else
|
|
throw std::runtime_error ("invalid rotation axis: " + axis);
|
|
}
|
|
};
|
|
|
|
template<class R>
|
|
class OpGetPos : public Interpreter::Opcode0
|
|
{
|
|
public:
|
|
|
|
virtual void execute (Interpreter::Runtime& runtime)
|
|
{
|
|
MWWorld::Ptr ptr = R()(runtime);
|
|
|
|
std::string axis = runtime.getStringLiteral (runtime[0].mInteger);
|
|
runtime.pop();
|
|
|
|
if(axis == "x")
|
|
{
|
|
runtime.push(ptr.getRefData().getPosition().pos[0]);
|
|
}
|
|
else if(axis == "y")
|
|
{
|
|
runtime.push(ptr.getRefData().getPosition().pos[1]);
|
|
}
|
|
else if(axis == "z")
|
|
{
|
|
runtime.push(ptr.getRefData().getPosition().pos[2]);
|
|
}
|
|
else
|
|
throw std::runtime_error ("invalid axis: " + axis);
|
|
}
|
|
};
|
|
|
|
template<class R>
|
|
class OpSetPos : public Interpreter::Opcode0
|
|
{
|
|
public:
|
|
|
|
virtual void execute (Interpreter::Runtime& runtime)
|
|
{
|
|
MWWorld::Ptr ptr = R()(runtime);
|
|
|
|
if (!ptr.isInCell())
|
|
return;
|
|
|
|
if (ptr == MWBase::Environment::get().getWorld()->getPlayerPtr())
|
|
{
|
|
MWBase::Environment::get().getWorld()->getPlayer().setTeleported(true);
|
|
}
|
|
|
|
std::string axis = runtime.getStringLiteral (runtime[0].mInteger);
|
|
runtime.pop();
|
|
Interpreter::Type_Float pos = runtime[0].mFloat;
|
|
runtime.pop();
|
|
|
|
float ax = ptr.getRefData().getPosition().pos[0];
|
|
float ay = ptr.getRefData().getPosition().pos[1];
|
|
float az = ptr.getRefData().getPosition().pos[2];
|
|
|
|
MWWorld::Ptr updated = ptr;
|
|
if(axis == "x")
|
|
{
|
|
updated = MWBase::Environment::get().getWorld()->moveObject(ptr,pos,ay,az);
|
|
}
|
|
else if(axis == "y")
|
|
{
|
|
updated = MWBase::Environment::get().getWorld()->moveObject(ptr,ax,pos,az);
|
|
}
|
|
else if(axis == "z")
|
|
{
|
|
updated = MWBase::Environment::get().getWorld()->moveObject(ptr,ax,ay,pos);
|
|
}
|
|
else
|
|
throw std::runtime_error ("invalid axis: " + axis);
|
|
|
|
dynamic_cast<MWScript::InterpreterContext&>(runtime.getContext()).updatePtr(updated);
|
|
}
|
|
};
|
|
|
|
template<class R>
|
|
class OpGetStartingPos : public Interpreter::Opcode0
|
|
{
|
|
public:
|
|
|
|
virtual void execute (Interpreter::Runtime& runtime)
|
|
{
|
|
MWWorld::Ptr ptr = R()(runtime);
|
|
|
|
std::string axis = runtime.getStringLiteral (runtime[0].mInteger);
|
|
runtime.pop();
|
|
|
|
if(axis == "x")
|
|
{
|
|
runtime.push(ptr.getCellRef().getPosition().pos[0]);
|
|
}
|
|
else if(axis == "y")
|
|
{
|
|
runtime.push(ptr.getCellRef().getPosition().pos[1]);
|
|
}
|
|
else if(axis == "z")
|
|
{
|
|
runtime.push(ptr.getCellRef().getPosition().pos[2]);
|
|
}
|
|
else
|
|
throw std::runtime_error ("invalid axis: " + axis);
|
|
}
|
|
};
|
|
|
|
template<class R>
|
|
class OpPositionCell : public Interpreter::Opcode0
|
|
{
|
|
public:
|
|
|
|
virtual void execute (Interpreter::Runtime& runtime)
|
|
{
|
|
MWWorld::Ptr ptr = R()(runtime);
|
|
|
|
if (ptr.getContainerStore())
|
|
return;
|
|
|
|
if (ptr == MWBase::Environment::get().getWorld()->getPlayerPtr())
|
|
{
|
|
MWBase::Environment::get().getWorld()->getPlayer().setTeleported(true);
|
|
}
|
|
|
|
Interpreter::Type_Float x = runtime[0].mFloat;
|
|
runtime.pop();
|
|
Interpreter::Type_Float y = runtime[0].mFloat;
|
|
runtime.pop();
|
|
Interpreter::Type_Float z = runtime[0].mFloat;
|
|
runtime.pop();
|
|
Interpreter::Type_Float zRot = runtime[0].mFloat;
|
|
runtime.pop();
|
|
std::string cellID = runtime.getStringLiteral (runtime[0].mInteger);
|
|
runtime.pop();
|
|
|
|
MWWorld::CellStore* store = 0;
|
|
try
|
|
{
|
|
store = MWBase::Environment::get().getWorld()->getInterior(cellID);
|
|
}
|
|
catch(std::exception&)
|
|
{
|
|
const ESM::Cell* cell = MWBase::Environment::get().getWorld()->getExterior(cellID);
|
|
int cx,cy;
|
|
MWBase::Environment::get().getWorld()->positionToIndex(x,y,cx,cy);
|
|
store = MWBase::Environment::get().getWorld()->getExterior(cx,cy);
|
|
if(!cell)
|
|
{
|
|
runtime.getContext().report ("unknown cell (" + cellID + ")");
|
|
std::cerr << "unknown cell (" << cellID << ")\n";
|
|
}
|
|
}
|
|
if(store)
|
|
{
|
|
MWBase::Environment::get().getWorld()->moveObject(ptr,store,x,y,z);
|
|
ptr = MWWorld::Ptr(ptr.getBase(), store);
|
|
dynamic_cast<MWScript::InterpreterContext&>(runtime.getContext()).updatePtr(ptr);
|
|
|
|
float ax = Ogre::Radian(ptr.getRefData().getPosition().rot[0]).valueDegrees();
|
|
float ay = Ogre::Radian(ptr.getRefData().getPosition().rot[1]).valueDegrees();
|
|
// Note that you must specify ZRot in minutes (1 degree = 60 minutes; north = 0, east = 5400, south = 10800, west = 16200)
|
|
// except for when you position the player, then degrees must be used.
|
|
// See "Morrowind Scripting for Dummies (9th Edition)" pages 50 and 54 for reference.
|
|
if(ptr != MWBase::Environment::get().getWorld()->getPlayerPtr())
|
|
zRot = zRot/60.0f;
|
|
MWBase::Environment::get().getWorld()->rotateObject(ptr,ax,ay,zRot);
|
|
|
|
ptr.getClass().adjustPosition(ptr, false);
|
|
}
|
|
}
|
|
};
|
|
|
|
template<class R>
|
|
class OpPosition : public Interpreter::Opcode0
|
|
{
|
|
public:
|
|
|
|
virtual void execute (Interpreter::Runtime& runtime)
|
|
{
|
|
MWWorld::Ptr ptr = R()(runtime);
|
|
|
|
if (!ptr.isInCell())
|
|
return;
|
|
|
|
if (ptr == MWBase::Environment::get().getWorld()->getPlayerPtr())
|
|
{
|
|
MWBase::Environment::get().getWorld()->getPlayer().setTeleported(true);
|
|
}
|
|
|
|
Interpreter::Type_Float x = runtime[0].mFloat;
|
|
runtime.pop();
|
|
Interpreter::Type_Float y = runtime[0].mFloat;
|
|
runtime.pop();
|
|
Interpreter::Type_Float z = runtime[0].mFloat;
|
|
runtime.pop();
|
|
Interpreter::Type_Float zRot = runtime[0].mFloat;
|
|
runtime.pop();
|
|
int cx,cy;
|
|
MWBase::Environment::get().getWorld()->positionToIndex(x,y,cx,cy);
|
|
|
|
// another morrowind oddity: player will be moved to the exterior cell at this location,
|
|
// non-player actors will move within the cell they are in.
|
|
MWWorld::Ptr updated;
|
|
if (ptr == MWBase::Environment::get().getWorld()->getPlayerPtr())
|
|
{
|
|
MWWorld::CellStore* cell = MWBase::Environment::get().getWorld()->getExterior(cx,cy);
|
|
MWBase::Environment::get().getWorld()->moveObject(ptr,cell,x,y,z);
|
|
updated = MWWorld::Ptr(ptr.getBase(), cell);
|
|
}
|
|
else
|
|
{
|
|
updated = MWBase::Environment::get().getWorld()->moveObject(ptr, x, y, z);
|
|
}
|
|
dynamic_cast<MWScript::InterpreterContext&>(runtime.getContext()).updatePtr(updated);
|
|
|
|
float ax = Ogre::Radian(ptr.getRefData().getPosition().rot[0]).valueDegrees();
|
|
float ay = Ogre::Radian(ptr.getRefData().getPosition().rot[1]).valueDegrees();
|
|
// Note that you must specify ZRot in minutes (1 degree = 60 minutes; north = 0, east = 5400, south = 10800, west = 16200)
|
|
// except for when you position the player, then degrees must be used.
|
|
// See "Morrowind Scripting for Dummies (9th Edition)" pages 50 and 54 for reference.
|
|
if(ptr != MWBase::Environment::get().getWorld()->getPlayerPtr())
|
|
zRot = zRot/60.0f;
|
|
MWBase::Environment::get().getWorld()->rotateObject(ptr,ax,ay,zRot);
|
|
ptr.getClass().adjustPosition(ptr, false);
|
|
}
|
|
};
|
|
|
|
template<class R>
|
|
class OpPlaceItemCell : public Interpreter::Opcode0
|
|
{
|
|
public:
|
|
|
|
virtual void execute (Interpreter::Runtime& runtime)
|
|
{
|
|
std::string itemID = runtime.getStringLiteral (runtime[0].mInteger);
|
|
runtime.pop();
|
|
std::string cellID = runtime.getStringLiteral (runtime[0].mInteger);
|
|
runtime.pop();
|
|
|
|
Interpreter::Type_Float x = runtime[0].mFloat;
|
|
runtime.pop();
|
|
Interpreter::Type_Float y = runtime[0].mFloat;
|
|
runtime.pop();
|
|
Interpreter::Type_Float z = runtime[0].mFloat;
|
|
runtime.pop();
|
|
Interpreter::Type_Float zRot = runtime[0].mFloat;
|
|
runtime.pop();
|
|
|
|
MWWorld::CellStore* store = 0;
|
|
try
|
|
{
|
|
store = MWBase::Environment::get().getWorld()->getInterior(cellID);
|
|
}
|
|
catch(std::exception&)
|
|
{
|
|
const ESM::Cell* cell = MWBase::Environment::get().getWorld()->getExterior(cellID);
|
|
int cx,cy;
|
|
MWBase::Environment::get().getWorld()->positionToIndex(x,y,cx,cy);
|
|
store = MWBase::Environment::get().getWorld()->getExterior(cx,cy);
|
|
if(!cell)
|
|
{
|
|
runtime.getContext().report ("unknown cell (" + cellID + ")");
|
|
std::cerr << "unknown cell (" << cellID << ")\n";
|
|
}
|
|
}
|
|
if(store)
|
|
{
|
|
ESM::Position pos;
|
|
pos.pos[0] = x;
|
|
pos.pos[1] = y;
|
|
pos.pos[2] = z;
|
|
pos.rot[0] = pos.rot[1] = 0;
|
|
pos.rot[2] = zRot;
|
|
MWWorld::ManualRef ref(MWBase::Environment::get().getWorld()->getStore(),itemID);
|
|
ref.getPtr().getCellRef().setPosition(pos);
|
|
MWWorld::Ptr placed = MWBase::Environment::get().getWorld()->safePlaceObject(ref.getPtr(),store,pos);
|
|
placed.getClass().adjustPosition(placed, true);
|
|
}
|
|
}
|
|
};
|
|
|
|
template<class R>
|
|
class OpPlaceItem : public Interpreter::Opcode0
|
|
{
|
|
public:
|
|
|
|
virtual void execute (Interpreter::Runtime& runtime)
|
|
{
|
|
std::string itemID = runtime.getStringLiteral (runtime[0].mInteger);
|
|
runtime.pop();
|
|
|
|
Interpreter::Type_Float x = runtime[0].mFloat;
|
|
runtime.pop();
|
|
Interpreter::Type_Float y = runtime[0].mFloat;
|
|
runtime.pop();
|
|
Interpreter::Type_Float z = runtime[0].mFloat;
|
|
runtime.pop();
|
|
Interpreter::Type_Float zRot = runtime[0].mFloat;
|
|
runtime.pop();
|
|
|
|
MWWorld::Ptr player = MWBase::Environment::get().getWorld()->getPlayerPtr();
|
|
MWWorld::CellStore* store = NULL;
|
|
if (player.getCell()->isExterior())
|
|
{
|
|
int cx,cy;
|
|
MWBase::Environment::get().getWorld()->positionToIndex(x,y,cx,cy);
|
|
store = MWBase::Environment::get().getWorld()->getExterior(cx,cy);
|
|
}
|
|
else
|
|
store = player.getCell();
|
|
|
|
ESM::Position pos;
|
|
pos.pos[0] = x;
|
|
pos.pos[1] = y;
|
|
pos.pos[2] = z;
|
|
pos.rot[0] = pos.rot[1] = 0;
|
|
pos.rot[2] = zRot;
|
|
MWWorld::ManualRef ref(MWBase::Environment::get().getWorld()->getStore(),itemID);
|
|
ref.getPtr().getCellRef().setPosition(pos);
|
|
MWWorld::Ptr placed = MWBase::Environment::get().getWorld()->safePlaceObject(ref.getPtr(),store,pos);
|
|
placed.getClass().adjustPosition(placed, true);
|
|
}
|
|
};
|
|
|
|
template<class R, bool pc>
|
|
class OpPlaceAt : public Interpreter::Opcode0
|
|
{
|
|
public:
|
|
|
|
virtual void execute (Interpreter::Runtime& runtime)
|
|
{
|
|
MWWorld::Ptr actor = pc
|
|
? MWBase::Environment::get().getWorld()->getPlayerPtr()
|
|
: R()(runtime);
|
|
|
|
std::string itemID = runtime.getStringLiteral (runtime[0].mInteger);
|
|
runtime.pop();
|
|
|
|
Interpreter::Type_Integer count = runtime[0].mInteger;
|
|
runtime.pop();
|
|
Interpreter::Type_Float distance = runtime[0].mFloat;
|
|
runtime.pop();
|
|
Interpreter::Type_Integer direction = runtime[0].mInteger;
|
|
runtime.pop();
|
|
|
|
if (count<0)
|
|
throw std::runtime_error ("count must be non-negative");
|
|
|
|
for (int i=0; i<count; ++i)
|
|
{
|
|
ESM::Position ipos = actor.getRefData().getPosition();
|
|
Ogre::Vector3 pos(ipos.pos[0],ipos.pos[1],ipos.pos[2]);
|
|
Ogre::Quaternion rot(Ogre::Radian(-ipos.rot[2]), Ogre::Vector3::UNIT_Z);
|
|
if(direction == 0) pos = pos + distance*rot.yAxis();
|
|
else if(direction == 1) pos = pos - distance*rot.yAxis();
|
|
else if(direction == 2) pos = pos - distance*rot.xAxis();
|
|
else if(direction == 3) pos = pos + distance*rot.xAxis();
|
|
else throw std::runtime_error ("direction must be 0,1,2 or 3");
|
|
|
|
ipos.pos[0] = pos.x;
|
|
ipos.pos[1] = pos.y;
|
|
ipos.pos[2] = pos.z;
|
|
|
|
if (actor.getClass().isActor())
|
|
{
|
|
// TODO: should this depend on the 'direction' parameter?
|
|
ipos.rot[0] = 0;
|
|
ipos.rot[1] = 0;
|
|
ipos.rot[2] = 0;
|
|
}
|
|
else
|
|
{
|
|
ipos.rot[0] = actor.getRefData().getPosition().rot[0];
|
|
ipos.rot[1] = actor.getRefData().getPosition().rot[1];
|
|
ipos.rot[2] = actor.getRefData().getPosition().rot[2];
|
|
}
|
|
// create item
|
|
MWWorld::CellStore* store = actor.getCell();
|
|
MWWorld::ManualRef ref(MWBase::Environment::get().getWorld()->getStore(), itemID, 1);
|
|
ref.getPtr().getCellRef().setPosition(ipos);
|
|
|
|
MWBase::Environment::get().getWorld()->safePlaceObject(ref.getPtr(),store,ipos);
|
|
}
|
|
}
|
|
};
|
|
|
|
template<class R>
|
|
class OpRotate : public Interpreter::Opcode0
|
|
{
|
|
public:
|
|
|
|
virtual void execute (Interpreter::Runtime& runtime)
|
|
{
|
|
const MWWorld::Ptr& ptr = R()(runtime);
|
|
|
|
std::string axis = runtime.getStringLiteral (runtime[0].mInteger);
|
|
runtime.pop();
|
|
Interpreter::Type_Float rotation = (runtime[0].mFloat*MWBase::Environment::get().getFrameDuration());
|
|
runtime.pop();
|
|
|
|
float ax = Ogre::Radian(ptr.getRefData().getLocalRotation().rot[0]).valueDegrees();
|
|
float ay = Ogre::Radian(ptr.getRefData().getLocalRotation().rot[1]).valueDegrees();
|
|
float az = Ogre::Radian(ptr.getRefData().getLocalRotation().rot[2]).valueDegrees();
|
|
|
|
if (axis == "x")
|
|
{
|
|
MWBase::Environment::get().getWorld()->localRotateObject(ptr,ax+rotation,ay,az);
|
|
}
|
|
else if (axis == "y")
|
|
{
|
|
MWBase::Environment::get().getWorld()->localRotateObject(ptr,ax,ay+rotation,az);
|
|
}
|
|
else if (axis == "z")
|
|
{
|
|
MWBase::Environment::get().getWorld()->localRotateObject(ptr,ax,ay,az+rotation);
|
|
}
|
|
else
|
|
throw std::runtime_error ("invalid rotation axis: " + axis);
|
|
}
|
|
};
|
|
|
|
template<class R>
|
|
class OpRotateWorld : public Interpreter::Opcode0
|
|
{
|
|
public:
|
|
|
|
virtual void execute (Interpreter::Runtime& runtime)
|
|
{
|
|
MWWorld::Ptr ptr = R()(runtime);
|
|
|
|
std::string axis = runtime.getStringLiteral (runtime[0].mInteger);
|
|
runtime.pop();
|
|
Interpreter::Type_Float rotation = (runtime[0].mFloat*MWBase::Environment::get().getFrameDuration());
|
|
runtime.pop();
|
|
|
|
const float *objRot = ptr.getRefData().getPosition().rot;
|
|
|
|
float ax = Ogre::Radian(objRot[0]).valueDegrees();
|
|
float ay = Ogre::Radian(objRot[1]).valueDegrees();
|
|
float az = Ogre::Radian(objRot[2]).valueDegrees();
|
|
|
|
if (axis == "x")
|
|
{
|
|
MWBase::Environment::get().getWorld()->rotateObject(ptr,ax+rotation,ay,az);
|
|
}
|
|
else if (axis == "y")
|
|
{
|
|
MWBase::Environment::get().getWorld()->rotateObject(ptr,ax,ay+rotation,az);
|
|
}
|
|
else if (axis == "z")
|
|
{
|
|
MWBase::Environment::get().getWorld()->rotateObject(ptr,ax,ay,az+rotation);
|
|
}
|
|
else
|
|
throw std::runtime_error ("invalid rotation axis: " + axis);
|
|
}
|
|
};
|
|
|
|
template<class R>
|
|
class OpSetAtStart : public Interpreter::Opcode0
|
|
{
|
|
public:
|
|
|
|
virtual void execute (Interpreter::Runtime& runtime)
|
|
{
|
|
MWWorld::Ptr ptr = R()(runtime);
|
|
|
|
if (!ptr.isInCell())
|
|
return;
|
|
|
|
MWWorld::LocalRotation rot;
|
|
rot.rot[0] = 0;
|
|
rot.rot[1] = 0;
|
|
rot.rot[2] = 0;
|
|
ptr.getRefData().setLocalRotation(rot);
|
|
|
|
MWBase::Environment::get().getWorld()->rotateObject(ptr, 0,0,0,true);
|
|
|
|
dynamic_cast<MWScript::InterpreterContext&>(runtime.getContext()).updatePtr(
|
|
MWBase::Environment::get().getWorld()->moveObject(ptr, ptr.getCellRef().getPosition().pos[0],
|
|
ptr.getCellRef().getPosition().pos[1], ptr.getCellRef().getPosition().pos[2]));
|
|
|
|
}
|
|
};
|
|
|
|
template<class R>
|
|
class OpMove : public Interpreter::Opcode0
|
|
{
|
|
public:
|
|
|
|
virtual void execute (Interpreter::Runtime& runtime)
|
|
{
|
|
const MWWorld::Ptr& ptr = R()(runtime);
|
|
|
|
if (!ptr.isInCell())
|
|
return;
|
|
|
|
std::string axis = runtime.getStringLiteral (runtime[0].mInteger);
|
|
runtime.pop();
|
|
Interpreter::Type_Float movement = (runtime[0].mFloat*MWBase::Environment::get().getFrameDuration());
|
|
runtime.pop();
|
|
|
|
Ogre::Vector3 posChange;
|
|
if (axis == "x")
|
|
{
|
|
posChange=Ogre::Vector3(movement, 0, 0);
|
|
}
|
|
else if (axis == "y")
|
|
{
|
|
posChange=Ogre::Vector3(0, movement, 0);
|
|
}
|
|
else if (axis == "z")
|
|
{
|
|
posChange=Ogre::Vector3(0, 0, movement);
|
|
}
|
|
else
|
|
throw std::runtime_error ("invalid movement axis: " + axis);
|
|
|
|
if (!ptr.getRefData().getBaseNode())
|
|
return;
|
|
|
|
Ogre::Vector3 diff = ptr.getRefData().getBaseNode()->getOrientation() * posChange;
|
|
Ogre::Vector3 worldPos(ptr.getRefData().getPosition().pos);
|
|
worldPos += diff;
|
|
MWBase::Environment::get().getWorld()->moveObject(ptr, worldPos.x, worldPos.y, worldPos.z);
|
|
}
|
|
};
|
|
|
|
template<class R>
|
|
class OpMoveWorld : public Interpreter::Opcode0
|
|
{
|
|
public:
|
|
|
|
virtual void execute (Interpreter::Runtime& runtime)
|
|
{
|
|
MWWorld::Ptr ptr = R()(runtime);
|
|
|
|
if (!ptr.isInCell())
|
|
return;
|
|
|
|
std::string axis = runtime.getStringLiteral (runtime[0].mInteger);
|
|
runtime.pop();
|
|
Interpreter::Type_Float movement = (runtime[0].mFloat*MWBase::Environment::get().getFrameDuration());
|
|
runtime.pop();
|
|
|
|
const float *objPos = ptr.getRefData().getPosition().pos;
|
|
|
|
MWWorld::Ptr updated;
|
|
if (axis == "x")
|
|
{
|
|
updated = MWBase::Environment::get().getWorld()->moveObject(ptr, objPos[0]+movement, objPos[1], objPos[2]);
|
|
}
|
|
else if (axis == "y")
|
|
{
|
|
updated = MWBase::Environment::get().getWorld()->moveObject(ptr, objPos[0], objPos[1]+movement, objPos[2]);
|
|
}
|
|
else if (axis == "z")
|
|
{
|
|
updated = MWBase::Environment::get().getWorld()->moveObject(ptr, objPos[0], objPos[1], objPos[2]+movement);
|
|
}
|
|
else
|
|
throw std::runtime_error ("invalid movement axis: " + axis);
|
|
}
|
|
};
|
|
|
|
class OpResetActors : public Interpreter::Opcode0
|
|
{
|
|
public:
|
|
|
|
virtual void execute (Interpreter::Runtime& runtime)
|
|
{
|
|
MWBase::Environment::get().getWorld()->resetActors();
|
|
}
|
|
};
|
|
|
|
void installOpcodes (Interpreter::Interpreter& interpreter)
|
|
{
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeSetScale,new OpSetScale<ImplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeSetScaleExplicit,new OpSetScale<ExplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeSetAngle,new OpSetAngle<ImplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeSetAngleExplicit,new OpSetAngle<ExplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeGetScale,new OpGetScale<ImplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeGetScaleExplicit,new OpGetScale<ExplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeGetAngle,new OpGetAngle<ImplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeGetAngleExplicit,new OpGetAngle<ExplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeGetPos,new OpGetPos<ImplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeGetPosExplicit,new OpGetPos<ExplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeSetPos,new OpSetPos<ImplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeSetPosExplicit,new OpSetPos<ExplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeGetStartingPos,new OpGetStartingPos<ImplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeGetStartingPosExplicit,new OpGetStartingPos<ExplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodePosition,new OpPosition<ImplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodePositionExplicit,new OpPosition<ExplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodePositionCell,new OpPositionCell<ImplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodePositionCellExplicit,new OpPositionCell<ExplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodePlaceItemCell,new OpPlaceItemCell<ImplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodePlaceItem,new OpPlaceItem<ImplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodePlaceAtPc,new OpPlaceAt<ImplicitRef, true>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodePlaceAtMe,new OpPlaceAt<ImplicitRef, false>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodePlaceAtMeExplicit,new OpPlaceAt<ExplicitRef, false>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeModScale,new OpModScale<ImplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeModScaleExplicit,new OpModScale<ExplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeRotate,new OpRotate<ImplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeRotateExplicit,new OpRotate<ExplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeRotateWorld,new OpRotateWorld<ImplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeRotateWorldExplicit,new OpRotateWorld<ExplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeSetAtStart,new OpSetAtStart<ImplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeSetAtStartExplicit,new OpSetAtStart<ExplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeMove,new OpMove<ImplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeMoveExplicit,new OpMove<ExplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeMoveWorld,new OpMoveWorld<ImplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeMoveWorldExplicit,new OpMoveWorld<ExplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeGetStartingAngle, new OpGetStartingAngle<ImplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeGetStartingAngleExplicit, new OpGetStartingAngle<ExplicitRef>);
|
|
interpreter.installSegment5(Compiler::Transformation::opcodeResetActors, new OpResetActors);
|
|
}
|
|
}
|
|
}
|