//fields
private float x, y;
private float vx, vy;
private float elapsedTime = -1;
private final float g = -10;
private final float jumpingPower = 6;

private final int FPS = 60;
private final float DELTA = 1f/FPS;

public void update() {
    //crap here

    if(/*spacebar is pressed*/) {
        vy = jumpingPower; //you probably want a mechanism limiting the frequency of jumps
        elapsedTime = 0;
    }
    
    //gravity affects vy constantly
    if (elapsedTime != -1) {
        vy = elapsedTime * DELTA * jumpingPower + g / 2 * elapsedTime * elapsedTime * DELTA * DELTA; // alternatively, set initial value of vy as the stuff before the + sign, and increment by the stuff after the + sign
        y += vy;
        elapsedTime++; // alternatively, increment by 'DELTA' and get rid of 'DELTA' in equation for solving vy
    }
    
    //collision detection
    for(Blocks b : randomBlocks) {
        if(this.intersects(b)) {
            if (vy >= 0) { // We hit our head on something, start falling
                elapsedTime = -2f * jumpingPower / g; // The time when vy changes from positive to negative, i.e. you start falling. Completely inelastic collision.
            } else { // We landed on a platform, stop moving
                vy = 0;
                elapsedTime = -1;
            }
        }
    }
}

            float difY = tile.top() - tile.bottom();
            int offZ = off % 360;
            float o_ = 0;
            for (int z = offZ; z <= 360 + offZ; ) {
               float x_ = (float) (Math.sin(z * DEG_2_RAD) * 2 * PIXEL_X);

               gl.glTexCoord2f(tile.left(), tile.bottom() + difY * (z - offZ) / 360);
               gl.glVertex2f(l + o_, b + h_interval * (z - offZ) / 360); // bottom-left
               gl.glTexCoord2f(tile.right(), tile.bottom() + difY * (z - offZ) / 360);
               gl.glVertex2f(r + o_, b + h_interval * (z - offZ) / 360); // bottom-right

               z += 30;
               o_ = x_;

               gl.glTexCoord2f(tile.right(), tile.bottom() + difY * (z - offZ) / 360);
               gl.glVertex2f(r + x_, b + h_interval * (z - offZ) / 360); // top-right
               gl.glTexCoord2f(tile.left(), tile.bottom() + difY * (z - offZ) / 360);
               gl.glVertex2f(l + x_, b + h_interval * (z - offZ) / 360); // top-left
            }

 if (obj instanceof Window) {
...

   private final float A = W * 0.08f;
   private final float B = W * (1f - 0.08f);

   private final void createTrapezium(BufferedImage src, BufferedImage out) {
      int[] pix = ((DataBufferInt) src.getRaster().getDataBuffer()).getData();
      int[] pix2 = ((DataBufferInt) out.getRaster().getDataBuffer()).getData();
      Arrays.fill(pix2, 0);
      for (int y = 0; y < HEIGHT; y++) {
         int yw = y * W;
         float y_to_h = y / (float) HEIGHT;
         float C_A_offset = A * (1 - y_to_h);
         float trapeziumLine = -C_A_offset + B + (W - B) * y_to_h;
         float k = trapeziumLine / W;
         for (int x = 0; x < W; x++) {
            int destX = (int) (C_A_offset + x * k);
            pix2[yw + destX] = pix[yw + x];
         }
      }
   }

private static final Direction[] directions = {
     EAST, SOUTH, WEST, NORTH
};

public static final Direction get(int dx, int dy) {
     return directions[dx & 2 | dy & 3];
}

public boolean paused;
public long pauseElapsed, pauseStarted;
public void pause(boolean on) {
   paused = on;
   if (on) {
      pauseStarted = System.currentTimeMillis();
   } else {
      pauseElapsed += System.currentTimeMillis() - pauseStarted;
   }
}
...
if (!paused) {
   millis = System.currentTimeMillis() - startTime - pauseElapsed;
   hours = millis / (1000 * 60 * 60);
   millis -= hours * (1000 * 60 * 60);
   minutes = millis / (1000 * 60);
   millis -= minutes * (1000 * 60);
   seconds = millis / 1000;
}
g.drawString("Time: " + hours + ":" + minutes + ":" + seconds, 300, 10);

public class Packets {

   private static final int[] sizes = new int[256];
   private static final Packet[] packets = new Packet[256];
   static {
      packets[187] = new AttemptLogin();
      sizes[187] = -1;
      packets[23] = new RemotePlayer();
      sizes[23] = -1;
      packets[112] = new DrawingAction();
      sizes[112] = -1;
      packets[83] = new ChatMessage();
      sizes[83] = -1; // size can change, send it as a byte
      packets[241] = new RegionRequest();
      sizes[241] = -2; // size can change, send it as an int
   }

   public static Buffer fragment;
   public static ISAAC decryptor;

   public static void handle(Buffer buffer) { // read a chunk of data as a byte[] and pass it along to my custom Buffer class for easy reading
      boolean decrypt = true;
      if (fragment != null) {
         buffer.insertStart(fragment.array());
         fragment = null;
         decrypt = false;
      }
      while (buffer.remaining() > 0) {
         int opcode = buffer.getSigned();
         if (decrypt) {
            if (decryptor != null)
               opcode -= decryptor.next();
         } else {
            decrypt = true;
         }
         opcode &= 0xFF;

         int size = sizes[opcode];
         Packet packet = packets[opcode];
         if (packet == null) {
            System.out.println("Non-existant packet: " + opcode);
            return;
         }

         if (size == -1) {
            if (buffer.remaining() > 0)
               size = buffer.get();
            else {
               fragment = new Buffer(2).put(opcode);
               buffer.clear();
               System.out.println("Storing fragmented packet " + opcode + ".");
               return;
            }
         } else if (size == -2) {
            if (buffer.remaining() > 3)
               size = buffer.getInt();
            else {
               fragment = new Buffer(2).put(opcode);
               buffer.clear();
               System.out.println("Storing fragmented packet " + opcode + ".");
               return;
            }
         }

         int remaining = buffer.remaining() - size;

         if (remaining < 0) {
            fragment = new Buffer().put(opcode);
            if (sizes[opcode] == -2)
               fragment.putInt(size);
            else
               fragment.put(size);
            fragment.put(buffer.getBackingBuffer(), buffer.readPosition(), buffer.remaining());
            buffer.clear();
            System.out.println("Storing fragmented packet " + opcode + ", size " + fragment.writePosition() + ".");
            return;
         }

         try {
            packet.execute(buffer, opcode, size);
         } catch (Exception e) {
            e.printStackTrace();
         }

         if (buffer.remaining() != remaining) {
            System.out.println("<Opcode:" + opcode + "> Expected: " + remaining +", Actual: " + buffer.remaining());
            buffer.skip(buffer.remaining() - remaining);
         }
      }
   }

}