//Overwrites old information. This means that threads blocking on turn completion
//will now wait for this new turn instead. Not sure if this is the expected behaviour
//Other option would be to kill them. Or perhaps unblock them.
void CCobInstance::AddAnim(AnimType type, int piece, int axis, int speed, int dest, int accel, bool interpolated)
{
struct AnimInfo *ai;
//Turns override spins.. Not sure about the other way around? If so the system should probably be redesigned
//to only have two types of anims.. turns and moves, with spin as a bool
if (type == ATurn)
RemoveAnim(ASpin, piece, axis);
if (type == ASpin)
RemoveAnim(ATurn, piece, axis);
ai = FindAnim(type, piece, axis);
if (!ai) {
ai = new struct AnimInfo;
ai->type = type;
ai->piece = piece;
ai->axis = axis;
anims.push_back(ai);
//If we were not animating before, inform the engine of this so it can schedule us
if (anims.size() == 1) {
GCobEngine.AddInstance(this);
}
// Check to make sure the piece exists
if (piece >= pieces.size()) {
logOutput.Print("Invalid piece in anim %d (%d)", piece, pieces.size());
}
}
ai->speed = speed;
ai->dest = dest;
ai->accel = accel;
ai->interpolated = interpolated;
}
//Overwrites old information. This means that threads blocking on turn completion
//will now wait for this new turn instead. Not sure if this is the expected behaviour
//Other option would be to kill them. Or perhaps unblock them.
void CUnitScript::AddAnim(AnimType type, int piece, int axis, float speed, float dest, float accel, bool interpolated)
{
if (!PieceExists(piece)) {
ShowScriptError("Invalid piecenumber");
return;
}
float destf;
if (type == AMove) {
destf = pieces[piece]->original->offset[axis] + dest;
} else {
destf = dest;
if (type == ATurn) {
ClampRad(&destf);
}
}
struct AnimInfo *ai;
//Turns override spins.. Not sure about the other way around? If so the system should probably be redesigned
//to only have two types of anims.. turns and moves, with spin as a bool
//todo: optimize, atm RemoveAnim and FindAnim search twice through all anims
if (type == ATurn)
RemoveAnim(ASpin, piece, axis);
if (type == ASpin)
RemoveAnim(ATurn, piece, axis);
ai = FindAnim(type, piece, axis);
if (!ai) {
// If we were not animating before, inform the engine of this so it can schedule us
if (anims.empty()) {
GUnitScriptEngine.AddInstance(this);
}
ai = new struct AnimInfo;
ai->type = type;
ai->piece = piece;
ai->axis = axis;
anims.push_back(ai);
}
ai->dest = destf;
ai->speed = speed;
ai->accel = accel;
ai->interpolated = interpolated;
}
void CCobInstance::StopSpin(int piece, int axis, int decel)
{
struct AnimInfo *ai;
ai = FindAnim(ASpin, piece, axis);
if (!ai)
return;
if (decel == 0) {
RemoveAnim(ASpin, piece, axis);
}
else
AddAnim(ASpin, piece, axis, ai->speed, 0, -decel);
}
void CUnitScript::StopSpin(int piece, int axis, float decel)
{
std::list<AnimInfo*>::iterator animInfoIt = FindAnim(ASpin, piece, axis);
if (decel <= 0) {
RemoveAnim(ASpin, animInfoIt);
} else {
if (animInfoIt == anims[ASpin].end())
return;
AnimInfo* ai = *animInfoIt;
ai->dest = 0;
ai->accel = decel;
}
}
void CUnitScript::StopSpin(int piece, int axis, float decel)
{
if (decel <= 0) {
RemoveAnim(ASpin, piece, axis);
}
else {
struct AnimInfo *ai;
ai = FindAnim(ASpin, piece, axis);
if (!ai)
return;
ai->dest = 0;
ai->accel = decel;
}
}
// dtor -------------
// -----
plAGAnim::~plAGAnim()
{
if (!fName.IsNull())
{
RemoveAnim(fName);
}
//int numChannels = fChannels.size();
int numApps = fApps.size();
for (int i = 0; i < numApps; i++)
{
plAGApplicator *app = fApps[i];
if (app)
{
plAGChannel *channel = app->GetChannel();
if(channel)
delete channel;
delete app;
}
}
}
//Overwrites old information. This means that threads blocking on turn completion
//will now wait for this new turn instead. Not sure if this is the expected behaviour
//Other option would be to kill them. Or perhaps unblock them.
void CUnitScript::AddAnim(AnimType type, int piece, int axis, float speed, float dest, float accel)
{
if (!PieceExists(piece)) {
ShowScriptError("Invalid piecenumber");
return;
}
float destf = 0.0f;
if (type == AMove) {
destf = pieces[piece]->original->offset[axis] + dest;
} else {
destf = dest;
if (type == ATurn) {
ClampRad(&destf);
}
}
std::list<AnimInfo*>::iterator animInfoIt;
AnimInfo* ai = NULL;
AnimType overrideType = ANone;
// first find an animation of a type we override
// Turns override spins.. Not sure about the other way around? If so
// the system should probably be redesigned to only have two types of
// anims (turns and moves), with spin as a bool
switch (type) {
case ATurn: {
overrideType = ASpin;
animInfoIt = FindAnim(overrideType, piece, axis);
} break;
case ASpin: {
overrideType = ATurn;
animInfoIt = FindAnim(overrideType, piece, axis);
} break;
case AMove: {
// ensure we never remove an animation of this type
overrideType = AMove;
animInfoIt = anims[overrideType].end();
} break;
default: {
} break;
}
if (animInfoIt != anims[overrideType].end())
RemoveAnim(overrideType, animInfoIt);
// now find an animation of our own type
animInfoIt = FindAnim(type, piece, axis);
if (animInfoIt == anims[type].end()) {
// If we were not animating before, inform the engine of this so it can schedule us
// FIXME: this could be done in a cleaner way
if (!HaveAnimations()) {
GUnitScriptEngine.AddInstance(this);
}
ai = new AnimInfo();
ai->type = type;
ai->piece = piece;
ai->axis = axis;
anims[type].push_back(ai);
} else {
ai = *animInfoIt;
}
ai->dest = destf;
ai->speed = speed;
ai->accel = accel;
ai->done = false;
}