src/com/replica/replicaisland/NPCAnimationComponent.java

/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.replica.replicaisland;

import com.replica.replicaisland.ChannelSystem.Channel;
import com.replica.replicaisland.GameObject.ActionType;

public class NPCAnimationComponent extends GameComponent {

    // Animations
    public static final int IDLE = 0;
    public static final int WALK = 1;
    public static final int RUN_START = 2;
    public static final int RUN = 3;
    public static final int SHOOT = 4;
    public static final int JUMP_START = 5;
    public static final int JUMP_AIR = 6;
    public static final int TAKE_HIT = 7;
    public static final int SURPRISED = 8;
    public static final int DEATH = 9;

    
    protected static final float RUN_SPEED_THRESHOLD = 100.0f;
    protected static final float JUMP_SPEED_THRESHOLD = 25.0f;
    protected static final float FALL_SPEED_THRESHOLD = -25.0f;
    protected static final float FALL_TIME_THRESHOLD = 0.2f;
    
    private int mCurrentAnimation;
    private SpriteComponent mSprite;
    private ChannelSystem.Channel mChannel;
    private int mChannelTrigger;
    private boolean mFlying;
    private boolean mStopAtWalls;	// Controls whether or not the character will go back 
    								// to idle when running into a wall

    
    public NPCAnimationComponent() {
        super();
        reset();
        setPhase(GameComponent.ComponentPhases.ANIMATION.ordinal());
    }
    
    @Override
    public void reset() {
        mCurrentAnimation = IDLE;
        mChannel = null;
        mSprite = null;
        mFlying = false;
        mStopAtWalls = true;
    }
    
    @Override
    public void update(float timeDelta, BaseObject parent) {
        if (mSprite != null) {
            GameObject parentObject = (GameObject)parent;
            
            final int oldAnimation = mCurrentAnimation;
            switch(mCurrentAnimation) {
                case IDLE:
                    idle(parentObject);
                    break;
                case WALK:
                    walk(parentObject);
                    break;
                case RUN_START:
                    runStart(parentObject);
                    break;
                case RUN:
                    run(parentObject);
                    break;
                case SHOOT:
                    shoot(parentObject);
                    break;
                case JUMP_START:
                    jumpStart(parentObject);
                    break;
                case JUMP_AIR:
                    jumpAir(parentObject);
                    break;
                case TAKE_HIT:
                	takeHit(parentObject);
                	break;
                case SURPRISED:
                	surprised(parentObject);
                	break;
                case DEATH:
                	death(parentObject);
                	break;
               default:
                    assert(false);
            }
            
            if (mChannel != null) {
            	if (mChannel.value != null 
            			&& ((ChannelSystem.ChannelBooleanValue)mChannel.value).value) {
            		mCurrentAnimation = mChannelTrigger;
            	}
            }
            
            if (oldAnimation != mCurrentAnimation) {
                mSprite.playAnimation(mCurrentAnimation);
            }
        }
    }
    
    protected boolean shouldFall(GameObject parentObject) {
        boolean result = false;
        TimeSystem time = sSystemRegistry.timeSystem;
        final float airTime = time.getGameTime() - parentObject.getLastTouchedFloorTime();
        if (!mFlying && !parentObject.touchingGround() && airTime > FALL_TIME_THRESHOLD) {
            final Vector2 velocity = parentObject.getVelocity();
            if (velocity.y < FALL_SPEED_THRESHOLD) {
                result = true;
            }
        }
        return result;
    }
    
    protected boolean shouldJump(GameObject parentObject) {
        boolean result = false;
        
        if (!mFlying) {
	        final Vector2 velocity = parentObject.getVelocity();
	        if (velocity.y > JUMP_SPEED_THRESHOLD) {
	            result = true;
	        }
        }
        return result;
    }
    
    protected boolean shouldRun(GameObject parentObject) {
        boolean result = false;
        if (!mFlying && parentObject.touchingGround()) {
            final Vector2 velocity = parentObject.getVelocity();
            if (Math.abs(velocity.x) >= RUN_SPEED_THRESHOLD) {
                result = true;
            }
        }
        return result;
    }
    
    protected boolean shouldMove(GameObject parentObject) {
        boolean result = true;
        final Vector2 velocity = parentObject.getVelocity();
        
        if (mStopAtWalls) {
	        if ((velocity.x < 0.0f && parentObject.touchingLeftWall()) 
	                || (velocity.x > 0.0f && parentObject.touchingRightWall())) {
	            result = false;
	        }
        }
        return result;
    }
    
    protected boolean shouldTakeHit(GameObject parentObject) {
    	boolean result = false;
    	if (parentObject.getCurrentAction() == ActionType.HIT_REACT 
    			&& mSprite.findAnimation(TAKE_HIT) != null) {
    		result = true;
    	}
    	return result;
    }
    
    protected void gotoRunStart() {
        if (mSprite.findAnimation(RUN_START) != null) {
            mCurrentAnimation = RUN_START;
        } else {
            mCurrentAnimation = RUN;
        }
    }
    
    protected void gotoRun() {
        mCurrentAnimation = RUN;
    }
    
    protected void idle(GameObject parentObject) {
        final GameObject.ActionType currentAction = parentObject.getCurrentAction();
        if (currentAction == ActionType.MOVE) {
            final Vector2 velocity = parentObject.getVelocity();
            if (shouldFall(parentObject)) {
                mCurrentAnimation = JUMP_AIR;
            } else if (shouldJump(parentObject)) {
                mCurrentAnimation = JUMP_START;
                parentObject.positionLocked = true;
            } else if (Math.abs(velocity.x) > 0.0f && shouldMove(parentObject)) {
                if (shouldRun(parentObject)) {
                	gotoRunStart();
                	parentObject.positionLocked = true;
                } else {
                    mCurrentAnimation = WALK;
                }
            }
        } else if (currentAction == ActionType.ATTACK) {
            mCurrentAnimation = SHOOT;
        } else if (shouldTakeHit(parentObject)) {
        	mCurrentAnimation = TAKE_HIT;
        } else if (parentObject.getCurrentAction() == ActionType.DEATH) {
        	mCurrentAnimation = DEATH;
        }
     }
    
    protected void walk(GameObject parentObject) {
        final GameObject.ActionType currentAction = parentObject.getCurrentAction();
        if (currentAction == ActionType.MOVE) {
            final Vector2 velocity = parentObject.getVelocity();
            if (shouldFall(parentObject)) {
                mCurrentAnimation = JUMP_AIR;
            } else if (shouldJump(parentObject)) {
                mCurrentAnimation = JUMP_START;
                parentObject.positionLocked = true;
            } else if (Math.abs(velocity.x) > 0.0f) {
                if (shouldRun(parentObject)) {
                    gotoRun();
                }
                if (velocity.x > 0.0f) {
                    parentObject.facingDirection.x = 1;
                } else {
                    parentObject.facingDirection.x = -1; 
                }
            } else {
                mCurrentAnimation = IDLE;
            }
        } else if (currentAction == ActionType.ATTACK) {
            mCurrentAnimation = SHOOT;
        } else if (shouldTakeHit(parentObject)) {
        	mCurrentAnimation = TAKE_HIT;
        } else if (parentObject.getCurrentAction() == ActionType.DEATH) {
        	mCurrentAnimation = DEATH;
        }
    }

    protected void runStart(GameObject parentObject) {
    	parentObject.positionLocked = true;
        if (mSprite.animationFinished()) {
            mCurrentAnimation = RUN;
            parentObject.positionLocked = false;
        }
    }
    protected void run(GameObject parentObject) {
        final GameObject.ActionType currentAction = parentObject.getCurrentAction();
        if (currentAction == ActionType.MOVE) {
            final Vector2 velocity = parentObject.getVelocity();
            if (shouldFall(parentObject)) {
                mCurrentAnimation = JUMP_AIR;
            } else if (shouldJump(parentObject)) {
                parentObject.positionLocked = true;
                mCurrentAnimation = JUMP_START;
            } else if (Math.abs(velocity.x) > 0.0f) {
                if (!shouldRun(parentObject)) {
                    mCurrentAnimation = WALK;
                }
                
                if (velocity.x > 0.0f) {
                    parentObject.facingDirection.x = 1;
                } else {
                    parentObject.facingDirection.x = -1; 
                }
            } else {
            	mCurrentAnimation = IDLE;
            }
        } else if (currentAction == ActionType.ATTACK) {
            mCurrentAnimation = SHOOT;
        } else if (shouldTakeHit(parentObject)) {
        	mCurrentAnimation = TAKE_HIT;
        } else if (parentObject.getCurrentAction() == ActionType.DEATH) {
        	mCurrentAnimation = DEATH;
        }
    }

    protected void shoot(GameObject parentObject) {
        if (mSprite.animationFinished() || parentObject.getCurrentAction() != ActionType.ATTACK) {
            mCurrentAnimation = IDLE;
        } else if (shouldTakeHit(parentObject)) {
        	mCurrentAnimation = TAKE_HIT;
        } else if (parentObject.getCurrentAction() == ActionType.DEATH) {
            	mCurrentAnimation = DEATH;
        } else {
            final Vector2 velocity = parentObject.getVelocity();

        	if (velocity.x > 0.0f) {
                parentObject.facingDirection.x = 1;
            } else if (velocity.x < 0.0f) {
                parentObject.facingDirection.x = -1; 
            }
        }
    }

    protected void jumpStart(GameObject parentObject) {
        final Vector2 velocity = parentObject.getVelocity();

        if (velocity.x > 0.0f) {
            parentObject.facingDirection.x = 1;
        } else if (velocity.x < 0.0f) {
            parentObject.facingDirection.x = -1; 
        }
        parentObject.positionLocked = true;
        
        if (mSprite.animationFinished()) {
            mCurrentAnimation = JUMP_AIR;
            parentObject.positionLocked = false;
        }
    }
    
    protected void jumpAir(GameObject parentObject) {
        final GameObject.ActionType currentAction = parentObject.getCurrentAction();
        if (currentAction == ActionType.MOVE) {
            final Vector2 velocity = parentObject.getVelocity();

            if (parentObject.touchingGround()) {
                if (Math.abs(velocity.x) > 0.0f) {
                    if (shouldRun(parentObject)) {
                        mCurrentAnimation = RUN;
                    } else {
                        mCurrentAnimation = WALK;
                    }
                } else {
                    mCurrentAnimation = IDLE;
                }
            } else {
                
                if (velocity.x > 0.0f) {
                    parentObject.facingDirection.x = 1;
                } else if (velocity.x < 0.0f) {
                    parentObject.facingDirection.x = -1; 
                }
                
            }
        } else {
            mCurrentAnimation = IDLE;
        }
    }
      
    protected void takeHit(GameObject parentObject) {
    	if (mSprite.animationFinished()) {
    		if (parentObject.life > 0 && parentObject.getCurrentAction() != ActionType.DEATH) {
    			if (parentObject.getCurrentAction() != ActionType.HIT_REACT) {
    				mCurrentAnimation = IDLE;
    			}
			} else {
    			mCurrentAnimation = DEATH;
    		}
    	}	
    }
    
    protected void surprised(GameObject parentObject) {
    	if (mSprite.animationFinished()) {
    		mCurrentAnimation = IDLE;
    	}
    }
    
    protected void death(GameObject parentObject) {
    }
    
    public void setSprite(SpriteComponent sprite) {
        mSprite = sprite;
    }

	public void setChannel(Channel channel) {
		mChannel = channel;
	}

	public void setChannelTrigger(int animation) {
		mChannelTrigger = animation;
	}
	
	public void setFlying(boolean flying) {
		mFlying = flying;
	}
	
	public void setStopAtWalls(boolean stop) {
		mStopAtWalls = stop;
	}
}