Space Invaders - Elements

package net.jnk.Unknown;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;

import javax.swing.JPanel;

public class Elements extends JPanel{

    // ***VARIABLES***

    // Player Variables
    private static int playerPos = 0;
    private static final int MOVEMENT_SPEED = 1;
    private static boolean playerDead = false;

    // HUD Variables
    private static int maxLives = 10;
    private static int currentLives = 3;
    private static int healthHUDpos = SpaceInvaders.SIZE.width - 35;

    // Window Focus and Title Variables
    private static boolean runningTitle = true;
    private static boolean titleDisplay = false;
    private static int titleDisplayTick = 0;
    private static int titleTickCount = 0;
    private static int captionDir = 1;
    private static int captionPosY = 375;
    private static int focusCount = 0;

    // Score Keeping Variables
    private static int score = 0;
    private static int scoreLifeCount = 0;
    private static final int SCORE_ENEMY = 50; // Point Value of Regular Enemy
    private static final int SCORE_BONUS = 250; // Point Value of Bonus Ship
    private static final int SCORE_LIFE = 1000; // Point Value of extra life
    private static final int SCORE_DEATH = 500; // Point Value of losing a life
    private static boolean scoreAdd = false;
    private static boolean scoreSub = false;
    private static int scoreMod = 0;

    // Title Display Variables
    private static int titleTankX = -80;
    private static int titleTankY = SpaceInvaders.SIZE.height / 2 + 155;
    private static int titleEnemyX = -15;
    private static int titleEnemyY = SpaceInvaders.SIZE.height / 2 + 35;

    // Starting Variables
    public static boolean hasFocus = true;
    public static boolean isNewBoard = true;
    public static boolean displayDebug = false;
    public static int clearBoardTick = 0;

    //Level Counter
    private static int level = 1;

    // Enemy Movement and Position Variables
    // 1 = Right; 0 = Left
    private static int enemyMoveDir = 1;
    private static int enemyXPos = 30; // (Range 0 - 90)
    private static int enemyYPos = 40; // (Range 40 - 350)
    private static int maxXDistance = 100;
    private static int maxYDistance = 350;
    private static int enemyMoveDelay = 500;
    private static int currentEnemies = 55;

    // Variables for the "Bonus" ship. displayBonus can be manually toggled here for debugging purposes.
    private static boolean displayBonus = false;
    private static boolean bonusDrop = false;
    private static int bonusTickCount = 0;
    private static int bonusMoveSpeed = 1;
    private static int bonusX = -20;
    private static int bonusY = 15;

    // Variables for the Bonus Drop
    private static boolean dropPicked = false;
    private static boolean drawGuide = false;
    private static int dropX = 0;
    private static int dropY = 0;
    private static int dropColorTick = 0;
    private static int dropEffectTick = 0;
    private static int guideX = 0;

    private static int flashTick = 0;
    private static int flashIntensity = 0;
    private static boolean flashStage1 = true;
    private static boolean flashTrigger = false;

    // Amount of time to subtract from the move delay each time the grid moves closer to the player
    private static int enemyMoveDelaySub = 15;

    // Counter for Enemy Grid Movement
    private static int enemyTickCounter = 0;
    private static int enemyBonusTick = 0;

    // Number of pixels enemy grid moves on X and Y Axis
    private static int enemyXMoveSpeed = 3;
    private static int enemyYMoveSpeed = 20;

    // X and Y Size for the Enemy Grid
    private static int gridWidth = 11;
    private static int gridHeight = 5;

    // Technical Variables used for enemy grid and HUD elements;
    private static int gridXOffset = 0;
    private static int gridYOffset = 0;
    private static int healthHUDoffset = 0;
    private static int addXPosTick = 0;
    private static int subXPosTick = 0;
    private static int addXPos = 20;
    private static int subXPos = 20;

    // Bullet Variables
    private static boolean bulletShot = false;
    private static boolean doesAlign = false;
    private static boolean bonusAlign = false;
    private static boolean bulletHit = false;
    private static boolean setYPos = false;
    private static boolean setXPos = false;
    private static int bulletSpeed = 2;
    private static int bulletY = 0;
    private static int bulletX = 0;

    // Enemy Bullet Variables
    private static boolean enemyBulletShot = false;
    private static boolean enemyBulletHit = false;
    private static boolean setEnemyYPos = false;
    private static boolean setEnemyXPos = false;
    private static int enemyBulletY = 0;
    private static int enemyBulletX = 0;
    private static int enemyWaitTick = 0;
    private static int enemyTimeToWait = 500;

    private static int iVal = 0;

    // Enemy Control Array
    private static boolean[] enemies = new boolean[gridWidth * gridHeight];
    private static int[] enemyLocation = new int[gridWidth]; // Only the X Positions are required for calculations

    private static long timeStart;
    private static long timeEnd;
    private static boolean tick = false;
    private static boolean changeTime = true;

    private static final long serialVersionUID = 1L;

    // ***METHODS***

    // Main graphics method (Main Loop)
    public void paint(Graphics g) {

        if (changeTime) {
            timeStart = System.nanoTime();
            changeTime = false;
        }

        if (tick) {
            // Setting background to dark purple
            g.setColor(new Color(0x2B112A));
            g.fillRect(0, 0, SpaceInvaders.SIZE.width, SpaceInvaders.SIZE.height);

            if(!runningTitle) {
                //Creating "Ground"
                g.setColor(new Color(0x3B8C1B));
                g.fillRect(0, SpaceInvaders.SIZE.height - 35, SpaceInvaders.SIZE.width, 10);

                // METHOD CALLS

                // Draw Bonus Drop Effect (Aiming Guide) (We want this to be behind all other elements)
                drawDropEffect(g);
                // Draw Tank
                drawTank(g);
                // Draw Enemies
                drawEnemies(g, enemyXPos, enemyYPos);
                // Draw Bonus Ship
                drawBonus(g, bonusX, bonusY);
                // Draw HUD Components
                drawHUD(g);
                // Draw Bullet
                drawBullet(g);
                // Draw Enemy Bullet
                drawEnemyBullet(g);
                // Draw Bonus Ship Drop
                drawBonusDrop(g);
                // Enemy Movement AI
                enemyMove();
                // Check Enemy Status
                enemyCheck();
                // Draw Screen Flash when requested
                screenFlash(g);

                // Display a "Click to Focus" message when game does not have focus
                if (!hasFocus) {
                    // Draw Background
                    g.setColor(new Color(0,0,0,100));
                    g.fillRect(0, 0, SpaceInvaders.SIZE.width, SpaceInvaders.SIZE.height);

                    // Draw Border
                    g.setColor(Color.darkGray);
                    g.fillRect((SpaceInvaders.SIZE.width / 2) - 67, (SpaceInvaders.SIZE.height / 2) - 35, 150, 30);

                    // Draw Text
                    if (focusCount <= 180) {
                        g.setColor(Color.WHITE);
                        g.setFont(new Font("Segoe UI", Font.PLAIN, 16));
                        Graphics2D g2d = (Graphics2D)g;
                        g2d.setRenderingHint(
                                RenderingHints.KEY_TEXT_ANTIALIASING,
                                RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
                        g.drawString("CLICK TO FOCUS", (SpaceInvaders.SIZE.width / 2) - 60, (SpaceInvaders.SIZE.height / 2) - 15);

                        focusCount++;
                    } else {
                        if (focusCount > 180 && focusCount <= 360) {
                            focusCount++;
                        } else {
                            focusCount = 0;
                        }
                    }
                }

                // Display Debug Information when the F3 key is pressed (displayDebug == true)
                if (displayDebug) {
                    g.setColor(Color.WHITE);
                    g.setFont(new Font("Arial", Font.PLAIN, 10));
                    g.drawString("Grid X: " + enemyXPos, 3, 10);
                    g.drawString("Grid Y: " + enemyYPos, 60, 10);
                    g.drawString("Movement Delay: " + enemyMoveDelay, 117, 10);
                    g.drawString("Maximum Lives: " + maxLives, 3, 20);
                    g.drawString("Current Lives: " + currentLives, 105, 20);
                    g.drawString("Level:  " + level, 185, 20);
                    g.drawString("Number of Enemies: " + currentEnemies, 3, 30);
                    g.drawString("Bonus Ship Time: " + enemyBonusTick, 120, 30);
                    g.drawString("Drop Effect Tick: " + dropEffectTick, 3, 40);
                }
            }

            // Update Input
            input();

            // Draw Title Screen
            if (runningTitle) drawTitleScreen(g);

            tick = false;
        }

        timeEnd = System.nanoTime();

        // Limit number of updates to help with game speed.
        if ((timeEnd - timeStart) >= 1000000000 / 800) {
            tick = true;
            changeTime = true;
        }

        // Loop
        repaint();
    }

    // Draws the game's title screen
    private void drawTitleScreen(Graphics g) {
        g.setColor(Color.WHITE);

        g.setFont(new Font("FixedsysTTF", Font.ITALIC, 120));
        g.drawString("Space", 90, 165);
        g.drawString("Invaders", 170, 270);

        g.setFont(new Font("Arial", Font.PLAIN, 14));
        g.drawString("PRESS FIRE TO START...", (SpaceInvaders.SIZE.width / 2) - 80 , captionPosY);

        g.drawString("Jnk Games \u00a9 2012 - 2013. This software is released under GPL v3.0.", 5, SpaceInvaders.SIZE.height - 30);
        g.drawString("Press F1 for help.", SpaceInvaders.SIZE.width - 125, SpaceInvaders.SIZE.height - 30);

        // Title Screen Enemy Model
        g.setColor(Color.RED);
        g.fillRect(530, 92, 75, 24);
        g.fillRect(515, 107, 15, 9);
        g.fillRect(605, 107, 15, 9);
        g.fillRect(530, 86, 9, 6);
        g.fillRect(596, 86, 9, 6);
        g.fillRect(515, 116, 6, 6);
        g.fillRect(614, 116, 6, 6);
        g.fillRect(590, 80, 6, 12);
        g.fillRect(539, 80, 6, 12);
        g.fillRect(524, 80, 6, 18);
        g.fillRect(605, 80, 6, 18);
        g.fillRect(566, 74, 6, 18);
        g.fillRect(539, 116, 6, 9);
        g.fillRect(590, 116, 6, 9);
        g.fillRect(545, 116, 45, 6);

        // Animate "Press Fire to Start..." message
        if (titleTickCount % 8 == 0) {
            if (captionDir == 1) {
                if (captionPosY <= 415) {
                    captionPosY += MOVEMENT_SPEED;
                } else if (captionPosY > 415) captionDir = 0;
            } else if (captionDir == 0) {
                if (captionPosY >= 375) {
                    captionPosY -= MOVEMENT_SPEED;
                } else if (captionPosY < 375) {
                    captionDir = 1;
                    titleTickCount = 0;
                }
            }
        }

        titleTickCount++;

        // Display Alien and Tank animation on title
        if (titleDisplayTick < 7000) {
            titleDisplayTick++;
        } else if (titleDisplayTick >= 7000) {
            titleDisplay = true;
            if (titleDisplay) {
                // Tank Model
                g.setColor(Color.WHITE);
                g.fillRect(titleTankX + 10, titleTankY - 25, 30, 15);
                g.fillRect(titleTankX + 22, titleTankY - 32, 6, 8);

                // Enemy Model
                g.setColor(Color.GREEN);
                g.fillRect(titleEnemyX + 10, titleEnemyY + 14, 25, 8);
                g.fillRect(titleEnemyX + 5, titleEnemyY + 19, 5, 3);
                g.fillRect(titleEnemyX + 35, titleEnemyY + 19, 5, 3);
                g.fillRect(titleEnemyX + 10, titleEnemyY + 12, 3, 2);
                g.fillRect(titleEnemyX + 32, titleEnemyY + 12, 3, 2);

                titleDisplayTick++;

                if (titleTankX < SpaceInvaders.SIZE.width + 20 && titleDisplayTick % 2 == 0) {
                    titleTankX++;
                    titleEnemyX++;
                } else if (titleTankX > SpaceInvaders.SIZE.width + 20) {
                    titleTankX = -35;
                    titleEnemyX = -15;
                    titleDisplay = false;
                }
            } else if (!titleDisplay) {
                titleDisplayTick = 0;
            }
        }
    }

    // Draws the player model to the screen
    public static void drawTank(Graphics g) {
        // Player Model
        if (!playerDead) {
            g.setColor(Color.WHITE);
            g.fillRect(playerPos + 10, SpaceInvaders.SIZE.height - 50, 30, 15);
            g.fillRect(playerPos + 22, SpaceInvaders.SIZE.height - 57, 6, 8);
        }

        if (currentLives == 0) {
            clearBoard(false);
        }
    }

    // Draws the enemy grid to the screen
    public static void drawEnemies(Graphics g, int posX, int posY) {
        /* Enemy X Spacing: 75
         * Enemy Y Spacing: 40
         */
        int enemyArray = 0;

        if (isNewBoard) {
            for(int reset = 0; reset < enemies.length; reset++) {
                enemies[reset] = true;
            }
            isNewBoard = false;
        }

        for(int height = 0; height < gridHeight; height++) {
            for(int width = 0; width < gridWidth; width++) {
                if (enemies[enemyArray]) {
                    // Enemy Model
                    g.setColor(Color.GREEN);
                    g.fillRect(posX + gridXOffset + 10, posY + gridYOffset + 14, 25, 8);
                    g.fillRect(posX + gridXOffset + 5, posY + gridYOffset + 19, 5, 3);
                    g.fillRect(posX + gridXOffset + 35, posY + gridYOffset + 19, 5, 3);
                    g.fillRect(posX + gridXOffset + 10, posY + gridYOffset + 12, 3, 2);
                    g.fillRect(posX + gridXOffset + 32, posY + gridYOffset + 12, 3, 2);
                }
                gridXOffset += 65;
                enemyArray++;
            }
            gridYOffset += 40;
            gridXOffset = 0;
        }
        gridYOffset = 0;

        // Controls when bonus ship enters screen
        if(hasFocus) {
            if (enemyBonusTick < 20000) {
                enemyBonusTick++;
            } else if (enemyBonusTick <= 20000) {
                enemyBonusTick = 0;
                displayBonus = true;
            }
        }
    }

    // Draws the Bonus Ship to the screen
    public static void drawBonus(Graphics g, int posX, int posY) {
        if (displayBonus) {
            // Bonus Ship Model
            g.setColor(Color.RED);
            g.fillRect(bonusX + 10, bonusY + 14, 25, 8);
            g.fillRect(bonusX + 5, bonusY + 19, 5, 3);
            g.fillRect(bonusX + 35, bonusY + 19, 5, 3);
            g.fillRect(bonusX + 10, bonusY + 12, 3, 2);
            g.fillRect(bonusX + 32, bonusY + 12, 3, 2);
            g.fillRect(bonusX + 5, bonusY + 22, 2, 2);
            g.fillRect(bonusX + 38, bonusY + 22, 2, 2);
            g.fillRect(bonusX + 30, bonusY + 10, 2, 4);
            g.fillRect(bonusX + 13, bonusY + 10, 2, 4);
            g.fillRect(bonusX + 8, bonusY + 10, 2, 6);
            g.fillRect(bonusX + 35, bonusY + 10, 2, 6);
            g.fillRect(bonusX + 22, bonusY + 8, 2, 6);
            g.fillRect(bonusX + 13, bonusY + 22, 2, 3);
            g.fillRect(bonusX + 30, bonusY + 22, 2, 3);
            g.fillRect(bonusX + 15, bonusY + 22, 15, 2);

            // Check if bullet is in alignment with the bonus ship
            if (bulletX >= bonusX && bulletX <= bonusX + 35) {
                bonusAlign  = true;
            } else {
                bonusAlign = false; // To prevent bonusAlign from sticking once the bonus ship moves out of bullet trajectory
            }

            if (hasFocus) {
                bonusTickCount++;

                if (bonusTickCount % 3 == 0) {
                    if (bonusX < SpaceInvaders.SIZE.width + 30) {
                        bonusX += bonusMoveSpeed;
                    } else {
                        displayBonus = false;
                        bonusX = -20;
                        bonusTickCount = 0;
                    }
                }
            }
        }
    }

    // Draw the power-up orb that is seen when the bonus ship is shot down.
    public static void drawBonusDrop(Graphics g) {
        if (bonusDrop && hasFocus) {

            if (dropY < SpaceInvaders.SIZE.height - 50) dropY += MOVEMENT_SPEED;

            if (dropColorTick <= 50) {
                g.setColor(new Color(0xD6B547));
                dropColorTick++;
            } else if (dropColorTick > 50 && dropColorTick <= 100) {
                g.setColor(Color.LIGHT_GRAY);
                dropColorTick++;
            } else if (dropColorTick > 100) {
                dropColorTick = 0;
            }

            g.fillOval(dropX, dropY, 15, 15);
            g.setColor(Color.LIGHT_GRAY);

            if (dropY >= SpaceInvaders.SIZE.height - 70 && dropY <= SpaceInvaders.SIZE.height - 55) {
                if (dropX >= playerPos && dropX <= playerPos + 45) {
                    dropPicked = true;
                    flashTrigger = true;
                    drawGuide = true;
                    dropY = -20;
                    bonusDrop = false;
                }
            } else if (dropY > SpaceInvaders.SIZE.height - 55) {
                dropY = -20;
                bonusDrop = false;
            }
        }
    }

    // Draw the Laser Sight that appears when power-up orb is picked up.
    public static void drawDropEffect(Graphics g) {
        if (dropPicked && hasFocus) {
            if (dropEffectTick < 10000) {
                dropEffectTick += 1;
            } else if (dropEffectTick >= 10000 && dropEffectTick <= 13000) {
                if (dropEffectTick % 32 == 0) {
                    if (drawGuide) {
                        drawGuide = false;
                    } else {
                        drawGuide = true;
                    }
                }
                dropEffectTick += 1;
            } else if (dropEffectTick > 13000) {
                dropPicked = false;
                dropEffectTick = 0;
            }

            if (drawGuide) {
                guideX = playerPos + 24;
            }

            if (!drawGuide) {
                guideX = -5;
            }

            g.setColor(Color.RED);
            g.drawLine(guideX, enemyYPos + 10, guideX, SpaceInvaders.SIZE.height - 55);
            g.setColor(new Color(0xDB8181));
            g.drawLine(guideX + 1, enemyYPos + 10, guideX + 1, SpaceInvaders.SIZE.height - 55);
            g.setColor(Color.LIGHT_GRAY);
        }
    }

    // Screen flash. Reusable in multiple locations if needed.
    public static void screenFlash(Graphics g) {
        if (flashTrigger && hasFocus) {

            flashTick += 1;

            if (flashStage1) {
                if (flashIntensity < 255) {
                    flashIntensity += 10;

                    if (flashIntensity > 255) {
                        flashIntensity = 255;
                    }
                }
            } else if (!flashStage1) {
                if (flashIntensity > 0) {
                    if (flashTick % 6 == 0) flashIntensity -= 1;
                    if (flashIntensity < 0) {
                        flashIntensity = 0;
                    }
                }
            }

            if (flashIntensity == 255) flashStage1 = false;
            if (flashIntensity == 0) flashTrigger = false;

            g.setColor(new Color(255, 255, 255, flashIntensity));
            g.fillRect(0, 0, SpaceInvaders.SIZE.width, SpaceInvaders.SIZE.height);
            g.setColor(Color.LIGHT_GRAY);

            if (!flashTrigger) {
                flashTick = 0;
                flashStage1 = true;
            }
        }
    }

    // Draws the tank bullets to the screen
    public static void drawBullet(Graphics g) {
        // Draw "Bullet"
        if (bulletShot) {
            if (!setYPos) {
                bulletY = SpaceInvaders.SIZE.height - 55;
                setYPos = true;
            }

            if (!setXPos) {
                bulletX = playerPos + 23;
                setXPos = true;
            }

            // Bullet Model
            g.fillRect(bulletX, bulletY, 4, 6);

            if (!bulletHit) {
                bulletLogic();
            }

            if (bulletY > -5) {
                bulletY -= bulletSpeed;
            } else if (bulletY <= -5) {
                doesAlign = false;
                bulletHit = false;
                setYPos = false;
                setXPos = false;
                bulletShot = false;
            }
        }
    }

    // Draws the enemy bullet
    public static void drawEnemyBullet(Graphics g) {
        // Draw "Enemy Bullet"
        if (enemyBulletShot) {
            if (!setEnemyYPos) {
                for(int i = 0; i < enemyLocation.length - 1; i++) {
                    iVal = i;
                    if (playerPos + 23 >= enemyLocation[i] + 5 && playerPos + 23 <= enemyLocation[i + 1] - 30) {
                        if (enemies[i + (4 * gridWidth)]) {
                            enemyBulletY = enemyYPos + (40 * 4) + 23;
                            setEnemyYPos = true;
                            break;
                        } else if (enemies[i + (3 * gridWidth)]) {
                            enemyBulletY = enemyYPos + (40 * 3) + 23;
                            setEnemyYPos = true;
                            break;
                        } else if (enemies[i + (2 * gridWidth)]) {
                            enemyBulletY = enemyYPos + (40 * 2) + 23;
                            setEnemyYPos = true;
                            break;
                        } else if (enemies[i + gridWidth]) {
                            enemyBulletY = enemyYPos + 63;
                            setEnemyYPos = true;
                            break;
                        } else if (enemies[i]) {
                            enemyBulletY = enemyYPos + 23;
                            setEnemyYPos = true;
                            break;
                        }
                    }
                }
            }

            if (!setEnemyXPos) {
                enemyBulletX = enemyLocation[iVal] + 15;
                setEnemyXPos = true;
            }

            // Bullet Model
            g.fillRect(enemyBulletX, enemyBulletY, 4, 6);

            if (!enemyBulletHit) {
                enemyBulletLogic();
            }

            if (enemyBulletY < SpaceInvaders.SIZE.height - 35) {
                enemyBulletY += bulletSpeed;
            } else if (enemyBulletY >= SpaceInvaders.SIZE.height - 35) {
                enemyWaitTick = 0;
                enemyBulletHit = false;
                setEnemyYPos = false;
                setEnemyXPos = false;
                enemyBulletShot = false;
            }
        }
    }

    // Check to see if enemy bullet has hit the player
    private static void enemyBulletLogic() {
        if (enemyBulletY >= SpaceInvaders.SIZE.height - 55 && enemyBulletY <= SpaceInvaders.SIZE.height - 35) {
            if (enemyBulletX >= playerPos + 10 && enemyBulletX <= playerPos + 40) {
                enemyBulletHit = true;
                enemyBulletY = SpaceInvaders.SIZE.height + 4; // Move the bullet out of the screen area
                playerPos = 0;
                scoreChange(SCORE_DEATH, false);
                dropPicked = false;
                dropEffectTick = 0;
                currentLives--;
            }
        }

        if (enemyBulletY == bulletY) {
            if (enemyBulletX >= bulletX && enemyBulletX <= bulletX + 3) {
                enemyBulletY = SpaceInvaders.SIZE.height + 4;
            }
        }
    }

    // Checks to see if bullet has hit an enemy and, if it has, destroys the enemy
    public static void bulletLogic() {
        // Determine the position of all the enemies programmatically

        // If statement to prevent unnecessary waste of CPU cycles on location calculations
        if (bulletShot) {
            // Defining X Locations for Each Enemy Column
            int i = 0;

            for (i = 0; i < enemyLocation.length; i++) {
                enemyLocation[i] = enemyXPos + (65 * i);
                if (bulletX >= enemyLocation[i] && bulletX <= enemyLocation[i] + 35) {
                    doesAlign = true;
                    break;
                }
            }

            // Generate Y Locations of enemies and create "bullet collision"
            if (doesAlign && i != 11) {
                if (enemies[i + (4 * gridWidth)] && bulletY <= (enemyYPos + 10) + (40 * 4)) {
                    enemies[i + (4 * gridWidth)] = false;
                    bulletHit = true;
                    scoreChange(SCORE_ENEMY, true);
                    bulletY = -4;
                } else if (!bulletHit && enemies[i + (3 * gridWidth)] && bulletY <= (enemyYPos + 10) + (40 * 3)) {
                    enemies[i + (3 * gridWidth)] = false;
                    bulletHit = true;
                    scoreChange(SCORE_ENEMY, true);
                    bulletY = -4;
                } else if (!bulletHit && enemies[i + (2 * gridWidth)] && bulletY <= (enemyYPos + 10) + (40 * 2)) {
                    enemies[i + (2 * gridWidth)] = false;
                    bulletHit = true;
                    scoreChange(SCORE_ENEMY, true);
                    bulletY = -4;
                } else if (!bulletHit && enemies[i + gridWidth] && bulletY <= (enemyYPos + 10) + 40) {
                    enemies[i + gridWidth] = false;
                    bulletHit = true;
                    scoreChange(SCORE_ENEMY, true);
                    bulletY = -4;
                } else if (!bulletHit && enemies[i] && bulletY <= enemyYPos + 10) {
                    enemies[i] = false;
                    bulletHit = true;
                    scoreChange(SCORE_ENEMY, true);
                    bulletY = -4;
                }
            }

            // Create "bullet collision" for Bonus Ship - Trigger Bonus Drop
            if (bonusAlign && bulletY <= 30 && !bulletHit) {
                bonusX = SpaceInvaders.SIZE.width + 31;
                bulletY = -4;
                scoreChange(SCORE_BONUS, true);
                bonusAlign = false;

                dropX = bulletX - 7;
                bonusDrop = true;
            }
        }
    }

    // Checks if there are any living enemies left on stage
    public static void enemyCheck() {
        int enemyCount = 0;

        for(int i = 0; i < enemies.length; i++) {
            if (enemies[i]) enemyCount++;
        }

        currentEnemies = enemyCount;
        if (enemyCount == 0) clearBoard(true);
    }

    // Actions for when keys are pressed
    public static void input() {
        if(!runningTitle && !playerDead) {
            // Player Movement Left
            if (Input.buttons[0]) {
                if (playerPos > 0) playerPos -= MOVEMENT_SPEED;
            }

            // Player Movement Right
            if (Input.buttons[1]) {
                if (playerPos < SpaceInvaders.SIZE.width - 55) playerPos += MOVEMENT_SPEED;
            }
        }

        // Fire
        if (Input.buttons[2]) {
            if (runningTitle) {
                runningTitle = false;
                playerDead = false;
            } else if (!runningTitle) {
                if (!bulletShot && !playerDead) {
                    bulletShot = true;
                }
            }
        }

        // Exit
        if (Input.buttons[3]) System.exit(0);
    }

    // Controls Movement of the Enemy Grid
    public static void enemyMove() {
        if (hasFocus) {
            if (enemyTickCounter < enemyMoveDelay) {
                enemyTickCounter++;
            } else if (enemyTickCounter >= enemyMoveDelay) {
                if (enemyMoveDir == 1) {
                    if (enemyXPos < maxXDistance) {
                        enemyXPos += enemyXMoveSpeed;
                    } else if (enemyXPos >= maxXDistance) {
                        enemyMoveDir = 0;
                        enemyYPos += enemyYMoveSpeed;
                        enemyMoveDelay -= enemyMoveDelaySub;
                    }
                } else if (enemyMoveDir == 0) {
                    if (enemyXPos > 0) {
                        enemyXPos -= enemyXMoveSpeed;
                    } else if (enemyXPos <= 0) {
                        enemyMoveDir = 1;
                        enemyYPos += enemyYMoveSpeed;
                        enemyMoveDelay -= enemyMoveDelaySub;
                    }
                }
                enemyTickCounter = 0;
            }
            if (enemyYPos >= maxYDistance) clearBoard(false);
        }

        // Shoot bullet at player
        if (enemyWaitTick >= 0 && enemyWaitTick <= enemyTimeToWait) {
            enemyWaitTick++;
        } else if (enemyWaitTick >= enemyTimeToWait) {
            enemyWaitTick = -1;
            if(!enemyBulletShot) enemyBulletShot = true;
        }
    }

    // Draws the Heads Up Display; Also handles score change animations
    public static void drawHUD(Graphics g) {
        // Lives Display
        int count = 1;
        for(int i = 0; i < maxLives; i++) {
            if (count <= currentLives) {
                g.setColor(Color.LIGHT_GRAY);
                g.fillRect(healthHUDpos + healthHUDoffset + 10, 9, 15, 7);
                g.fillRect(healthHUDpos + healthHUDoffset + 16, 5, 3, 4);
            }
            count++;
            healthHUDoffset -= 20;
        }
        healthHUDoffset = 0;

        // Score Display
        g.setColor(Color.LIGHT_GRAY);
        g.drawString("Score: " + score, (SpaceInvaders.SIZE.width / 2) - 40, 15);

        // Display the score changing animation

        // If we are adding to the score, then display "+SCORE_NUMBER"
        if (scoreAdd) {
            g.drawString("+ " + scoreMod, (SpaceInvaders.SIZE.width / 2) + addXPos, 15);
            addXPosTick++;
            if (addXPosTick < 75 && addXPosTick % 2 == 0) {
                addXPos += 1;
            } else if (addXPosTick >= 75) {
                addXPos = 20;
                addXPosTick = 0;
                scoreMod = 0;
                scoreAdd = false;
            }

            // For every ten thousand points earned, if the player does not already have ten lives, then award an extra life
            if (scoreLifeCount >= 10000) {
                scoreLifeCount = 0;
                if (currentLives < maxLives) currentLives += 1;
                scoreChange(SCORE_LIFE, true);
            }
        // If we are subtracting from the score, then display "-SCORE_NUMBER"
        } else if (scoreSub) {
            g.drawString("- " + scoreMod, (SpaceInvaders.SIZE.width / 2) + subXPos, 15);
            subXPosTick++;
            if (subXPosTick < 75 && subXPosTick % 2 == 0) {
                subXPos += 1;
            } else if (subXPosTick >= 75) {
                subXPos = 20;
                subXPosTick = 0;
                scoreMod = 0;
                scoreSub = false;
            }
        }
    }

    // Change the Score
    public static void scoreChange (int scoreNew, boolean addToScore) {
        if (addToScore) {
            scoreMod = scoreNew;
            score += scoreMod;
            scoreLifeCount += scoreMod;
            scoreAdd = true;
        } else if (!addToScore) {
            scoreMod = scoreNew;
            if (score >= scoreMod) {
                score -= scoreMod;
            } else if (score < scoreMod) {
                score = 0; // Prevent Negative Score
            }
            // Losing points will also subtract from the point counter for earning an extra life
            if (scoreLifeCount >= 250) scoreLifeCount -= scoreMod;
            scoreSub = true;
        }
    }

    // "Reset" Method. Called when the game is won or lost.
    public static void clearBoard(boolean win) {
        // Wait 500 ticks before resetting the board

        if (!win) playerDead = true;

        if (clearBoardTick < 1000) {
            clearBoardTick++;
        } else if (clearBoardTick >= 1000) {
            clearBoardTick = 0;

            // Reset
            isNewBoard = true;

            enemyMoveDir = 1;
            enemyXPos = 30;
            enemyYPos = 40;
            enemyTickCounter = 0;

            enemyMoveDelay = 500;

            /* If player has beat a level, then 'win' will evaluate to true. When this happens, the
             * level counter goes up. If the player did not beat a level, then the game resets to
             * it's starting variables. */
            if (win) {
                level++;
                if (enemyTimeToWait > 25) {
                    enemyTimeToWait -= 25; // Make the time between enemy bullets less with each level advance
                } else {
                    enemyTimeToWait = 0;
                }
            } else if (!win) {
                currentLives = 3;
                level = 1;
                score = 0;
                bonusTickCount = 0;
                runningTitle = true;
            }
        }
    }
}

// ***END_OF_CLASS***