Main.java

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

import org.w3c.dom.css.RGBColor;

import java.util.ArrayList;

import java.awt.image.BufferedImage;
import java.io.*;
import java.util.Objects;
import javax.imageio.ImageIO;
import java.net.URL;
import java.util.Random;
import java.util.Scanner;

public class Main extends JPanel implements KeyListener, Runnable {
    // GS 0 = Main Screen
    // GS 1 = Credits
    // GS 2 = Settings
    // GS 3 = Character Selection
    // GS 4 = Keybind Select
    // GS 5 = Map Select
    // GS 6 = Gameplay
    // GS 7 = Winner and Loser Screen


    // what each of the many arrays indexes represent
    static int forward = 0;
    static int back = 1;
    static int idle = 2;
    static int punch = 3;
    static int kick = 4;
    static int jump = 5;
    static int jumpKick = 6;
    static int jumpPunch = 7;
    static int duck = 8;
    static int duckPunch = 9;
    static int duckKick = 10;
    static int block = 11;
    static int duckBlock = 12;
    static int hit = 13;
    static int duckHit = 14;
    static int knocked = 15;
    static int special = 16;
    static int knockedOut = 17;


    // this method takes an image and returns a specific part of the image that you want
    public static BufferedImage grabImage(BufferedImage image, int spriteNum) {
        return image.getSubimage(200 * spriteNum, 0, 200, 140);
    }

    //miscilaneous variables
    public static int gameState = 0;
    public static boolean blink = true;
    public static int frameController = 0;
    public static boolean hoverBlink = true;

    // creating background and the title screen
    public static Image bg;
    public static BufferedImage[] ui = new BufferedImage[1];

    // game music/sfx 
    public static boolean gameMusic = true;
    public static boolean gameSFX = true;

    public static int logoHeight = 0;

    // character select related
    public static BufferedImage p1retsuBig, p2retsuBig;
    public static BufferedImage p1ryuBig, p2ryuBig;
    public static BufferedImage retsuPortrait;
    public static BufferedImage ryuPortrait;
    public static BufferedImage comingSoon, comingSoonBig;

    // total moves for characters
    public static int totalMoves = 18;

    // creating array for each character and their p1 and p2 varients
    public static BufferedImage[] p1Retsu = new BufferedImage[totalMoves];
    public static BufferedImage[] p2Retsu = new BufferedImage[totalMoves];

    public static BufferedImage[] p1Ryu = new BufferedImage[totalMoves];
    public static BufferedImage[] p2Ryu = new BufferedImage[totalMoves];
    // loading Ryu's special projectile
    public static BufferedImage p1RyuSpecial;
    public static BufferedImage p2RyuSpecial;
    public static boolean isp1RyuThrowSpecial = false;
    public static boolean isp2RyuThrowSpecial = false;
    public static int p1RyuProjectileX;
    public static int p2RyuProjectileX;

    // used for gamestate 3 to see if both players have selected characters.
    public static boolean charactersSelected = false;

    // map select related
    public static Image map0Icon, map1Icon, map2Icon, map3Icon;
    public static Image map0, map1, map2, map3;
    public static Image chosenMap;
    public static int chosenMapNum = -1;

    public static int defaultPosY = 0;

    public static String startTimer = "3";
    // p1 and p2 related variables
    public static BufferedImage[][] p1 = new BufferedImage[totalMoves][10]; // thsi variable holds the sprite png for each move, and inside that has each indivdial sprite
    public static String p1Char = "";
    public static BufferedImage p1CurrentMovement;
    public static int p1PosX = 100;
    public static int p1PosY = 250;
    public static int p1Health = 100;
    public static int p1Stamina = 100;
    public static int p1Hover = 0;
    public static int p1HoverCharMovement = -50;
    public static boolean p1CharSwitch = false;
    public static int p1Map = -1;
    public static int p1Combo = 0;
    public static boolean p1Action[] = new boolean[totalMoves]; // all of the boolean isp1 doing something variables
    public static boolean p2Action[] = new boolean[totalMoves];

    public static BufferedImage[][] p2 = new BufferedImage[totalMoves][10];
    public static String p2Char = "";
    public static BufferedImage p2CurrentMovement;
    public static int[] p1Sprite = new int[totalMoves];
    public static int[] p2Sprite = new int[totalMoves];
    public static int[] p1MoveStamina = new int[totalMoves];
    public static int[] p2MoveStamina = new int[totalMoves];

    public static int p2PosX = 700;
    public static int p2PosY = 250;
    public static int p2Health = 100;
    public static int p2Stamina = 100;
    public static int p2Hover = 0;
    public static int p2HoverCharMovement = 495;
    public static boolean p2CharSwitch = false;
    public static int p2Map = -1;

    // map score
    public static int p1Score = 0;
    public static int p2Score = 0;

    // has each player hit in a move's span
    public static boolean hasp1Hit = false;
    public static boolean hasp2Hit = false;

    // fonts sizes
    public static Font largeText, text, comboText;

    // staminas
    public static boolean takenP1Stamina = false;
    public static boolean takenP2Stamina = false;

    // keybind related
    public static Scanner p1BindFile;
    public static Scanner p2BindFile;
    public static PrintWriter p1BindFileOutputing;
    public static PrintWriter p2BindFileOutputing;
    public static int p1ForwardBind, p2ForwardBind;
    public static int p1BackBind, p2BackBind;
    public static int p1JumpBind, p2JumpBind;
    public static int p1KickBind, p2KickBind;
    public static int p1PunchBind, p2PunchBind;
    public static int p1DuckBind, p2DuckBind;
    public static int p1BlockBind, p2BlockBind;
    public static int p1SpecialBind, p2SpecialBind;
    public static int p2Combo = 0;

    // the damages for each attack for each player
    public static int p1PunchDamage = 5;
    public static int p1KickDamage = 7;
    public static int p1JumpPunchDamage = 7;
    public static int p1JumpKickDamage = 10;
    public static int p1SpecialDamage = 15;

    public static int p2PunchDamage = 5;
    public static int p2KickDamage = 7;
    public static int p2JumpPunchDamage = 7;
    public static int p2JumpKickDamage = 10;
    public static int p2SpecialDamage = 15;

    // holds the length of each move for each character;
    public static int[] p1MoveLength = new int[totalMoves];
    public static int[] p2MoveLength = new int[totalMoves];

    // controls the height of the jump for each;
    public static int p1JumpY;
    public static int p2JumpY;
    public static int p1JumpX;
    public static int p2JumpX;

    // holds the keys currently pressed
    public static ArrayList<Integer> keysPressed = new ArrayList();


    // audio
    public static URL music;
    public static java.applet.AudioClip musicAudio;

    public static URL fight;
    public static java.applet.AudioClip fightAudio;

    public static URL win;
    public static java.applet.AudioClip winAudio;

    public static boolean winMusicIsPlaying = false;

    public static boolean p1KeySelect = false;
    public static boolean p2KeySelect = false;

    public Main() {
        setPreferredSize(new Dimension(800, 367));
        setFocusable(true);
        addKeyListener(this);
        Thread t = new Thread(this);
        t.start();
    }

    public static void main(String[] args) throws FontFormatException, IOException {
        // Image Importation
        try {
            // this line is for fonts
            GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();


            // registering fonts
            largeText = Font.createFont(Font.TRUETYPE_FONT, new File("UI/Act_Of_Rejection.ttf")).deriveFont(80f);
            ge.registerFont(largeText);

            comboText = Font.createFont(Font.TRUETYPE_FONT, new File("UI/Act_Of_Rejection.ttf")).deriveFont(30f);
            ge.registerFont(comboText);

            text = Font.createFont(Font.TRUETYPE_FONT, new File("UI/PressStart2P.ttf")).deriveFont(15f);
            ge.registerFont(text);

            //loading the main screen background
            bg = new ImageIcon(new File("bg/0.gif").toURL()).getImage();

            // loading all the character select images
            comingSoon = ImageIO.read(new File("Characters/comingSoon.png"));

            comingSoonBig = ImageIO.read(new File("Characters/comingSoonBig.png"));

            retsuPortrait = ImageIO.read(new File("Characters/Retsu/portrait.png"));

            ryuPortrait = ImageIO.read(new File("Characters/Ryu/portrait.png"));

            p1retsuBig = ImageIO.read(new File("Characters/Retsu/p1/retsuBig.png"));

            p2retsuBig = ImageIO.read(new File("Characters/Retsu/p2/retsuBig.png"));

            p1ryuBig = ImageIO.read(new File("Characters/Ryu/p1/ryuBig.png"));

            p2ryuBig = ImageIO.read(new File("Characters/Ryu/p2/ryuBig.png"));

            // map select related
            map0Icon = new ImageIcon(new File("bg/0s.gif").toURL()).getImage();
            map1Icon = new ImageIcon(new File("bg/1s.gif").toURL()).getImage();
            map2Icon = new ImageIcon(new File("bg/2s.gif").toURL()).getImage();
            map3Icon = new ImageIcon(new File("bg/3s.gif").toURL()).getImage();

            map0 = new ImageIcon(new File("bg/0.gif").toURL()).getImage();
            map1 = new ImageIcon(new File("bg/1.gif").toURL()).getImage();
            map2 = new ImageIcon(new File("bg/2.gif").toURL()).getImage();
            map3 = new ImageIcon(new File("bg/3.gif").toURL()).getImage();


            // load all character sprites
            for (int i = 0; i < p1.length; i++) {
                p1Retsu[i] = ImageIO.read(new File("Characters/Retsu/p1/" + i + ".png"));
                p2Retsu[i] = ImageIO.read(new File("Characters/Retsu/p2/" + i + ".png"));

                p1Ryu[i] = ImageIO.read(new File("Characters/Ryu/p1/" + i + ".png"));
                p2Ryu[i] = ImageIO.read(new File("Characters/Ryu/p2/" + i + ".png"));
            }

            //  ryu special sprites
            p1RyuSpecial = ImageIO.read(new File("Characters/Ryu/p1/ryuSpecial.png"));
            p2RyuSpecial = ImageIO.read(new File("Characters/Ryu/p2/ryuSpecial.png"));


            //audio 
            music = new File("Audio/music.wav").toURI().toURL();
            fight = new File("Audio/fight.wav").toURI().toURL();
            win = new File("Audio/win.wav").toURI().toURL();
            musicAudio = java.applet.Applet.newAudioClip(music);
            fightAudio = java.applet.Applet.newAudioClip(fight);
            winAudio = java.applet.Applet.newAudioClip(win);
            toggleMusic();

        } catch (IOException e) {
            System.out.println("Something Wrong");
        }

        p1RyuSpecial = crop(p1RyuSpecial); // runs a function that crops the sprite
        p2RyuSpecial = crop(p2RyuSpecial);


        //loading the keybinds
        p1BindFile = new Scanner(new File("keybinds/p1Keybinds.txt"));
        p2BindFile = new Scanner(new File("keybinds/p2Keybinds.txt"));
        p1ForwardBind = p1BindFile.nextInt();
        p1JumpBind = p1BindFile.nextInt();
        p1BackBind = p1BindFile.nextInt();
        p1DuckBind = p1BindFile.nextInt();
        p1PunchBind = p1BindFile.nextInt();
        p1SpecialBind = p1BindFile.nextInt();
        p1KickBind = p1BindFile.nextInt();
        p1BlockBind = p1BindFile.nextInt();

        p2ForwardBind = p2BindFile.nextInt();
        p2JumpBind = p2BindFile.nextInt();
        p2BackBind = p2BindFile.nextInt();
        p2DuckBind = p2BindFile.nextInt();
        p2PunchBind = p2BindFile.nextInt();
        p2SpecialBind = p2BindFile.nextInt();
        p2KickBind = p2BindFile.nextInt();
        p2BlockBind = p2BindFile.nextInt();

        JFrame frame = new JFrame("Game");
        Main panel = new Main();
        frame.add(panel);
        frame.setVisible(true);
        frame.pack();
    }

    public void paintComponent(Graphics g) {
        frameController++;
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D) g;
        GradientPaint gradientBackground = new GradientPaint(0, 0, Color.ORANGE, 0, 700, Color.RED);
        Color textColor = new Color(255, 165, 0);
        if (gameState == 0) {
            // main screen loading
            g2d.setColor(Color.BLACK);
            // g2d.fillRect(0, 0, getWidth(), getHeight());
            g.drawImage(map0, 0, 0, this);
            g2d.setPaint(new GradientPaint(0, 0, Color.ORANGE, 0, 200, Color.RED));
            g2d.setFont(largeText);
            centerString(g2d, "Fighting Fury", "H" + logoHeight);
            g2d.setFont(text);
            g2d.setPaint(Color.WHITE);
            if (logoHeight == 100) {
                centerString(g2d, "PRESS ENTER TO CONTINUE", "H250");
                centerString(g2d, "PRESS ESC FOR SETTINGS", "H300");
                g.drawString("MADE BY: FAHAD", 550, 365);
                centerString(g2d, "PRESS M FOR INSTRUCTIONS", "H350");
            }

            // logo height adds a animation where the logo comes from the top
            logoHeight = logoHeight == 100 ? logoHeight : logoHeight + 2;

        } else if (gameState == 1) {
            // a secret credits page if you press backspace on mani menu
            g2d.setColor(Color.BLACK);
            g2d.fillRect(0, 0, getWidth(), getHeight());
            g2d.setFont(largeText);
            g2d.setPaint(gradientBackground);
            centerString(g2d, "SECRET CREDITS", "H85");

            g2d.setFont(text);
            g2d.setPaint(textColor);
            centerString(g2d, "Mr. Chow And His 15 Cars which ", "H200");
            centerString(g2d, "was a massive inspiration", "H230");
            centerString(g2d, "Press BACKSPACE to go back to main screen", "H340");

        }

        else if (gameState == 2) {
            // menu page where you can press shift to toggle music and caps lock to toggle sfx
            g2d.setPaint(gradientBackground);
            g2d.setFont(largeText);
            g2d.fillRect(0, 0, 800, 367);
            g2d.setPaint(Color.WHITE);
            centerString(g2d, "SETTINGS", "H100");

            g2d.setFont(text);
            String gameSoundText = gameMusic ? "ON" : "OFF";
            String gameSFXText = gameSFX ? "ON" : "OFF";
            centerString(g2d, "GAME MUSIC: " + gameSoundText, "H250");
            centerString(g2d, "GAME SFX: " + gameSFXText, "H300");
        }

        else if (gameState == 3) {
            // character select screen
            g2d.setPaint(gradientBackground);
            g2d.fillRect(0, 0, 800, 367);
            g2d.setFont(largeText);
            g2d.setPaint(Color.WHITE);
            centerString(g2d, "CHARACTER SELECT", "H100");
            g2d.setStroke(new BasicStroke(3));
            // loading the rectangles for characters
            g2d.fillRect(getWidth() / 2 - 115, 200, 50, 50);
            g2d.fillRect(getWidth() / 2 - 55, 200, 50, 50);
            g2d.fillRect(getWidth() / 2 + 5, 200, 50, 50);
            g2d.fillRect(getWidth() / 2 + 65, 200, 50, 50);

            g2d.setPaint(Color.BLACK);

            g2d.drawRect(getWidth() / 2 - 115, 200, 50, 50);
            g2d.drawRect(getWidth() / 2 - 55, 200, 50, 50);
            g2d.drawRect(getWidth() / 2 + 5, 200, 50, 50);
            g2d.drawRect(getWidth() / 2 + 65, 200, 50, 50);

            
            //loading the character images
            g.drawImage(retsuPortrait, getWidth() / 2 - 110, 205, null);
            g.drawImage(ryuPortrait, getWidth() / 2 - 50, 205, null);
            g.drawImage(comingSoon, getWidth() / 2 + 10, 205, null);
            g.drawImage(comingSoon, getWidth() / 2 + 70, 205, null);

            
            // p1/p2 hover related things. Uses a p1Hover and p2Hover variable to see which character they are hovering
            if (!p1Char.equals("")) { // the p1Hover icon stays permanantely if they have selected
                g2d.setStroke(new BasicStroke(5));
                int moveAmount = 0;

                g2d.setPaint(new Color(171, 26, 219));
                moveAmount = p1Hover == 0 ? -115 : p1Hover == 1 ? -55 : p1Hover == 2 ? 5 : 65; // loads rectangle depending on the p1Hover
                g2d.drawRect(getWidth() / 2 + moveAmount, 200, 50, 50);
            }

            if (!p2Char.equals("")) {
                g2d.setStroke(new BasicStroke(5));
                int moveAmount = 0;

                g2d.setPaint(new Color(219, 26, 113));
                moveAmount = p2Hover == 0 ? -115 : p2Hover == 1 ? -55 : p2Hover == 2 ? 5 : 65;
                g2d.drawRect(getWidth() / 2 + moveAmount, 200, 50, 50);
            }

            if (hoverBlink) { // if player has not selected, the icon blinks
                g2d.setStroke(new BasicStroke(5));
                int moveAmount = 0;

                if (p1Char.equals("")) {
                    // p1 hover
                    g2d.setPaint(new Color(171, 26, 219));
                    moveAmount = p1Hover == 0 ? -115 : p1Hover == 1 ? -55 : p1Hover == 2 ? 5 : 65;
                    g2d.drawRect(getWidth() / 2 + moveAmount, 200, 50, 50);
                }

                if (p2Char.equals("")) {
                    // p2 hover
                    g2d.setPaint(new Color(219, 26, 113));
                    moveAmount = p2Hover == 0 ? -115 : p2Hover == 1 ? -55 : p2Hover == 2 ? 5 : 65;
                    g2d.drawRect(getWidth() / 2 + moveAmount, 200, 50, 50);
                }
                if (p1Hover == p2Hover) {
                    g2d.setPaint(new Color(81, 26, 219));
                    moveAmount = p1Hover == 0 ? -115 : p1Hover == 1 ? -55 : p1Hover == 2 ? 5 : 65;
                    g2d.drawRect(getWidth() / 2 + moveAmount, 200, 50, 50);
                }
            }

            // checks if players just switched their characters for animation reset
            if (p1CharSwitch) {
                p1CharSwitch = false;
                p1HoverCharMovement = -50;
            }
            if (p2CharSwitch) {
                p2CharSwitch = false;
                p2HoverCharMovement = 495;
            }

            g2d.setPaint(new Color(171, 26, 219));
            // animation for hover
            if (p1Hover == 0) {
                g.drawImage(p1retsuBig, p1HoverCharMovement, -10, null);
                g2d.drawString("RETSU", 50, -p1HoverCharMovement + 280);
                if (p1HoverCharMovement != -20) {
                    p1HoverCharMovement += 1;
                }
            } else if (p1Hover == 1) {
                g.drawImage(p1ryuBig, p1HoverCharMovement, 30, null);
                g2d.drawString("RYU", 50, -p1HoverCharMovement + 280);
                if (p1HoverCharMovement != -20) {
                    p1HoverCharMovement += 1;
                }
            } else {
                g.drawImage(comingSoonBig, p1HoverCharMovement, -10, null);
                g2d.drawString("SOON", 60, -p1HoverCharMovement + 280);
                if (p1HoverCharMovement != -20) {
                    p1HoverCharMovement += 1;
                }
            }

            g2d.setPaint(new Color(219, 26, 113));
            if (p2Hover == 0) {
                g.drawImage(p2retsuBig, p2HoverCharMovement, -10, null);
                g2d.drawString("RETSU", 550, p2HoverCharMovement - 165);
                if (p2HoverCharMovement != 465) {
                    p2HoverCharMovement -= 1;
                }
            } else if (p2Hover == 1) {
                g.drawImage(p2ryuBig, p2HoverCharMovement, 30, null);
                g2d.drawString("RYU", 630, p2HoverCharMovement - 165);
                if (p2HoverCharMovement != 465) {
                    p2HoverCharMovement -= 1;
                }
            } else {
                g.drawImage(comingSoonBig, p2HoverCharMovement, -10, null);
                g2d.drawString("SOON", 540, p2HoverCharMovement - 165);
                if (p2HoverCharMovement != 465) {
                    p2HoverCharMovement -= 1;
                }
            }

            if (frameController % 5 == 0) {
                // used for the blink animation
                hoverBlink = hoverBlink ? false : true;
            }

        }

        else if (gameState == 4) { // uses textfile streaming to get keybinds and upload them if they changed
            g2d.setPaint(gradientBackground);
            g2d.fillRect(0, 0, 800, 367);
            g2d.setFont(largeText);
            g2d.setPaint(Color.WHITE);
            centerString(g2d, "KEYBIND SELECT", "H100");
            g2d.setFont(text);
            for (int i = 0; i < 4; i++) {
                g.drawRect(30, 152 + i * 40, 175, 40);
                g.drawRect(205, 152 + i * 40, 175, 40);
                g.drawRect(420, 152 + i * 40, 175, 40);
                g.drawRect(595, 152 + i * 40, 175, 40);
            }
            g.drawString("FORWARD: " + (char) p1ForwardBind, 40, 180);
            g.drawString("BACK:    " + (char) p1BackBind, 40, 220);
            g.drawString("PUNCH:   " + (char) p1PunchBind, 40, 260);
            g.drawString("KICK:    " + (char) p1KickBind, 40, 300);
            g.drawString("JUMP:    " + (char) p1JumpBind, 215, 180);
            g.drawString("DUCK:    " + (char) p1DuckBind, 215, 220);
            g.drawString("SPECIAL: " + (char) p1SpecialBind, 215, 260);
            g.drawString("BLOCK:   " + (char) p1BlockBind, 215, 300);
            // ← ↑ →
            g.drawString(
                    "FORWARD: "
                            + (char) (p2ForwardBind == 38 ? '↑'
                                    : p2ForwardBind == 39 ? '→'
                                            : p2ForwardBind == 40 ? '↓' : p2ForwardBind == 37 ? '←' : p2ForwardBind),
                    430, 180);
            g.drawString(
                    "BACK:    " + (char) (p2BackBind == 38 ? '↑'
                            : p2BackBind == 39 ? '→' : p2BackBind == 40 ? '↓' : p2BackBind == 37 ? '←' : p2BackBind),
                    430, 220);
            g.drawString("PUNCH:   " + (char) p2PunchBind, 430, 260);
            g.drawString("KICK:    " + (char) p2KickBind, 430, 300);
            g.drawString(
                    "JUMP:    " + (char) (p2JumpBind == 38 ? '↑'
                            : p2JumpBind == 39 ? '→' : p2JumpBind == 40 ? '↓' : p2JumpBind == 37 ? '←' : p2BackBind),
                    605, 180);
            g.drawString(
                    "DUCK:    " + (char) (p2DuckBind == 38 ? '↑'
                            : p2DuckBind == 39 ? '→' : p2DuckBind == 40 ? '↓' : p2DuckBind == 37 ? '←' : p2BackBind),
                    605, 220);
            g.drawString("SPECIAL: " + (char) p2SpecialBind, 605, 260);
            g.drawString("BLOCK:   " + (char) p2BlockBind, 605, 300);

            // hover and selected for keybinds
            if (hoverBlink || p1KeySelect) {
                g2d.setPaint(new Color(171, 26, 219));
                g2d.setStroke(new BasicStroke(3));
                if (p1Hover % 2 == 0) {
                    g.drawRect(30, 152 + (p1Hover / 2) * 40, 175, 40);
                } else {
                    g.drawRect(205, 152 + ((p1Hover - 1) / 2) * 40, 175, 40);
                }
            }

            if (hoverBlink || p2KeySelect) {
                g2d.setPaint(new Color(219, 26, 113));
                g2d.setStroke(new BasicStroke(3));
                if (p2Hover % 2 == 0) {
                    g.drawRect(420, 152 + (p2Hover / 2) * 40, 175, 40);
                } else {
                    g.drawRect(595, 152 + ((p2Hover - 1) / 2) * 40, 175, 40);
                }
            }

            if (frameController % 5 == 0) {
                hoverBlink = hoverBlink ? false : true;
            }
        }

        else if (gameState == 5) {
            // map select, similar process to the last two 
            g2d.setPaint(gradientBackground);
            g2d.fillRect(0, 0, 800, 367);
            g2d.setFont(largeText);
            g2d.setPaint(Color.WHITE);
            centerString(g2d, "MAP SELECT", "H100");

            g.drawImage(map0Icon, getWidth() / 2 - 222, 130, null);
            g.drawImage(map1Icon, getWidth() / 2 + 15, 130, null);
            g.drawImage(map2Icon, getWidth() / 2 - 222, 250, null);
            g.drawImage(map3Icon, getWidth() / 2 + 15, 250, null);

            g2d.setPaint(Color.BLACK);
            g2d.setStroke(new BasicStroke(5));
            g2d.drawRect(getWidth() / 2 - 222, 130, 207, 95);
            g2d.drawRect(getWidth() / 2 + 15, 130, 207, 95);
            g2d.drawRect(getWidth() / 2 - 222, 250, 207, 95);
            g2d.drawRect(getWidth() / 2 + 15, 250, 207, 95);

            if (p1Map != -1 && p2Map != -1) {
                g2d.setPaint(new Color(81, 26, 219));
                if (chosenMapNum == 0) {
                    g2d.drawRect(getWidth() / 2 - 222, 130, 207, 95);
                    p1PosY = 240;
                    p2PosY = 240;
                    defaultPosY = 240;
                } else if (chosenMapNum == 1) {
                    g2d.drawRect(getWidth() / 2 + 15, 130, 207, 95);
                    p1PosY = 265;
                    p2PosY = 265;
                    defaultPosY = 265;
                } else if (chosenMapNum == 2) {
                    g2d.drawRect(getWidth() / 2 - 222, 250, 207, 95);
                    p1PosY = 250;
                    p2PosY = 250;
                    defaultPosY = 250;
                } else {
                    g2d.drawRect(getWidth() / 2 + 15, 250, 207, 95);
                    p1PosY = 250;
                    p2PosY = 250;
                    defaultPosY = 250;
                }
                gameState = 6;
            } else {
                if (p1Map != -1) {
                    g2d.setPaint(new Color(171, 26, 219));
                    if (p1Hover == 0) {
                        g2d.drawRect(getWidth() / 2 - 222, 130, 207, 95);
                    } else if (p1Hover == 1) {
                        g2d.drawRect(getWidth() / 2 + 15, 130, 207, 95);
                    } else if (p1Hover == 2) {
                        g2d.drawRect(getWidth() / 2 - 222, 250, 207, 95);
                    } else {
                        g2d.drawRect(getWidth() / 2 + 15, 250, 207, 95);
                    }
                }

                if (p2Map != -1) {
                    g2d.setPaint(new Color(219, 26, 113));
                    if (p2Hover == 0) {
                        g2d.drawRect(getWidth() / 2 - 222, 130, 207, 95);
                    } else if (p2Hover == 1) {
                        g2d.drawRect(getWidth() / 2 + 15, 130, 207, 95);
                    } else if (p2Hover == 2) {
                        g2d.drawRect(getWidth() / 2 - 222, 250, 207, 95);
                    } else {
                        g2d.drawRect(getWidth() / 2 + 15, 250, 207, 95);
                    }
                }

                if (hoverBlink) {

                    if (p1Map == -1) { // if p2Map is -1 that means they have not selected
                        // p1 hover
                        g2d.setPaint(new Color(171, 26, 219));
                        if (p1Hover == 0) {
                            g2d.drawRect(getWidth() / 2 - 222, 130, 207, 95);
                        } else if (p1Hover == 1) {
                            g2d.drawRect(getWidth() / 2 + 15, 130, 207, 95);
                        } else if (p1Hover == 2) {
                            g2d.drawRect(getWidth() / 2 - 222, 250, 207, 95);
                        } else {
                            g2d.drawRect(getWidth() / 2 + 15, 250, 207, 95);
                        }
                    }

                    if (p2Map == -1) { 
                        // p2 hover
                        g2d.setPaint(new Color(219, 26, 113));
                        if (p2Hover == 0) {
                            g2d.drawRect(getWidth() / 2 - 222, 130, 207, 95);
                        } else if (p2Hover == 1) {
                            g2d.drawRect(getWidth() / 2 + 15, 130, 207, 95);
                        } else if (p2Hover == 2) {
                            g2d.drawRect(getWidth() / 2 - 222, 250, 207, 95);
                        } else {
                            g2d.drawRect(getWidth() / 2 + 15, 250, 207, 95);
                        }
                    }

                    if (p1Hover == p2Hover) { // has a different color if both are same hover
                        g2d.setPaint(new Color(81, 26, 219));
                        if (p1Hover == 0) {
                            g2d.drawRect(getWidth() / 2 - 222, 130, 207, 95);
                        } else if (p1Hover == 1) {
                            g2d.drawRect(getWidth() / 2 + 15, 130, 207, 95);
                        } else if (p1Hover == 2) {
                            g2d.drawRect(getWidth() / 2 - 222, 250, 207, 95);
                        } else {
                            g2d.drawRect(getWidth() / 2 + 15, 250, 207, 95);
                        }
                    }
                }

                if (frameController % 15 == 0) {
                    hoverBlink = hoverBlink ? false : true;
                }
            }

        } else if (gameState == 6) {  // main screen
            // loads the chosen map the characters and the UI
            g.drawImage(chosenMap, 0, 0, this);

            g2d.setColor(Color.WHITE);
            g2d.fillRect(19, 16, 304, 29);
            g2d.fillRect(getWidth() - 22 - 300, 16, 304, 29);

            g2d.setColor(Color.RED);
            g2d.fillRect(21, 18, 300, 25);
            g2d.fillRect(getWidth() - 21 - 300, 18, 300, 25);

            g2d.setColor(Color.YELLOW);
            g2d.fillRect(21, 18, p1Health * 3, 25);
            g2d.fillRect(getWidth() - 21 - p2Health * 3, 18, p2Health * 3, 25);

            g2d.setPaint(gradientBackground);
            g2d.fillRect(21, 52, p1Stamina * 3, 5);
            g2d.fillRect(getWidth() - 21 - p2Stamina * 3, 52, p2Stamina * 3, 5);

            g2d.setPaint(Color.WHITE);
            g2d.setStroke(new BasicStroke(2));

            g2d.setPaint(gradientBackground);
            if (p1Score == 1) {
                g.fillOval(300, 70, 10, 10);
            }
            if (p2Score == 1) {
                g.fillOval(490, 70, 10, 10);
            }

            g2d.setPaint(Color.WHITE);
            g.drawOval(300, 70, 10, 10);
            g.drawOval(490, 70, 10, 10);


            // shows the p1/p2 combo on the left/right
            g.setFont(comboText);
            if (p1Combo > 0) {
                g.drawString("x" + p1Combo, 20, 250);
            }
            if (p2Combo > 0) {
                g.drawString("x" + p2Combo, 760, 250);
            }

            // for start timer
            if (Integer.parseInt(startTimer) > -1) {
                g2d.setFont(largeText);
                if (startTimer.equals("3") && gameSFX) {
                    fightAudio.play();
                }
                if (!startTimer.equals("0")) {
                    centerString(g2d, startTimer, "B");
                }

                if (startTimer.equals("0")) {
                    centerString(g2d, "FIGHT!", "B");
                }

                if (frameController % 100 == 0) {
                    startTimer = "" + (Integer.parseInt(startTimer) - 1);
                }
                return;
            }


            // all of the actions that p1 can do
            if (p1Action[knockedOut])
                knockedOut(g, "p1");
            if (p1Action[hit] && !p1Action[knockedOut])
                hit(g, "p1");
            else if (p1Action[duck])
                duck(g, "p1");
            else if (p1Action[block])
                block(g, "p1");
            else if (p1Action[jump])
                jump(g, "p1");
            else if (p1Action[forward])
                moveForward(g, "p1");
            else if (p1Action[back])
                moveBack(g, "p1");
            else if (p1Action[punch])
                punch(g, "p1");
            else if (p1Action[kick])
                kick(g, "p1");
            else if (p1Action[special])
                special(g, "p1");
            else if (!p1Action[knockedOut])
                idle(g, "p1");
            if (isp1RyuThrowSpecial)
                throwRyuSpecial(g, "p1");


                // adds stamina if p1 is not attacking
            if (!p1Action[punch] && !p1Action[kick] && !p1Action[block] && frameController % 15 == 0) {
                p1Stamina = p1Stamina + 5 >= 100 ? 100 : p1Stamina + 5;
            }


            // all moves that p2 can do
            if (p2Action[knockedOut])
                knockedOut(g, "p2");
            else if (p2Action[hit])
                hit(g, "p2");
            else if (p2Action[duck])
                duck(g, "p2");
            else if (p2Action[block])
                block(g, "p2");
            else if (p2Action[jump])
                jump(g, "p2");
            else if (p2Action[forward])
                moveForward(g, "p2");
            else if (p2Action[back])
                moveBack(g, "p2");
            else if (p2Action[punch])
                punch(g, "p2");
            else if (p2Action[kick])
                kick(g, "p2");
            else if (p2Action[special])
                special(g, "p2");
            else if (!p2Action[knockedOut])
                idle(g, "p2");
            if (isp2RyuThrowSpecial)
                throwRyuSpecial(g, "p2");


                // adds stamina if not attacking
            if (!p2Action[punch] && !p2Action[kick] && !p2Action[block] && frameController % 15 == 0) {
                p2Stamina = p2Stamina + 5 >= 100 ? 100 : p2Stamina + 5;
            }
        }
        if (gameState == 7) {
            // p1 win screen
            g2d.setPaint(gradientBackground);
            g.fillRect(0, 0, 800, 367);
            if (p1Char.equals("Retsu")) {
                g.drawImage(p1retsuBig, 200, 0, null);
            }
            if (p1Char.equals("Ryu")) {
                g.drawImage(p1ryuBig, 200, 0, null);
            }
            g2d.setFont(largeText);
            g2d.setPaint(new Color(171, 26, 219));
            centerString(g2d, "PLAYER 1 WINS", "B");
            g2d.setFont(text);
            g2d.setPaint(Color.WHITE);
            centerString(g2d, "Press BACKSPACE For Main Menu", "H300");
            centerString(g2d, "Press ENTER To Restart With Same Settings", "H350");
        }

        if (gameState == 8) {
            // p2 win screen
            g2d.setPaint(gradientBackground);
            g.fillRect(0, 0, 800, 367);
            if (p2Char.equals("Retsu")) {
                g.drawImage(p2retsuBig, 250, 0, null);
            }
            g2d.setFont(largeText);
            g2d.setPaint(new Color(219, 26, 113));
            centerString(g2d, "PLAYER 2 WINS", "B");
            g2d.setFont(text);
            g2d.setPaint(Color.WHITE);
            centerString(g2d, "Press BACKSPACE For Main Menu", "H300");
            centerString(g2d, "Press ENTER To Restart With Same Settings", "H350");

        }

        if (gameState == 9) {
            g2d.setPaint(Color.BLACK);

            g2d.fillRect(0, 0, 800, 367);

            g2d.setPaint(Color.WHITE);
            g2d.setFont(largeText);
            centerString(g2d, "MENU", "H100");

            g2d.setFont(text);
            g.drawString("P1 Select:   M", 100, 150);
            g.drawString("P1 Navigate: WASD", 100, 200);
            g.drawString("P1 Select:   /", 450, 150);
            g.drawString("P1 Navigate: arrow keys", 450, 200);

        }

        if (p2Health <= 0) {
            // activates knockedout of health <= 0
            p2Action[knockedOut] = true;
        } else if (p1Health <= 0) {
            p1Action[knockedOut] = true;

        }
    }

    // move forward function that makes characters move forward
    public void moveForward(Graphics g, String player) {
        if (player.equals("p1")) {
            g.drawImage(p1[forward][p1Sprite[forward]], p1PosX, p1PosY, null);
            p1CurrentMovement = p1[forward][p1Sprite[forward]];
            if (frameController % p1MoveLength[forward] == 0) {
                if (!checkForCollisions("p1", "walk").equals("Collision")) { // checks for collisions to see if they collide with player 2
                    p1PosX += 5;
                }

                // increase sprite num
                p1Sprite[forward] = (p1Sprite[forward] + 1) % p1[forward].length;
            }
        } else {
            g.drawImage(p2[forward][p2Sprite[forward]], p2PosX, p2PosY, null);
            p2CurrentMovement = p2[forward][p2Sprite[forward]];
            if (frameController % p2MoveLength[forward] == 0) {
                if (!checkForCollisions("p2", "walk").equals("Out of bounds")) {
                    p2PosX += 5;
                } else {
                    p2PosX = getWidth() - (p2CurrentMovement.getWidth() == 199 ? 70 : p2CurrentMovement.getWidth());
                }
                p2Sprite[forward] = (p2Sprite[forward] + 1) % p2[forward].length;
            }
        }

    }
    // move backward. Check for collision and if they do not collide with opponent or wall it moves
    public void moveBack(Graphics g, String player) {
        if (player.equals("p1")) {
            g.drawImage(p1[back][p1Sprite[back]], p1PosX, p1PosY, null);
            p1CurrentMovement = p1[back][p1Sprite[back]];
            if (frameController % p1MoveLength[back] == 0) {
                if (!checkForCollisions("p1", "walk").equals("Out of bounds")) {
                    p1PosX -= 5;
                } else {
                    p1PosX = 0;
                }
                p1Sprite[back] = (p1Sprite[back] + 1) % p1[back].length; // increase sprite num
            }
        } else {
            g.drawImage(p2[back][p2Sprite[back]], p2PosX, p2PosY, null);
            p2CurrentMovement = p2[back][p2Sprite[back]];
            if (frameController % p2MoveLength[back] == 0) {
                if (!checkForCollisions("p2", "walk").equals("Collision")) {
                    p2PosX -= 5;
                } else {
                    p2PosX += 5;
                }
                p2Sprite[back] = (p2Sprite[back] + 1) % p2[back].length;
            }
        }
    }

    // punching
    public void punch(Graphics g, String player) {
        if (player.equals("p1")) {
            g.drawImage(p1[punch][p1Sprite[punch]], p1PosX, p1PosY, null);
            p1CurrentMovement = p1[punch][p1Sprite[punch]];

            if (frameController % p1MoveLength[punch] == 0) {
                if (checkForCollisions("p1", "attack").equals("Collision") && !hasp1Hit) { // checks for collision with opponent and that player has not already hit so they don't hit 50 times in one move
                    p2Health = p2Health - p1PunchDamage < 0 ? 0 : p2Health - p1PunchDamage;
                    p2Action[hit] = true;
                    hasp1Hit = true;
                    p1Combo++; // increaes p1 combo
                    p2Combo = 0; // reset p2 combo

                }
                p1Sprite[punch] = (p1Sprite[punch] + 1) % p1[punch].length; // sprite num increase
                if (p1Sprite[punch] == 0) {
                    // if the sprite has come back down to 0, meaning that it is finished then it stops punching
                    p1Action[punch] = false;
                    hasp1Hit = false;
                }
            }
        } else {
            g.drawImage(p2[punch][p2Sprite[punch]], p2PosX, p2PosY, null);
            p2CurrentMovement = p2[punch][p2Sprite[punch]];

            if (frameController % p2MoveLength[punch] == 0) {
                if (p2Sprite[punch] == 0)
                    p2PosX -= 35;
                else if (p2Sprite[punch] == 1)
                    p2PosX += 35;

                if (checkForCollisions("p2", "attack").equals("Collision") && !hasp2Hit) {
                    p1Health = p1Health - p2PunchDamage < 0 ? 0 : p1Health - p2PunchDamage;
                    p1Action[hit] = true;
                    hasp2Hit = true;
                    p2Combo++;
                    p1Combo = 0;
                }
                p2Sprite[punch] = (p2Sprite[punch] + 1) % p2[punch].length;
                if (p2Sprite[punch] == 0) {
                    p2Action[punch] = false;
                    hasp2Hit = false;
                }
            }
        }

    }

    public void kick(Graphics g, String player) {
        if (player.equals("p1")) {
            g.drawImage(p1[kick][p1Sprite[kick]], p1PosX, p1PosY, null);
            p1CurrentMovement = p1[kick][p1Sprite[kick]];

            if (frameController % p1MoveLength[kick] == 0) {
                if (checkForCollisions("p1", "attack").equals("Collision") && !hasp1Hit) { // checks to see if p1 is colloding with p2 and that they have already not hit
                    p2Health = p2Health - p1KickDamage < 0 ? 0 : p2Health - p1KickDamage;
                    p2Action[hit] = true;
                    hasp1Hit = true;
                    p1Combo++;
                    p2Combo = 0;
                }
                p1Sprite[kick] = (p1Sprite[kick] + 1) % p1[kick].length; // reset, similar to punch
                if (p1Sprite[kick] == 0) {
                    p1Action[kick] = false;
                    hasp1Hit = false;
                }
            }

        } else {
            g.drawImage(p2[kick][p2Sprite[kick]], p2PosX, p2PosY, null);
            p2CurrentMovement = p2[kick][p1Sprite[kick]];
            if (frameController % p2MoveLength[kick] == 0) {
                if (p2Sprite[kick] == 1)
                    p2PosX -= 35;
                else if (p2Sprite[kick] == 2)
                    p2PosX += 35;
                if (checkForCollisions("p2", "attack").equals("Collision") && !hasp2Hit) {
                    p1Health = p1Health - p2KickDamage < 0 ? 0 : p1Health - p2KickDamage;
                    p1Action[hit] = true;
                    hasp2Hit = true;
                    p2Combo++;
                    p1Combo = 0;
                }
                p2Sprite[kick] = (p2Sprite[kick] + 1) % p2[kick].length;
                if (p2Sprite[kick] == 0) {
                    p2Action[kick] = false;
                    hasp2Hit = false;
                }
            }
        }
    }

    public void jump(Graphics g, String player) {
        if (player.equals("p1")) {
            if (p1Action[punch] && p1Sprite[jump] > 1 // if player is punching while jumping, it runs the jump punch
                    && (takenP1Stamina || p1Stamina >= p1MoveStamina[jumpPunch])) {
                if (!takenP1Stamina) {
                    p1Stamina -= p1MoveStamina[jumpPunch];
                    takenP1Stamina = true;
                }
                g.drawImage(p1[jumpPunch][0], p1PosX, p1PosY, null);
                p1CurrentMovement = p1[jumpPunch][0];
                if (checkForCollisions("p1", "high").equals("Collision") && !hasp1Hit) {
                    p2Health = p2Health - p1JumpPunchDamage < 0 ? 0 : p2Health - p1JumpPunchDamage;
                    p2Action[hit] = true;
                    hasp1Hit = true;
                    p1Combo++;
                    p2Combo = 0;
                }
            }

            else if (p1Action[kick] && p1Sprite[jump] > 1 // if player is kicking in the air, then it runs jump kick
                    && (takenP1Stamina || p1Stamina >= p1MoveStamina[jumpKick]) && !keysPressed.contains(p1PunchBind)) {
                if (!takenP1Stamina) {
                    p1Stamina -= p1MoveStamina[jumpKick];
                    takenP1Stamina = true;
                }
                g.drawImage(p1[jumpKick][0], p1PosX, p1PosY, null);
                p1CurrentMovement = p1[jumpKick][0];
                if (checkForCollisions("p1", "high").equals("Collision") && !hasp1Hit) {
                    p2Health = p2Health - p1JumpKickDamage < 0 ? 0 : p2Health - p1JumpKickDamage;
                    p2Action[hit] = true;
                    hasp1Hit = true;
                    p1Combo++;
                    p2Combo = 0;
                }
            }

            else {
                g.drawImage(p1[jump][p1Sprite[jump]], p1PosX, p1PosY, null); // if player not attacking it just jumps
                p1CurrentMovement = p1[jump][p1Sprite[jump]];
            }

            if (frameController % p1MoveLength[jump] == 0) {
                if (keysPressed.contains(68) && !checkForCollisions("p1", "jump").equals("Collision")) { // goes forward if button is pressed and does not collide 
                    p1PosX += p1JumpX;
                }
                if (keysPressed.contains(65) && !checkForCollisions("p1", "jump").equals("Out of bounds")) { // goes back if button is pressed and does not hit wall
                    p1PosX -= p1JumpX;
                }
                if (p1[jump].length % 2 == 0) { // different for characters that have even jump sprite and odd jump sprite
                    if (p1Sprite[jump] + 1 > p1[jump].length / 2) { // goes up for half and go down for half
                        p1PosY += p1JumpY;
                    } else {
                        p1PosY -= p1JumpY;
                    }
                } else {
                    if (p1Sprite[jump] != p1[jump].length / 2) {
                        if (p1Sprite[jump] + 1 > p1[jump].length / 2) {
                            p1PosY += p1JumpY;
                        } else {
                            p1PosY -= p1JumpY;
                        }
                    }

                }
                p1Sprite[jump] = (p1Sprite[jump] + 1) % p1[jump].length;
                if (p1Sprite[jump] == 0) {
                    // reset everything if the jump is complete
                    p1Action[jump] = false;
                    p1Action[kick] = false;
                    p1Action[punch] = false;
                    hasp1Hit = false;
                }
            }
        } else {
            if (p2Action[punch] && p2Sprite[jump] > 1
                    && (takenP2Stamina || p2Stamina >= p2MoveStamina[jumpPunch])) {
                if (!takenP2Stamina) {
                    p2Stamina -= p2MoveStamina[jumpPunch];
                    takenP2Stamina = true;
                }
                g.drawImage(p2[jumpPunch][0], p2PosX, p2PosY, null);
                p2CurrentMovement = p2[jumpPunch][0];
                if (checkForCollisions("p2", "high").equals("Collision") && !hasp2Hit) {
                    p1Health = p1Health - p2JumpPunchDamage < 0 ? 0 : p1Health - p2JumpPunchDamage;
                    p1Action[hit] = true;
                    hasp2Hit = true;
                    p2Combo++;
                    p1Combo = 0;
                }
            } else if (p2Action[kick] && p2Sprite[jump] > 1
                    && (takenP2Stamina || p2Stamina >= p2MoveStamina[jumpKick])) {
                if (!takenP2Stamina) {
                    p2Stamina -= p2MoveStamina[jumpKick];
                    takenP2Stamina = true;
                }
                g.drawImage(p2[jumpKick][0], p2PosX, p2PosY, null);
                p2CurrentMovement = p2[jumpKick][0];
                if (checkForCollisions("p2", "high").equals("Collision") && !hasp2Hit) {
                    p1Health = p1Health - p1JumpKickDamage < 0 ? 0 : p1Health - p1JumpKickDamage;
                    p1Action[hit] = true;
                    hasp2Hit = true;
                    p2Combo++;
                    p1Combo = 0;
                }
            } else {
                g.drawImage(p2[jump][p2Sprite[jump]], p2PosX, p2PosY, null);
                p2CurrentMovement = p2[jump][p2Sprite[jump]];
            }

            if (frameController % p2MoveLength[jump] == 0) {
                if (keysPressed.contains(37) && !checkForCollisions("p2", "jump").equals("Collision")) {
                    p2PosX -= p2JumpX;
                }
                if (keysPressed.contains(39) && !checkForCollisions("p2", "jump").equals("Out of bounds")) {
                    p2PosX += p2JumpX;
                }
                if (p2[jump].length % 2 == 0) {
                    if (p2Sprite[jump] + 1 > p2[jump].length / 2) {
                        p2PosY += p2JumpY;
                    } else {
                        p2PosY -= p2JumpY;
                    }
                } else {
                    if (p2Sprite[jump] != p2[jump].length / 2) {
                        if (p2Sprite[jump] + 1 > p2[jump].length / 2) {
                            p2PosY += p2JumpY;
                        } else {
                            p2PosY -= p2JumpY;
                        }
                    }

                }
                p2Sprite[jump] = (p2Sprite[jump] + 1) % p2[jump].length;
                if (p2Sprite[jump] == 0) {
                    p2Action[jump] = false;
                    p2Action[punch] = false;
                    p2Action[kick] = false;
                    hasp2Hit = false;
                }
            }
        }
    }

    // ducking
    public void duck(Graphics g, String player) {
        if (player.equals("p1")) {
            if (p1Action[block]) { // if player is pressing the duck key while blocking
                g.drawImage(p1[duckBlock][p1Sprite[duckBlock]], p1PosX,
                        p1PosY - (p1Char.equals("Retsu") ? 15 : p1Char.equals("Ryu") ? 29 : 0),
                        null);
                p1CurrentMovement = p1[duckBlock][p1Sprite[duckBlock]];
                p1Stamina--;

                if (frameController % p1MoveLength[duckBlock] == 0) {
                    p1Sprite[duckBlock] = (p1Sprite[duckBlock] + 1) % p1[duckBlock].length;
                }
                if (p1Stamina - 1 <= 0) {
                    p1Action[block] = false; // reduces stamina 
                }

            }

            else if (p1Action[punch] && !keysPressed.contains(p1KickBind)) { // for punching while ducking, similar to normal 
                g.drawImage(p1[duckPunch][p1Sprite[duckPunch]], p1PosX, p1PosY, null);
                p1CurrentMovement = p1[duckPunch][p1Sprite[duckPunch]];
                if (checkForCollisions("p1", "low").equals("Collision") && !hasp1Hit) {
                    p2Health = p2Health - p1PunchDamage < 0 ? 0 : p2Health - p1PunchDamage;
                    p2Action[hit] = true;
                    hasp1Hit = true;
                    p1Combo++;
                    p2Combo = 0;
                }

                if (frameController % p1MoveLength[duckPunch] == 0) {
                    p1Sprite[duckPunch] = (p1Sprite[duckPunch] + 1) % p1[duckPunch].length;

                    if (p1Sprite[duckPunch] == 0) {
                        // reset
                        takenP1Stamina = false;
                        hasp1Hit = false;
                        p1Action[punch] = false;
                        hasp1Hit = false;
                    }
                }

            }

            else if ((p1Action[kick])) { // if kicking while ducking
                g.drawImage(p1[duckKick][p1Sprite[duckKick]], p1PosX, p1PosY, null);
                p1CurrentMovement = p1[duckKick][p1Sprite[duckKick]];
                if (checkForCollisions("p1", "low").equals("Collision") && !hasp1Hit) { 
                    p2Health = p2Health - p1KickDamage < 0 ? 0 : p2Health - p1KickDamage;
                    p2Action[hit] = true;
                    hasp1Hit = true;
                    p1Combo++;
                    p2Combo = 0;
                }
                if (frameController % p1MoveLength[duckKick] == 0) {
                    p1Sprite[duckKick] = (p1Sprite[duckKick] + 1) % p1[duckKick].length;

                    if (p1Sprite[duckKick] == 0) {
                        //reset
                        takenP1Stamina = false;
                        hasp1Hit = false;
                        p1Action[kick] = false;
                        hasp1Hit = false;
                    }
                }

            }

            else {
                // if player is not attacking while ducking, then it does normal duck
                g.drawImage(p1[duck][p1Sprite[duck]], p1PosX, p1PosY, null);
                p1CurrentMovement = p1[duck][p1Sprite[duck]];
                takenP1Stamina = false;
                p1Sprite[duckPunch] = 0;
            }

            if (frameController % p1MoveLength[duck] == 0) {
                p1Sprite[duck] = (p1Sprite[duck] + 1) % p1[duck].length;
            }
        } else {
            if (p2Action[block]) {
                g.drawImage(p2[duckBlock][p2Sprite[duckBlock]], p2PosX - (p2Char.equals("Retsu") ? 15 : 0),
                        p2PosY - (p2Char.equals("Retsu") ? 15 : p2Char.equals("Ryu") ? 29 : 0), null);
                p2CurrentMovement = p2[duckBlock][p2Sprite[duckBlock]];
                p2Stamina--;
                // isp2Block = true;
                if (frameController % p2MoveLength[duckBlock] == 0) {
                    p2Sprite[duckBlock] = (p2Sprite[duckBlock] + 1) % p2[duckBlock].length;
                }
                if (p2Stamina - 1 <= 0) {
                    p2Action[duckBlock] = false;
                }
            }

            else if (p2Action[punch] && !keysPressed.contains(p2KickBind)) {
                g.drawImage(p2[duckPunch][p2Sprite[duckPunch]], p2PosX, p2PosY,
                        null);
                p2CurrentMovement = p2[duckPunch][p2Sprite[duckPunch]];
                if (checkForCollisions("p2", "low").equals("Collision") && !hasp2Hit) {
                    p1Health = p1Health - p1PunchDamage < 0 ? 0 : p1Health - p1PunchDamage;
                    p1Action[hit] = true;
                    hasp2Hit = true;
                    p2Combo++;
                    p1Combo = 0;
                }

                if (frameController % p2MoveLength[duckPunch] == 0) {
                    p2Sprite[duckPunch] = (p2Sprite[duckPunch] + 1) % p2[duckPunch].length;
                    if (p2Sprite[duckPunch] == 1) {
                        p2PosX -= 20;
                    }
                    if (p2Sprite[duckPunch] == p2[duckPunch].length - 1) {
                        p2PosX += 20;
                    }

                    if (p2Sprite[duckPunch] == 0) {
                        takenP2Stamina = false;
                        hasp2Hit = false;
                        p2Action[punch] = false;
                        hasp2Hit = false;
                    }
                }

            }

            else if (p2Action[kick]) {
                g.drawImage(p2[duckKick][p2Sprite[duckKick]], p2PosX, p2PosY,
                        null);
                p2CurrentMovement = p2[duckKick][p2Sprite[duckKick]];
                if (checkForCollisions("p2", "low").equals("Collision") && !hasp2Hit) {
                    p1Health = p1Health - p2KickDamage < 0 ? 0 : p1Health - p2KickDamage;
                    p1Action[hit] = true;
                    hasp2Hit = true;
                    p2Combo++;
                    p1Combo = 0;
                }
                if (frameController % p2MoveLength[duckKick] == 0) {
                    p2Sprite[duckKick] = (p2Sprite[duckKick] + 1) % p2[duckKick].length;
                    if (p2Char.equals("Retsu")) {
                        if (p2Sprite[duckKick] == 2) {
                            p2PosX -= 30;
                        }
                        if (p2Sprite[duckKick] == 3) {
                            p2PosX += 30;
                        }
                    }
                    if (p2Char.equals("Ryu")) {
                        if (p2Sprite[duckKick] == 1) {
                            p2PosX -= 30;
                        }
                        if (p2Sprite[duckKick] == 2) {
                            p2PosX += 30;
                        }
                    }

                    if (p2Sprite[duckKick] == 0) {
                        takenP2Stamina = false;
                        hasp2Hit = false;
                        p2Action[kick] = false;
                        hasp2Hit = false;
                    }
                }
            }

            else {
                g.drawImage(p2[duck][p2Sprite[duck]], p2PosX, p2PosY, null);
                p2CurrentMovement = p2[duck][p2Sprite[duck]];
                takenP2Stamina = false;
                p2Sprite[duckPunch] = 0;
            }

            if (frameController % p2MoveLength[duck] == 0) {
                p2Sprite[duck] = (p2Sprite[duck] + 1) % p2[duck].length;
            }
        }
    }

    // is player hit
    public void hit(Graphics g, String player) {
        if (player.equals("p1")) {

            if (p1Action[jump]) { // if the player is hit while in mid air, it goes up then down, but really fast
                if (p1[jump].length % 2 == 0) {
                    if (p1Sprite[jump] + 1 > p1[jump].length / 2) {
                        p1PosY += p1JumpY;
                    } else {
                        p1PosY -= p1JumpY;
                    }
                } else {
                    if (p1Sprite[jump] != p1[jump].length / 2) {
                        if (p1Sprite[jump] + 1 > p1[jump].length / 2) {
                            p1PosY += p1JumpY;
                        } else {
                            p1PosY -= p1JumpY;
                        }
                    }
                }
                p1Sprite[jump] = (p1Sprite[jump] + 1) % p1[jump].length;
                if (p1Sprite[jump] == 0) {
                    p1Action[jump] = false;
                }
            }

            if (p2Combo % 5 == 0 && p2Combo > 0) { // if the combo of the opposing player is a modular of 5, then it plays the getting knocked down animation
                g.drawImage(p1[knocked][p1Sprite[knocked]], p1PosX, p1PosY, null);
                p1CurrentMovement = p1[knocked][p1Sprite[knocked]];

                if (frameController % p1MoveLength[knocked] <= 0) {
                    p1Sprite[knocked] = (p1Sprite[knocked] + 1) % p1[knocked].length;
                    if (p1Sprite[knocked] == 0)
                        p1Action[hit] = false;
                    if (p1Sprite[knocked] < p1[knocked].length / 2) {
                        if (!checkForCollisions("p1", "walk").equals("Out of bounds")) { // checks for out of bounds when on the ground, adjust the x movement accordingly
                            if (p1Sprite[knocked] != 0)
                                p1PosX -= 40;
                        } else {
                            p1PosX = 0;
                        }
                    }
                    if (p1Char.equals("Ryu")) { // differnt for each character
                        if (p1Sprite[knocked] == 1) {
                            p1PosY = defaultPosY + 20;
                        } else if (p1Sprite[knocked] < 4) {
                            p1PosY += 20;
                        } else if (p1Sprite[knocked] > 5) {
                            p1PosY -= 20;
                        }
                    } else if (p1Char.equals("Retsu")) {
                        if (p1Sprite[knocked] == 1) {
                            p1PosY = defaultPosY + 30;
                        } else if (p1Sprite[knocked] < 3 && p1Sprite[knocked] != 0)
                            p1PosY += 30;
                        else if (p1Sprite[knocked] == 6)
                            p1PosY = defaultPosY;
                        else if (p1Sprite[knocked] > 3)
                            p1PosY -= 15;
                    }
                }
            }

            else if (p1Action[duck]) {// if player is ducking while getting hit it runs this 
                g.drawImage(p1[duckHit][p1Sprite[duckHit]], p1PosX, p1PosY, null);
                p1CurrentMovement = p1[duckHit][p1Sprite[duckHit]];

                if (frameController % p1MoveLength[duckHit] == 0) {
                    p1Sprite[duckHit] = (p1Sprite[duckHit] + 1) % p1[duckHit].length;
                    if (p1Sprite[duckHit] == 0)
                        p1Action[hit] = false;

                }
            } else {
                // if they are doing none of the above, it runs the normal getting hit animation
                g.drawImage(p1[hit][p1Sprite[hit]], p1PosX, p1PosY, null);
                p1CurrentMovement = p1[hit][p1Sprite[hit]];

                if (frameController % p1MoveLength[hit] <= 0) {
                    p1Sprite[hit] = (p1Sprite[hit] + 1) % p1[hit].length;
                    if (p1Sprite[hit] == 0)
                        p1Action[hit] = false;
                }
            }
        } else {
            if (p2Action[jump]) {
                if (p2[jump].length % 2 == 0) {
                    if (p2Sprite[jump] + 1 > p2[jump].length / 2) {
                        p2PosY += p2JumpY;
                    } else {
                        p2PosY -= p2JumpY;
                    }
                } else {
                    if (p2Sprite[jump] != p2[jump].length / 2) {
                        if (p2Sprite[jump] + 1 > p2[jump].length / 2) {
                            p2PosY += p2JumpY;
                        } else {
                            p2PosY -= p2JumpY;
                        }
                    }
                }
                p2Sprite[jump] = (p2Sprite[jump] + 1) % p2[jump].length;
                if (p2Sprite[jump] == 0) {
                    p2Action[jump] = false;
                }
            }

            if (p1Combo % 5 == 0 && p1Combo > 0) {
                g.drawImage(p2[knocked][p2Sprite[knocked]], p2PosX, p2PosY, null);
                p2CurrentMovement = p2[knocked][p2Sprite[knocked]];

                if (frameController % p2MoveLength[knocked] == 0) {
                    p2Sprite[knocked] = (p2Sprite[knocked] + 1) % p2[knocked].length;
                    if (p2Sprite[knocked] == 0)
                        p2Action[hit] = false;
                    if (p2Sprite[knocked] < p2[knocked].length / 2) {
                        if (p2Sprite[knocked] != 0)
                            p2PosX += 40;
                        if (checkForCollisions("p2", "walk").equals("Out of bounds") && p2Sprite[knocked] != 0) {
                            p2PosX = 800 - p2CurrentMovement.getWidth();
                        }
                    }
                    if (p2Char.equals("Ryu")) {
                        if (p2Sprite[knocked] < 4) {
                            p2PosY += 20;
                        } else if (p2Sprite[knocked] > 5) {
                            p2PosY -= 20;
                        }
                    } else if (p1Char.equals("Retsu")) {
                        if (p2Sprite[knocked] < 3 && p2Sprite[knocked] != 0)
                            p2PosY += 30;
                        else if (p2Sprite[knocked] == 6)
                            p2PosY = defaultPosY;
                        else if (p2Sprite[knocked] > 3)
                            p2PosY -= 15;
                    }
                }
            }

            else if (p2Action[duck]) {
                g.drawImage(p2[duckHit][p2Sprite[duckHit]], p2PosX, p2PosY, null);
                p2CurrentMovement = p2[duckHit][p2Sprite[duckHit]];

                if (frameController % p2MoveLength[duckHit] == 0) {
                    p2Sprite[duckHit] = (p2Sprite[duckHit] + 1) % p2[duckHit].length;
                    if (p2Sprite[duckHit] == 0)
                        p2Action[hit] = false;
                }
            } else {
                g.drawImage(p2[hit][p2Sprite[hit]], p2PosX, p2PosY, null);
                p2CurrentMovement = p2[hit][p2Sprite[hit]];

                if (frameController % p2MoveLength[hit] == 0) {
                    p2Sprite[hit] = (p2Sprite[hit] + 1) % p2[hit].length;
                    if (p2Sprite[hit] == 0)
                        p2Action[hit] = false;
                }
            }
        }
    }


    // if player is blocking
    public void block(Graphics g, String player) {
        if (player.equals("p1")) {
            // if player is blocking, then it runs the sprite num and they can not get hit
            g.drawImage(p1[block][p1Sprite[block]], p1PosX, p1PosY, null);
            p1CurrentMovement = p1[block][p1Sprite[block]];
            p1Stamina -= 1;
            if (p1Stamina - 1 <= 0) {
                p1Sprite[block] = 0;
                p1Action[block] = false;
            }
        } else {
            g.drawImage(p2[block][p2Sprite[block]], p2PosX - 14, p2PosY, null);
            p2CurrentMovement = p2[block][p2Sprite[block]];
            p2Stamina -= 1;
            if (p2Stamina - 1 <= 0) {
                p2Sprite[block] = 0;
                p2Action[block] = false;
            }
        }
    }

    // the special attacks
    public void special(Graphics g, String player) {
        if (player.equals("p1")) {
            // special attack for retsu is that he goes 100 pixels forward and does a uppercut that does damage
            if (p1Char.equals("Retsu")) {
                g.drawImage(p1[special][p1Sprite[special]],
                        p1PosX + (p1PosX + 100 + p1[special][p1Sprite[special]].getWidth() < 800 ? 100
                                : p1[special][p1Sprite[special]].getWidth()),
                        defaultPosY - (p1Sprite[special] == 2 ? 20 : 0), null);
                p1CurrentMovement = p1[special][p1Sprite[special]];

                if (checkForCollisions("p1", p1Char + "Special").equals("Collision") && !hasp1Hit) {
                    p2Action[hit] = true;
                    hasp1Hit = true;
                    p2Health = p2Health - p1SpecialDamage < 0 ? 0 : p2Health - p1SpecialDamage;
                    p1Combo++;
                    p2Combo = 0;
                }
            }

        // special for Ryu
            if (p1Char.equals("Ryu")) {
                g.drawImage(p1[special][p1Sprite[special]], p1PosX, p1PosY, null);
                p1CurrentMovement = p1[special][p1Sprite[special]];
            }

            if (frameController % p1MoveLength[special] == 0) {
                p1Sprite[special] = (p1Sprite[special] + 1) % p1[special].length;
                if (p1Sprite[special] == 1 && !p1Char.equals("Ryu"))
                    p1Stamina -= p1MoveStamina[special];
                if (p1Sprite[special] == 0) {
                    p1Action[special] = false;
                    hasp1Hit = false;
                    if (p1Char.equals("Ryu")) {
                        // if ryus special animation is complete it starts rendering and running the actual projectile
                        isp1RyuThrowSpecial = true;
                        p1RyuProjectileX = p1PosX;
                    }
                }

            }
        } else {
            if (p2Char.equals("Retsu")) {
                g.drawImage(p2[special][p2Sprite[special]],
                        p2PosX - (p2PosX - 100 - p2[special][p2Sprite[special]].getWidth() > 0 ? 100
                                : p2[special][p2Sprite[special]].getWidth()),
                        defaultPosY - (p2Sprite[special] == 2 ? 20 : 0), null);
                p2CurrentMovement = p2[special][p2Sprite[special]];

                if (checkForCollisions("p2", p2Char + "Special").equals("Collision") && !hasp2Hit) {
                    p1Action[hit] = true;
                    hasp2Hit = true;
                    p1Health = p1Health - p1SpecialDamage < 0 ? 0 : p1Health - p1SpecialDamage;
                    p2Combo++;
                    p1Combo = 0;
                }
            }

            if (p2Char.equals("Ryu")) {
                g.drawImage(p2[special][p2Sprite[special]], p2PosX, p2PosY, null);
                p2CurrentMovement = p2[special][p2Sprite[special]];
            }

            if (frameController % p2MoveLength[special] == 0) {
                p2Sprite[special] = (p2Sprite[special] + 1) % p2[special].length;
                if (p2Sprite[special] == 1)
                    p2Stamina -= p2MoveStamina[special];
                if (p2Sprite[special] == 0) {
                    p2Action[special] = false;
                    hasp2Hit = false;
                    if (p2Char.equals("Ryu")) {
                        isp2RyuThrowSpecial = true;
                        p2RyuProjectileX = p2PosX;
                    }
                }
            }
        }
    }

    // if player is knocked out aka their health is 0
    public void knockedOut(Graphics g, String player) {
        if (player.equals("p1")) {
            g.drawImage(p1[knockedOut][p1Sprite[knockedOut]], p1PosX, p1PosY, null);
            p1CurrentMovement = p1[knockedOut][p1Sprite[knockedOut]];

            if (frameController % p1MoveLength[knockedOut] == 0) {
                p1Sprite[knockedOut] = (p1Sprite[knockedOut] + 1 == p1[knockedOut].length ? p1Sprite[knockedOut]
                        : p1Sprite[knockedOut] + 1);

                if (p1Char.equals("Retsu") && p1Sprite[knockedOut] <= 2) { // different movement for each character
                    if (!checkForCollisions("p1", "walk").equals("Out of bounds")) {
                        p1PosX -= 40;
                    } else {
                        p1PosX = 0;
                    }
                    p1PosY = defaultPosY + 120 > p1PosY ? p1PosY + (300 - p1PosY) / 3 : p1PosY;
                    if (p1PosY >= 367) {
                        p1PosY = 340;
                    }
                    if (p1Sprite[knockedOut] == 2) {
                        p1PosY = 300;
                    }
                }

                if (p1Char.equals("Ryu")) {
                    if (p1Sprite[knockedOut] == 1) {
                        p1PosY = defaultPosY + 20;
                        p1PosX -= 20;
                    } else if (p1Sprite[knockedOut] < 4) {
                        p1PosY += 20;
                        p1PosX -= 20;
                    }
                }
            }
            if (p1Sprite[knockedOut] == p1[knockedOut].length - 1) {
                g.setFont(largeText);
                centerString((Graphics2D) g, "P2 WIN!", "B");
                if (!winMusicIsPlaying && gameSFX && p2Score == 1) {
                    winAudio.play();
                    winMusicIsPlaying = true;
                }

                if (frameController % 300 == 0) {
                    winMusicIsPlaying = false;
                    if (p2Score == 1) {
                        gameState = 8;
                    } else {
                        reset("p2");
                    }
                }
            }
        } else {
            g.drawImage(p2[knockedOut][p2Sprite[knockedOut]], p2PosX, p2PosY, null);
            p2CurrentMovement = p2[knockedOut][p2Sprite[knockedOut]];

            if (frameController % p2MoveLength[knockedOut] == 0) {
                p2Sprite[knockedOut] = (p2Sprite[knockedOut] + 1 == p2[knockedOut].length ? p2Sprite[knockedOut]
                        : p2Sprite[knockedOut] + 1);
                if (p2Char.equals("Retsu") && p2Sprite[knockedOut] <= 2) {
                    if (!checkForCollisions("p2", "walk").equals("Out of bounds")) {
                        p2PosX += 40;
                    } else {
                        p2PosX = 800 - p2CurrentMovement.getWidth();
                    }
                    p2PosY = defaultPosY + 120 > p2PosY ? p2PosY + (340 - p2PosY) / 3 : p2PosY;
                    if (p2PosY >= 367) {
                        p2PosY = 340;
                    }
                    if (p2Sprite[knockedOut] == 2) {
                        p2PosY = 300;
                    }
                }
                else if (p2Char.equals("Ryu")) {
                    if (p2Sprite[knockedOut] == 1) {
                        p2PosY = defaultPosY + 20;
                        p2PosX += 20;
                    } else if (p2Sprite[knockedOut] < 4) {
                        p2PosY += 20;
                        p2PosX += 20;
                    }
                }
            }
            if (p2Sprite[knockedOut] == p2[knockedOut].length - 1) {
                g.setFont(largeText);
                centerString((Graphics2D) g, "P1 WIN!", "B");
                // winAudio.play();
                if (frameController % 300 == 0) {
                    if (p1Score == 1) {
                        gameState = 7;
                    } else {
                        reset("p1");
                    }
                }

            }
        }
    }


    // idle movement
    public void idle(Graphics g, String player) {
        if (player.equals("p1")) {
            g.drawImage(p1[idle][p1Sprite[idle]], p1PosX, p1PosY, null);
            p1CurrentMovement = p1[idle][p1Sprite[idle]];
            if (frameController % p1MoveLength[idle] == 0) {
                p1Sprite[idle] = (p1Sprite[idle] + 1) % p1[idle].length;
            }
        } else {
            g.drawImage(p2[idle][p2Sprite[idle]], p2PosX, p2PosY, null);
            p2CurrentMovement = p2[idle][p2Sprite[idle]];
            if (frameController % p2MoveLength[idle] == 0) {
                p2Sprite[idle] = (p2Sprite[idle] + 1) % p2[idle].length;
            }
        }
    }

    public void keyTyped(KeyEvent e) {
    }

    public void keyPressed(KeyEvent e) {

        // adds the pressed keys into the keysPressed arraylist
        if (!keysPressed.contains(e.getKeyCode())) {
            keysPressed.add(e.getKeyCode());
        }

        // System.out.println(e.getKeyCode());
// checks for each gameState keypress and does the action required for each press
        if (gameState == 0) {
            if (keysPressed.contains(27)) {
                gameState = 2;
            }
            if (keysPressed.contains(10)) { // 13 = ENTER
                gameState = 3;
            }
            if (keysPressed.contains(8)) { // 8 = BACKSPACE
                gameState = 1;
            }
            if (keysPressed.contains(77)) { 
                gameState = 9;
            }
        }

        else if (gameState == 1) {
            if (keysPressed.contains(8)) { // 8 = BACKSPACE
                gameState = 0;
            }
        }

        else if (gameState == 2) {
            if (keysPressed.contains(27)) {
                gameState = 0;
            }
            if (keysPressed.contains(16)) {
                gameMusic = gameMusic ? false : true;
                toggleMusic();
            }
            if (keysPressed.contains(20)) {
                gameSFX = gameSFX ? false : true;
            }
        }

        else if (gameState == 3) {
            if (keysPressed.contains(8)) { // 8 = BACKSPACE
                gameState = 0;
            }
            // p1
            if (keysPressed.contains(68)) { // 68 = d
                p1Hover = (p1Hover + 1) % 4;
                p1CharSwitch = true;
            }
            if (keysPressed.contains(65)) { // 65 = a
                p1Hover = (p1Hover - 1) % 4;
                p1CharSwitch = true;
            }
            if (keysPressed.contains(69)) { // 69 = e
                p1Char = p1Hover == 0 ? "Retsu" : p1Hover == 1 ? "Ryu" : ""; // if character selects
                System.out.println(p1Char);
                if (!p2Char.equals("")) { // checks if opponent has selected character and goes forward
                    loadSprites();
                    gameState = 4;
                    p1Hover = 0;
                    p2Hover = 0;
                }
            }

            // p2
            if (keysPressed.contains(39)) { // 39 = ->
                p2Hover = (p2Hover + 1) % 4;
                p2CharSwitch = true;
            }
            if (keysPressed.contains(37)) { // 37 = <-
                p2Hover = (p2Hover - 1) % 4;
                p2CharSwitch = true;
            }
            if (keysPressed.contains(47)) { // 47 = /
                p2Char = p2Hover == 0 ? "Retsu" : p2Hover == 1 ? "Ryu" : "";
                if (!p1Char.equals("")) {
                    loadSprites();
                    gameState = 4;
                    p1Hover = 0;
                    p2Hover = 0;
                }
            }
        }

        else if (gameState == 4) {

            if (p1KeySelect) {
                if (isNewBind(e.getKeyCode())) {
                    if (p1Hover == 0) {
                        p1ForwardBind = e.getKeyCode();
                    }
                    if (p1Hover == 1) // changes the keybind when player is changing
                        p1JumpBind = e.getKeyCode();
                    if (p1Hover == 2)
                        p1BackBind = e.getKeyCode();
                    if (p1Hover == 3)
                        p1DuckBind = e.getKeyCode();
                    if (p1Hover == 4)
                        p1PunchBind = e.getKeyCode();
                    if (p1Hover == 5)
                        p1SpecialBind = e.getKeyCode();
                    if (p1Hover == 6)
                        p1KickBind = e.getKeyCode();
                    if (p1Hover == 7)
                        p1BlockBind = e.getKeyCode();
                }
                p1KeySelect = false;
            }

            if (p2KeySelect) {
                if (isNewBind(e.getKeyCode())) {
                    if (p2Hover == 0) {
                        p2ForwardBind = e.getKeyCode();
                    }
                    if (p2Hover == 1)
                        p2JumpBind = e.getKeyCode();
                    if (p2Hover == 2)
                        p2BackBind = e.getKeyCode();
                    if (p2Hover == 3)
                        p2DuckBind = e.getKeyCode();
                    if (p2Hover == 4)
                        p2PunchBind = e.getKeyCode();
                    if (p2Hover == 5)
                        p2SpecialBind = e.getKeyCode();
                    if (p2Hover == 6)
                        p2KickBind = e.getKeyCode();
                    if (p2Hover == 7)
                        p2BlockBind = e.getKeyCode();
                }
                p2KeySelect = false;
            }
            if (keysPressed.contains(10)) { // 13 = ENTER
                gameState = 5;
                try {
                    updateBinds();
                    System.out.println("updated binds");
                } catch (IOException e1) {
                }
            }
// changes the p1Hover depending on the keypress
            if (keysPressed.contains(65) && p1Hover > 0) { 
                p1Hover -= 1;
            }
            if (keysPressed.contains(87) && p1Hover > 1) {
                p1Hover -= 2;
            }
            if (keysPressed.contains(68) && p1Hover < 7) {
                p1Hover += 1;
            }
            if (keysPressed.contains(83) && p1Hover < 6) {
                p1Hover += 2;
            }
            if (keysPressed.contains(69) && !p1KeySelect) {
                p1KeySelect = true;
            }

            if (keysPressed.contains(38) && p2Hover > 1) {
                p2Hover -= 2;
            }
            if (keysPressed.contains(40) && p2Hover < 6) {
                p2Hover += 2;
            }
            if (keysPressed.contains(37) && p2Hover > 0) {
                p2Hover -= 1;
            }
            if (keysPressed.contains(39) && p2Hover < 7) {
                p2Hover += 1;
            }
            if (keysPressed.contains(47) && !p2KeySelect) {
                p2KeySelect = true;
            }

        }

        else if (gameState == 5) {
            if (keysPressed.contains(8)) { // 8 = BACKSPACE
                gameState = 0;
            }
            // p1
            if (keysPressed.contains(68)) { // 68 = d
                if (p1Hover == 0) {
                    p1Hover = 1;
                }
                if (p1Hover == 2) {
                    p1Hover = 3;
                }

                p1Map = -1;
            }
            if (keysPressed.contains(65)) { // 65 = a
                if (p1Hover == 1) {
                    p1Hover = 0;
                }
                if (p1Hover == 3) {
                    p1Hover = 2;
                }
                p1Map = -1;
            }
            if (keysPressed.contains(87)) { // 87 = w
                if (p1Hover == 2) {
                    p1Hover = 0;
                } else if (p1Hover == 3) {
                    p1Hover = 1;
                }
                p1Map = -1;
            }
            if (keysPressed.contains(83)) { // 83 = s
                if (p1Hover == 0) {
                    p1Hover = 2;
                } else if (p1Hover == 1) {
                    p1Hover = 3;
                }
                p1Map = -1;
            }
            if (keysPressed.contains(69)) { // 69 = e
                p1Map = p1Hover;
                if (p2Map != -1) {
                    Random rand = new Random();
                    int n = rand.nextInt(2);
                    if (n == 0) {
                        chosenMapNum = p1Map;
                    } else {
                        chosenMapNum = p2Map;
                    }
                    if (chosenMapNum == 0) {
                        chosenMap = map0;
                    } else if (chosenMapNum == 1) {
                        chosenMap = map1;
                    } else if (chosenMapNum == 2) {
                        chosenMap = map2;
                    } else {
                        chosenMap = map3;
                    }
                }
            }

            // p2
            if (keysPressed.contains(39)) { // 39 = ->
                if (p2Hover == 0) {
                    p2Hover = 1;
                } else if (p2Hover == 2) {
                    p2Hover = 3;
                }
                p2Map = -1;
            }
            if (keysPressed.contains(37)) { // 37 = <-
                if (p2Hover == 1) {
                    p2Hover = 0;
                } else if (p2Hover == 3) {
                    p2Hover = 2;
                }
                p2Map = -1;
            }
            if (keysPressed.contains(38)) { // 38 = ↑
                if (p2Hover == 2) {
                    p2Hover = 0;
                } else if (p2Hover == 3) {
                    p2Hover = 1;
                }
                p2Map = -1;
            }
            if (keysPressed.contains(40)) { // 40 == ↓
                if (p2Hover == 0) {
                    p2Hover = 2;
                } else if (p2Hover == 1) {
                    p2Hover = 3;
                }
                p2Map = -1;
            }
            if (keysPressed.contains(47)) { // 47 = /
                p2Map = p2Hover;
                if (p1Map != -1) { // runs if p1 and p2 have selected maps selected a map yet
                    Random rand = new Random();
                    int n = rand.nextInt(2); // choses a random map between the maps chosen
                    if (n == 0) {
                        chosenMapNum = p1Map;
                    } else {
                        chosenMapNum = p2Map;
                    }
                    if (chosenMapNum == 0) {
                        chosenMap = map0;
                    } else if (chosenMapNum == 1) {
                        chosenMap = map1;
                    } else if (chosenMapNum == 2) {
                        chosenMap = map2;
                    } else {
                        chosenMap = map3;
                    }
                }
            }
        }

        else if (gameState == 6 && startTimer.equals("-1") && !p1Action[knockedOut] && !p2Action[knockedOut]) {

            // all of the actions for each player. Checks if player is doing certain thigns that would not make sense to do at once
            // p1 movement
            if (keysPressed.contains(p1ForwardBind) && !p1Action[duck] && !p1Action[hit]) { // 68 = d
                p1Action[forward] = true;
            }
            if (keysPressed.contains(p1BackBind) && !p1Action[duck] && !p1Action[hit]) { // 65 = a
                p1Action[back] = true;
            }
            if (keysPressed.contains(p1JumpBind) && !p1Action[jump] && !p1Action[hit] && !p1Action[duck]
                    && !p1Action[knockedOut]) {
                p1Action[jump] = true;
            }
            if (keysPressed.contains(p1PunchBind) && !p1Action[hit]) { // 69 = e
                if (p1Stamina >= p1MoveStamina[punch] && !p1Action[punch] && !p1Action[kick]) {
                    p1Stamina -= p1MoveStamina[punch];
                    p1Action[punch] = true;
                }

            }
            if (keysPressed.contains(p1KickBind) && !p1Action[hit]) { // 81 = q
                if (p1Stamina >= p1MoveStamina[kick] && !p1Action[punch] && !p1Action[kick]) {
                    p1Stamina -= p1MoveStamina[kick];
                    p1Action[kick] = true;
                }
            }
            if (keysPressed.contains(p1DuckBind) && !p1Action[duck] && !p1Action[jump] && !p1Action[hit]) {
                p1Action[duck] = true;
                p1PosY += 30;
            }

            if (keysPressed.contains(p1BlockBind) && !p1Action[hit] && p1Stamina >= 30 && !p1Action[knockedOut]
                    && !p1Action[jump]) {
                p1Action[block] = true;
            }

            if (keysPressed.contains(p1SpecialBind) && !p1Action[hit] && p1Stamina >= p1MoveStamina[special]
                    && !p1Action[special]) {
                p1Action[special] = true;
            }

            // p2 movement
            if (keysPressed.contains(p2ForwardBind) && !p2Action[duck] && !p2Action[hit]) { // 39 = ->
                p2Action[forward] = true;
            }
            if (keysPressed.contains(p2BackBind) && !p2Action[duck] && !p2Action[hit]) { // 37 = <-
                p2Action[back] = true;
            }
            if (keysPressed.contains(p2JumpBind) && !p2Action[hit] && !p2Action[jump] && !p2Action[duck]) { // 38 = ↑
                p2Action[jump] = true;
            }
            if (keysPressed.contains(p2PunchBind) && !p2Action[hit]) { // 47 = /
                if (p2Stamina >= p2MoveStamina[punch] && !p2Action[punch] && !p2Action[kick]) {
                    p2Stamina -= p2Action[punch] ? 0 : p2MoveStamina[punch];
                    p2Action[punch] = true;
                }
            }
            if (keysPressed.contains(p2KickBind) && !p2Action[hit]) { // 46 = .
                if (p2Stamina >= p2MoveStamina[kick] && !p2Action[punch] && !p2Action[kick]) {
                    p2Stamina -= p2MoveStamina[kick];
                    p2Action[kick] = true;
                }
            }

            if (keysPressed.contains(p2DuckBind) && !p2Action[duck] && !p2Action[jump] && !p2Action[hit]) {
                p2Action[duck] = true;
                p2PosY += 30;
            }
            if (keysPressed.contains(p2BlockBind) && !p2Action[hit] && p2Stamina >= 30 && !p2Action[knockedOut]
                    && !p2Action[jump]) {
                p2Action[block] = true;
            }
            if (keysPressed.contains(p2SpecialBind) && !p2Action[hit] && p2Stamina >= p2MoveStamina[special]
                    && !p2Action[special]) {
                p2Action[special] = true;
            }

        }

        else if (gameState == 7 || gameState == 8) {
            // if player has won, then it resets differently based on if they hard reset or soft reset
            if (keysPressed.contains(8)) { // 8 = BACKSPACE
                resetSprites("");
                gameState = 0;
                p1Health = 100;
                p2Health = 100;
                p1PosX = 100;
                p2PosX = 700;
                p1PosY = defaultPosY;
                p2PosY = defaultPosY;
                p1Char = "";
                p2Char = "";
                p1Hover = 0;
                p2Hover = 0;
                p1Map = -1;
                p2Map = -1;
                chosenMapNum = -1;
                defaultPosY = -1;
                p1HoverCharMovement = -50;
                p2HoverCharMovement = 495;
                p1CharSwitch = false;
                p2CharSwitch = false;
                p1Score = 0;
                p2Score = 0;
                p1Combo = 0;
                p2Combo = 0;
                startTimer = "3";
            }
            if (keysPressed.contains(10)) { // 13 = ENTER
                gameState = 6;
                p1Health = 100;
                p2Health = 100;
                p1PosX = 100;
                p2PosX = 700;
                p1Score = 0;
                p2Score = 0;
                startTimer = "3";
                p1Combo = 0;
                p2Combo = 0;
                resetSprites("");
            }
        }
        if (gameState == 9) {
            if (keysPressed.contains(8)) {
                gameState = 0;
            }
        }
        repaint();

    }

    public boolean isNewBind(int bind) { // checks if the keybind player is trtying to change to is not already selected
        if (bind != p1ForwardBind && bind != p1BackBind && bind != p1JumpBind && bind != p1DuckBind
                && bind != p1PunchBind && bind != p1KickBind && bind != p1BlockBind && bind != p1SpecialBind &&
                bind != p2ForwardBind && bind != p2BackBind && bind != p2JumpBind && bind != p2DuckBind
                && bind != p2PunchBind && bind != p2KickBind && bind != p2BlockBind && bind != p2SpecialBind)
            return true;
        else
            return false;

    }


    public void keyReleased(KeyEvent e) {
        if (keysPressed.contains(e.getKeyCode())) {
            // certains actions last for an indefinite amount of time so this is needed
            if (gameState == 6) {
                // p1
                if (e.getKeyCode() == 68) { // 68 = d
                    p1Action[forward] = false;
                }
                if (e.getKeyCode() == 65) { // 65 = a
                    p1Action[back] = false;
                }
                if (e.getKeyCode() == p1DuckBind && p1Action[duck] && p1PosY != defaultPosY && !p1Action[jump]) {
                    p1Action[duck] = false;
                    p1PosY -= 30;
                    p1Sprite[duck] = 0;
                }

                if (e.getKeyCode() == p1BlockBind) {
                    p1Action[block] = false;
                }

                // p2
                if (e.getKeyCode() == 39) { // 39 = ->
                    p2Action[forward] = false;
                }

                if (e.getKeyCode() == 37) { // 37 = <-
                    p2Action[back] = false;
                }

                if (e.getKeyCode() == p2DuckBind && p2Action[duck] && p2PosY != defaultPosY && !p2Action[jump]) {
                    p2Action[duck] = false;
                    p2PosY -= 30;
                }
                if (e.getKeyCode() == p2BlockBind) {
                    p2Action[block] = false;
                }

            }
            keysPressed.remove(keysPressed.indexOf(e.getKeyCode()));
        }
        repaint();
    }


    // this method crops image
    public static BufferedImage crop(BufferedImage img) {
        // gets the max and min values for the Integer type
        int minX = Integer.MAX_VALUE;
        int maxX = Integer.MIN_VALUE;
        int minY = Integer.MAX_VALUE;
        int maxY = Integer.MIN_VALUE;
        for (int x = 0; x < img.getWidth(); x++) { // loops throguh each column of pixels
            for (int y = 0; y < img.getHeight(); y++) { // loops through each pixel in the column
                int color = img.getRGB(x, y); // gets the rgb color for the pixel
                int alpha = (color >> 24) & 0xFF; // uses bitwise opertion to get the alpha value which deterimes the transparency
                if (alpha != 0) { // checks if pixel is not transparent
                    // then updates the min/max pixel values if it is required
                    minX = Math.min(x, minX);
                    maxX = Math.max(x, maxX);
                    minY = Math.min(y, minY);
                    maxY = Math.max(y, maxY);
                }
            }
        }
        // by this point I know the minimum and maximum pixel values for the image to crop it

        BufferedImage result = new BufferedImage(maxX - minX, maxY - minY, BufferedImage.TYPE_INT_ARGB); // creates a new bufferedimage with the new dimensons
        for (int x = 0; x < maxX - minX; x++) { // loops through the max-min amount, which is the length required for new image
            for (int y = 0; y < maxY - minY; y++) { // loops through each pixel
                result.setRGB(x, y, img.getRGB(x + minX, y + minY)); // sets the pixel color for that pixel on the new image to match the pre croped image
            }
        }
        return result;
    }


    //checks for collision
    public static String checkForCollisions(String playerToCheck, String move) {
        // getting points for both characters
        int p1Right = p1PosX + p1CurrentMovement.getWidth();
        int p1Top = p1PosY;
        int p1Bottom = p1PosY + p1CurrentMovement.getHeight();
        int[] p1TopLeft = { p1PosX, p1PosY };
        int[] p1TopRight = { p1PosX + p1CurrentMovement.getWidth(), p1PosY };
        int[] p1BottomLeft = { p1PosX, p1PosY + p1CurrentMovement.getHeight() };
        int[] p1BottomRight = { p1PosX + p1CurrentMovement.getWidth(), p1PosY + p1CurrentMovement.getHeight() };

        int p2Left = p2PosX;
        int p2Right = p2PosX + (p2CurrentMovement.getWidth() == 199 ? 70 : p2CurrentMovement.getWidth());

        int p2Top = p2PosY;
        int p2Bottom = p2PosY + p2CurrentMovement.getHeight();
        int[] p2TopLeft = { p2PosX, p2PosY };
        int[] p2BottomLeft = { p2PosX, p2PosY + p2CurrentMovement.getHeight() };
        // checks for the collisions
        if (playerToCheck.equals("p1")) {
            if (p2Action[block])
                return "";

            else if (move.equals("high") && p1Char.equals("Ryu")) {
                if (p1Right >= p2Left && p1Top >= p2Top) {
                    return "Collision";
                }

            }
            if (move.equals("high")) {
                if (p1Right >= p2Left && p1Top + (p1CurrentMovement.getHeight() / 2) >= p2Top) {
                    return "Collision";
                }
            }

            else if (move.equals("low")) {
                if (p1Right >= p2Left && p1Top + (p1CurrentMovement.getHeight() / 2) <= p2Bottom) {
                    return "Collision";
                }
            }

            else if (move.equals("attack")) {
                if (p1TopRight[0] >= p2TopLeft[0] || p1BottomRight[0] >= p2BottomLeft[0]) {
                    return "Collision";
                }
            }

            else if (move.equals("RetsuSpecial")) {
                if (p1Right + 100 > p2Left && p1Right + 100 <= p2Left + p2CurrentMovement.getWidth()) {
                    return "Collision";
                }
            }

            else if (move.equals("ryuSpecial")) {
                if (p1RyuProjectileX + p1RyuSpecial.getWidth() > p2Left
                        && p1RyuProjectileX + p1RyuSpecial.getWidth() < p2Right
                        && p2PosY >= defaultPosY - p1RyuSpecial.getHeight() && p2PosY <= defaultPosY) {
                    return "Collision";
                }
            }

            else {
                // all p1 false cases
                if (p1TopLeft[0] < 0 || p1BottomLeft[0] < 0) {
                    return "Out of bounds";
                }
                if (p1TopRight[0] >= p2TopLeft[0] || p1BottomRight[0] >= p2BottomLeft[0]) {
                    return "Collision";
                }
                return "";
            }

        } else {
            if (p1Action[block])
                return "";
            if (move.equals("high")) {
                if (p2Left <= p1Right && p2Top + (p2CurrentMovement.getHeight() / 2) >= p1Top) {
                    return "Collision";
                }
            } else if (move.equals("low")) {
                if (p2Left <= p1Right && p2Top + (p2CurrentMovement.getHeight() / 2) <= p1Bottom) {
                    return "Collision";
                }
            }

            else if (move.equals("attack")) {
                if (p2TopLeft[0] <= p1TopRight[0] || p2BottomLeft[0] <= p1BottomRight[0]) {
                    return "Collision";
                }
            }

            else if (move.equals("RetsuSpecial")) {
                int clonePositionX = p2Left - 100 - p2CurrentMovement.getWidth() > 0 ? 100
                        : p2CurrentMovement.getWidth();
                if (p2Left - clonePositionX < p1Right
                        && p2Left - clonePositionX >= p1Right - p1CurrentMovement.getWidth()) {
                    return "Collision";
                }
            }

            else if (move.equals("ryuSpecial")) {
                if (p2RyuProjectileX < p1Right && p2RyuProjectileX > p1PosX
                        && p1PosY >= defaultPosY - p2RyuSpecial.getHeight() && p1PosY <= defaultPosY) {
                    return "Collision";
                }
            }

            else {
                if (p2Right > 800) {
                    return "Out of bounds";
                }

                if (p2TopLeft[0] <= p1TopRight[0] || p2BottomLeft[0] <= p1BottomRight[0]) {
                    return "Collision";
                }
                return "";
            }

        }
        return "";
    }

    public void run() {
        while (true) {
            repaint();
            try {
                Thread.sleep(20);
            } catch (Exception e) {
            }
        }
    }

    // this method I just used to make my life easier that centers the text
    public void centerString(Graphics2D g2d, String str, String type) {
        FontMetrics fm = g2d.getFontMetrics();
        int x = ((getWidth() - fm.stringWidth(str)) / 2);
        int y = ((getHeight() - fm.getHeight()) / 2) + fm.getAscent();

        if (type.charAt(0) == 'B') { // if it is both, then it fully centers it
            g2d.drawString(str, x, y);
        } else if (type.charAt(0) == 'H') { // if it is horizontal only, it centers horizontally
            g2d.drawString(str, x, Integer.parseInt(type.substring(1)));
        } else { // last case scenario is only vertical center
            g2d.drawString(str, Integer.parseInt(type.substring(1)), y);
        }

    }


    // resets everything
    public void reset(String winner) {
        p1Health = 100;
        p2Health = 100;
        resetSprites("");
        p1PosX = 100;
        p1PosY = defaultPosY;
        p2PosX = 700;
        p2PosY = defaultPosY;
        gameState = 6;
        p1Combo = 0;
        p2Combo = 0;
        startTimer = "3";
        if (winner.equals("p1")) {
            p1Score++;
        }
        if (winner.equals("p2")) {
            p2Score++;
        }
    }

    // resets all sprites
    public static void resetSprites(String whos) {
        for (int i = 0; i < p1Sprite.length; i++) {
            p1Sprite[i] = 0;
            p2Sprite[i] = 0;
            p1Action[i] = false;
            p2Action[i] = false;
        }

    }

    // this method throws the Ryu special once ryu has finished the animation. If player collides they get hit. if it goes past the map, it disappears
    public void throwRyuSpecial(Graphics g, String player) {
        if (player.equals("p1")) {
            if (p1RyuProjectileX == p1PosX) {
                p1Stamina -= p1MoveStamina[special];
            }
            g.drawImage(p1RyuSpecial, p1RyuProjectileX, defaultPosY, null);
            if (frameController % 5 == 0) {
                p1RyuProjectileX += 25;
            }
            if (checkForCollisions("p1", "ryuSpecial").equals("Collision")) {
                p2Health = p2Health - p1SpecialDamage < 0 ? 0 : p2Health - p1SpecialDamage;
                p2Action[hit] = true;
                p1Combo++;
                p2Combo = 0;
                isp1RyuThrowSpecial = false;
            }

            if (p1RyuProjectileX >= 800) {
                isp1RyuThrowSpecial = false;
            }
        } else {
            if (p2RyuProjectileX == p2PosX) {
                p2Stamina -= p2MoveStamina[special];
            }
            g.drawImage(p2RyuSpecial, p2RyuProjectileX, defaultPosY, null);
            if (frameController % 5 == 0) {
                p2RyuProjectileX -= 25;
            }
            if (checkForCollisions("p2", "ryuSpecial").equals("Collision")) {
                p1Health = p1Health - p2SpecialDamage < 0 ? 0 : p1Health - p2SpecialDamage;
                p1Action[hit] = true;
                p2Combo++;
                p1Combo = 0;
                isp2RyuThrowSpecial = false;
            }

            if (p2RyuProjectileX <= 0) {
                isp2RyuThrowSpecial = false;
            }
        }
    }


    // loads all the sprites once the characters have been selected
    public void loadSprites() {
        try {
            BufferedImage[] p1Character = new BufferedImage[totalMoves];
            BufferedImage[] p2Character = new BufferedImage[totalMoves];

            if (p1Char.equals("Retsu"))
                p1Character = p1Retsu;
            if (p2Char.equals("Retsu"))
                p2Character = p2Retsu;

            if (p1Char.equals("Ryu"))
                p1Character = p1Ryu;
            if (p2Char.equals("Ryu"))
                p2Character = p2Ryu;

            for (int i = 0; i < totalMoves; i++) {
                p1[i] = new BufferedImage[p1Character[i].getWidth() / 200];
                for (int x = 0; x < p1[i].length; x++) {
                    p1[i][x] = p1Character[i];
                    p1Sprite[i] = x % p1[i].length;
                    p1[i][x] = grabImage(p1[i][x], p1Sprite[i]);
                    p1Sprite[i] = 0;
                    p1[i][x] = crop(p1[i][x]);
                }
            }
            for (int i = 0; i < totalMoves; i++) {
                p2[i] = new BufferedImage[p2Character[i].getWidth() / 200];
                for (int x = 0; x < p2[i].length; x++) {
                    p2[i][x] = p2Character[i];
                    p2Sprite[i] = x % p2[i].length;
                    p2[i][x] = grabImage(p2[i][x], p2Sprite[i]);
                    p2Sprite[i] = 0;
                    p2[i][x] = crop(p2[i][x]);
                }
            }
        } catch (Exception e) {
            System.out.println("something wrong");
        }

        if (p1Char.equals("Retsu")) {
            p1MoveLength[forward] = 3;
            p1MoveLength[back] = 3;
            p1MoveLength[punch] = 10;
            p1MoveLength[kick] = 10;
            p1MoveLength[jump] = 7;
            p1MoveLength[duckBlock] = 48;
            p1MoveLength[duckPunch] = 10;
            p1MoveLength[duckKick] = 10;
            p1MoveLength[duck] = 48;
            p1MoveLength[knocked] = 15;
            p1MoveLength[hit] = 5;
            p1MoveLength[duckHit] = 5;
            p1MoveLength[special] = 20;
            p1MoveLength[knockedOut] = 10;
            p1MoveLength[idle] = 8;
            p1JumpX = 20;
            p1JumpY = 60;

            p1MoveStamina[punch] = 10;
            p1MoveStamina[kick] = 20;
            p1MoveStamina[jumpKick] = 30;
            p1MoveStamina[jumpPunch] = 15;
            p1MoveStamina[special] = 30;
        }
        if (p2Char.equals("Retsu")) {
            p2MoveLength[forward] = 3;
            p2MoveLength[back] = 3;
            p2MoveLength[punch] = 10;
            p2MoveLength[kick] = 10;
            p2MoveLength[jump] = 7;
            p2MoveLength[duckBlock] = 48;
            p2MoveLength[duckPunch] = 10;
            p2MoveLength[duckKick] = 10;
            p2MoveLength[duck] = 48;
            p2MoveLength[knocked] = 15;
            p2MoveLength[hit] = 5;
            p2MoveLength[duckHit] = 5;
            p2MoveLength[special] = 10;
            p2MoveLength[knockedOut] = 10;
            p2MoveLength[idle] = 8;
            p2JumpX = 20;
            p2JumpY = 60;

            p1MoveStamina[punch] = 10;
            p1MoveStamina[kick] = 20;
            p1MoveStamina[jumpKick] = 30;
            p1MoveStamina[jumpPunch] = 15;
            p1MoveStamina[special] = 30;
        }

        if (p1Char.equals("Ryu")) {
            p1MoveLength[forward] = 3; // work
            p1MoveLength[back] = 3; // work
            p1MoveLength[punch] = 10; // work
            p1MoveLength[kick] = 10; // sprite mis alligned (FIXED)
            p1MoveLength[jump] = 7; // goes too down (FIXED)
            p1MoveLength[duckBlock] = 48; // goes further down on the block (FIXED)
            p1MoveLength[duckPunch] = 10; // work
            p1MoveLength[duckKick] = 10; // work
            p1MoveLength[duck] = 48; // work
            p1MoveLength[knocked] = 8; // messed up
            p1MoveLength[hit] = 5; // work
            p1MoveLength[duckHit] = 5;
            p1MoveLength[special] = 10;
            p1MoveLength[knockedOut] = 10; // messed
            p1MoveLength[idle] = 8; // work
            p1JumpX = 20;
            p1JumpY = 60;

            p1MoveStamina[punch] = 10;
            p1MoveStamina[kick] = 20;
            p1MoveStamina[jumpKick] = 30;
            p1MoveStamina[jumpPunch] = 15;
            p1MoveStamina[special] = 30;
        }

        if (p2Char.equals("Ryu")) {
            p2MoveLength[forward] = 3; // work
            p2MoveLength[back] = 3; // work
            p2MoveLength[punch] = 10; // work
            p2MoveLength[kick] = 10; // sprite mis alligned (FIXED)
            p2MoveLength[jump] = 7; // goes too down (FIXED)
            p2MoveLength[duckBlock] = 48; // goes further down on the block (FIXED)
            p2MoveLength[duckPunch] = 10; // work
            p2MoveLength[duckKick] = 10; // work
            p2MoveLength[duck] = 48; // work
            p2MoveLength[knocked] = 8; // messed up
            p2MoveLength[hit] = 5; // work
            p2MoveLength[duckHit] = 5;
            p2MoveLength[special] = 10;
            p2MoveLength[knockedOut] = 10; // messed
            p2MoveLength[idle] = 8; // work
            p2JumpX = 20;
            p2JumpY = 60;

            p1MoveStamina[punch] = 10;
            p1MoveStamina[kick] = 20;
            p1MoveStamina[jumpKick] = 30;
            p1MoveStamina[jumpPunch] = 15;
            p1MoveStamina[special] = 30;
        }
    }

    public static void updateBinds() throws IOException {
        p1BindFileOutputing = new PrintWriter(new FileWriter("keybinds/p1Keybinds.txt"));
        p2BindFileOutputing = new PrintWriter(new FileWriter("keybinds/p2Keybinds.txt"));

        p1BindFileOutputing.println(p1ForwardBind);
        p1BindFileOutputing.println(p1JumpBind);
        p1BindFileOutputing.println(p1BackBind);
        p1BindFileOutputing.println(p1DuckBind);
        p1BindFileOutputing.println(p1PunchBind);
        p1BindFileOutputing.println(p1SpecialBind);
        p1BindFileOutputing.println(p1KickBind);
        p1BindFileOutputing.println(p1BlockBind);

        p2BindFileOutputing.println(p2ForwardBind);
        p2BindFileOutputing.println(p2JumpBind);
        p2BindFileOutputing.println(p2BackBind);
        p2BindFileOutputing.println(p2DuckBind);
        p2BindFileOutputing.println(p2PunchBind);
        p2BindFileOutputing.println(p2SpecialBind);
        p2BindFileOutputing.println(p2KickBind);
        p2BindFileOutputing.println(p2BlockBind);

        p1BindFileOutputing.close();
        p2BindFileOutputing.close();

    }


    public static void toggleMusic() {
        if (gameMusic) {
            musicAudio.loop();
        } else {
            musicAudio.stop();
        }
    }
}