SceneType MainCharacter::animate(Scene &scene, float delta) {
checkInputs();
move(scene, delta);
createTransformationMatrix();
return scene.sceneType;
}
SceneType PlayerPokemon::animate(Scene &scene, float delta) {
if (scene.sceneType == SceneType::BATTLE_SCEEN) {
attackDelay += delta;
if (wasAttacked && attackDelay > 3.0f) {
if (startingPos.z < this->position.z && scene.isWPressed()) {
if (this->position.z + delta > startingPos.z)
this->position.z = startingPos.z;
else
this->position.z += delta;
return scene.sceneType;
}
canAttack = true;
}
for (auto objectLoop : scene.objects) {
if (objectLoop.get() == this)
continue;
auto att = std::dynamic_pointer_cast<Attack>(objectLoop);
if (!att) {
continue;
}
else {
if (att->collisionDelay > 0.5f ) {
if (collidedWith(objectLoop)) {
objectLoop->needsDeletion = true;
attackDelay = 0.0f;
wasAttacked = true;
this->currentHp -= 1;
this->position.z += att->knockbackForce;
}
}
}
}
if (scene.isTPressed() && canAttack) {
canAttack = false;
wasAttacked = false;
attack(scene);
}
}
createTransformationMatrix();
if (this->currentHp <= 0)
return SceneType::MAIN_SCEEN;
return scene.sceneType ;
}
//
// Calls applyRotationLocks && applyRotationLimits
// This method verifies that the passed value can be set on the
// rotate plugs. In the base class, limits as well as locking are
// checked by this method.
//
// The compute, validateAndSetValue, and rotateTo functions
// all use this method.
//
MStatus rockingTransformCheckNode::checkAndSetRotation(MDataBlock &block,
const MPlug& plug,
const MEulerRotation& newRotation,
MSpace::Space space )
{
const MDGContext context = block.context();
updateMatrixAttrs(context);
MStatus status = MS::kSuccess;
MEulerRotation outRotation = newRotation;
if (context.isNormal()) {
// For easy reading.
//
MPxTransformationMatrix *xformMat = baseTransformationMatrix;
// Get the current translation in transform space for
// clamping and locking.
//
MEulerRotation savedRotation =
xformMat->eulerRotation(MSpace::kTransform, &status);
ReturnOnError(status);
// Translate to transform space, since the limit test needs the
// values in transform space. The locking test needs the values
// in the same space as the savedR value - which is transform
// space as well.
//
status = baseTransformationMatrix->rotateTo(newRotation, space);
ReturnOnError(status);
outRotation = xformMat->eulerRotation(MSpace::kTransform, &status);
ReturnOnError(status);
// Now that everything is in the same space, apply limits
// and change the value to adhere to plug locking.
//
outRotation = applyRotationLimits(outRotation, block, &status);
ReturnOnError(status);
outRotation = applyRotationLocks(outRotation, savedRotation, &status);
ReturnOnError(status);
// The value that remain is in transform space.
//
status = xformMat->rotateTo(outRotation, MSpace::kTransform);
ReturnOnError(status);
// Get the value that was just set. It needs to be in transform
// space since it is used to set the datablock values at the
// end of this method. Getting the vaolue right before setting
// ensures that the transformation matrix and data block will
// be synchronized.
//
outRotation = xformMat->eulerRotation(MSpace::kTransform, &status);
ReturnOnError(status);
} else {
// Get the rotation for clamping and locking. This will get the
// rotate value in transform space.
//
double3 &s3 = block.inputValue(rotate).asDouble3();
MEulerRotation savedRotation(s3[0], s3[1], s3[2]);
// Create a local transformation matrix for non-normal context
// calculations.
//
MPxTransformationMatrix *local = createTransformationMatrix();
if (NULL == local) {
MGlobal::displayError("rockingTransformCheck::checkAndSetRotation internal error");
return status;
}
// Fill the newly created transformation matrix.
//
status = computeLocalTransformation(local, block);
if ( MS::kSuccess != status)
{
delete local;
return status;
}
// Translate the values to transform space. This will allow the
// limit and locking tests to work properly.
//
status = local->rotateTo(newRotation, space);
if ( MS::kSuccess != status)
{
delete local;
return status;
}
outRotation = local->eulerRotation(MSpace::kTransform, &status);
if ( MS::kSuccess != status)
{
delete local;
return status;
}
// Apply limits
//
outRotation = applyRotationLimits(outRotation, block, &status);
if ( MS::kSuccess != status)
{
delete local;
return status;
}
outRotation = applyRotationLocks(outRotation, savedRotation, &status);
if ( MS::kSuccess != status)
{
delete local;
return status;
}
status = local->rotateTo(outRotation, MSpace::kTransform);
if ( MS::kSuccess != status)
{
delete local;
return status;
}
// Get the rotate value in transform space for placement in the
// datablock.
//
outRotation = local->eulerRotation(MSpace::kTransform, &status);
if ( MS::kSuccess != status)
{
delete local;
return status;
}
delete local;
}
MDataHandle handle = block.outputValue(plug, &status);
if ( MS::kSuccess != status)
{
return status;
}
if (plug == rotate) {
handle.set(outRotation.x, outRotation.y, outRotation.z);
} else if (plug == rotateX) {
handle.set(outRotation.x);
} else if (plug == rotateY) {
handle.set(outRotation.y);
} else {
handle.set(outRotation.z);
}
return status;
}