content: package com.almasb.l4d;
  /**
   * Comment free (yay) source code for Left 4k Dead by Markus Persson
   * Please don't reuse any of this code in other projects.
   * http://www.mojang.com/notch/j4k/l4kd/
   */
  import java.applet.Applet;
  import java.awt.*;
  import java.awt.event.*;
  import java.awt.image.*;
  import java.util.*;
  
  public class L4d extends Applet implements Runnable
  {
      @Override
      public void run() {
  
      }
  
  
  //    private boolean[] k = new boolean[32767];
  //    private int m;
  //
  //    public void start()
  //    {
  //        enableEvents(AWTEvent.KEY_EVENT_MASK | AWTEvent.MOUSE_EVENT_MASK | AWTEvent.MOUSE_MOTION_EVENT_MASK);
  //        new Thread(this).start();
  //    }
  //
  //    public void run()
  //    {
  //        BufferedImage image = new BufferedImage(240, 240, BufferedImage.TYPE_INT_RGB);
  //        Graphics ogr = image.getGraphics();
  //
  //        Random random = new Random();
  //        int[] pixels = ((DataBufferInt) image.getRaster().getDataBuffer()).getData();
  //        int[] sprites = new int[18 * 4 * 16 * 12 * 12];
  //        int pix = 0;
  //
  //        for (int i = 0; i < 18; i++)
  //        {
  //            int skin = 0xFF9993;
  //            int clothes = 0xFFffff;
  //
  //            if (i > 0)
  //            {
  //                skin = 0xa0ff90;
  //                clothes = (random.nextInt(0x1000000) & 0x7f7f7f);
  //            }
  //
  //            for (int t = 0; t < 4; t++)
  //            {
  //                for (int d = 0; d < 16; d++)
  //                {
  //                    double dir = d * Math.PI * 2 / 16.0;
  //
  //                    if (t == 1) dir += 0.5 * Math.PI * 2 / 16.0;
  //                    if (t == 3) dir -= 0.5 * Math.PI * 2 / 16.0;
  //
  ////                    if (i == 17)
  ////                    {
  ////                        dir = d * Math.PI * 2 / 64;
  //                    //}
  //
  //                    double cos = Math.cos(dir);
  //                    double sin = Math.sin(dir);
  //
  //                    for (int y = 0; y < 12; y++)
  //                    {
  //                        int col = 0x000000;
  //                        for (int x = 0; x < 12; x++)
  //                        {
  //                            int xPix = (int) (cos * (x - 6) + sin * (y - 6) + 6.5);
  //                            int yPix = (int) (cos * (y - 6) - sin * (x - 6) + 6.5);
  //
  //                            if (i == 17)
  //                            {
  //                                if (xPix > 3 && xPix < 9 && yPix > 3 && yPix < 9)
  //                                {
  //                                    col = 0xff0000 + (t & 1) * 0xff00;
  //                                }
  //                            }
  //                            else
  //                            {
  //                                if (t == 1 && xPix > 1 && xPix < 4 && yPix > 3 && yPix < 8) col = skin;
  //                                if (t == 3 && xPix > 8 && xPix < 11 && yPix > 3 && yPix < 8) col = skin;
  //
  //                                if (xPix > 1 && xPix < 11 && yPix > 5 && yPix < 8)
  //                                {
  //                                    col = clothes;
  //                                }
  //                                if (xPix > 4 && xPix < 8 && yPix > 4 && yPix < 8)
  //                                {
  //                                    col = skin;
  //                                }
  //                            }
  //                            sprites[pix++] = col;
  //                            if (col > 1)
  //                            {
  //                                col = 1;
  //                            }
  //                            else
  //                            {
  //                                col = 0;
  //                            }
  //                        }
  //                    }
  //                }
  //            }
  //        }
  //
  //        int score = 0;
  //        int hurtTime = 0;
  //        int bonusTime = 0;
  //        int xWin0 = 0;
  //        int yWin0 = 0;
  //        int xWin1 = 0;
  //        int yWin1 = 0;
  //
  //        restart: while (true)
  //        {
  //            boolean gameStarted = false;
  //            int level = 0;
  //            int shootDelay = 0;
  //            int rushTime = 150;
  //            int damage = 20;
  //            int ammo = 20;
  //            int clips = 20;
  //
  //            winLevel: while (true)
  //            {
  //                int tick = 0;
  //                level++;
  //                int[] map = new int[1024 * 1024];
  //                random = new Random(4329+level);
  //
  //                int[] monsterData = new int[320 * 16];
  //                {
  //                    int i = 0;
  //                    for (int y = 0; y < 1024; y++)
  //                        for (int x = 0; x < 1024; x++)
  //                        {
  //                            int br = random.nextInt(32) + 112;
  //                            map[i] = (br / 3) << 16 | (br) << 8;
  //                            if (x < 4 || y < 4 || x >= 1020 || y >= 1020)
  //                            {
  //                                map[i] = 0xFFFEFE;
  //                            }
  //                            i++;
  //                        }
  //
  //                    for (i = 0; i < 70; i++)
  //                    {
  //                        int w = random.nextInt(8) + 2;
  //                        int h = random.nextInt(8) + 2;
  //                        int xm = random.nextInt(64 - w - 2) + 1;
  //                        int ym = random.nextInt(64 - h - 2) + 1;
  //
  //                        w *= 16;
  //                        h *= 16;
  //
  //                        w += 5;
  //                        h += 5;
  //                        xm *= 16;
  //                        ym *= 16;
  //
  //                        if (i==68)
  //                        {
  //                            monsterData[0] = xm+w/2;
  //                            monsterData[1] = ym+h/2;
  //                            monsterData[15] = 0x808080;
  //                            monsterData[11] = 1;
  //                        }
  //
  //                        xWin0 = xm+5;
  //                        yWin0 = ym+5;
  //                        xWin1 = xm + w-5;
  //                        yWin1 = ym + h-5;
  //                        for (int y = ym; y < ym + h; y++)
  //                            for (int x = xm; x < xm + w; x++)
  //                            {
  //                                int d = x - xm;
  //                                if (xm + w - x - 1 < d) d = xm + w - x - 1;
  //                                if (y - ym < d) d = y - ym;
  //                                if (ym + h - y - 1 < d) d = ym + h - y - 1;
  //
  //                                map[x + y * 1024] = 0xFF8052;
  //                                if (d > 4)
  //                                {
  //                                    int br = random.nextInt(16) + 112;
  //                                    if (((x + y) & 3) == 0)
  //                                    {
  //                                        br += 16;
  //                                    }
  //                                    map[x + y * 1024] = (br * 3 / 3) << 16 | (br * 4 / 4) << 8 | (br * 4 / 4);
  //                                }
  //                                if (i == 69)
  //                                {
  //                                    map[x + y * 1024] &= 0xff0000;
  //                                }
  //                            }
  //
  //                        for (int j = 0; j < 2; j++)
  //                        {
  //                            int xGap = random.nextInt(w - 24) + xm + 5;
  //                            int yGap = random.nextInt(h - 24) + ym + 5;
  //                            int ww = 5;
  //                            int hh = 5;
  //
  //                            xGap = xGap / 16 * 16 + 5;
  //                            yGap = yGap / 16 * 16 + 5;
  //                            if (random.nextInt(2) == 0)
  //                            {
  //                                xGap = xm + (w - 5) * random.nextInt(2);
  //                                hh = 11;
  //                            }
  //                            else
  //                            {
  //                                ww = 11;
  //                                yGap = ym + (h - 5) * random.nextInt(2);
  //                            }
  //                            for (int y = yGap; y < yGap + hh; y++)
  //                                for (int x = xGap; x < xGap + ww; x++)
  //                                {
  //                                    int br = random.nextInt(32) + 112 - 64;
  //                                    map[x + y * 1024] = (br * 3 / 3) << 16 | (br * 4 / 4) << 8 | (br * 4 / 4);
  //                                }
  //                        }
  //                    }
  //
  //                    for (int y = 1; y < 1024 - 1; y++)
  //                        inloop: for (int x = 1; x < 1024 - 1; x++)
  //                        {
  //                            for (int xx = x - 1; xx <= x + 1; xx++)
  //                                for (int yy = y - 1; yy <= y + 1; yy++)
  //                                    if (map[xx + yy * 1024] < 0xff0000) continue inloop;
  //
  //                            map[x + y * 1024] = 0xffffff;
  //                        }
  //                }
  //
  //                long lastTime = System.nanoTime();
  //
  //                int[] lightmap = new int[240 * 240];
  //                int[] brightness = new int[512];
  //
  //                double offs = 30;
  //                double playerDir = 0;
  //                for (int i = 0; i < 512; i++)
  //                {
  //                    brightness[i] = (int) (255.0 * offs / (i + offs));
  //                    if (i < 4) brightness[i] = brightness[i] * i / 4;
  //                }
  //
  //                Graphics sg = getGraphics();
  //                random = new Random();
  //                while (true)
  //                {
  //                    if (gameStarted)
  //                    {
  //                        tick++;
  //                        rushTime++;
  //
  //                        if (rushTime >= 150)
  //                        {
  //                            rushTime = -random.nextInt(2000);
  //                        }
  //                        // Move player:
  //                        int mouse = m;
  //                        playerDir = Math.atan2(mouse / 240 - 120, mouse % 240 - 120);
  //
  //                        double shootDir = playerDir + (random.nextInt(100) - random.nextInt(100)) / 100.0 * 0.2;
  //                        double cos = Math.cos(-shootDir);
  //                        double sin = Math.sin(-shootDir);
  //
  //                        int xCam = monsterData[0];
  //                        int yCam = monsterData[1];
  //
  //                        for (int i = 0; i < 960; i++)
  //                        {
  //                            int xt = i % 240 - 120;
  //                            int yt = (i / 240 % 2) * 239 - 120;
  //
  //                            if (i >= 480)
  //                            {
  //                                int tmp = xt;
  //                                xt = yt;
  //                                yt = tmp;
  //                            }
  //
  //                            double dd = Math.atan2(yt, xt) - playerDir;
  //                            if (dd < -Math.PI) dd += Math.PI * 2;
  //                            if (dd >= Math.PI) dd -= Math.PI * 2;
  //
  //                            int brr = (int) ((1 - dd * dd) * 255);
  //
  //                            int dist = 120;
  //                            if (brr < 0)
  //                            {
  //                                brr = 0;
  //                                dist = 32;
  //                            }
  //                            if (tick < 60) brr = brr * tick / 60;
  //
  //                            int j = 0;
  //                            for (; j < dist; j++)
  //                            {
  //                                int xx = xt * j / 120 + 120;
  //                                int yy = yt * j / 120 + 120;
  //                                int xm = xx + xCam - 120;
  //                                int ym = yy + yCam - 120;
  //
  //                                if (map[(xm + ym * 1024) & (1024 * 1024 - 1)] == 0xffffff) break;
  //
  //                                int xd = (xx - 120) * 256 / 120;
  //                                int yd = (yy - 120) * 256 / 120;
  //
  //                                int ddd = (xd * xd + yd * yd) / 256;
  //                                int br = brightness[ddd] * brr / 255;
  //
  //                                if (ddd < 16)
  //                                {
  //                                    int tmp = 128 * (16 - ddd) / 16;
  //                                    br = br + tmp * (255 - br) / 255;
  //                                }
  //
  //                                lightmap[xx + yy * 240] = br;
  //                            }
  //                        }
  //                        for (int y = 0; y < 240; y++)
  //                        {
  //                            int xm = xCam - 120;
  //                            int ym = y + yCam - 120;
  //                            for (int x = 0; x < 240; x++)
  //                            {
  //                                pixels[x + y * 240] = map[(xm + x + ym * 1024) & (1024 * 1024 - 1)];
  //                            }
  //                        }
  //
  //                        int closestHitDist = 0;
  //                        for (int j = 0; j < 250; j++)
  //                        {
  //                            int xm = xCam + (int) (cos * j / 2);
  //                            int ym = yCam - (int) (sin * j / 2);
  //                            if (map[(xm + ym * 1024) & (1024 * 1024 - 1)] == 0xffffff) break;
  //                            closestHitDist = j / 2;
  //                        }
  //
  //                        boolean shoot = shootDelay-- < 0 && k[1];
  //
  //                        {
  //                            int closestHit = 0;
  //
  //                            nextMonster: for (int m = 0; m < 256 + 16; m++)
  //                            {
  //                                int xPos = monsterData[m * 16 + 0];
  //                                int yPos = monsterData[m * 16 + 1];
  //                                if (monsterData[m * 16 + 11] == 0)
  //                                {
  //                                    xPos = (random.nextInt(62) + 1) * 16 + 8;
  //                                    yPos = (random.nextInt(62) + 1) * 16 + 8;
  //
  //                                    int xd = xCam - xPos;
  //                                    int yd = yCam - yPos;
  //
  //                                    if (xd * xd + yd * yd < 180 * 180)
  //                                    {
  //                                        xPos = 1;
  //                                        yPos = 1;
  //                                    }
  //
  //                                    if (map[xPos + yPos * 1024] < 0xfffffe && (m <= 128 || rushTime > 0 || (m > 255 && tick == 1)))
  //                                    {
  //                                        monsterData[m * 16 + 0] = xPos;
  //                                        monsterData[m * 16 + 1] = yPos;
  //                                        monsterData[m * 16 + 15] = map[xPos + yPos * 1024];
  //                                        map[xPos + yPos * 1024] = 0xfffffe;
  //                                        monsterData[m * 16 + 9] = (rushTime > 0 || random.nextInt(3) == 0) ? 127 : 0;
  //                                        monsterData[m * 16 + 11] = 1;
  //                                        monsterData[m * 16 + 2] = m & 15;
  //                                    }
  //                                    else
  //                                    {
  //                                        continue;
  //                                    }
  //                                }
  //                                else
  //                                {
  //                                    int xd = xPos - xCam;
  //                                    int yd = yPos - yCam;
  //
  //                                    if (m >= 255)
  //                                    {
  //                                        if (xd * xd + yd * yd < 8 * 8)
  //                                        {
  //                                            map[xPos + yPos * 1024] = monsterData[m * 16 + 15];
  //                                            monsterData[m * 16 + 11] = 0;
  //                                            bonusTime = 120;
  //                                            if ((m & 1) == 0)
  //                                            {
  //                                                damage = 20;
  //                                            }
  //                                            else
  //                                            {
  //                                                clips = 20;
  //                                            }
  //                                            continue;
  //                                        }
  //                                    }
  //                                    else if (xd * xd + yd * yd > 340 * 340)
  //                                    {
  //                                        map[xPos + yPos * 1024] = monsterData[m * 16 + 15];
  //                                        monsterData[m * 16 + 11] = 0;
  //                                        continue;
  //                                    }
  //                                }
  //
  //
  //                                int xm = xPos - xCam + 120;
  //                                int ym = monsterData[m * 16 + 1] - yCam + 120;
  //
  //                                int d = monsterData[m * 16 + 2];
  //                                if (m == 0)
  //                                {
  //                                    d = (((int) (playerDir / (Math.PI * 2) * 16 + 4.5 + 16)) & 15);
  //                                }
  //
  //                                d += ((monsterData[m * 16 + 3] / 4) & 3) * 16;
  //
  //                                int p = (0 * 16 + d) * 144;
  //                                if (m > 0)
  //                                {
  //                                    p += ((m & 15) + 1) * 144 * 16 * 4;
  //                                }
  //
  //                                if (m > 255)
  //                                {
  //                                    p = (17 * 4 * 16 + ((m & 1) * 16 + (tick & 15))) * 144;
  //                                }
  //
  //                                for (int y = ym - 6; y < ym + 6; y++)
  //                                    for (int x = xm - 6; x < xm + 6; x++)
  //                                    {
  //                                        int c = sprites[p++];
  //                                        if (c > 0 && x >= 0 && y >= 0 && x < 240 && y < 240)
  //                                        {
  //                                            pixels[x + y * 240] = c;
  //                                        }
  //                                    }
  //
  //
  //                                boolean moved = false;
  //
  //                                if (monsterData[m * 16 + 10] > 0)
  //                                {
  //                                    monsterData[m * 16 + 11] += random.nextInt(3) + 1;
  //                                    monsterData[m * 16 + 10] = 0;
  //
  //                                    double rot = 0.25;
  //                                    int amount = 8;
  //                                    double poww = 32;
  //
  //
  //                                    if (monsterData[m * 16 + 11] >= 2+level)
  //                                    {
  //                                        rot = Math.PI * 2;
  //                                        amount = 60;
  //                                        poww = 16;
  //                                        map[(xPos) + (yPos) * 1024] = 0xa00000;
  //                                        monsterData[m * 16 + 11] = 0;
  //                                        score += level;
  //                                    }
  //                                    for (int i = 0; i < amount; i++)
  //                                    {
  //                                        double pow = (random.nextInt(100) * random.nextInt(100)) * poww / 10000+4;
  //                                        double dir = (random.nextInt(100) - random.nextInt(100)) / 100.0 * rot;
  //                                        double xdd = (Math.cos(playerDir + dir) * pow) + random.nextInt(4) - random.nextInt(4);
  //                                        double ydd = (Math.sin(playerDir + dir) * pow) + random.nextInt(4) - random.nextInt(4);
  //                                        int col = (random.nextInt(128) + 120);
  //                                        bloodLoop: for (int j = 2; j < pow; j++)
  //                                        {
  //                                            int xd = (int) (xPos + xdd * j / pow);
  //                                            int yd = (int) (yPos + ydd * j / pow);
  //                                            int pp = ((xd) + (yd) * 1024) & (1024 * 1024 - 1);
  //                                            if (map[pp] >= 0xff0000) break bloodLoop;
  //                                            if (random.nextInt(2) != 0)
  //                                            {
  //                                                map[pp] = col << 16;
  //                                                col = col * 8 / 9;
  //                                            }
  //                                        }
  //                                    }
  //
  //                                    continue nextMonster;
  //                                }
  //
  //                                int xPlayerDist = xCam - xPos;
  //                                int yPlayerDist = yCam - yPos;
  //
  //                                if (m <= 255)
  //                                {
  //                                    double rx = -(cos * xPlayerDist - sin * yPlayerDist);
  //                                    double ry = cos * yPlayerDist + sin * xPlayerDist;
  //
  //                                    if (rx > -6 && rx < 6 && ry > -6 && ry < 6 && m > 0)
  //                                    {
  //                                        damage++;
  //                                        hurtTime += 20;
  //                                    }
  //                                    if (rx > -32 && rx < 220 && ry > -32 && ry < 32 && random.nextInt(10) == 0)
  //                                    {
  //                                        monsterData[m * 16 + 9]++;
  //                                    }
  //                                    if (rx > 0 && rx < closestHitDist && ry > -8 && ry < 8)
  //                                    {
  //                                        closestHitDist = (int) (rx);
  //                                        closestHit = m;
  //                                    }
  //
  //                                    dirLoop: for (int i = 0; i < 2; i++)
  //                                    {
  //                                        int xa = 0;
  //                                        int ya = 0;
  //                                        xPos = monsterData[m * 16 + 0];
  //                                        yPos = monsterData[m * 16 + 1];
  //
  //                                        if (m == 0)
  //                                        {
  //                                            if (k[KeyEvent.VK_A]) xa--;
  //                                            if (k[KeyEvent.VK_D]) xa++;
  //                                            if (k[KeyEvent.VK_W]) ya--;
  //                                            if (k[KeyEvent.VK_S]) ya++;
  //                                        }
  //                                        else
  //                                        {
  //                                            if (monsterData[m * 16 + 9] < 8) continue nextMonster;
  //
  //                                            if (monsterData[m * 16 + 8] != 12)
  //                                            {
  //                                                xPlayerDist = (monsterData[m * 16 + 8]) % 5 - 2;
  //                                                yPlayerDist = (monsterData[m * 16 + 8]) / 5 - 2;
  //                                                if (random.nextInt(10) == 0)
  //                                                {
  //                                                    monsterData[m * 16 + 8] = 12;
  //                                                }
  //                                            }
  //
  //                                            double xxd = Math.sqrt(xPlayerDist * xPlayerDist);
  //                                            double yyd = Math.sqrt(yPlayerDist * yPlayerDist);
  //                                            if (random.nextInt(1024) / 1024.0 < yyd / xxd)
  //                                            {
  //                                                if (yPlayerDist < 0) ya--;
  //                                                if (yPlayerDist > 0) ya++;
  //                                            }
  //                                            if (random.nextInt(1024) / 1024.0 < xxd / yyd)
  //                                            {
  //                                                if (xPlayerDist < 0) xa--;
  //                                                if (xPlayerDist > 0) xa++;
  //                                            }
  //
  //                                            moved = true;
  //                                            double dir = Math.atan2(yPlayerDist, xPlayerDist);
  //                                            monsterData[m * 16 + 2] = (((int) (dir / (Math.PI * 2) * 16 + 4.5 + 16)) & 15);
  //                                        }
  //
  //                                        ya *= i;
  //                                        xa *= 1 - i;
  //
  //                                        if (xa != 0 || ya != 0)
  //                                        {
  //                                            map[xPos + yPos * 1024] = monsterData[m * 16 + 15];
  //                                            for (int xx = xPos + xa - 3; xx <= xPos + xa + 3; xx++)
  //                                                for (int yy = yPos + ya - 3; yy <= yPos + ya + 3; yy++)
  //                                                    if (map[xx + yy * 1024] >= 0xfffffe)
  //                                                    {
  //                                                        map[xPos + yPos * 1024] = 0xfffffe;
  //                                                        monsterData[m * 16 + 8] = random.nextInt(25);
  //                                                        continue dirLoop;
  //                                                    }
  //
  //                                            moved = true;
  //                                            monsterData[m * 16 + 0] += xa;
  //                                            monsterData[m * 16 + 1] += ya;
  //                                            monsterData[m * 16 + 15] = map[(xPos + xa) + (yPos + ya) * 1024];
  //                                            map[(xPos + xa) + (yPos + ya) * 1024] = 0xfffffe;
  //                                        }
  //                                    }
  //                                    if (moved)
  //                                    {
  //                                        monsterData[m * 16 + 3]++;
  //                                    }
  //                                }
  //                            }
  //
  //                            if (shoot)
  //                            {
  //                                if (ammo >= 220)
  //                                {
  //                                    shootDelay = 2;
  //                                    k[1] = false;
  //                                }
  //                                else
  //                                {
  //                                    shootDelay = 1;
  //                                    ammo += 4;
  //                                }
  //                                if (closestHit > 0)
  //                                {
  //                                    monsterData[closestHit * 16 + 10] = 1;
  //                                    monsterData[closestHit * 16 + 9] = 127;
  //                                }
  //                                int glow = 0;
  //                                for (int j = closestHitDist; j >= 0; j--)
  //                                {
  //                                    int xm = +(int) (cos * j) + 120;
  //                                    int ym = -(int) (sin * j) + 120;
  //                                    if (xm > 0 && ym > 0 && xm < 240 && ym < 240)
  //                                    {
  //                                        if (random.nextInt(20) == 0 || j == closestHitDist)
  //                                        {
  //                                            pixels[xm + ym * 240] = 0xffffff;
  //                                            glow = 200;
  //                                        }
  //                                        lightmap[xm + ym * 240] += glow * (255 - lightmap[xm + ym * 240]) / 255;
  //                                    }
  //                                    glow = glow * 20 / 21;
  //                                }
  //
  //                                if (closestHitDist < 120)
  //                                {
  //                                    closestHitDist -= 3;
  //                                    int xx = (int) (120 + cos * closestHitDist);
  //                                    int yy = (int) (120 - sin * closestHitDist);
  //
  //                                    for (int x = -12; x <= 12; x++)
  //                                    {
  //                                        for (int y = -12; y <= 12; y++)
  //                                        {
  //                                            int xd = xx + x;
  //                                            int yd = yy + y;
  //                                            if (xd >= 0 && yd >= 0 && xd < 240 && yd < 240)
  //                                            {
  //                                                lightmap[xd + yd * 240] += 2000 / (x * x + y * y + 10) * (255 - lightmap[xd + yd * 240]) / 255;
  //                                            }
  //                                        }
  //                                    }
  //
  //                                    for (int i = 0; i < 10; i++)
  //                                    {
  //                                        double pow = random.nextInt(100) * random.nextInt(100) * 8.0 / 10000;
  //                                        double dir = (random.nextInt(100) - random.nextInt(100)) / 100.0;
  //                                        int xd = (int) (xx - Math.cos(playerDir + dir) * pow) + random.nextInt(4) - random.nextInt(4);
  //                                        int yd = (int) (yy - Math.sin(playerDir + dir) * pow) + random.nextInt(4) - random.nextInt(4);
  //                                        if (xd >= 0 && yd >= 0 && xd < 240 && yd < 240)
  //                                        {
  //                                            if (closestHit > 0)
  //                                            {
  //                                                pixels[xd + yd * 240] = 0xff0000;
  //                                            }
  //                                            else
  //                                            {
  //                                                pixels[xd + yd * 240] = 0xcacaca;
  //                                            }
  //                                        }
  //                                    }
  //                                }
  //                            }
  //                        }
  //
  //
  //                        if (damage >= 220)
  //                        {
  //                            k[1] = false;
  //                            hurtTime = 255;
  //                            continue restart;
  //                        }
  //                        if (k[KeyEvent.VK_R] && ammo > 20 && clips < 220)
  //                        {
  //                            shootDelay = 30;
  //                            ammo = 20;
  //                            clips += 10;
  //                        }
  //
  //                        if (xCam > xWin0 && xCam < xWin1 && yCam > yWin0 && yCam < yWin1)
  //                        {
  //                            continue winLevel;
  //                        }
  //                    }
  //
  //                    bonusTime = bonusTime * 8 / 9;
  //                    hurtTime /= 2;
  //
  //                    for (int y = 0; y < 240; y++)
  //                    {
  //                        for (int x = 0; x < 240; x++)
  //                        {
  //                            int noise = random.nextInt(16) * random.nextInt(16) / 16;
  //                            if (!gameStarted) noise *= 4;
  //
  //                            int c = pixels[x + y * 240];
  //                            int l = lightmap[x + y * 240];
  //                            lightmap[x + y * 240] = 0;
  //                            int r = ((c >> 16) & 0xff) * l / 255 + noise;
  //                            int g = ((c >> 8) & 0xff) * l / 255 + noise;
  //                            int b = ((c) & 0xff) * l / 255 + noise;
  //
  //                            r = r * (255 - hurtTime) / 255 + hurtTime;
  //                            g = g * (255 - bonusTime) / 255 + bonusTime;
  //                            pixels[x + y * 240] = r << 16 | g << 8 | b;
  //                        }
  //                        if (y % 2 == 0 && (y >= damage && y < 220))
  //                        {
  //                            for (int x = 232; x < 238; x++)
  //                            {
  //                                pixels[y * 240 + x] = 0x800000;
  //                            }
  //                        }
  //                        if (y % 2 == 0 && (y >= ammo && y < 220))
  //                        {
  //                            for (int x = 224; x < 230; x++)
  //                            {
  //                                pixels[y * 240 + x] = 0x808000;
  //                            }
  //                        }
  //                        if (y % 10 < 9 && (y >= clips && y < 220))
  //                        {
  //                            for (int x = 221; x < 222; x++)
  //                            {
  //                                pixels[y * 240 + 221] = 0xffff00;
  //                            }
  //                        }
  //                    }
  //
  //                    ogr.drawString("" + score, 4, 232);
  //                    if (!gameStarted)
  //                    {
  //                        ogr.drawString("Left 4k Dead", 80, 70);
  //                        if (k[1] && hurtTime == 0)
  //                        {
  //                            score = 0;
  //                            gameStarted = true;
  //                            k[1] = false;
  //                        }
  //                    }
  //                    else if (tick < 60)
  //                    {
  //                        ogr.drawString("Level " + level, 90, 70);
  //                    }
  //
  //                    sg.drawImage(image, 0, 0, 480, 480, 0, 0, 240, 240, null);
  //                    do
  //                    {
  //                        Thread.yield();
  //                    }
  //                    while (System.nanoTime() - lastTime < 0);
  //                    if (!isActive()) return;
  //
  //                    lastTime += (1000000000 / 30);
  //                }
  //            }
  //        }
  //    }
  //
  //    public void processEvent(AWTEvent e)
  //    {
  //        boolean down = false;
  //        switch (e.getID())
  //        {
  //            case KeyEvent.KEY_PRESSED:
  //                down = true;
  //            case KeyEvent.KEY_RELEASED:
  //                k[((KeyEvent) e).getKeyCode()] = down;
  //                break;
  //            case MouseEvent.MOUSE_PRESSED:
  //                down = true;
  //            case MouseEvent.MOUSE_RELEASED:
  //                k[((MouseEvent) e).getButton()] = down;
  //            case MouseEvent.MOUSE_MOVED:
  //            case MouseEvent.MOUSE_DRAGGED:
  //                m = ((MouseEvent) e).getX() / 2 + ((MouseEvent) e).getY() / 2 * 240;
  //        }
  //    }
  }
  