agents.andySloane.ShellState Maven / Gradle / Ivy

Go to download
package agents.andySloane;

public class ShellState extends SpriteState {
    public boolean carried = false;
    public boolean onGround = false;
    public boolean flyDeath = false;

    public static final float width = 4;
    public static final float height = 12;

    @Override
    public final float height() {
        return 12;
    }

    @Override
    public SpriteState clone() {
        ShellState e = new ShellState(x, y, false);
        e.xa = xa;
        e.ya = ya;
        e.facing = facing;
        e.deadTime = deadTime;
        e.carried = carried;
        e.onGround = onGround;
        e.flyDeath = flyDeath;
        return e;
    }

    @Override
    public final boolean dead() {
        return deadTime != 0;
    }

    ShellState(float _x, float _y, boolean predicted) {
        x = _x;
        y = _y;
        type = KIND_SHELL;
        xa = 0;
        ya = predicted ? -5 : -2.25f;
        facing = 0;
    }

    // returns false iff we should remove the enemy from the list
    public boolean move(WorldState ws) {
        if (carried) {
            ws.checkShellCollide(this);
            return false;
        }

        if (deadTime > 0) {
            deadTime--;

            // wait this is stupid. this function NEVER RETURNS FALSE
            if (deadTime == 0) {
                deadTime = 1; // keep us marked dead even when the timer goes away
                return false;
            }

            // we have to keep track of dead enemies so we can keep sync with their position
            if (flyDeath) {
                x += xa;
                y += ya;
                ya *= 0.95;
                ya += 1;
            }
            return true;
        }

        if (xa > 2)
            facing = 1;
        else if (xa < -2)
            facing = -1;

        if (facing != 0)
            ws.checkShellCollide(this);

        if (!move(xa, 0, ws))
            facing = -facing;

        onGround = false;
        move(0, ya, ws);
        ya *= 0.85f;
        xa *= DAMPING_X;

        if (!onGround)
            ya += 2;

        return true;
    }

    @Override
    public void resync(float x, float y, float prev_x, float prev_y) {
        this.x = x;
        this.y = y;
        this.xa = x - prev_x;
        facing = this.xa == 0 ? 0 : (this.xa < 0) ? -1 : 1;
        this.ya = (y - prev_y) * 0.85f;
        if (!onGround)
            ya += 2;
    }

    // WOO LET'S COPY AND PASTE THIS SOME MORE!
    private boolean move(float xa, float ya, WorldState ws) {
        while (xa > 8) {
            if (!move(8, 0, ws))
                return false;
            xa -= 8;
        }
        while (xa < -8) {
            if (!move(-8, 0, ws))
                return false;
            xa += 8;
        }
        while (ya > 8) {
            if (!move(0, 8, ws))
                return false;
            ya -= 8;
        }
        while (ya < -8) {
            if (!move(0, -8, ws))
                return false;
            ya += 8;
        }

        boolean collide = false;
        if (ya > 0) {
            if (isBlocking(x + xa - width, y + ya, xa, 0, ws))
                collide = true;
            else if (isBlocking(x + xa + width, y + ya, xa, 0, ws))
                collide = true;
            else if (isBlocking(x + xa - width, y + ya + 1, xa, ya, ws))
                collide = true;
            else if (isBlocking(x + xa + width, y + ya + 1, xa, ya, ws))
                collide = true;
        }
        if (ya < 0) {
            if (isBlocking(x + xa, y + ya - height, xa, ya, ws))
                collide = true;
            else if (collide || isBlocking(x + xa - width, y + ya - height, xa, ya, ws))
                collide = true;
            else if (collide || isBlocking(x + xa + width, y + ya - height, xa, ya, ws))
                collide = true;
        }
        if (xa > 0) {
            if (isBlocking(x + xa + width, y + ya - height, xa, ya, ws))
                collide = true;
            if (isBlocking(x + xa + width, y + ya - height / 2, xa, ya, ws))
                collide = true;
            if (isBlocking(x + xa + width, y + ya, xa, ya, ws))
                collide = true;
        }
        if (xa < 0) {
            if (isBlocking(x + xa - width, y + ya - height, xa, ya, ws))
                collide = true;
            if (isBlocking(x + xa - width, y + ya - height / 2, xa, ya, ws))
                collide = true;
            if (isBlocking(x + xa - width, y + ya, xa, ya, ws))
                collide = true;
        }

        if (collide) {
            if (xa < 0) {
                x = (int) ((x - width) / 16) * 16 + width;
                this.xa = 0;
            }
            if (xa > 0) {
                x = (int) ((x + width) / 16 + 1) * 16 - width - 1;
                this.xa = 0;
            }
            if (ya < 0) {
                y = (int) ((y - height) / 16) * 16 + height;
                this.ya = 0;
            }
            if (ya > 0) {
                y = (int) (y / 16 + 1) * 16 - 1;
                onGround = true;
            }
            return false;
        } else {
            x += xa;
            y += ya;
            return true;
        }
    }

    private boolean isBlocking(float _x, float _y, float xa, float ya, WorldState ws) {
        int x = (int) (_x / 16);
        int y = (int) (_y / 16);
        if (x == (int) (this.x / 16) && y == (int) (this.y / 16))
            return false;

        return ws.isBlocking(x, y, xa, ya);
    }

    @Override
    public SpriteState stomp(WorldState ws, MarioState ms) {
        ShellState e = (ShellState) clone();
        if (facing != 0) {
            e.facing = 0;
            e.xa = 0;
        } else {
            e.facing = ms.facing;
        }
        return e;
    }

    @Override
    public WorldState collideCheck(WorldState ws, MarioState ms) {
        if (deadTime != 0)
            return ws;

        float xMarioD = ms.x - x;
        float yMarioD = ms.y - y;
        float height = this.height();
        if (xMarioD > -width * 2 - 4 && xMarioD < width * 2 + 4) {
            if (yMarioD > -height && yMarioD < ms.height()) {
                if (!spiky() && ms.ya > 0 && yMarioD <= 0 && (!ms.onGround || !ms.wasOnGround)) {
                    ws = ws.stomp(this, ms);
                } else {
                    if (facing != 0)
                        ms.getHurt();
                    else {
                        ws.kick(this);
                        facing = ms.facing;
                    }
                }
            }
        }
        return ws;
    }

    /*
     *
     * // if shells hit one another, they both go poof public boolean
     * shellCollideCheck(ShellState shell) { if (deadTime != 0) return false;
     *
     * float xD = shell.x - x; float yD = shell.y - y;
     *
     * if (xD > -16 && xD < 16) { if (yD > -height() && yD < shell.height) { xa =
     * shell.facing * 2; ya = -5; flyDeath = true; deadTime = 100; return true; } }
     * return false; }
     *
     * public SpriteState fireballCollideCheck(SpriteState fireball) { if (deadTime
     * != 0) return false;
     *
     * float xD = fireball.x - x; float yD = fireball.y - y;
     *
     * if (xD > -16 && xD < 16) { if (yD > -height && yD < 8) { xa = fireball.facing
     * * 2; ya = -5; flyDeath = true; deadTime = 100; return true; } } return false;
     * }
     *
     * public SpriteState bumpCheck(int xTile, int yTile, MarioState ms) { if
     * (deadTime != 0) return;
     *
     * if (x + width > xTile * 16 && x - width < xTile * 16 + 16 && yTile == (int)
     * ((y - 1) / 16)) { xa = -ms.facing * 2; ya = -5; flyDeath = true; deadTime =
     * 100; } }
     */

}