GraphicsDevice gd;

        GraphicsEnvironment ge = 
              GraphicsEnvironment.getLocalGraphicsEnvironment();
          gd = ge.getDefaultScreenDevice();
          GraphicsConfiguration gc = gd.getDefaultConfiguration();

         final int currentRefreshrate = gd.getDisplayMode().getRefreshRate();
         
         System.out.println("Reported Refreshrate=" + currentRefreshrate);
         targetFps = (currentRefreshrate==DisplayMode.REFRESH_RATE_UNKNOWN?60:currentRefreshrate);
            
      Frame frame = new Frame(gc);
      frame.setIgnoreRepaint(true);
      frame.setUndecorated( true );
      frame.setLayout(null);
      setIgnoreRepaint(true);
      setBounds(0,0,WINDOWS_WIDTH,WINDOWS_HEIGHT);
      frame.add(this);
      frame.setSize(WINDOWS_WIDTH,WINDOWS_HEIGHT);
      frame.setFocusTraversalKeysEnabled(false);
      frame.setResizable(false);
      frame.setLocationRelativeTo(null);
      frame.setVisible(true);
      
       // Change to full screen
       gd.setFullScreenWindow(frame);
       if( gd.isDisplayChangeSupported() ) {
         gd.setDisplayMode( 
           new DisplayMode( WINDOWS_WIDTH, WINDOWS_HEIGHT, 32, DisplayMode.REFRESH_RATE_UNKNOWN )
         );
       }

                Frame frame = new Frame("Test Scroller");
      frame.setLayout(null);
      setBounds(0,0,WINDOWS_WIDTH,WINDOWS_HEIGHT);
      frame.add(this);
      frame.setSize(WINDOWS_WIDTH,WINDOWS_HEIGHT);
      frame.setResizable(false);
      frame.setLocationRelativeTo(null);
      frame.setVisible(true);
      
//      Exit windows
      frame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent e) {
            System.exit(0);
         }
      });
      
      /** create the strategy used for accelerated rendering. */ 
      createBufferStrategy(2);
      strategy = getBufferStrategy();

            //I simply added these 2 lines to the original code
       GraphicsEnvironment.getLocalGraphicsEnvironment().
            getDefaultScreenDevice().setFullScreenWindow(frame);

Frame frame = new Frame("Side Scroller");
      frame.setLayout(null);
      setBounds(0,0,WINDOWS_WIDTH,WINDOWS_HEIGHT);
      frame.add(this);
      frame.setSize(WINDOWS_WIDTH,WINDOWS_HEIGHT);
      frame.setResizable(false);
      frame.setLocationRelativeTo(null);
      frame.setVisible(true);
      
//      Exit windows
      frame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent e) {
            System.exit(0);
         }
      });
      
      /** create the strategy used for accelerated rendering. */ 
      createBufferStrategy(2);
      strategy = getBufferStrategy();

C:\>java -jar -Xprof GGt.jar

Flat profile of 34.68 secs (3128 total ticks): AWT-Windows

  Interpreted + native   Method
 99.7%     0  +  3119    sun.awt.windows.WToolkit.eventLoop
  0.1%     2  +     0    sun.awt.AWTAutoShutdown.setToolkitBusy
  0.0%     1  +     0    sun.reflect.NativeMethodAccessorImpl.invoke
  0.0%     1  +     0    sun.awt.SunToolkit.wakeupEventQueue
  0.0%     0  +     1    java.lang.Object.hashCode
  0.0%     0  +     1    sun.awt.windows.WToolkit.init
 99.9%     4  +  3121    Total interpreted

     Compiled + native   Method
  0.1%     0  +     3    sun.awt.AWTAutoShutdown.setToolkitBusy
  0.1%     0  +     3    Total compiled


Flat profile of 0.11 secs (7 total ticks): Thread-1

  Interpreted + native   Method
100.0%     0  +     7    sun.awt.windows.WToolkit.shutdown
100.0%     0  +     7    Total interpreted


Flat profile of 34.70 secs (3127 total ticks): AWT-EventQueue-0

  Interpreted + native   Method
 31.0%     0  +    26    sun.awt.windows.WFramePeer.setState
 23.8%     0  +    20    sun.awt.windows.WGlobalCursorManager.setCursor
 13.1%     0  +    11    sun.awt.windows.WGlobalCursorManager.findHeavyweightUnd
erCursor
  9.5%     0  +     8    sun.awt.windows.WComponentPeer.nativeHandleEvent
  8.3%     1  +     6    sun.awt.Win32GraphicsDevice.enumDisplayModes
  1.2%     0  +     1    java.lang.Thread.holdsLock
  1.2%     0  +     1    java.lang.Object.clone
  1.2%     0  +     1    java.lang.Class.getInterfaces
  1.2%     0  +     1    sun.awt.windows.WComponentPeer.reshape
  1.2%     0  +     1    sun.java2d.loops.FillRect.FillRect
  1.2%     0  +     1    sun.java2d.windows.GDIBlitLoops.nativeBlit
  1.2%     1  +     0    java.awt.DisplayMode.<init>
  1.2%     1  +     0    sun.awt.AWTAutoShutdown.notifyThreadBusy
  1.2%     1  +     0    java.awt.Window.processWindowEvent
  1.2%     1  +     0    java.awt.EventQueue.setCurrentEventAndMostRecentTimeImp
l
 97.6%     5  +    77    Total interpreted

     Compiled + native   Method
  1.2%     1  +     0    sun.awt.AppContext.get
  1.2%     1  +     0    Total compiled

         Stub + native   Method
  1.2%     0  +     1    java.lang.Thread.currentThread
  1.2%     0  +     1    Total stub

  Thread-local ticks:
 97.3%  3043             Blocked (of total)


Flat profile of 34.78 secs (3134 total ticks): AWT-Shutdown

  Thread-local ticks:
100.0%  3134             Blocked (of total)


Flat profile of 34.80 secs (3136 total ticks): Java2D Disposer

  Thread-local ticks:
100.0%  3136             Blocked (of total)


Flat profile of 34.88 secs (3142 total ticks): main

  Interpreted + native   Method
  2.9%     0  +    92    sun.nio.ch.FileDispatcher.read0
  1.9%     0  +    61    sun.java2d.windows.GDIBlitLoops.nativeBlit
  1.1%     0  +    36    sun.java2d.loops.Blit.Blit
  0.4%     0  +    14    sun.java2d.loops.FillRect.FillRect
  0.4%     0  +    13    java.io.RandomAccessFile.close0
  0.2%     0  +     5    java.io.RandomAccessFile.open
  0.2%     5  +     0    java.awt.image.DataBufferByte.<init>
  0.2%     0  +     5    java.util.zip.Inflater.inflateBytes
  0.1%     0  +     4    sun.font.FontManager.populateFontFileNameMap
  0.1%     0  +     3    sun.font.FileFont.getGlyphImage
  0.1%     3  +     0    java.lang.AbstractStringBuilder.<init>
  0.1%     0  +     3    sun.java2d.loops.DrawGlyphList.DrawGlyphList
  0.1%     0  +     2    java.lang.Throwable.fillInStackTrace
  0.1%     1  +     1    sun.java2d.loops.MaskBlit.MaskBlit
  0.1%     2  +     0    java.awt.image.DataBufferInt.<init>
  0.1%     2  +     0    com.sun.imageio.plugins.png.PNGImageReader.decodePaethF
ilter
  0.0%     1  +     0    sun.font.TrueTypeFont.close
  0.0%     0  +     1    sun.awt.windows.WWindowPeer.reshapeFrame
  0.0%     1  +     0    sun.java2d.SunGraphics2D.drawImage
  0.0%     1  +     0    sun.net.www.protocol.file.Handler.createFileURLConnecti
on
  0.0%     0  +     1    java.io.RandomAccessFile.seek
  0.0%     0  +     1    sun.awt.Win32GraphicsDevice.enterFullScreenExclusive
  0.0%     0  +     1    java.lang.reflect.Array.newArray
  0.0%     0  +     1    java.io.WinNTFileSystem.list
  0.0%     1  +     0    java.awt.Rectangle.setBounds
  9.4%    43  +   251    Total interpreted (including elided)

     Compiled + native   Method
 50.7%  1591  +     0    java.awt.image.ComponentColorModel.getRGBComponent
 16.8%   529  +     0    java.awt.image.ComponentColorModel.getRGB
 15.4%   485  +     0    sun.awt.image.ByteInterleavedRaster.getDataElements
  3.5%   110  +     0    sun.java2d.loops.OpaqueCopyAnyToArgb.Blit
  1.0%    30  +     0    com.sun.imageio.plugins.png.PNGImageReader.decodePaethF
ilter
  0.2%     7  +     0    com.sun.imageio.plugins.png.PNGImageReader.decodeUpFilt
er
  0.0%     1  +     0    java.io.BufferedInputStream.read
  0.0%     1  +     0    com.sun.imageio.plugins.png.PNGImageReader.decodePass
  0.0%     1  +     0    Map.Map.paint
 87.7%  2755  +     0    Total compiled

         Stub + native   Method
  2.2%     0  +    69    sun.java2d.loops.MaskBlit.MaskBlit
  0.4%     0  +    12    java.util.zip.Inflater.inflateBytes
  0.2%     0  +     7    java.lang.System.arraycopy
  0.1%     0  +     2    java.lang.Thread.currentThread
  0.0%     0  +     1    java.io.RandomAccessFile.readBytes
  2.9%     0  +    91    Total stub

  Thread-local ticks:
  0.0%     1             Blocked (of total)
  0.0%     1             Class loader


Global summary of 34.88 seconds:
100.0%  3163             Received ticks
  0.7%    21             Received GC ticks
  0.2%     7             Compilation
  0.0%     1             Class loader

        /** Image transperancy value*/
   float transperancy = 0;

   public BufferedImage drawAlpha() {
      /** Load Image, note that it is better if you preload the image else where, this is just to show you how its loaded. */
      BufferedImage loaded = ImageIO.read(new File("images/buildings/g_u_1.png"));

      /** Create alpha image */
      BufferedImage aimg = new BufferedImage(loaded.getWidth(), loaded.getHeight(), BufferedImage.TRANSLUCENT);  

       /** Get image graphics */ 
      Graphics2D g = aimg.createGraphics();

      /** Set the Graphics composite to Alpha */
      g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, transperancy));  

      /** Draw the loaded image into the prepared reciver image */
      g.drawImage(loaded, null, 0, 0);  

      /** Release system resource in this graphics */
      g.dispose();
      
      return aimg;
   }

public void paint(Graphics2D g) { 
      g.drawImage(drawAlpha(), x, y, width, height, null);
}

mapPosX = Camera.visibleX - Camera.x;
mapPosY = Camera.visibleY - Camera.y;
cornerShift();

/** Offset X for Camera */
int offsetX = (int)((GameCore.mapPosX + GameCore.fixX)* Map.TILE_SIZE);

/** Offset Y for Camera */
int offsetY = (int)((GameCore.mapPosY + GameCore.fixY) * Map.TILE_SIZE);

// Somewhere in paint method I draw the rectangle with the offset
g.drawRect(xp + offsetX, yp + offsetY, width, height);

Frame frame = new Frame("Stone of Franks");
      Panel panel = new Panel();
      panel.setLayout(null);
      
      Canvas canvas = new Canvas();
      canvas.setBounds(0,0,WINDOWS_WIDTH,WINDOWS_HEIGHT);
      canvas.setIgnoreRepaint(true);
      
      panel.add(canvas);
      frame.add(panel);

      frame.setSize(WINDOWS_WIDTH,WINDOWS_HEIGHT);
      frame.setResizable(false);
      frame.setLocationRelativeTo(null);
      frame.setVisible(true);
      
      /** create the strategy used for accelerated rendering. */ 
      canvas.createBufferStrategy(2);
      strategy = canvas.getBufferStrategy();
      
      canvas.requestFocus();
      
      //Exit windows
      frame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent e) {
            System.exit(0);
         }
      });


         /** Add Key Listener */
      canvas.addKeyListener(this);
      
      /** Add Mouse Listener */
      canvas.addMouseListener(this);
      canvas.addMouseMotionListener(this);

   GameCore() {
      Frame frame = new Frame("Side Scroller");
      frame.setLayout(null);
      setBounds(0,0,WINDOWS_WIDTH,WINDOWS_HEIGHT);
      frame.add(this);
      frame.setSize(WINDOWS_WIDTH,WINDOWS_HEIGHT);
      frame.setResizable(false);
      frame.setLocationRelativeTo(null);
      frame.setVisible(true);
      frame.addKeyListener(this);
      addKeyListener(this);
      //Exit windows
      frame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent e) {
            System.exit(0);
         }
      });
      

      /** create the strategy used for accelerated rendering. */ 
      createBufferStrategy(2);
      strategy = getBufferStrategy();

                 //Other code here
         
      setFPS();
      gameLoop();
   }


private void gameRender() {
      Graphics2D g = (Graphics2D) strategy.getDrawGraphics();
      
      // clear the screen
      g.setColor(Color.WHITE);
      g.fillRect(0,0,WINDOWS_WIDTH,WINDOWS_HEIGHT);
      g.translate(0, 10);

      if(player.isAlive() && gameStart) {
         /** Paint map */
         map.paint(g);
         
         /** Paint enemies */
         spawn.paint(g);
         
         /** Pain Power Ups */
         powerUp.paint(g);
         
         /** Paint player */
         player.paint(g);
         
         /** Paint GUI */
         gui.paint(g);
      }

      /** Paint Scene */
      scene.paint(g);
      
      /** flip the buffer so we can see the rendering */
      g.dispose();
      strategy.show();
   }

   /** Draw Player */
   public void paint(Graphics2D g) {
      /** Paint spells */
      for(int i = spellList.size() - 1; i >= 0 ; i--) {
            spellList.get(i).paint(g);
      }
         
      /** Paint explosions */
      for(int i = explosion.size() - 1; i >= 0; i--) {
         if(explosion.get(i).Length() != 0) {
            explosion.get(i).paint(g);
         }
      }

      g.drawImage(anim.getCurrentImage(), xp + offsetX - 10, yp + offsetY, null);
   }

        private int fps;
   private long timeThen;

   /** Set FPS */
   private void setFPS() {
      fps = 60;
      timeThen = System.nanoTime();
   }

        /** Timer */
   public void sync() {
      long gapTo = 1000000000L / fps + timeThen;
      long timeNow = System.nanoTime();
      
      while (gapTo > timeNow) {
         try { Thread.sleep(1);
         } catch (InterruptedException e) {}
         timeNow = System.nanoTime();
      }
      timeThen = timeNow;
   }


       /** Fixed Framerate Game loop */
   private void gameLoop() {
      long currentUpdateTime = System.nanoTime();
      long lastUpdateTime;   
         
      while(gameRunning) {
         
         lastUpdateTime = currentUpdateTime;
         currentUpdateTime = System.nanoTime();
         long elapsedTime = (currentUpdateTime -    lastUpdateTime)/(1000*1000);
         
         /** Update Game */
         gameUpdate(elapsedTime);
         /** Render */
         gameRender();
         /** Run timer */
         sync();
      }
   }

   
/** Enter slope from higher tile */
      if(map.onSlope(tileX, tileY + 1) && !jumping) {
         py = tileY + 0.4f;
      }

/** Check if there's a slope and shift Y according to it */
   int prevSlopeType = -1;
   private void checkSlope(float x, float y) {
      /** X used for slope check */
      float checkX = x + sizeW / 2;
      /** Y used for slope check */
      float checkY = y + sizeH;
      
      int tileX = (int)checkX;
      int tileY = (int)checkY;
      
      int slopeType = map.slopeStyle(tileX, tileY);
      
      /** Enter slope from higher tile */
      if(map.onSlope(tileX, tileY + 1) && !jumping) {
         py = tileY + 0.4f;
      }
      /** On slope, shift Y, ignore check if jumpDistance < 0, ie player jumping up */
      if(map.onSlope(tileX, tileY) && !(jumping && jumpDistance < 0)) {
         onSlope = true;
         jumping = false;
         idle = false;
         float xpos = checkX - tileX;
         if(slopeType == Map.SLOPE_L) {
            prevSlopeType = Map.SLOPE_L;
            py = tileY + 1 - sizeH - xpos;
         } 
         if(slopeType == Map.SLOPE_R) {
            prevSlopeType = Map.SLOPE_R;
            py = tileY + 1 - sizeH - (1 - xpos);
         }
      } else {
         if((prevSlopeType == Map.SLOPE_L && faceDir == States.RIGHT) || (prevSlopeType == Map.SLOPE_R && faceDir == States.LEFT)) {
            py = tileY - sizeH - 0.1f;
         }
         onSlope = false;
         prevSlopeType = Map.NOT_ON_SLOPE;
      }
   }

if(map.onSlope((int)checkX, (int)y + sizeH)) {
         onSlope = true;
         moveY(moveSpeed);
      } 

/** Move x and check collision  2010-1-10 */
   public boolean moveX(float dx) {
      /**  work out what the new position of this entity will be */
      float nx = px + dx;
      
      /** Check if next location is a valid one */
      if (validLocation(nx, py)) {
         // if it doesn't then change our position to the new position
         px = nx;
         return true;
      }
      
      /** If blocked don't move */
      return false;
   }
   
   /** Move y and check collision  2010-1-10 */
   public boolean moveY(float dy) {
      /** work out what the new position of this entity will be */
      float ny = py + dy;
      
      /** Check if next location is a valid one */
      if (validLocation(px, ny)) {
         // if it doesn't then change our position to the new position
         py = ny;
         return true;
      }
      
      /** If blocked don't move */
      return false;
   }

/** Tile Collision Check */
   private boolean validLocation(float nx, float ny) {
      if(!onSlope) {
         /** Up Left */
         if (map.blocked(nx, ny)) {
            return false;
         }
         /** Up Right */
         if (map.blocked(nx + sizeW, ny)) {
            return false;
         }
         /** Down Left */
         if (map.blocked(nx, ny + sizeH)) {
            /** If player is jumping, change state to IDLE */
            if(jumping) {
               jumping = false;
               jumpDistance = 0;
               idle = true;
            }
            return false;
         }
         /** Down Right */
         if (map.blocked(nx + sizeW, ny + sizeH)) {
            /** If player is jumping, change state to IDLE */
            if(jumping) {
               jumping = false;
               jumpDistance = 0;
               idle = true;
            }
            return false;
         }
      }
      
      /** If none blocked, return true*/
      return true;
   }

/** Handle key press */
   public void keyPressed(KeyEvent e) {
   //Handle other inputs here, left/right/attack etc
      /** Jumping */
      if (e.getKeyCode() == KeyEvent.VK_SPACE && !jumping && !attacking && !pressSpace) {
         space = true;
         pressSpace = true;
      }
   }
   
   /** Handle key release */
   public void keyReleased(KeyEvent e) {   
         //Handle other input here, left/right/attack etc

      /** Jumping */
      if(e.getKeyCode() == KeyEvent.VK_SPACE) {
         space = false;
         pressSpace = false;
      }
   }

public void update(long elapsedTime) {
      float dx = 0, dy = 0;
      
      moveSpeed = 0.1f;
      moveSpeed *= elapsedTime * 0.05f;

                /** Player jumping*/
      if(space && !jumping) {
         if(anim.getCurrentState() == States.ATTACKING ||              
                             anim.getCurrentState() == States.HIT) {
         } else {
            idle = false;
            jumping = true;
            jumpDistance = maxJumpHeight;
         }
      }

               /** Make player jump */
      jump(elapsedTime);
}

/** Makes player jump */
   private void jump(long elapsedTime) {
      /** Check if player is jumping */
      if(jumping) {
         idle = false;
         /** Increase gravity */
         jumpDistance += gravity;
         //jumping up
         if(jumpDistance < 0) {
            /** Check if hits roof */
            if(validLocation(px, py - moveSpeed)) {
               moveY(-moveSpeed);
            } else {
               jumpDistance = 0;
            }
         // Falling down
         } else if(jumpDistance > 0) {
            moveY(moveSpeed);
         }
         /** Set Jumping Animation */
         if(States.JUMPING > anim.getCurrentState()) {
            anim.setCurrentState(States.JUMPING);
         }
         
         /** Update animation */
         updateAnim(elapsedTime);
      } 
   }