diff --git a/src/BackgroundImage.java b/src/BackgroundImage.java
index 6dd1a73..9e64047 100644
--- a/src/BackgroundImage.java
+++ b/src/BackgroundImage.java
@@ -2,15 +2,16 @@
 import javax.swing.*;
 import java.awt.*;
 import java.awt.image.BufferedImage;
+import java.io.Serializable;
 
-public class BackgroundImage {
+public class BackgroundImage implements Serializable {
     public int x, y;
     public int width, height;
     public int parallaxRatio;
-    public BufferedImage backgroundImage;
+    public BufferedImageWrapper backgroundImage;
     public Camera camera;
 
-    public BackgroundImage(int x, int y, BufferedImage backgroundImage, int width, int height, int parallaxRatio, Camera camera) {
+    public BackgroundImage(int x, int y, BufferedImageWrapper backgroundImage, int width, int height, int parallaxRatio, Camera camera) {
         this.x = x;
         this.y = y;
         this.width = width;
@@ -22,8 +23,8 @@ public class BackgroundImage {
         this.camera = camera;
     }
     public void draw(Graphics g){
-        g.drawImage(backgroundImage, x-camera.x/parallaxRatio % width, y, width, height, null);
+        g.drawImage(backgroundImage.image, x-camera.x/parallaxRatio % width, y, width, height, null);
         // added to prevent the background image from disappearing
-        g.drawImage(backgroundImage, x-camera.x/parallaxRatio % width + width - 1, y, width, height, null);
+        g.drawImage(backgroundImage.image, x-camera.x/parallaxRatio % width + width - 1, y, width, height, null);
     }
 }
diff --git a/src/BombDirectionShow.java b/src/BombDirectionShow.java
index c243be3..568de43 100644
--- a/src/BombDirectionShow.java
+++ b/src/BombDirectionShow.java
@@ -1,7 +1,8 @@
 import java.awt.*;
 import java.awt.image.BufferedImage;
+import java.io.Serializable;
 
-public class BombDirectionShow extends StickyBomb{
+public class BombDirectionShow extends StickyBomb implements Serializable {
     public BombDirectionShow(int x, int y, int xVelocity, int yVelocity) {
         super(x, y, xVelocity, yVelocity, null, null);
         WIDTH = 25;
@@ -15,7 +16,7 @@ public class BombDirectionShow extends StickyBomb{
         while(isMove&&loopCounter<10) {
             super.move();
             if(isMove&&canUpdate(0,0)) {
-                g.drawRect(x - GamePanel.camera.x + Player.PLAYER_WIDTH / 2, y + Player.PLAYER_HEIGHT / 2, 2, 2);
+                g.drawRect(x - GameFrame.game.camera.x + Player.PLAYER_WIDTH / 2, y + Player.PLAYER_HEIGHT / 2, 2, 2);
             }
             loopCounter++;
         }
diff --git a/src/BufferedImage.java b/src/BufferedImage.java
deleted file mode 100644
index 7023972..0000000
--- a/src/BufferedImage.java
+++ /dev/null
@@ -1,40 +0,0 @@
-import javax.imageio.ImageIO;
-import java.awt.image.ColorModel;
-import java.awt.image.IndexColorModel;
-import java.awt.image.WritableRaster;
-import java.io.*;
-import java.util.Hashtable;
-
-public class BufferedImage extends java.awt.image.BufferedImage implements Serializable {
-
-    public BufferedImage(int width, int height, int imageType) {
-        super(width, height, imageType);
-    }
-
-    public BufferedImage(int width, int height, int imageType, IndexColorModel cm) {
-        super(width, height, imageType, cm);
-    }
-
-    public BufferedImage(ColorModel cm, WritableRaster raster, boolean isRasterPremultiplied, Hashtable<?, ?> properties) {
-        super(cm, raster, isRasterPremultiplied, properties);
-    }
-
-    @Serial
-    private void writeObject(ObjectOutputStream out) throws IOException {
-        ImageIO.write(this, "png", out); // png is lossless
-    }
-
-    @Serial
-    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
-        java.awt.image.BufferedImage temporaryImage = ImageIO.read(in);
-        ColorModel cm = temporaryImage.getColorModel();
-        boolean isAlphaPremultiplied = cm.isAlphaPremultiplied();
-        WritableRaster raster = temporaryImage.copyData(null);
-        // TODO: make work
-        setState(this, new BufferedImage(cm, raster, isAlphaPremultiplied, null));
-    }
-
-    private void setState(BufferedImage currentImage, BufferedImage newImage) {
-        currentImage = newImage;
-    }
-}
diff --git a/src/BufferedImageWrapper.java b/src/BufferedImageWrapper.java
new file mode 100644
index 0000000..955e3d6
--- /dev/null
+++ b/src/BufferedImageWrapper.java
@@ -0,0 +1,38 @@
+import javax.imageio.ImageIO;
+import java.awt.image.BufferedImage;
+import java.awt.image.ColorModel;
+import java.awt.image.IndexColorModel;
+import java.awt.image.WritableRaster;
+import java.io.*;
+import java.util.Hashtable;
+
+public class BufferedImageWrapper implements Serializable {
+    public BufferedImage image;
+    public BufferedImageWrapper(int width, int height, int imageType) {
+        image = new BufferedImage(width, height, imageType);
+    }
+
+    public BufferedImageWrapper(int width, int height, int imageType, IndexColorModel cm) {
+        image = new BufferedImage(width, height, imageType, cm);
+    }
+
+    public BufferedImageWrapper(ColorModel cm, WritableRaster raster, boolean isRasterPremultiplied, Hashtable<?, ?> properties) {
+        image = new BufferedImage(cm, raster, isRasterPremultiplied, properties);
+    }
+
+    public BufferedImageWrapper(BufferedImage image) {
+        this.image = image;
+    }
+
+    public BufferedImageWrapper() {}
+
+    @Serial
+    private void writeObject(ObjectOutputStream out) throws IOException {
+        ImageIO.write(image, "png", out); // png is lossless
+    }
+
+    @Serial
+    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+        image = ImageIO.read(in);
+    }
+}
diff --git a/src/FileManager.java b/src/FileManager.java
index 1a72371..36afdd5 100644
--- a/src/FileManager.java
+++ b/src/FileManager.java
@@ -27,8 +27,13 @@ public class FileManager {
     }
 
     public static Object readObjectFromFile(String fileLocation, List<String> allowedObject) throws IOException, ClassNotFoundException {
+        ObjectInputStream objectStream;
         FileInputStream fileStream = new FileInputStream(fileLocation);
-        SafeObjectInputStream objectStream = new SafeObjectInputStream(fileStream, allowedObject);
+        if (!allowedObject.contains("Any")) {
+            objectStream = new SafeObjectInputStream(fileStream, allowedObject);
+        } else {
+            objectStream = new ObjectInputStream(fileStream);
+        }
         return objectStream.readObject();
     }
 
diff --git a/src/GameFrame.java b/src/GameFrame.java
index edb1c18..523b1e2 100644
--- a/src/GameFrame.java
+++ b/src/GameFrame.java
@@ -16,28 +16,34 @@ import javax.swing.*;
 public class GameFrame extends JFrame{
 
   MenuPanel menu;
-  GamePanel game;
+  public static GamePanel game;
   SettingPanel settings;
   CameraPanel main;
 
   public GameFrame(){
-    try {
-      // read previously saved controls
-      // SafeObjectInputStream was implemented to prevent arbitrary code execution from occurring if the save files were modified
-      GamePanel.middlewareArray = (ArrayList<Middleware>)FileManager.
-              readObjectFromFile("local/controls", Arrays.asList("java.util.ArrayList", "Middleware"));
-    } catch (IOException | ClassNotFoundException | ClassCastException | SecurityException e) {
-      GamePanel.middlewareArray = new ArrayList<Middleware>();
-    }
     try {
       main = new CameraPanel();
       main.setLayout(new CardLayout());
       menu = new MenuPanel(main);
       try {
-        game = (GamePanel)FileManager.readObjectFromFile("local/game_state", Collections.singletonList("GamePanel"));
+        game = (GamePanel)FileManager.readObjectFromFile("local/game_state", Arrays.asList("Any"));
+        game.gameFrame = main;
+        game.startThread();
       } catch (IOException | ClassNotFoundException | ClassCastException | SecurityException e) {
+        System.out.println(e);
         game = new GamePanel(main); //run GamePanel constructor
+        game.startThread();
       }
+      /*
+      try {
+        // read previously saved controls
+        // SafeObjectInputStream was implemented to prevent arbitrary code execution from occurring if the save files were modified
+        game.middlewareArray = (ArrayList<Middleware>)FileManager.
+                readObjectFromFile("local/controls", Arrays.asList("java.util.ArrayList", "Middleware"));
+      } catch (IOException | ClassNotFoundException | ClassCastException | SecurityException e) {
+        game.middlewareArray = new ArrayList<Middleware>();
+      }
+      */
       settings = new SettingPanel(main);
       main.add(menu, "menu");
       main.add(settings, "settings");
@@ -45,6 +51,7 @@ public class GameFrame extends JFrame{
     } catch (IOException | SpriteException | UnsupportedAudioFileException | LineUnavailableException e) {
       // TODO: handle IO errors gracefully
       // exceptions are raised when tiles are not found or are of incorrect dimensions
+      throw new RuntimeException(e);
     }
     this.add(main);
     this.setTitle("GUI is cool!"); //set title for frame
diff --git a/src/GamePanel.java b/src/GamePanel.java
index 97855ba..4f8214e 100644
--- a/src/GamePanel.java
+++ b/src/GamePanel.java
@@ -25,12 +25,12 @@ public class GamePanel extends JPanel implements Runnable, KeyListener, Serializ
   public static final int GAME_WIDTH = 1225;
   public static final int GAME_HEIGHT = 630;
 
-  public JPanel gameFrame;
+  public transient JPanel gameFrame;
 
-  public Thread gameThread;
-  public Image image;
-  public Graphics graphics;
-  public static Player player;
+  public transient Thread gameThread;
+  public transient Image image;
+  public transient Graphics graphics;
+  public Player player;
   public BackgroundImage background;
   public int playerFrame, enemyFrame;
   // keeps track of how many ticks has elapsed since last frame change
@@ -40,35 +40,27 @@ public class GamePanel extends JPanel implements Runnable, KeyListener, Serializ
   public PauseMenu pauseMenu;
 
 
-  public static BufferedImage[][][] playerSpriteArray = new BufferedImage[2][2][11];
-  public static BufferedImage[][][] slimeSpriteArray = new BufferedImage[2][2][3];
-  public static BufferedImage[] explosionArray = new BufferedImage[9];
+  public BufferedImageWrapper[][][] playerSpriteArray = new BufferedImageWrapper[2][2][11];
+  public BufferedImageWrapper[][][] slimeSpriteArray = new BufferedImageWrapper[2][2][3];
+  public BufferedImageWrapper[] explosionArray = new BufferedImageWrapper[9];
 
   //public static ArrayList<Tile>map = new ArrayList<Tile>();
 
-  public static Tile[][]map = new Tile[300][18];
-  public static ArrayList<Middleware> middlewareArray = new ArrayList<Middleware>();
+  public Tile[][]map = new Tile[300][18];
+  public ArrayList<Middleware> middlewareArray = new ArrayList<Middleware>();
 
-  public static ArrayList<Tile>particleTiles = new ArrayList<Tile>();
-  public static ArrayList<NonPlayer>enemy = new ArrayList<NonPlayer>();
-  public static ArrayList<StickyBomb>bombs = new ArrayList<>();
+  public ArrayList<Tile>particleTiles = new ArrayList<Tile>();
+  public ArrayList<NonPlayer>enemy = new ArrayList<NonPlayer>();
+  public ArrayList<StickyBomb>bombs = new ArrayList<>();
   public BombDirectionShow bombDir = null;
-  public static ArrayList<Particle>particles = new ArrayList<Particle>();
-  public static Camera camera;
+  public ArrayList<Particle>particles = new ArrayList<Particle>();
+  public Camera camera;
 
   // image imports begin here
-  public BufferedImage backgroundImage = getImage("img/backgrounds/pointyMountains.png");
-  public BufferedImage box = getImage("img/tiles/boxes/box.png");
-  public BufferedImage boxCoin = getImage("img/tiles/boxes/boxCoin.png");
-  public static BufferedImage bomb;
-
-  static {
-    try {
-      bomb = getImage("img/misc/bomb.png");
-    } catch (IOException e) {
-      throw new RuntimeException(e);
-    }
-  }
+  public BufferedImageWrapper backgroundImage = new BufferedImageWrapper(getImage("img/backgrounds/pointyMountains.png"));
+  public BufferedImageWrapper box = new BufferedImageWrapper(getImage("img/tiles/boxes/box.png"));
+  public BufferedImageWrapper boxCoin = new BufferedImageWrapper(getImage("img/tiles/boxes/boxCoin.png"));
+  public BufferedImageWrapper bomb;
 
 
   public GamePanel(JPanel gameFrame) throws IOException, SpriteException, UnsupportedAudioFileException, LineUnavailableException {
@@ -81,31 +73,34 @@ public class GamePanel extends JPanel implements Runnable, KeyListener, Serializ
       for (int i = 0; i < 11; i++) {
         BufferedImage sprite = getImage(String.format("img/walk/p1_walk%s.png", String.format("%1$2s", i+1).replace(' ', '0')));
 
-        playerSpriteArray[1][0][i] = sprite;
-        playerSpriteArray[1][1][i] = sprite;
-        playerSpriteArray[0][0][i] = flipImageHorizontally(sprite);
-        playerSpriteArray[0][1][i] = flipImageHorizontally(sprite);
+        playerSpriteArray[1][0][i] = new BufferedImageWrapper(sprite);
+        playerSpriteArray[1][1][i] = new BufferedImageWrapper(sprite);
+        playerSpriteArray[0][0][i] = new BufferedImageWrapper(flipImageHorizontally(sprite));
+        playerSpriteArray[0][1][i] = new BufferedImageWrapper(flipImageHorizontally(sprite));
       }
       for (int i = 0; i < 9; i++) {
-        explosionArray[i] = getImage("img/misc/bomb/sonicExplosion0" + i + ".png");
+        explosionArray[i] = new BufferedImageWrapper(getImage("img/misc/bomb/sonicExplosion0" + i + ".png"));
       }
       // load slime sprites from disk here
       // these variables were not defined above because they are temporary variables
-      BufferedImage[] temporarySlimeArray = {getImage("img/enemy/slime/slimeWalk1.png"),
-              getImage("img/enemy/slime/slimeWalk2.png"),
-              getImage("img/enemy/slime/slimeDead.png")};
-      BufferedImage[] flippedTemporarySlimeArray = {flipImageHorizontally(getImage("img/enemy/slime/slimeWalk1.png")),
-              flipImageHorizontally(getImage("img/enemy/slime/slimeWalk2.png")),
-              flipImageHorizontally(getImage("img/enemy/slime/slimeDead.png"))};
+      BufferedImageWrapper[] temporarySlimeArray = {new BufferedImageWrapper(getImage("img/enemy/slime/slimeWalk1.png")),
+              new BufferedImageWrapper(getImage("img/enemy/slime/slimeWalk2.png")),
+                      new BufferedImageWrapper(getImage("img/enemy/slime/slimeDead.png"))};
+      BufferedImageWrapper[] flippedTemporarySlimeArray = {new BufferedImageWrapper(flipImageHorizontally(getImage("img/enemy/slime/slimeWalk1.png"))),
+              new BufferedImageWrapper(flipImageHorizontally(getImage("img/enemy/slime/slimeWalk2.png"))),
+                      new BufferedImageWrapper(flipImageHorizontally(getImage("img/enemy/slime/slimeDead.png")))};
       // please note that these sprites are reversed compared to the player sprites
       slimeSpriteArray[0][0] = temporarySlimeArray;
       slimeSpriteArray[0][1] = temporarySlimeArray;
       slimeSpriteArray[1][0] = flippedTemporarySlimeArray;
       slimeSpriteArray[1][1] = flippedTemporarySlimeArray;
+
+      // load bomb sprites
+      bomb = new BufferedImageWrapper(getImage("img/misc/bomb.png"));
     } catch (IOException e) {
       e.printStackTrace();
     }
-    player = new Player(GAME_WIDTH/2, GAME_HEIGHT/2, 'W', 'A', 'S', 'D', playerSpriteArray); //create a player controlled player, set start location to middle of screenk
+    player = new Player(GAME_WIDTH/2, GAME_HEIGHT/2, playerSpriteArray); //create a player controlled player, set start location to middle of screenk
     // the height of 35 is set because it is half of the original tile height (i.e., 70px)
     this.setFocusable(true); //make everything in this class appear on the screen
     this.addKeyListener(this); //start listening for keyboard input
@@ -124,9 +119,7 @@ public class GamePanel extends JPanel implements Runnable, KeyListener, Serializ
 			public void mousePressed(MouseEvent e) {
               try {
                 player.mousePressed(e);
-              } catch (SpriteException ex) {
-                throw new RuntimeException(ex);
-              } catch (IOException ex) {
+              } catch (SpriteException | IOException ex) {
                 throw new RuntimeException(ex);
               }
             }
@@ -146,12 +139,14 @@ public class GamePanel extends JPanel implements Runnable, KeyListener, Serializ
       }
     });
     this.setPreferredSize(new Dimension(GAME_WIDTH, GAME_HEIGHT));
+  }
 
-
-
+  // startThread is to be called after the game has started to avoid any issues TODO: better explanation
+  public void startThread() {
     //make this class run at the same time as other classes (without this each class would "pause" while another class runs). By using threading we can remove lag, and also allows us to do features like display timers in real time!
     gameThread = new Thread(this);
     gameThread.start();
+    System.out.println(gameFrame);
   }
 
   //paint is a method in java.awt library that we are overriding. It is a special method - it is called automatically in the background in order to update what appears in the window. You NEVER call paint() yourself
@@ -179,7 +174,7 @@ public class GamePanel extends JPanel implements Runnable, KeyListener, Serializ
       g2d.setPaint(Color.white);
     }
     //Don't want to draw off screen items
-    int xMin = Math.max(0,((GamePanel.camera.x+GAME_WIDTH)/Tile.length)-(GAME_WIDTH/(2*Tile.length))-5);
+    int xMin = Math.max(0,((this.camera.x+GAME_WIDTH)/Tile.length)-(GAME_WIDTH/(2*Tile.length))-5);
     int xMax = Math.min(map.length, 7+xMin + GAME_WIDTH/Tile.length);
     for(int i=xMin; i<xMax; i++){
       for(int j=0; j<map[0].length; j++){
@@ -212,8 +207,8 @@ public class GamePanel extends JPanel implements Runnable, KeyListener, Serializ
     }
     if(player.leftMouseDown){
 
-      bombDir = new BombDirectionShow(GamePanel.player.x + GamePanel.camera.x + WIDTH/2, GamePanel.player.y+HEIGHT/2,
-              (player.mouseX - GamePanel.player.x) / 20, (player.mouseY - GamePanel.player.y) / 10);
+      bombDir = new BombDirectionShow(this.player.x + this.camera.x + WIDTH/2, this.player.y+HEIGHT/2,
+              (player.mouseX - this.player.x) / 20, (player.mouseY - this.player.y) / 10);
       bombDir.draw(g);
     }
 
@@ -231,7 +226,7 @@ public class GamePanel extends JPanel implements Runnable, KeyListener, Serializ
 
 //   g.drawString(camera.x+" "+((camera.x+GAME_WIDTH)/Tile.length)+" "+player.leftMouseDown,100,100);
 //    g.drawString(camera.x+" "+((player.mouseX+camera.x+GAME_WIDTH/2)/Tile.length)+" "+player.leftMouseDown,100,200);
-    g.drawImage(bomb,20,20,35,35,null);
+    g.drawImage(bomb.image,20,20,35,35,null);
     g.drawString("X"+LevelManager.bombs,60,40);
     if (isPaused) {
       g.setColor(new Color(255, 255, 255, 100));
diff --git a/src/GenericSprite.java b/src/GenericSprite.java
index 03d40d4..eaa40ef 100644
--- a/src/GenericSprite.java
+++ b/src/GenericSprite.java
@@ -7,8 +7,9 @@ In 2D GUI, basically everything is a rectangle even if it doesn't look like it!
 import java.awt.*;
 import java.awt.event.*;
 import java.io.IOException;
+import java.io.Serializable;
 
-public class GenericSprite extends Rectangle{
+public class GenericSprite extends Rectangle implements Serializable {
 
   public double yVelocity;
   public double xVelocity;
@@ -87,14 +88,14 @@ public class GenericSprite extends Rectangle{
   public boolean canUpdate(double x, double y){
     boolean canUpdate = true;
     int lowX = Math.max(0, (this.x+GamePanel.GAME_WIDTH/2)/Tile.length-4);
-    int highX = Math.min(lowX + 8, GamePanel.map.length);
+    int highX = Math.min(lowX + 8, GameFrame.game.map.length);
     int lowY = Math.max(0,(this.y/Tile.length)-6);
-    int highY = Math.min(lowY + 12, GamePanel.map[0].length);
+    int highY = Math.min(lowY + 12, GameFrame.game.map[0].length);
     for(int i=lowX; i<highX; i++) {
       for (int j = lowY; j < highY; j++) {
-        if (GamePanel.map[i][j] != null) {
-          if (collide(GamePanel.map[i][j], this.x + x, this.y + y)) {
-            if (GamePanel.map[i][j].isFinish&&isPlayer) {
+        if (GameFrame.game.map[i][j] != null) {
+          if (collide(GameFrame.game.map[i][j], this.x + x, this.y + y)) {
+            if (GameFrame.game.map[i][j].isFinish&&isPlayer) {
               LevelManager.nextLevel();
               return true;
             }
diff --git a/src/GlobalState.java b/src/GlobalState.java
index ccb4148..6134f76 100644
--- a/src/GlobalState.java
+++ b/src/GlobalState.java
@@ -1,4 +1,6 @@
-public class GlobalState {
+import java.io.Serializable;
+
+public class GlobalState implements Serializable {
     public static final int second = 10;
     public static int randInt(int low, int high){
         return (int)(Math.random()*(high-low+1))+low;
diff --git a/src/LevelManager.java b/src/LevelManager.java
index b31c6dc..5b00928 100644
--- a/src/LevelManager.java
+++ b/src/LevelManager.java
@@ -1,8 +1,9 @@
 import javax.sound.sampled.LineUnavailableException;
 import javax.sound.sampled.UnsupportedAudioFileException;
 import java.io.IOException;
+import java.io.Serializable;
 
-public class LevelManager {
+public class LevelManager implements Serializable {
     public static int level = 1;
     public static int xSpawn = 0;
     public static int ySpawn = 600;
@@ -11,8 +12,8 @@ public class LevelManager {
 
     public static int bombs;
     public static void setLevel(int level){
-        GamePanel.player.yVelocity = 0;
-        GamePanel.player.xVelocity = 0;
+        GameFrame.game.player.yVelocity = 0;
+        GameFrame.game.player.xVelocity = 0;
         LevelManager.level = level;
         if(level == 1){
             xSpawn = 0;
diff --git a/src/MapReader.java b/src/MapReader.java
index 6cfa628..f46fa8e 100644
--- a/src/MapReader.java
+++ b/src/MapReader.java
@@ -3,7 +3,7 @@ import javax.sound.sampled.UnsupportedAudioFileException;
 import java.io.*;
 import java.util.Arrays;
 
-public class MapReader {
+public class MapReader implements Serializable {
     public static int x = 0;
     public static int y = 0;
     public static int TileX = 0;
@@ -26,10 +26,10 @@ public class MapReader {
     public static void inputMap(String filePath) throws IOException, SpriteException, UnsupportedAudioFileException, LineUnavailableException {
         x = 0;
         y = 0;
-      GamePanel.enemy.clear();
-      GamePanel.particleTiles.clear();
-      for(int i=0; i<GamePanel.map.length; i++){
-          Arrays.fill(GamePanel.map[i], null);
+      GameFrame.game.enemy.clear();
+      GameFrame.game.particleTiles.clear();
+      for(int i=0; i<GameFrame.game.map.length; i++){
+          Arrays.fill(GameFrame.game.map[i], null);
       }
       String file = FileManager.readFile(filePath);
       for(int i=0; i<file.length(); i++){
@@ -76,33 +76,33 @@ public class MapReader {
               newTile("img/tiles/terrain/cornerBottomRight.png");
           } else if(file.charAt(i)=='b'){
               newTile("img/tiles/boxes/box.png");
-              GamePanel.map[x][y].breakable = true;
+              GameFrame.game.map[x][y].breakable = true;
           } else if(file.charAt(i)=='!'){
-              GamePanel.enemy.add(new NonPlayer(TileX, TileY, GamePanel.slimeSpriteArray, 50, 28, 100));
+              GameFrame.game.enemy.add(new NonPlayer(TileX, TileY, GameFrame.game.slimeSpriteArray, 50, 28, 100));
 
           } else if(file.charAt(i)=='+') {
               newTile("img/tiles/boxes/finish.png");
-              GamePanel.map[x][y].isFinish = true;
-              GamePanel.map[x][y].nonBombCollide = true;
+              GameFrame.game.map[x][y].isFinish = true;
+              GameFrame.game.map[x][y].nonBombCollide = true;
           }  else if(file.charAt(i)=='v'){
               newTile("img/tiles/background/wall.png");
-              GamePanel.map[x][y].collision = false;
-              GamePanel.map[x][y].replaceAble = true;
+              GameFrame.game.map[x][y].collision = false;
+              GameFrame.game.map[x][y].replaceAble = true;
           } else if(file.charAt(i)=='l'){
               newTile("img/tiles/terrain/lava.png");
-              GamePanel.map[x][y].nonBombCollide = true;
-              GamePanel.map[x][y].kills = true;
-              if(y>0&&GamePanel.map[x][y-1]==null) {
-                  GamePanel.particleTiles.add(GamePanel.map[x][y]);
+              GameFrame.game.map[x][y].nonBombCollide = true;
+              GameFrame.game.map[x][y].kills = true;
+              if(y>0&&GameFrame.game.map[x][y-1]==null) {
+                  GameFrame.game.particleTiles.add(GameFrame.game.map[x][y]);
               }
           } else if(file.charAt(i)=='o'){
               newTile("img/tiles/boxes/steel.png");
-              GamePanel.map[x][y].movable = true;
+              GameFrame.game.map[x][y].movable = true;
           }
           x+=1;
       }
     }
     public static void newTile(String filePath) throws IOException, SpriteException {
-        GamePanel.map[x][y]=(new SingleTile(TileX,TileY, GamePanel.getImage(filePath)));
+        GameFrame.game.map[x][y]=(new SingleTile(TileX,TileY, new BufferedImageWrapper(GamePanel.getImage(filePath))));
     }
 }
diff --git a/src/MenuPanel.java b/src/MenuPanel.java
index 189976e..e480007 100644
--- a/src/MenuPanel.java
+++ b/src/MenuPanel.java
@@ -39,7 +39,7 @@ public class MenuPanel extends JPanel implements Runnable, KeyListener{
     public static boolean gameStart = false;
 
     // image imports begin here
-    public BufferedImage backgroundImage = GamePanel.getImage("img/backgrounds/pointyMountains.png");
+    public BufferedImageWrapper backgroundImage = new BufferedImageWrapper(GamePanel.getImage("img/backgrounds/pointyMountains.png"));
 
     public MenuPanel(CameraPanel gameFrame) throws IOException, SpriteException, UnsupportedAudioFileException, LineUnavailableException {
         this.gameFrame = gameFrame;
@@ -148,7 +148,7 @@ public class MenuPanel extends JPanel implements Runnable, KeyListener{
     //if a key is pressed, we'll send it over to the Player class for processing
     public void keyPressed(KeyEvent e) {
 
-        e = UtilityFunction.intercept(e, GamePanel.middlewareArray);
+        e = UtilityFunction.intercept(e, GameFrame.game.middlewareArray);
         if (e.getKeyCode() == KeyEvent.VK_ENTER) {
             if(textBoxArray.get(currentBox).id.equals("game")){
                 gameStart = true;
diff --git a/src/NonPlayer.java b/src/NonPlayer.java
index 124e923..b49f630 100644
--- a/src/NonPlayer.java
+++ b/src/NonPlayer.java
@@ -7,8 +7,9 @@ import javax.sound.sampled.UnsupportedAudioFileException;
 import java.awt.*;
 import java.awt.image.BufferedImage;
 import java.io.IOException;
+import java.io.Serializable;
 
-public class NonPlayer extends GenericSprite {
+public class NonPlayer extends GenericSprite implements Serializable {
   public final int SPEED = 3;
   // please note that these are not static, in contrast to the player class, as different enemies will have different heights
   public int npcWidth;
@@ -23,8 +24,8 @@ public class NonPlayer extends GenericSprite {
   public double fadeCounter;
   // private final Sound bump;
 
-  public BufferedImage[][][] spriteArray;
-  public NonPlayer(int x, int y, BufferedImage[][][] sprites, int npcWidth, int npcHeight, int health) throws UnsupportedAudioFileException, LineUnavailableException, IOException {
+  public BufferedImageWrapper[][][] spriteArray;
+  public NonPlayer(int x, int y, BufferedImageWrapper[][][] sprites, int npcWidth, int npcHeight, int health) throws UnsupportedAudioFileException, LineUnavailableException, IOException {
     super(x, y, npcHeight, npcWidth);
     // bump = new Sound("sound/bump.wav");
     this.health = health;
@@ -49,7 +50,7 @@ public class NonPlayer extends GenericSprite {
 
 
   public void update(){
-    realX = x-GamePanel.camera.x;
+    realX = x-GameFrame.game.camera.x;
   }
   public void move(){
     if (isDead) {
@@ -88,21 +89,16 @@ public class NonPlayer extends GenericSprite {
       frame %= spriteArray[0][0].length - 1;
       currentXDirection = (int)(Math.signum(xVelocity) + 1) / 2;
       currentYDirection = (int)(Math.signum(yVelocity) + 1) / 2;
-      // x-GamePanel.camera.x is used as the camera doesn't follow NPCs
-      g.drawImage(spriteArray[currentXDirection][currentYDirection][frame], x-GamePanel.camera.x, y, null);
+      // x-GameFrame.game.camera.x is used as the camera doesn't follow NPCs
+      g.drawImage(spriteArray[currentXDirection][currentYDirection][frame].image, x-GameFrame.game.camera.x, y, null);
       return 1;
     } else {
-      try {
-        ((Graphics2D) g).setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, (float) fadeCounter));
-        g.drawImage(spriteArray[currentXDirection][currentYDirection][spriteArray[0][0].length - 1], x - GamePanel.camera.x, (int) (y + HEIGHT / 1.7), null);
-        // reset composite to not affect other sprites being drawn
-        ((Graphics2D) g).setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1));
-        fadeCounter -= 0.01;
-        return 0;
-      }catch(Exception e){
-        return 0;
-      }
-
+      ((Graphics2D)g).setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, (float)fadeCounter));
+      g.drawImage(spriteArray[currentXDirection][currentYDirection][spriteArray[0][0].length-1].image, x-GameFrame.game.camera.x, (int)(y+HEIGHT/1.7), null);
+      // reset composite to not affect other sprites being drawn
+      ((Graphics2D)g).setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1));
+      fadeCounter -= 0.01;
+      return 0;
     }
   }
 }
\ No newline at end of file
diff --git a/src/Particle.java b/src/Particle.java
index 7525446..c6e52e3 100644
--- a/src/Particle.java
+++ b/src/Particle.java
@@ -1,8 +1,9 @@
 import java.awt.*;
 import java.awt.image.BufferedImage;
 import java.io.IOException;
+import java.io.Serializable;
 
-public class Particle extends GenericSprite{
+public class Particle extends GenericSprite implements Serializable {
     public static final int small = 3;
     public static final int big = 10;
 
@@ -12,13 +13,13 @@ public class Particle extends GenericSprite{
 
     public int lifeSpan = 10;
 
-    public BufferedImage sprite;
+    public BufferedImageWrapper sprite;
 
     public Particle(int x, int y, int xVelocity, int yVelocity, int length, String filePath) throws IOException {
         super(x,y,length, length);
         this.xVelocity = xVelocity;
         this.yVelocity = yVelocity;
-        sprite = GamePanel.getImage(filePath);
+        sprite = new BufferedImageWrapper(GamePanel.getImage(filePath));
     }
     public void move(){
     x+=xVelocity;
@@ -26,7 +27,7 @@ public class Particle extends GenericSprite{
     yVelocity+=0.5;
     }
     public void draw(Graphics g){
-        g.drawImage(sprite,x-GamePanel.camera.x,y,WIDTH,HEIGHT, null);
+        g.drawImage(sprite.image,x-GameFrame.game.camera.x,y,WIDTH,HEIGHT, null);
     }
 
 }
diff --git a/src/PauseMenu.java b/src/PauseMenu.java
index 1b7e64c..9f289cd 100644
--- a/src/PauseMenu.java
+++ b/src/PauseMenu.java
@@ -1,6 +1,7 @@
 import java.awt.*;
+import java.io.Serializable;
 
-public class PauseMenu extends TextBox {
+public class PauseMenu extends TextBox implements Serializable {
     public PauseMenu(int y, int textYOffset, int xWidth, int yHeight, int totalWidth, Font font, String text) {
         super(y, xWidth, yHeight, totalWidth, font, text, null);
         this.y -= textYOffset;
diff --git a/src/Player.java b/src/Player.java
index d77f550..c322093 100644
--- a/src/Player.java
+++ b/src/Player.java
@@ -18,11 +18,10 @@ public class Player extends GenericSprite {
 
   public static final int steelReachRange = 3*Tile.length;
   public int lastXDirection, lastYDirection, lastFrame;
-  public int upKey, downKey, rightKey, leftKey;
 
   public static final int walkSpeedCap = 5;
   public boolean alive;
-  private final Sound jump;
+  private transient final Sound jump = new Sound("sound/jump.wav");
 
   public static int mouseX;
   public static int mouseY;
@@ -38,14 +37,10 @@ public class Player extends GenericSprite {
   // sA[1] is x, -y
   // sA[2] is -x, y
   // sA[3] is x, y
-  public BufferedImage[][][] spriteArray;
-  public Player(int x, int y, int upKey, int downKey, int leftKey, int rightKey, BufferedImage[][][] sprites) throws UnsupportedAudioFileException, LineUnavailableException, IOException {
+  public BufferedImageWrapper[][][] spriteArray;
+  public Player(int x, int y, BufferedImageWrapper[][][] sprites) throws UnsupportedAudioFileException, LineUnavailableException, IOException {
     super(x, y, PLAYER_HEIGHT, PLAYER_WIDTH);
-    jump = new Sound("sound/jump.wav");
-    this.upKey = upKey;
-    this.downKey = downKey;
-    this.leftKey = leftKey;
-    this.rightKey = rightKey;
+    // jump = new Sound("sound/jump.wav");
     spriteArray = sprites;
     alive = true;
     isPlayer = true;
@@ -102,21 +97,21 @@ public class Player extends GenericSprite {
 
   public boolean canUpdate(double x, double y){
     boolean canUpdate = true;
-    int lowX = Math.max(0, ((GamePanel.camera.x+GamePanel.GAME_WIDTH)/Tile.length)-4);
-    int highX = Math.min(lowX + 8, GamePanel.map.length);
+    int lowX = Math.max(0, ((GameFrame.game.camera.x+GamePanel.GAME_WIDTH)/Tile.length)-4);
+    int highX = Math.min(lowX + 8, GameFrame.game.map.length);
     int lowY = Math.max(0,(this.y/Tile.length)-6);
-    int highY = Math.min(lowY + 12, GamePanel.map[0].length);
+    int highY = Math.min(lowY + 12, GameFrame.game.map[0].length);
     for(int i=lowX; i<highX; i++) {
       for (int j = lowY; j < highY; j++) {
-        if (GamePanel.map != null) {
-          if (collide(GamePanel.map[i][j], this.x + x, this.y + y)) {
-            if (GamePanel.map[i][j].isFinish) {
+        if (GameFrame.game.map != null) {
+          if (collide(GameFrame.game.map[i][j], this.x + x, this.y + y)) {
+            if (GameFrame.game.map[i][j].isFinish) {
               LevelManager.nextLevel();
-              GamePanel.player.reset();
+              GameFrame.game.player.reset();
               return true;
             }
-            if (GamePanel.map[i][j].kills) {
-              GamePanel.player.reset();
+            if (GameFrame.game.map[i][j].kills) {
+              GameFrame.game.player.reset();
               return true;
             }
             canUpdate = false;
@@ -137,7 +132,7 @@ public class Player extends GenericSprite {
   public void updatePlaceSteel(int x, int y){
     canPlaceSteel = true;
     boolean adjacent = false;
-    int realX = x*Tile.length-GamePanel.camera.x;
+    int realX = x*Tile.length-GameFrame.game.camera.x;
     double xDis = (realX - GamePanel.GAME_WIDTH/2+ Tile.length/2) - (this.x+WIDTH/2);
     double yDis = (y*Tile.length + Tile.length/2) - (this.y+HEIGHT/2);
     double hypo = Math.sqrt(xDis*xDis+yDis*yDis);
@@ -145,7 +140,7 @@ public class Player extends GenericSprite {
     int[][]check = {{1,0},{0,1},{-1,0},{0,-1}};
     for(int[]a: check){
       try{
-        if(GamePanel.map[x+a[0]][y+a[1]]!=null&&!GamePanel.map[x+a[0]][y+a[1]].replaceAble){
+        if(GameFrame.game.map[x+a[0]][y+a[1]]!=null&&!GameFrame.game.map[x+a[0]][y+a[1]].replaceAble){
           adjacent = true;
           break;
         }
@@ -154,19 +149,19 @@ public class Player extends GenericSprite {
       }
     }
     if(!adjacent){canPlaceSteel = false; return;}
-    if(GamePanel.map[x][y]!=null&&!GamePanel.map[x][y].replaceAble){canPlaceSteel = false; return;};
     if(hypo>3*Tile.length){canPlaceSteel = false; return;}
+    if(GameFrame.game.map[x][y]!=null&&!GameFrame.game.map[x][y].replaceAble){canPlaceSteel = false; return;};
   }
   public void move() throws IOException {
 //    mouseX = MouseInfo.getPointerInfo().getLocation().x;
 //    mouseY = MouseInfo.getPointerInfo().getLocation().y;
-    int Tilex = (mouseX + GamePanel.camera.x + GamePanel.GAME_WIDTH / 2) / Tile.length;
+    int Tilex = (mouseX + GameFrame.game.camera.x + GamePanel.GAME_WIDTH / 2) / Tile.length;
     int Tiley = (mouseY / Tile.length);
     if(holdingSteel){
       updatePlaceSteel(Tilex,Tiley);
     }
     if(canUpdate(xVelocity, 0)&&canUpdate(0, yVelocity)&&!canUpdate(xVelocity, yVelocity)){
-      GamePanel.camera.x += -Math.signum(xVelocity);
+      GameFrame.game.camera.x += -Math.signum(xVelocity);
     }
     if(!canUpdate(xVelocity, 0)){
       int updateAmount = 0;
@@ -174,12 +169,12 @@ public class Player extends GenericSprite {
         while(canUpdate(updateAmount, 0)){
           updateAmount++;
         }
-        GamePanel.camera.x+=updateAmount-1;
+        GameFrame.game.camera.x+=updateAmount-1;
       } else if(xVelocity<0){
         while(canUpdate(updateAmount, 0)){
           updateAmount--;
         }
-        GamePanel.camera.x+=updateAmount+1;
+        GameFrame.game.camera.x+=updateAmount+1;
       }
       //xVelocity = 0;
     }
@@ -198,12 +193,12 @@ public class Player extends GenericSprite {
     }
     if(canUpdate(xVelocity, yVelocity)) {
       y = y + (int) yVelocity;
-      GamePanel.camera.x = GamePanel.camera.x + (int) xVelocity;
+      GameFrame.game.camera.x = GameFrame.game.camera.x + (int) xVelocity;
     } else if(canUpdate(0,yVelocity)){
       y = y + (int) yVelocity;
       xVelocity*=0.75;
     } else if(canUpdate(xVelocity,0)){
-      GamePanel.camera.x = GamePanel.camera.x + (int) xVelocity;
+      GameFrame.game.camera.x = GameFrame.game.camera.x + (int) xVelocity;
 
     }
 
@@ -249,7 +244,7 @@ public class Player extends GenericSprite {
 
   public void reset(){
     LevelManager.setLevel(LevelManager.level);
-    GamePanel.camera.x = LevelManager.xSpawn;
+    GameFrame.game.camera.x = LevelManager.xSpawn;
     y = LevelManager.ySpawn;
     holdingSteel = false;
   }
@@ -261,28 +256,28 @@ public class Player extends GenericSprite {
       leftMouseDown = true;
     }
     if(e.getButton()==MouseEvent.BUTTON3) {
-      int x = (mouseX + GamePanel.camera.x + GamePanel.GAME_WIDTH / 2) / Tile.length;
+      int x = (mouseX + GameFrame.game.camera.x + GamePanel.GAME_WIDTH / 2) / Tile.length;
       int y = (mouseY / Tile.length);
       rightMouseDown = true;
         if (!holdingSteel) {
-          if (GamePanel.map[x][y] != null&&GamePanel.map[x][y].movable) {
-            double xDis = (this.x+WIDTH/2) - (GamePanel.map[x][y].realX+Tile.length/2);
-            double yDis = (this.y+HEIGHT/2) - (GamePanel.map[x][y].y+Tile.length/2);
+          if (GameFrame.game.map[x][y] != null&&GameFrame.game.map[x][y].movable) {
+            double xDis = (this.x+WIDTH/2) - (GameFrame.game.map[x][y].realX+Tile.length/2);
+            double yDis = (this.y+HEIGHT/2) - (GameFrame.game.map[x][y].y+Tile.length/2);
             double hypo = Math.sqrt(xDis*xDis+yDis*yDis);
             if(hypo<steelReachRange) {
               holdingSteel = true;
-              if (GamePanel.map[x][y].previousBlock != null) {
-                GamePanel.map[x][y] = GamePanel.map[x][y].previousBlock;
+              if (GameFrame.game.map[x][y].previousBlock != null) {
+                GameFrame.game.map[x][y] = GameFrame.game.map[x][y].previousBlock;
               } else {
-                GamePanel.map[x][y] = null;
+                GameFrame.game.map[x][y] = null;
               }
             }
           }
-        } else if((GamePanel.map[x][y] == null||GamePanel.map[x][y].replaceAble)&&canPlaceSteel){
-          Tile temp = GamePanel.map[x][y];
-          GamePanel.map[x][y] = new SingleTile(x*Tile.length - (GamePanel.GAME_WIDTH/2), y*Tile.length, GamePanel.getImage("img/tiles/boxes/steel.png"));
-          GamePanel.map[x][y].movable = true;
-          GamePanel.map[x][y].previousBlock = temp;
+        } else if((GameFrame.game.map[x][y] == null||GameFrame.game.map[x][y].replaceAble)&&canPlaceSteel){
+          Tile temp = GameFrame.game.map[x][y];
+          GameFrame.game.map[x][y] = new SingleTile(x*Tile.length - (GamePanel.GAME_WIDTH /2), y*Tile.length, new BufferedImageWrapper(GamePanel.getImage("img/tiles/boxes/steel.png")));
+          GameFrame.game.map[x][y].movable = true;
+          GameFrame.game.map[x][y].previousBlock = temp;
           holdingSteel = false;
         }
       }
@@ -305,10 +300,10 @@ public class Player extends GenericSprite {
     mouseY = e.getY();
     if(e.getButton()==MouseEvent.BUTTON1) {
       leftMouseDown = false;
-      if (GamePanel.bombs.size() < 3 && LevelManager.bombs>0) {
+      if (GameFrame.game.bombs.size() < 3 && LevelManager.bombs>0) {
         LevelManager.bombs--;
-        GamePanel.bombs.add(new StickyBomb(GamePanel.player.x + GamePanel.camera.x + WIDTH/2, GamePanel.player.y+HEIGHT/2,
-                (mouseX - GamePanel.player.x) / 20, (mouseY - GamePanel.player.y) / 10, GamePanel.bomb, GamePanel.explosionArray));
+        GameFrame.game.bombs.add(new StickyBomb(GameFrame.game.player.x + GameFrame.game.camera.x + WIDTH/2, GameFrame.game.player.y+HEIGHT/2,
+                (mouseX - GameFrame.game.player.x) / 20, (mouseY - GameFrame.game.player.y) / 10, GameFrame.game.bomb, GameFrame.game.explosionArray));
       }
     }
     if(e.getButton()==MouseEvent.BUTTON3){
@@ -317,7 +312,7 @@ public class Player extends GenericSprite {
   }
   public void addParticle(int x) throws IOException {
     if(GlobalState.randInt(1,3)==3) {
-      GamePanel.particles.add(new Particle(this.x + GamePanel.camera.x + WIDTH / 2 + GlobalState.randInt(-PLAYER_WIDTH / 2, PLAYER_WIDTH / 2)
+      GameFrame.game.particles.add(new Particle(this.x + GameFrame.game.camera.x + WIDTH / 2 + GlobalState.randInt(-PLAYER_WIDTH / 2, PLAYER_WIDTH / 2)
               , (int) (y + HEIGHT * 0.95), GlobalState.randInt(-2, 2) + x, GlobalState.randInt(-4, 1), GlobalState.randInt(1, 7), "img/particles/GrassParticle.png"));
     }
     }
@@ -327,13 +322,13 @@ public class Player extends GenericSprite {
       g.drawOval(x+WIDTH/2-steelReachRange,y+HEIGHT/2-steelReachRange, steelReachRange*2,steelReachRange*2);
     }
     if (!upPressed && !downPressed && !leftPressed && !rightPressed) {
-      g.drawImage(spriteArray[lastXDirection][lastYDirection][0], x-10, y, null);
+      g.drawImage(spriteArray[lastXDirection][lastYDirection][0].image, x-10, y, null);
       return 0;
     } else {
       lastXDirection = (int)(Math.signum(xVelocity) + 1) / 2;
       lastYDirection = (int)(Math.signum(yVelocity) + 1) / 2;
       lastFrame = frame;
-      g.drawImage(spriteArray[lastXDirection][lastYDirection][frame], x-10, y, null);
+      g.drawImage(spriteArray[lastXDirection][lastYDirection][frame].image, x-10, y, null);
       return 1;
     }
 
diff --git a/src/SettingPanel.java b/src/SettingPanel.java
index 1edb19d..5a61087 100644
--- a/src/SettingPanel.java
+++ b/src/SettingPanel.java
@@ -1,4 +1,4 @@
-/* GamePanel class acts as the main "game loop" - continuously runs the game and calls whatever needs to be called
+/* GameFrame.game.class acts as the main "game loop" - continuously runs the game and calls whatever needs to be called
 
 Child of JPanel because JPanel contains methods for drawing to the screen
 
@@ -36,9 +36,6 @@ public class SettingPanel extends MenuPanel {
     public int currentBox = 0;
     public PauseMenu pauseMenu;
 
-    // image imports begin here
-    public BufferedImage backgroundImage = GamePanel.getImage("img/backgrounds/pointyMountains.png");
-
     public SettingPanel(CameraPanel gameFrame) throws IOException, SpriteException, UnsupportedAudioFileException, LineUnavailableException {
         super(gameFrame);
 
@@ -63,19 +60,19 @@ public class SettingPanel extends MenuPanel {
         title.draw(g,null, Color.black);
         for (TextBox t: textBoxArray) {
             oldText = t.text;
-            middlewareIndex = GamePanel.middlewareArray.indexOf(new Middleware(Integer.parseInt(t.id), -1));
-            t.text += "(" + (middlewareIndex > -1 ? (char)GamePanel.middlewareArray.get(middlewareIndex).newCode:
-                    GamePanel.middlewareArray.contains(new Middleware(-2, Integer.parseInt(t.id))) ?
+            middlewareIndex = GameFrame.game.middlewareArray.indexOf(new Middleware(Integer.parseInt(t.id), -1));
+            t.text += "(" + (middlewareIndex > -1 ? (char)GameFrame.game.middlewareArray.get(middlewareIndex).newCode:
+                    GameFrame.game.middlewareArray.contains(new Middleware(-2, Integer.parseInt(t.id))) ?
                             "None":(char)Integer.parseInt(t.id)) + ")";
             t.draw(g, null, Color.cyan);
             t.text = oldText;
         }
         oldText = textBoxArray.get(currentBox).text;
         // TODO: clean up
-        middlewareIndex = GamePanel.middlewareArray.indexOf(new Middleware(Integer.parseInt(textBoxArray.get(currentBox).id), -1));
+        middlewareIndex = GameFrame.game.middlewareArray.indexOf(new Middleware(Integer.parseInt(textBoxArray.get(currentBox).id), -1));
         // -2 was chosen as oldCode instead of -1 to prevent conflicts
-        textBoxArray.get(currentBox).text += "(" + (middlewareIndex > -1 ? (char)GamePanel.middlewareArray.get(middlewareIndex).newCode:
-                GamePanel.middlewareArray.contains(new Middleware(-2, Integer.parseInt(textBoxArray.get(currentBox).id))) ?
+        textBoxArray.get(currentBox).text += "(" + (middlewareIndex > -1 ? (char)GameFrame.game.middlewareArray.get(middlewareIndex).newCode:
+                GameFrame.game.middlewareArray.contains(new Middleware(-2, Integer.parseInt(textBoxArray.get(currentBox).id))) ?
                         "None":(char)Integer.parseInt(textBoxArray.get(currentBox).id)) + ")";
         textBoxArray.get(currentBox).draw(g, Color.gray, Color.blue);
         textBoxArray.get(currentBox).text = oldText;
@@ -108,18 +105,18 @@ public class SettingPanel extends MenuPanel {
             boolean canRemove = true;
             while (canRemove) {
                 // newCode is -1 as it does not matter
-                canRemove = GamePanel.middlewareArray.remove(new Middleware(Integer.parseInt(textBoxArray.get(currentBox).id), lastKeyCode));
+                canRemove = GameFrame.game.middlewareArray.remove(new Middleware(Integer.parseInt(textBoxArray.get(currentBox).id), lastKeyCode));
             }
             // add actual middleware
-            GamePanel.middlewareArray.add(new Middleware(Integer.parseInt(textBoxArray.get(currentBox).id), lastKeyCode));
+            GameFrame.game.middlewareArray.add(new Middleware(Integer.parseInt(textBoxArray.get(currentBox).id), lastKeyCode));
             // add middleware to redirect default key
-            GamePanel.middlewareArray.add(new Middleware(-1, Integer.parseInt(textBoxArray.get(currentBox).id)));
+            GameFrame.game.middlewareArray.add(new Middleware(-1, Integer.parseInt(textBoxArray.get(currentBox).id)));
             // lastKeyCode is set to -1 to prevent endless execution
             lastKeyCode = -1;
 
             // save new key bind to file
             try {
-                FileManager.writeObjectToFile("local/controls", GamePanel.middlewareArray);
+                FileManager.writeObjectToFile("local/controls", GameFrame.game.middlewareArray);
             } catch (IOException e) {
                 e.printStackTrace();
             }
@@ -129,7 +126,7 @@ public class SettingPanel extends MenuPanel {
     //if a key is pressed, we'll send it over to the Player class for processing
     public void keyPressed(KeyEvent e) {
         if (!waitForKey) {
-            e = UtilityFunction.intercept(e, GamePanel.middlewareArray);
+            e = UtilityFunction.intercept(e, GameFrame.game.middlewareArray);
         }
         if (waitForKey) {
             if (e.getKeyCode() != KeyEvent.VK_ENTER) {
diff --git a/src/SingleTile.java b/src/SingleTile.java
index 454ca8b..445dc4c 100644
--- a/src/SingleTile.java
+++ b/src/SingleTile.java
@@ -1,18 +1,19 @@
 import java.awt.*;
 import java.awt.image.BufferedImage;
+import java.io.Serializable;
 
-public class SingleTile extends Tile {
-    public BufferedImage tileImage;
+public class SingleTile extends Tile implements Serializable {
+    public BufferedImageWrapper tileImage;
 
-    public SingleTile(int x, int y, BufferedImage tileImage) throws SpriteException {
+    public SingleTile(int x, int y, BufferedImageWrapper tileImage) throws SpriteException {
         super(x, y);
 
-        if (tileImage.getWidth() != tileImage.getHeight()) {
+        if (tileImage.image.getWidth() != tileImage.image.getHeight()) {
             throw new SpriteException();
         }
         this.tileImage = tileImage;
     }
     public void draw(Graphics g){
-        g.drawImage(tileImage, x-GamePanel.camera.x, y, length, length, null);
+        g.drawImage(tileImage.image, x-GameFrame.game.camera.x, y, length, length, null);
     }
 }
diff --git a/src/Sound.java b/src/Sound.java
index f5c24bf..9ad298e 100644
--- a/src/Sound.java
+++ b/src/Sound.java
@@ -1,8 +1,9 @@
 import javax.sound.sampled.*;
 import java.io.File;
 import java.io.IOException;
+import java.io.Serializable;
 
-public class Sound {
+public class Sound implements Serializable {
     private AudioInputStream audioInputStream;
     private Clip clip;
     private File file;
diff --git a/src/StickyBomb.java b/src/StickyBomb.java
index 89b4df5..aec0b25 100644
--- a/src/StickyBomb.java
+++ b/src/StickyBomb.java
@@ -2,8 +2,9 @@ import java.awt.*;
 import java.awt.event.KeyEvent;
 import java.awt.event.MouseEvent;
 import java.awt.image.BufferedImage;
+import java.io.Serializable;
 
-public class StickyBomb extends GenericSprite{
+public class StickyBomb extends GenericSprite implements Serializable {
 
     public static final int spriteLength = 35;
 
@@ -12,8 +13,8 @@ public class StickyBomb extends GenericSprite{
     public int yVelocity;
     public boolean isMove;
     public int realX;
-    public BufferedImage sprite ;
-    public BufferedImage[] explosionSpriteArray;
+    public BufferedImageWrapper sprite ;
+    public BufferedImageWrapper[] explosionSpriteArray;
 
     public int fuse;
     public int explosionPixel = 0;
@@ -25,7 +26,7 @@ public class StickyBomb extends GenericSprite{
 
 
 
-    public StickyBomb(int x, int y,  int xVelocity, int yVelocity, BufferedImage sprite, BufferedImage[] explosionSpriteArray){
+    public StickyBomb(int x, int y,  int xVelocity, int yVelocity, BufferedImageWrapper sprite, BufferedImageWrapper[] explosionSpriteArray){
         super(x,y,length,length);
         this.xVelocity = xVelocity;
         this.yVelocity = yVelocity;
@@ -40,43 +41,43 @@ public class StickyBomb extends GenericSprite{
 
 
     public void update(){
-        realX = x - GamePanel.camera.x;
+        realX = x - GameFrame.game.camera.x;
     }
 
     public void explode(){
-        double yDis = GamePanel.player.y+Player.PLAYER_HEIGHT/2-(y+(double)length/2);
-        double xDis = GamePanel.player.x+Player.PLAYER_WIDTH/2-(realX+(double)length/2);
+        double yDis = GameFrame.game.player.y+Player.PLAYER_HEIGHT/2-(y+(double)length/2);
+        double xDis = GameFrame.game.player.x+Player.PLAYER_WIDTH/2-(realX+(double)length/2);
         double hypo = Math.sqrt(yDis*yDis+xDis*xDis);
         if(hypo<300) {
             if (yDis != 0) {
-                GamePanel.player.yVelocity += 10 * (yDis) / (hypo);
+                GameFrame.game.player.yVelocity += 10 * (yDis) / (hypo);
             }
             if (xDis != 0) {
-                GamePanel.player.xVelocity += 10 * (xDis) / (hypo);
+                GameFrame.game.player.xVelocity += 10 * (xDis) / (hypo);
             }
         }
-        GamePanel.player.capSpeed();
+        GameFrame.game.player.capSpeed();
     alive = false;
-    for(int i=0; i<GamePanel.enemy.size(); i++){
-        double disX = GamePanel.enemy.get(i).x+GamePanel.enemy.get(i).npcWidth/2 - (x+length/2);
-        double disY = GamePanel.enemy.get(i).y+GamePanel.enemy.get(i).npcHeight/2 - (y+length/2);
+    for(int i=0; i<GameFrame.game.enemy.size(); i++){
+        double disX = GameFrame.game.enemy.get(i).x+GameFrame.game.enemy.get(i).npcWidth/2 - (x+length/2);
+        double disY = GameFrame.game.enemy.get(i).y+GameFrame.game.enemy.get(i).npcHeight/2 - (y+length/2);
         double eHypo = Math.sqrt(disX*disX+disY*disY);
         if(eHypo<200){
-            GamePanel.enemy.get(i).isDead = true;
+            GameFrame.game.enemy.get(i).isDead = true;
         }
 
     }
         int lowX = Math.max(0, ((x+GamePanel.GAME_WIDTH)/Tile.length)-4);
-        int highX = Math.min(lowX + 8, GamePanel.map.length);
+        int highX = Math.min(lowX + 8, GameFrame.game.map.length);
         int lowY = Math.max(0,(this.y/Tile.length)-6);
-        int highY = Math.min(lowY + 12, GamePanel.map[0].length);
+        int highY = Math.min(lowY + 12, GameFrame.game.map[0].length);
         for(int i=0; i<100; i++) {
             for (int j = lowY; j < highY; j++) {
-                if (GamePanel.map[i][j] != null && GamePanel.map[i][j].breakable) {
-                    double disX = (x + WIDTH / 2) - (GamePanel.map[i][j].x + Tile.length / 2);
-                    double disY = (y + HEIGHT / 2) - (GamePanel.map[i][j].y + Tile.length / 2);
+                if (GameFrame.game.map[i][j] != null && GameFrame.game.map[i][j].breakable) {
+                    double disX = (x + WIDTH / 2) - (GameFrame.game.map[i][j].x + Tile.length / 2);
+                    double disY = (y + HEIGHT / 2) - (GameFrame.game.map[i][j].y + Tile.length / 2);
                     if (Math.sqrt(disX * disX + disY * disY) < Tile.length * 5) {
-                        GamePanel.map[i][j] = null;
+                        GameFrame.game.map[i][j] = null;
                     }
                 }
             }
@@ -197,10 +198,10 @@ public class StickyBomb extends GenericSprite{
             explosionCounter -= 2;
         }
         if(alive) {
-            g.drawImage(sprite, x - GamePanel.camera.x - (spriteLength-length)/2, y - (spriteLength-length)/2, spriteLength, spriteLength, null);
-            //g.drawRect(x-GamePanel.camera.x,y,length,length);
+            g.drawImage(sprite.image, x - GameFrame.game.camera.x - (spriteLength-length)/2, y - (spriteLength-length)/2, spriteLength, spriteLength, null);
+            //g.drawRect(x-GameFrame.game.camera.x,y,length,length);
         } else if (explosionPixel < explosionSpriteArray.length - 1) {
-            g.drawImage(explosionSpriteArray[explosionPixel], x - GamePanel.camera.x - 10*explosionPixel,
+            g.drawImage(explosionSpriteArray[explosionPixel].image, x - GameFrame.game.camera.x - 10*explosionPixel,
                     y-10*explosionPixel, spriteLength+10*explosionPixel, spriteLength+10*explosionPixel, null);
             explosionCounter += 1;
         }  else {
diff --git a/src/TextBox.java b/src/TextBox.java
index 50cc885..5148c25 100644
--- a/src/TextBox.java
+++ b/src/TextBox.java
@@ -1,6 +1,7 @@
 import java.awt.*;
+import java.io.Serializable;
 
-public class TextBox extends Rectangle {
+public class TextBox extends Rectangle implements Serializable {
     int y;
     int xWidth, yHeight;
     int newX, newY;
diff --git a/src/Tile.java b/src/Tile.java
index 81e3aae..45c25a7 100644
--- a/src/Tile.java
+++ b/src/Tile.java
@@ -1,7 +1,8 @@
 import java.awt.*;
+import java.io.Serializable;
 
 // all tiles must be squares
-public class Tile {
+public class Tile implements Serializable {
     public int x;
     public int y;
 
@@ -34,11 +35,11 @@ public class Tile {
         previousBlock = null;
     }
     public void update(){
-        realX = x-GamePanel.camera.x;
+        realX = x-GameFrame.game.camera.x;
     }
 
     public void draw(Graphics g){
         g.setColor(Color.black);
-        g.fillRect(x-GamePanel.camera.x, y, length, length);
+        g.fillRect(x-GameFrame.game.camera.x, y, length, length);
     }
 }