nuclide-lite/src/system/ncAnimationManager.qc

.float idle_firstFrame;
.float idle_lastFrame;
.float idle_frameRate;
.float walk_firstFrame;
.float walk_lastFrame;
.float walk_frameRate;
.float override_firstFrame;
.float override_lastFrame;
.float override_frameRate;
.float wasWalking;

void ncAnimationManager::ncAnimationManager( void )
{
	idle_firstFrame = 0;
	idle_lastFrame = 0;
	idle_frameRate = 0;
	walk_firstFrame = 0;
	walk_lastFrame = 0;
	walk_frameRate = 0;
	override_firstFrame = 0;
	override_lastFrame = 0;
	override_frameRate = 0;
	wasWalking = 0;
}

void ncAnimationManager::ProgressCycle( void )
{
	float playerSpeed = ncMath::VLen(owner.velocity);
	bool isWalking = (playerSpeed > 2.0f) ? (true) : (false);
	bool isReverse = false;

	/* state switched */
	if (isWalking != wasWalking) {
		if (isWalking) {
			wasWalking = 1;
			owner.frame = walk_firstFrame;
			nextthink = time + walk_frameRate;
		} else {
			wasWalking = 0;
			owner.frame = idle_firstFrame;
			nextthink = time + idle_frameRate;
		}

		return;
	}

	/* at the end */
	if (isWalking) {
		wasWalking = 1;
		isReverse = ( walk_firstFrame > walk_lastFrame ) ? ( true ) : ( false );
		nextthink = time + walk_frameRate;

		if (owner.frame == walk_lastFrame) {
			owner.frame = walk_firstFrame;
			return;
		}
	} else {
		wasWalking = 0;
		isReverse = ( idle_firstFrame > idle_lastFrame ) ? ( true ) : ( false );
		nextthink = time + idle_frameRate;

		if (owner.frame == idle_lastFrame) {
			owner.frame = idle_firstFrame;
			return;
		}
	}

	/* is reverse */
	if (isReverse) {
		owner.frame--;
	} else {
		owner.frame++;
	}
}

void ncAnimationManager::ProgressOverride( void )
{
	bool isReverse = ( override_firstFrame > override_lastFrame ) ? ( true ) : ( false );

	/* at the end, back to idle/walk cycle */
	if (owner.frame == override_lastFrame) {
		nextthink = time + override_frameRate;
		think = ProgressCycle;
		wasWalking = 3; /* force state switch */
		return;
	}

	/* is reverse */
	if (isReverse) {
		owner.frame--;
	} else {
		owner.frame++;
	}

	nextthink = time + health;
}

void ncAnimationManager::ProgressWeaponIdle( void )
{
	ncEntity carrier = ( ncEntity )owner;
	float currentFrame = carrier.weaponframe;

	/* at the end */
	if (currentFrame == idle_lastFrame) {
		carrier.hud.SetWeaponFrame(idle_firstFrame);
	} else {
		/* is reverse */
		if (skin) {
			carrier.hud.SetWeaponFrame(currentFrame - 1);
		} else {
			carrier.hud.SetWeaponFrame(currentFrame + 1);
		}
	}

	nextthink = time + idle_frameRate;
}

void ncAnimationManager::ProgressWeapon( void )
{
	ncEntity carrier = ( ncEntity )owner;
	float currentFrame = carrier.weaponframe;

	/* at the end */
	if (currentFrame == override_lastFrame) {
		carrier.hud.SetWeaponFrame(idle_firstFrame);
		nextthink = time + idle_frameRate;
		think = ProgressWeaponIdle;
		return;
	}

	/* is reverse */
	if (skin) {
		carrier.hud.SetWeaponFrame(currentFrame - 1);
	} else {
		carrier.hud.SetWeaponFrame(currentFrame + 1);
	}

	nextthink = time + override_frameRate;
}

float ncAnimationManager::FPSToRate(float framesPerSecond)
{
	if (framesPerSecond <= 0.0) {
		return (0.1f); /* default is 10 fps. */
	} else {
		return (1 / framesPerSecond);
	}
}

void ncAnimationManager::SetIdleCycle( float firstFrame, float lastFrame, float frameRate )
{
	ncEntity targetEntity = ( ncEntity )owner;
	idle_firstFrame = firstFrame;
	idle_lastFrame = lastFrame;
	idle_frameRate = FPSToRate( frameRate );

	/* there may be a sequence active already, that's okay as its exit will go to cycle */
	if (!think) {
		think = ncAnimationManager::ProgressCycle;
		nextthink = ( time + idle_frameRate );
		targetEntity.SetFrame( firstFrame );
	}
}

void ncAnimationManager::SetWalkCycle( float firstFrame, float lastFrame, float frameRate )
{
	ncEntity targetEntity = ( ncEntity )owner;
	walk_firstFrame = firstFrame;
	walk_lastFrame = lastFrame;
	walk_frameRate = FPSToRate( frameRate );

	/* ditto, see  SetIdleCycle */
	if (!think) {
		think = ncAnimationManager::ProgressCycle;
		nextthink = ( time + walk_frameRate );
		targetEntity.SetFrame( firstFrame );
	}
}

void ncAnimationManager::PlayFrameSequence( float firstFrame, float lastFrame, float frameRate )
{
	ncEntity targetEntity = ( ncEntity )owner;
	override_firstFrame = firstFrame;
	override_lastFrame = lastFrame;
	override_frameRate = FPSToRate( frameRate );
	
	nextthink = ( time + override_frameRate );
	think = ncAnimationManager::ProgressOverride;
	targetEntity.SetFrame( firstFrame );
}

void ncAnimationManager::PlayWeaponFrameSequence( float firstFrame, float lastFrame, float frameRate )
{
	ncEntity targetEntity = ( ncEntity )owner;
	override_firstFrame = firstFrame;
	override_lastFrame = lastFrame;
	override_frameRate = FPSToRate( frameRate );

	nextthink = ( time + override_frameRate );
	think = ncAnimationManager::ProgressWeapon;
	targetEntity.hud.SetWeaponFrame( firstFrame );
}