super-snuvi/src/me/hammerle/supersnuvi/entity/components/ai/LondonerController.java

package me.hammerle.supersnuvi.entity.components.ai;

import me.hammerle.snuviengine.api.Shader;
import me.hammerle.snuviengine.api.Texture;
import me.hammerle.supersnuvi.entity.Entity;
import me.hammerle.supersnuvi.gamelogic.Level;
import me.hammerle.supersnuvi.tiles.Location;
import me.hammerle.supersnuvi.tiles.RampTile;
import me.hammerle.supersnuvi.tiles.Tile;
import me.hammerle.supersnuvi.util.Face;
import me.hammerle.supersnuvi.util.SoundUtils;
import me.hammerle.supersnuvi.util.Utils;

public class LondonerController extends Controller
{
    private final static Texture LONDONER = new Texture("resources/londoner.png");
    
    private final boolean evil;
    
    private float ox = 0.0f;
    private float tx = 0.0f;
    private float ty = 0.0f;
    
    private int walkFrame = 0;
    private int transformFrame = -1;
    private int deathCounter = 0;
    private int deathFrame = 0;
    
    private Face direction = Face.LEFT;
    
    private boolean shouldJump = false;
    
    private Entity hurt = null;
    private Entity attacker = null;

    public LondonerController(Entity ent, boolean evil) 
    {
        super(ent);
        this.evil = evil;
    }
    
    private boolean hasRedEyes()
    {
        return transformFrame >= 3;
    }
    
    @Override
    public boolean isAnimated()
    {
        return deathFrame < 7;
    }
    
    @Override
    public void tick(Level level) 
    {
        if(evil)
        {
            if(transformFrame != -1)
            {
                if(transformFrame < 3)
                {
                    ox = ent.getFace() == Face.RIGHT ? 0.0f: -1.125f * Tile.SIZE;
                    tx = transformFrame * 0.125f + 0.125f;
                    ty = 0.375f;
                    transformFrame++;
                    return;
                }
            }
            else if(level.getHero().getSquaredDistance(ent) <= 16384) // 4 Tiles
            {
                transformFrame = 0;
            }
        }
        
        if(ent.getHealth().isDead())
        {
            ox = ent.getFace() == Face.RIGHT ? -Tile.SIZE: -0.125f * Tile.SIZE;
            
            tx = deathFrame * 0.125f;
            ty = hasRedEyes() ? 0.125f : 0.25f;
            
            walkFrame = 0;
            deathCounter++;
            if(deathCounter >= 3)
            {
                deathCounter = 0;
                deathFrame++;
            }
            return;
        }
        
        if(hasRedEyes())
        {
            float hx = level.getHero().getCenterX();
            if(hx < ent.getCenterX())
            {
                ent.setMotionX(-ent.getMovement().getVelocityX());
            }
            else
            {
                ent.setMotionX(ent.getMovement().getVelocityX());
            }
        }
        else
        {
            if(direction == Face.LEFT)
            {
                ent.setMotionX(-ent.getMovement().getVelocityX());
            }
            else
            {
                ent.setMotionX(ent.getMovement().getVelocityX());
            }
        }
        
        if(shouldJump)
        {
            SoundUtils.playSound(SoundUtils.Sound.LONDONER_JUMP);
            ent.getMovement().jump();
            shouldJump = false;
        }
        
        if(attacker != null)
        {
            this.ent.getHealth().addHealthPercent(-0.201f);
            attacker.setMotionY(-attacker.getMovement().getJumpPower() * 0.5f);
            
            attacker = null;
            hurt = null;
        }
        
        if(hurt != null)
        {
            hurt.getHealth().addHealthPercent(-0.1f);

            hurt.setMotionY(ent.getMotionY() - 20.0f * Tile.SIZE_SCALE);

            if(ent.getCenterX() < hurt.getCenterX())
            {
                hurt.setMotionX(hurt.getMotionX() + 10.0f * Tile.SIZE_SCALE);
            }
            else
            {
                hurt.setMotionX(hurt.getMotionX() - 10.0f * Tile.SIZE_SCALE);
            }
            
            hurt = null;
        }
        
        ox = ent.getFace() == Face.RIGHT ? 0.0f: -1.125f * Tile.SIZE;
        
        if(ent.isOnGround())
        {
            if(ent.getMotionX() == 0.0f)
            {
                tx = 0.875f;
                ty = hasRedEyes() ? 0.25f : 0.375f;
            }
            else
            {
                deathFrame = 0;
                walkFrame = (walkFrame + 1) % 6;
                tx = walkFrame * 0.125f;
                ty = hasRedEyes() ? 0.5f : 0.625f;
            }
        }
        else
        {
            deathFrame = 0;
            walkFrame = 0;
            tx = 0.125f;
            ty = hasRedEyes() ? 0.5f : 0.625f;
        }
    }

    @Override
    public void renderTick(float lag)
    {
        if(ent.getHealth().wasHurt())
        {
            Shader.setColorEnabled(true);
            Shader.setMixColorEnabled(true);
            Shader.setMixColor(1.0f, 0.0f, 0.0f, 1.0f);
        }
        if(ent.getHealth().wasHealed())
        {
            Shader.setColorEnabled(true);
            Shader.setMixColorEnabled(true);
            Shader.setMixColor(0.0f, 1.0f, 0.0f, 1.0f);
        }
        
        LONDONER.bind();
        float x = Utils.interpolate(ent.getLastX(), ent.getX(), lag);
        float y = Utils.interpolate(ent.getLastY(), ent.getY(), lag);
        
        float m1;
        float m2;
        if(ent.getFace() == Face.LEFT)
        {
            m1 = 2.0f * Tile.SIZE;
            m2 = 0.0f;
        }
        else
        {
            m1 = 0.0f;
            m2 = 2.0f * Tile.SIZE;
        }
        Shader.getTextureRenderer().drawRectangle(
                x + ox + m1, y,
                x + ox + m2, y + 2.0f * Tile.SIZE, 
                tx, ty, 
                tx + 0.125f, ty + 0.125f);
        
        if(ent.getHealth().wasHurt() || ent.getHealth().wasHealed())
        {
            Shader.setColorEnabled(false);
            Shader.setMixColorEnabled(false);
        }
    }
    
    @Override
    public void onCollideWithTile(Location loc, Face face)
    {
        if(hasRedEyes())
        {
            if(!(loc.getTile() instanceof RampTile) && face == ent.getFace() && ent.getMotionX() == 0.0f)
            {
                shouldJump = true;
            }
        }
        else
        {
            if(loc.getTile().shouldAiUseCollisionBox(loc.getX(), loc.getY(), loc.getLevel()))
            {
                switch(face)
                {
                    case LEFT:
                        direction = Face.RIGHT;
                        break;
                    case RIGHT:
                        direction = Face.LEFT;
                        break;
                }
            }
        }
    }

    @Override
    public void onCollideWithEntity(Entity ent, Face face)
    {
        switch(face)
        {
            case LEFT:
            case RIGHT:
                if(ent.getItemCollector().isHero() && hasRedEyes())
                {
                    hurt = ent;
                }
                else
                {
                    direction = direction.getOpposite();
                }
                break;
            case UP:
                attacker = ent;
                break;
        }
    }
}