import java.applet.Applet;
import java.applet.AudioClip;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.image.CropImageFilter;
import java.awt.image.FilteredImageSource;
import java.io.*;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Random;

public class WW_Infinite extends Applet
    implements Runnable
{

    int jumparray[] = {
        -4, -4, -4, -4, -2, -2, -2, -2, 0, 0
    };
    int fallarray[] = {
        4, 4, 4, 4, 2, 2, 2, 2, 0, 0
    };
    int playercrop[] = {
        0, 0, 30, 0, 60, 0, 90, 0, 60, 0, 
        30, 0, 120, 0, 270, 0, 180, 0, 210, 0, 
        240, 0, 210, 0, 180, 0, 150, 0, 300, 0, 
        330, 0
    };
    boolean up;
    boolean down;
    boolean left;
    boolean right;
    boolean jump;
    boolean fall;
    boolean jumprelease;
    boolean standing;
    boolean collision;
    boolean paused;
    boolean death;
    boolean gameover;
    boolean ladder;
    boolean destroying;
    boolean isexplosion;
    Button again;
    Button send;
    TextField entryName;
    CGIcall cgi;
    boolean alreadysent;
    boolean Scoregameover;
    private final String param_cfg_file = "Scorepath";
    private String m_cfgfile;
    private String param;
    private String URLName;
    Image imgexplosion;
    Image bimg[];
    Image imgeye[];
    Image imgeye2[];
    Image imgblobs[];
    Image imgspike;
    Image bigstar;
    Image tiles[];
    Image background;
    Image close[];
    Image huh;
    Image imgswitch[];
    AudioClip blobau;
    AudioClip landau;
    AudioClip dieau;
    AudioClip stepau;
    AudioClip switchau;
    AudioClip startupau;
    AudioClip level2au;
    int explosion[][];
    int bottom[][];
    int blobs[][];
    int spike[][];
    int eye[][];
    int eye2[][];
    int witch[][];
    int lblobs[][];
    int points[][];
    int switches[][];
    int climbframe;
    int climbdelay;
    int lastpoints;
    boolean out[];
    int outx[];
    int outy[];
    int outd[];
    int bigstarx;
    int bigstary;
    int bigstars;
    int gameoverdelay;
    Random rn;
    Font big;
    Font overfont;
    Font barfont;
    int running;
    int scrolly;
    int offsety;
    int bc;
    int lives;
    int closestep;
    int direction;
    int frame;
    int gamestate;
    int donedelay;
    Image offScreenImage;
    Graphics off;
    Graphics backgroundgraphics;
    Player p;
    Map canvas;
    MapArchive maps;
    int jumpstep;
    int level;
    private MediaTracker tracker;
    long delay;
    long tm;
    long score;
    Thread game;
    long startTime;
    long lastTime;
    long secondsPassed;

    public void stop()
    {
        if(game != null && game.isAlive())
        {
            game.stop();
            game = null;
        }
    }

    public void ss(int i, int j, int k, int l, int i1, int j1, int k1, 
            int l1, int i2)
    {
        spike[i][0] = 100;
        spike[i][1] = j;
        spike[i][2] = k;
        spike[i][3] = l;
        spike[i][4] = j1;
        spike[i][5] = i1;
        spike[i][6] = k1;
        spike[i][7] = l1;
        spike[i][8] = i2;
    }

    private AudioClip LoadAudioClip(String s)
    {
        AudioClip audioclip = getAudioClip(getDocumentBase(), s);
        audioclip.play();
        audioclip.stop();
        return audioclip;
    }

    public void movement()
    {
        if(canvas.checkCollision(p.x, p.y + offsety, 24, 24) == 400)
        {
            startDeath();
        }
        if(left && !ladder)
        {
            int i = canvas.checkCollision(p.x - 2, p.y + offsety, 24, 24);
            if(i != 100 && i != 400)
            {
                p.x -= 2;
                running++;
                standing = false;
                if(running > 15)
                {
                    running = 3;
                }
            }
            if(i == 400)
            {
                startDeath();
            }
        }
        if(right && !ladder)
        {
            int j = canvas.checkCollision(p.x + 2, p.y + offsety, 24, 24);
            if(j != 100 && j != 400)
            {
                p.x += 2;
                running++;
                standing = false;
                if(running > 15)
                {
                    running = 3;
                }
            }
            if(j == 400)
            {
                startDeath();
            }
        }
        int k = canvas.checkCollision(p.x, (p.y + offsety) - 4, 24, 24);
        if(up && (p.y + offsety) % 4 == 0 && k != 100)
        {
            if(canvas.checkCollision(p.x + 8, p.y + offsety, 8, 24) == 300 || canvas.checkCollision(p.x + 8, p.y + offsety, 8, 24) == 310)
            {
                if(!ladder)
                {
                    jump = fall = false;
                    p.x = (p.x / 24) * 24;
                    if(canvas.checkCollision(p.x, p.y + offsety, 24, 24) != 300 && canvas.checkCollision(p.x, p.y + offsety, 24, 24) != 310)
                    {
                        p.x = ((p.x + 24) / 24) * 24;
                    }
                }
                ladder = true;
                climbdelay++;
                if(climbdelay > 3)
                {
                    climbframe *= -1;
                    climbdelay = 0;
                }
                if(p.y > 120 || offsety < 1)
                {
                    p.y -= 4;
                } else
                {
                    scrolly += 4;
                    offsety -= 4;
                }
            } else
            if(canvas.checkCollision(p.x, p.y + offsety, 16, 24) != 300)
            {
                ladder = false;
            }
        }
        if(down && !fall && !jump)
        {
            int l = canvas.checkCollision(p.x + 8, p.y + offsety, 8, 24);
            int i1 = canvas.checkCollision(p.x + 8, p.y + offsety + 4, 8, 24);
            if((l == 300 || i1 == 300 || l == 310 || i1 == 310) && i1 != 100)
            {
                if(!ladder)
                {
                    jump = fall = false;
                    p.x = (p.x / 24) * 24;
                    if(canvas.checkCollision(p.x, p.y + offsety + 4, 24, 24) != 300 && canvas.checkCollision(p.x, p.y + offsety + 4, 24, 24) != 310)
                    {
                        p.x = ((p.x + 24) / 24) * 24;
                    }
                }
                climbdelay++;
                if(climbdelay > 3)
                {
                    climbframe *= -1;
                    climbdelay = 0;
                }
                ladder = true;
                if(p.y < 240 || offsety == 720)
                {
                    p.y += 4;
                } else
                {
                    scrolly -= 4;
                    offsety += 4;
                }
            } else
            {
                ladder = false;
            }
        }
        if(!left && !right && !jump && !fall && !ladder)
        {
            standing = true;
            running = 1;
        }
        if(fall || jump)
        {
            if(direction == 0)
            {
                p.setFrame(6);
            } else
            {
                p.setFrame(13);
            }
        } else
        if(ladder)
        {
            if(climbframe < 0)
            {
                if(p.frame == 14)
                {
                    stepau.play();
                }
                p.setFrame(15);
            } else
            {
                if(p.frame == 15)
                {
                    stepau.play();
                }
                p.setFrame(14);
            }
        } else
        if(standing)
        {
            if(direction == 0)
            {
                p.setFrame(0);
            } else
            {
                p.setFrame(7);
            }
        } else
        {
            if(running == 6 || running == 12)
            {
                stepau.play();
            }
            if(direction == 0)
            {
                p.setFrame(running / 3);
            } else
            {
                p.setFrame(7 + running / 3);
            }
        }
        if(jump)
        {
            dojump();
            return;
        }
        if(!ladder)
        {
            dofall();
        }
    }

    public void resetEnemy()
    {
        int i = 0;
        do
        {
            switches[i][0] = switches[i][3] = switches[i][4] = bottom[i][0] = explosion[i][0] = 0;
        } while(++i < 8);
        i = 0;
        do
        {
            lblobs[i][0] = spike[i][0] = 0;
        } while(++i < 16);
        i = 0;
        do
        {
            out[i] = false;
        } while(++i < 4);
        i = 0;
        do
        {
            eye[i][0] = eye2[i][0] = 0;
        } while(++i < 4);
        i = 0;
        do
        {
            blobs[i][0] = 0;
        } while(++i < 24);
    }

    public void doDeathExplosion()
    {
        bigstars++;
        if(bigstars < 55)
        {
            off.drawImage(bigstar, bigstarx, bigstary + bigstars * 8, this);
            off.drawImage(bigstar, bigstarx + bigstars * 8, bigstary, this);
            off.drawImage(bigstar, bigstarx - bigstars * 8, bigstary, this);
            off.drawImage(bigstar, bigstarx, bigstary - bigstars * 8, this);
            off.drawImage(bigstar, bigstarx + bigstars * 4, bigstary - bigstars * 7, this);
            off.drawImage(bigstar, bigstarx - bigstars * 4, bigstary - bigstars * 7, this);
            off.drawImage(bigstar, bigstarx + bigstars * 7, bigstary - bigstars * 4, this);
            off.drawImage(bigstar, bigstarx - bigstars * 7, bigstary - bigstars * 4, this);
            off.drawImage(bigstar, bigstarx + bigstars * 4, bigstary + bigstars * 7, this);
            off.drawImage(bigstar, bigstarx - bigstars * 4, bigstary + bigstars * 7, this);
            off.drawImage(bigstar, bigstarx + bigstars * 7, bigstary + bigstars * 4, this);
            off.drawImage(bigstar, bigstarx - bigstars * 7, bigstary + bigstars * 4, this);
            return;
        }
        if(lives > 0)
        {
            gamestate = 30;
            closestep = 0;
            lives=lives;
            return;
        } else
        {
            gamestate = 40;
            gameover = true;
            closestep = 0;
            return;
        }
    }

    public boolean checkCollision(int i, int j, int k, int l, int i1, int j1, int k1, 
            int l1)
    {
        if(i >= i1 && i <= i1 + k1 && j >= j1 && j <= j1 + l1)
        {
            return true;
        }
        if(i >= i1 && i <= i1 + k1 && j + l >= j1 && j + l <= j1 + l1)
        {
            return true;
        }
        if(i + k >= i1 && i + k <= i1 + k1 && j >= j1 && j <= j1 + l1)
        {
            return true;
        }
        if(i + k >= i1 && i + k <= i1 + k1 && j + l >= j1 && j + l <= j1 + l1)
        {
            return true;
        }
        if(i1 >= i && i1 <= i + k && j1 >= j && j1 <= j + l)
        {
            return true;
        }
        if(i1 >= i && i1 <= i + k && j1 + l1 >= j && j1 + l1 <= j + l)
        {
            return true;
        }
        if(i1 + k1 >= i && i1 + k1 <= i + k && j1 >= j && j1 <= j + l)
        {
            return true;
        }
        return i1 + k1 >= i && i1 + k1 <= i + k && j1 + l1 >= j && j1 + l1 <= j + l;
    }

    public void startSwitch(int i, int j, int k)
    {
        switches[i][0] = switches[i][3] = 100;
        switches[i][1] = j;
        switches[i][2] = k;
        switches[i][4] = 0;
    }

    public void update(Graphics g)
    {
        paint(g);
    }

    public void processKeyEvent(KeyEvent keyevent)
    {
        switch(keyevent.getID())
        {
        default:
            break;

        case 401: 
            switch(keyevent.getKeyCode())
            {
            case 32: // ' '
                if(gamestate == 0)
                {
                    gamestate = 40;
                    closestep = 5;
                    level = 1;
                    resetEnemy();
                    levelSetup();
                    return;
                }
                if(!fall && !jump && jumprelease && canvas.checkCollision(p.x, (p.y - 4) + offsety, 24, 24) != 100)
                {
                    jump = true;
                    jumpstep = 0;
                    ladder = false;
                    return;
                }
                break;

            case 37: // '%'
                left = true;
                direction = 0;
                return;

            case 16: // '\020'
                if(!fall && !jump && jumprelease && canvas.checkCollision(p.x, (p.y - 4) + offsety, 24, 24) != 100)
                {
                    jump = true;
                    jumpstep = 0;
                    ladder = false;
                    return;
                }
                break;

            case 38: // '&'
                up = true;
                return;

            case 39: // '\''
                right = true;
                direction = 1;
                return;

            case 40: // '('
                down = true;
                return;
            }
            break;

        case 402: 
            switch(keyevent.getKeyCode())
            {
            default:
                break;

            case 37: // '%'
                left = false;
                return;

            case 16: // '\020'
                if(jumpstep < 1)
                {
                    jumprelease = true;
                    return;
                }
                break;

            case 38: // '&'
                up = false;
                return;

            case 39: // '\''
                right = false;
                return;

            case 40: // '('
                down = false;
                return;

            case 33: // '!'
                bc = 0;
                return;
            }
            break;
        }
    }

    public void start()
    {
        if(game == null)
        {
            game = new Thread(this);
        }
        game.start();
    }

    public void dofall()
    {
        boolean flag = fall;
        fall = false;
        boolean flag1 = false;
        if(jumpstep > 0)
        {
            jumpstep--;
            int i = canvas.checkCollision(p.x, p.y + fallarray[jumpstep] + offsety, 24, 24);
            boolean flag2;
            if(i == 310 && p.y % 24 != 0)
            {
                flag2 = true;
            }
            if(i == 400)
            {
                startDeath();
            }
            if(i != 100 && i != 310 || (p.y + offsety) % 24 != 0)
            {
                if(p.y < 240 || offsety == 720)
                {
                    p.y += fallarray[jumpstep];
                } else
                {
                    scrolly -= fallarray[jumpstep];
                    offsety += fallarray[jumpstep];
                }
                fall = true;
            } else
            {
                jumpstep = 0;
            }
        } else
        {
            int j = canvas.checkCollision(p.x, p.y + 4 + offsety, 24, 24);
            if(j == 400)
            {
                startDeath();
            }
            if(j != 100 && j != 310 || (p.y + offsety) % 24 != 0)
            {
                if(p.y < 240 || offsety == 720)
                {
                    p.y += 4;
                } else
                {
                    scrolly -= 4;
                    offsety += 4;
                }
                fall = true;
            } else
            {
                jumprelease = true;
            }
        }
        if(flag && !fall)
        {
            landau.play();
            destroying = false;
        }
    }

    public void sLB(int i, int j, int k, int l, int i1, int j1, int k1)
    {
        int l1 = rn.nextInt() % 30 + 3;
        if(l1 < 0)
        {
            l1 = -l1;
        }
        lblobs[i][0] = 100;
        lblobs[i][1] = j;
        lblobs[i][2] = k;
        lblobs[i][3] = l;
        lblobs[i][4] = i1;
        lblobs[i][5] = j1;
        lblobs[i][6] = k1;
        lblobs[i][7] = l1;
        lblobs[i][8] = 0;
    }

    public void levelSetup()
    {
        jumpstep = 0;
        fall = jump = death = gameover = ladder = false;
        lastpoints = 10;
        scrolly = offsety = 0;
        if(level > 20)
        {
            level = 1;
        }
        resetEnemy();
        level2au.play();
        switch(level)
        {
        default:
            break;

        case 1: // '\001'
            offsety = 216;
            scrolly = -216;
            p.setXY(48, 120);
            ss(0, 120, 504, 384, 24, 504, 504, 1, 0);
            ss(2, 216, 408, 216, 216, 456, 312, 0, -4);
            startSwitch(0, 408, 264);
            sB(0, 432, 420, 432, 432, 0);
            sB(1, 312, 420, 312, 240, -1);
            sB(2, 264, 276, 264, 264, -1);
            sB(3, 48, 252, 72, 24, 1);
            sB(4, 48, 252, 72, 24, -1);
            startBottom(0, 24, 456, 0, 0);
            startBottom(1, 48, 456, 20, 0);
            startBottom(2, 72, 456, 40, 0);
            startBottom(3, 96, 456, 60, 0);
            sOutSpike(0, 72, 192, 1);
            bc = 5;
            break;

        case 2: // '\002'
            sB(0, 336, 564, 408, 288, 2);
            sB(1, 240, 396, 240, 144, 1);
            sB(2, 98, 156, 142, 74, 2);
            sB(3, 48, 324, 48, 48, 0);
            sB(4, 384, 228, 432, 388, 2);
            sB(5, 384, 396, 408, 360, 1);
            sB(6, 384, 804, 384, 384, 0);
            ss(0, 264, 96, 264, 264, 384, 96, 0, -4);
            ss(1, 168, 144, 168, 168, 264, 96, 0, -4);
            ss(2, 432, 280, 432, 432, 768, 480, 0, -2);
            ss(3, 96, 216, 96, 96, 672, 192, 0, -2);
            ss(4, 48, 120, 48, 48, 312, 96, 0, -2);
            ss(5, 240, 504, 336, 96, 504, 504, 2, 0);
            starteye2(0, 240, 336);
            startSwitch(0, 312, 792);
            bc = 7;
            offsety = 240;
            scrolly = -240;
            p.setXY(48, 192);
            break;

        case 3: // '\003'
            ss(0, 396, 168, 396, 396, 336, 48, 0, -2);
            ss(1, 132, 336, 132, 132, 408, 240, 0, 1);
            ss(2, 204, 336, 204, 204, 408, 264, 0, -1);
            ss(3, 240, 24, 432, 24, 24, 24, 2, 0);
            ss(4, 240, 48, 432, 24, 48, 48, 4, 0);
            ss(5, 240, 768, 264, 168, 864, 740, 2, 2);
            sB(0, 120, 204, 144, 96, 1);
            sB(1, 120, 204, 144, 96, -1);
            sB(2, 384, 372, 408, 360, 1);
            sB(3, 384, 372, 408, 360, -1);
            sB(4, 384, 372, 408, 360, 0);
            sB(5, 120, 612, 192, 48, 1);
            sB(6, 120, 612, 192, 48, 2);
            sB(7, 120, 612, 192, 48, 4);
            sB(8, 120, 612, 192, 48, -1);
            sB(9, 120, 612, 192, 48, -2);
            sB(10, 120, 612, 192, 48, -4);
            sB(11, 72, 372, 72, 72, 0);
            sB(12, 24, 60, 24, 24, 0);
            sB(13, 144, 876, 264, 144, 1);
            sB(14, 120, 1020);
            sB(15, 144, 1020);
            sB(16, 192, 1020);
            sB(17, 216, 1020);
            sB(18, 264, 1020);
            sB(19, 288, 1020);
            sB(20, 48, 1020);
            sB(21, 72, 1020);
            starteye(0, 432, 456);
            starteye2(0, 72, 504);
            startSwitch(0, 264, 216);
            p.setXY(264, 96);
            bc = 22;
            break;

        case 4: // '\004'
            sB(0, 96, 204, 120, 96, 1);
            sB(1, 96, 372, 120, 96, 1);
            sB(2, 336, 204, 360, 336, 1);
            sB(3, 336, 372, 360, 336, 1);
            startBottom(0, 72, 192, 0, 0);
            startBottom(1, 144, 192, 0, 0);
            startBottom(2, 312, 192, 0, 0);
            startBottom(3, 384, 192, 0, 0);
            startBottom(4, 72, 360, 0, 0);
            startBottom(5, 144, 360, 0, 0);
            startBottom(6, 312, 360, 0, 0);
            startBottom(7, 384, 360, 0, 0);
            startSwitch(0, 48, 192);
            startSwitch(1, 48, 360);
            startSwitch(2, 408, 360);
            offsety = 240;
            scrolly = -240;
            sOutSpike(0, 240, 168, 1);
            sOutSpike(1, 240, 432, 2);
            sOutSpike(2, 24, 288, 4);
            sOutSpike(3, 432, 288, 3);
            p.setXY(144, 192);
            bc = 4;
            break;

        case 5: // '\005'
            ss(0, 336, 48, 432, 240, 48, 48, 2, 0);
            ss(1, 336, 120, 432, 240, 120, 120, -2, 0);
            ss(2, 336, 192, 432, 240, 192, 192, 2, 0);
            ss(3, 192, 168, 192, 192, 288, 72, 0, 2);
            ss(4, 144, 168, 144, 144, 240, 72, 0, -2);
            ss(5, 96, 168, 96, 96, 288, 72, 0, 2);
            ss(6, 48, 168, 48, 48, 288, 72, 0, -2);
            ss(7, 408, 168, 408, 408, 384, 168, 0, 1);
            sB(0, 240, 84, 240, 240, 0);
            sB(1, 432, 132, 432, 432, 0);
            sB(2, 240, 204, 240, 240, 0);
            sB(3, 72, 372, 72, 72, 0);
            sB(4, 288, 612, 336, 288, 1);
            sB(5, 312, 612, 336, 288, -1);
            sB(6, 384, 492, 384, 384, 0);
            sB(7, 408, 492, 408, 408, 0);
            sB(8, 96, 540, 96, 96, 0);
            sB(9, 120, 544, 120, 120, 0);
            sB(10, 144, 548, 144, 144, 0);
            sB(11, 168, 552, 168, 168, 0);
            sB(12, 192, 556, 192, 192, 0);
            sB(13, 216, 560, 216, 216, 0);
            sB(14, 240, 564, 240, 240, 0);
            startBottom(1, 216, 360, 9, 0);
            startBottom(2, 240, 360, 6, 0);
            startBottom(3, 264, 360, 3, 0);
            startBottom(4, 120, 432, 3, 0);
            startBottom(5, 216, 432, 6, 0);
            startBottom(6, 240, 432, 9, 0);
            starteye(0, 432, 240);
            p.setXY(240, 240);
            bc = 15;
            break;

        case 6: // '\006'
            ss(0, 168, 792, 312, 168, 648, 648, 1, 0);
            ss(1, 312, 792, 312, 168, 648, 648, -1, 0);
            ss(2, 312, 504, 312, 312, 504, 408, 0, -2);
            ss(3, 336, 480, 336, 336, 480, 408, 0, -2);
            ss(4, 288, 528, 288, 288, 528, 408, 0, -2);
            ss(5, 192, 432, 192, 192, 672, 408, 0, -2);
            ss(6, 120, 120, 144, 144, 336, 120, 0, -2);
            ss(7, 168, 192, 192, 192, 336, 192, 0, -2);
            ss(8, 264, 624, 432, 96, 624, 624, 2, 0);
            ss(9, 264, 648, 432, 120, 648, 648, 2, 0);
            sOutSpike(0, 24, 384, 4);
            sOutSpike(1, 264, 792, 2);
            sB(0, 384, 854, 432, 336, 2);
            sB(1, 48, 84, 120, 48, 1);
            sB(2, 120, 84, 120, 48, -1);
            sB(3, 336, 84, 408, 336, 1);
            sB(4, 408, 84, 408, 336, -1);
            sB(5, 144, 300, 144, 144, 0);
            sB(6, 48, 300, 96, 48, 1);
            sB(7, 96, 300, 96, 48, -1);
            sB(8, 336, 300, 336, 336, 0);
            sB(11, 120, 492, 120, 120, 0);
            sB(12, 216, 660, 408, 216, 1);
            sB(13, 408, 660, 408, 216, -1);
            startSwitch(0, 336, 144);
            startSwitch(1, 144, 144);
            startBottom(0, 288, 288, 12, 0);
            startBottom(1, 384, 288, 9, 0);
            startBottom(2, 168, 480, 6, 0);
            startBottom(3, 72, 648, 3, 0);
            startBottom(4, 120, 696, 3, 0);
            bc = 12;
            offsety = 456;
            scrolly = -456;
            p.setXY(96, 216);
            break;

        case 7: // '\007'
            bc = 15;
            scrolly = -720;
            offsety = 720;
            p.setXY(72, 144);
            startSwitch(0, 264, 696);
            sB(0, 264, 996, 288, 264, 1);
            sB(1, 264, 780, 288, 264, 1);
            sB(2, 48, 672, 48, 48, 0);
            sB(3, 48, 696, 48, 48, 0);
            sB(4, 48, 684, 48, 48, 0);
            sB(5, 48, 660, 48, 48, 0);
            ss(0, 168, 672, 168, 168, 840, 624, 0, -4);
            ss(1, 168, 552, 288, 72, 408, 408, -1, 0);
            ss(2, 180, 0, 180, 180, 360, 0, 0, 2);
            ss(3, 324, 0, 324, 324, 360, 0, 0, 2);
            ss(7, 252, 360, 252, 252, 360, 0, 0, -2);
            ss(8, 108, 360, 108, 108, 360, 0, 0, -2);
            ss(4, 48, 744, 408, 48, 744, 744, 2, 0);
            ss(5, 240, 840, 432, 48, 840, 840, 2, 0);
            ss(6, 240, 912, 432, 144, 912, 912, -1, 0);
            sB(6, 108, 192);
            sB(7, 180, 192);
            sB(8, 252, 192);
            sB(9, 324, 192);
            sB(10, 24, 540);
            sB(11, 72, 996, 144, 72, 1);
            sB(12, 96, 996, 144, 72, 1);
            sB(13, 120, 996, 144, 72, 1);
            sB(14, 144, 996, 144, 72, 1);
            starteye(0, 432, 768);
            starteye(1, 432, 720);
            break;

        case 8: // '\b'
            bc = 12;
            ss(0, 72, 168, 72, 72, 240, 120, 0, 2);
            ss(1, 168, 168, 168, 168, 240, 120, 0, 2);
            ss(2, 264, 168, 264, 264, 240, 120, 0, 2);
            ss(3, 360, 168, 360, 360, 240, 120, 0, 2);
            ss(4, 72, 312, 72, 72, 504, 312, 0, 2);
            ss(5, 168, 312, 168, 168, 432, 312, 0, 2);
            ss(6, 264, 312, 264, 264, 504, 312, 0, 2);
            ss(7, 360, 312, 360, 360, 432, 312, 0, 2);
            sB(0, 144, 60, 192, 144, 1);
            sB(1, 240, 60, 288, 240, 1);
            sB(2, 336, 60, 384, 336, 1);
            sB(3, 192, 156, 240, 192, 1);
            sB(4, 288, 156, 336, 288, 1);
            sB(5, 384, 156, 432, 384, 1);
            sB(6, 144, 252, 192, 144, 1);
            sB(7, 240, 252, 288, 240, 1);
            sB(8, 336, 252, 384, 336, 1);
            sB(9, 192, 348, 240, 192, 1);
            sB(10, 288, 348, 336, 288, 1);
            sB(11, 384, 348, 432, 384, 1);
            starteye(0, 432, 48);
            starteye(1, 432, 144);
            starteye(2, 432, 240);
            starteye(3, 432, 336);
            p.setXY(96, 48);
            break;

        case 9: // '\t'
            bc = 10;
            ss(0, 192, 168, 384, 72, 216, 144, 2, 2);
            ss(1, 192, 384, 384, 72, 408, 336, 2, 2);
            ss(2, 192, 384, 384, 72, 408, 336, -2, -2);
            ss(3, 192, 552, 384, 72, 600, 528, 1, 1);
            ss(4, 192, 552, 384, 72, 600, 528, 2, -2);
            ss(5, 192, 552, 384, 72, 600, 528, -3, 3);
            sB(0, 120, 108, 168, 72, 1);
            sB(1, 360, 108, 360, 264, -1);
            sB(2, 140, 300, 168, 72, 2);
            sB(3, 320, 300, 384, 264, -2);
            sB(4, 120, 492, 168, 72, 4);
            sB(5, 360, 492, 360, 264, -4);
            sB(6, 384, 228, 384, 384, 0);
            sB(7, 384, 420, 384, 384, 0);
            sB(8, 384, 612, 384, 384, 0);
            sB(9, 288, 684, 312, 288, 1);
            p.setXY(96, 24);
            break;

        case 10: // '\n'
            p.setXY(264, 24);
            bc = 18;
            startSwitch(0, 312, 408);
            startSwitch(1, 48, 432);
            startSwitch(2, 72, 192);
            startSwitch(3, 432, 24);
            ss(0, 360, 72, 432, 240, 72, 72, 1, 0);
            ss(1, 240, 192, 312, 144, 192, 192, 1, 0);
            ss(2, 48, 264, 48, 48, 312, 240, 0, 1);
            ss(3, 120, 264, 120, 120, 312, 240, 0, 1);
            ss(4, 192, 384, 192, 192, 432, 336, 0, 1);
            ss(5, 240, 552, 264, 192, 552, 552, 1, 0);
            ss(6, 240, 576, 264, 192, 576, 576, 1, 0);
            ss(7, 384, 576, 432, 312, 672, 456, 1, 1);
            ss(8, 384, 576, 432, 312, 672, 456, 1, -1);
            ss(9, 384, 576, 432, 312, 672, 456, -1, 1);
            ss(10, 384, 576, 432, 312, 672, 456, -1, -1);
            sB(0, 312, 156);
            sB(1, 336, 180);
            sB(2, 360, 276);
            sB(3, 336, 276);
            sB(4, 408, 168);
            sB(5, 24, 300);
            sB(6, 84, 348);
            sB(7, 48, 564);
            sB(8, 120, 564);
            sB(9, 72, 660);
            sB(10, 96, 684);
            sB(11, 192, 756, 432, 192, 1);
            sB(12, 216, 756, 432, 192, 1);
            sB(13, 240, 756, 432, 192, 1);
            sB(14, 264, 756, 432, 192, 1);
            sB(15, 288, 756, 432, 192, 1);
            sB(16, 312, 756, 432, 192, 1);
            sB(17, 432, 684);
            sLB(0, 72, 80, 192, 72, 2, 4);
            startBottom(0, 72, 144, 12, 0);
            startBottom(1, 96, 144, 9, 0);
            startBottom(2, 168, 144, 6, 0);
            startBottom(3, 192, 144, 3, 0);
            break;

        case 11: // '\013'
            p.setXY(24, 240);
            startSwitch(0, 288, 216);
            sB(0, 48, 588);
            sB(1, 72, 588);
            sB(2, 96, 588);
            sB(3, 96, 552);
            sB(4, 120, 556);
            sB(5, 144, 560);
            sB(6, 168, 564);
            sB(7, 192, 568);
            sB(8, 216, 572);
            sB(9, 180, 504);
            sB(10, 168, 456);
            sB(11, 192, 456);
            sB(12, 216, 456);
            sB(13, 96, 72);
            sB(14, 120, 108);
            sB(15, 84, 348);
            ss(0, 264, 264, 264, 264, 408, 264, 0, 2);
            ss(1, 312, 264, 312, 312, 408, 264, 0, 2);
            ss(2, 336, 264, 336, 336, 408, 216, 0, 2);
            ss(3, 384, 264, 384, 384, 408, 216, 0, 2);
            ss(4, 24, 96, 240, 24, 96, 96, 2, 0);
            startBottom(0, 288, 120, 12, 0);
            startBottom(1, 360, 120, 9, 0);
            startBottom(2, 384, 120, 6, 0);
            sOutSpike(0, 24, 72, 4);
            sOutSpike(1, 24, 96, 4);
            sOutSpike(2, 24, 120, 4);
            sOutSpike(3, 24, 144, 4);
            bc = 16;
            break;

        case 12: // '\f'
            p.setXY(240, 72);
            scrolly = offsety = 0;
            startSwitch(0, 432, 24);
            startSwitch(1, 432, 336);
            startSwitch(2, 336, 168);
            startSwitch(3, 216, 168);
            startSwitch(4, 168, 168);
            startSwitch(5, 72, 144);
            startSwitch(6, 144, 336);
            ss(0, 240, 120, 240, 240, 336, 120, 1, 1);
            ss(1, 360, 120, 360, 360, 336, 0, 1, 1);
            ss(2, 24, 24, 24, 24, 360, 24, 0, 4);
            ss(3, 120, 240, 432, 120, 240, 240, 2, 1);
            ss(4, 120, 336, 432, 120, 336, 316, 2, 1);
            ss(5, 384, 432, 384, 384, 816, 432, 0, 2);
            ss(6, 408, 672, 408, 408, 792, 432, 0, -2);
            ss(10, 384, 816, 384, 384, 816, 432, 0, -2);
            ss(11, 408, 672, 408, 408, 792, 432, 0, 2);
            ss(7, 168, 528, 240, 168, 528, 528, 1, 0);
            ss(8, 168, 600, 168, 96, 600, 600, 1, 0);
            ss(9, 120, 744, 144, 72, 744, 744, -1, 0);
            sLB(0, 278, 320, 274, 274, 0, 4);
            sLB(1, 280, 300, 274, 274, 0, 3);
            sLB(2, 282, 280, 274, 274, 0, 2);
            starteye2(0, 24, 768);
            starteye(0, 240, 816);
            sB(0, 312, 492);
            bc = 4;
            break;

        case 13: // '\r'
            bc = 24;
            sB(0, 48, 84);
            sB(1, 96, 108);
            sB(2, 144, 132);
            sB(3, 168, 132);
            sB(4, 192, 132);
            sB(5, 216, 132);
            sB(6, 168, 204);
            sB(7, 216, 228);
            sB(8, 168, 252);
            sB(9, 216, 276);
            sB(10, 96, 284);
            sB(11, 120, 288);
            sB(12, 144, 292);
            sB(13, 168, 296);
            sB(14, 192, 300);
            sB(15, 96, 348);
            sB(16, 144, 372);
            sB(17, 192, 396);
            sB(18, 288, 468);
            sB(19, 336, 540);
            sB(20, 312, 564);
            sB(21, 360, 660);
            sB(22, 384, 660);
            sB(23, 408, 660);
            scrolly = offsety = 0;
            p.setXY(24, 24);
            break;

        case 14: // '\016'
            bc = 10;
            sB(0, 72, 948);
            sB(1, 96, 948);
            sB(2, 120, 948);
            sB(3, 148, 948);
            sB(4, 96, 216);
            sB(5, 48, 228);
            sB(6, 384, 516);
            sB(7, 96, 540);
            sB(8, 360, 252);
            sB(9, 264, 612);
            ss(0, 240, 240, 456, 24, 720, 24, 1, 2);
            ss(1, 240, 240, 456, 24, 720, 24, 1, -1);
            ss(2, 240, 240, 456, 24, 720, 24, 2, 2);
            ss(3, 240, 240, 456, 24, 720, 24, -2, -2);
            ss(4, 240, 240, 456, 24, 720, 24, 2, 1);
            ss(5, 240, 240, 456, 24, 720, 24, 1, 4);
            ss(6, 240, 240, 456, 24, 720, 24, -1, 1);
            ss(7, 240, 240, 456, 24, 720, 24, 4, 4);
            scrolly = -240;
            offsety = 240;
            p.setXY(168, 96);
            break;

        case 15: // '\017'
            bc = 23;
            scrolly = offsety = 0;
            sB(0, 336, 84, 336, 336, 0);
            sB(1, 312, 84, 312, 312, 0);
            sB(2, 288, 84, 228, 228, 0);
            sB(3, 264, 84, 264, 264, 0);
            sB(4, 240, 84, 240, 240, 0);
            sB(5, 72, 132, 72, 72, 0);
            sB(6, 72, 180, 72, 72, 0);
            sB(7, 48, 228, 48, 48, 0);
            sB(8, 24, 324, 24, 24, 0);
            sB(9, 48, 348, 48, 48, 0);
            sB(10, 72, 372, 72, 72, 0);
            sB(11, 252, 300, 252, 252, 0);
            sB(12, 240, 396, 240, 240, 0);
            sB(13, 408, 396, 408, 408, 0);
            sB(14, 24, 540, 24, 72, 1);
            sB(16, 192, 684, 192, 192, 0);
            sB(17, 216, 684, 216, 216, 0);
            sB(18, 240, 684, 240, 240, 0);
            sB(19, 264, 684, 264, 264, 0);
            sB(20, 288, 684, 288, 288, 0);
            sB(21, 312, 684, 312, 312, 0);
            sB(22, 48, 756, 48, 48, 0);
            sB(15, 72, 756, 72, 72, 0);
            startSwitch(0, 24, 576);
            ss(0, 252, 240, 252, 252, 312, 168, 0, 1);
            ss(1, 408, 240, 432, 384, 312, 312, 1, 0);
            ss(2, 312, 516, 432, 216, 516, 516, 1, 0);
            ss(3, 312, 588, 360, 168, 588, 588, 1, 0);
            ss(4, 312, 660, 432, 168, 660, 660, 2, 0);
            p.setXY(432, 72);
            break;

        case 16: // '\020'
            p.setXY(24, 24);
            sLB(0, 72, 288, 432, 72, 2, 6);
            sLB(1, 240, 288, 432, 72, 2, 6);
            sLB(2, 200, 240, 432, 72, 1, 18);
            sB(0, 270, 204, 432, 240, 1);
            sB(1, 300, 204, 432, 240, 2);
            sB(2, 330, 204, 432, 240, 4);
            sB(3, 400, 204, 432, 240, -1);
            sB(4, 144, 396, 168, 144, 1);
            sB(5, 144, 468, 168, 144, 1);
            sB(6, 216, 420, 240, 216, 1);
            sB(7, 216, 492, 240, 216, 1);
            sB(8, 288, 444, 312, 288, 1);
            sB(9, 288, 516, 312, 288, 1);
            sB(10, 432, 60);
            sB(11, 324, 96);
            sB(11, 100, 60, 144, 96, 2);
            sB(12, 72, 696);
            sB(13, 120, 720);
            sB(14, 168, 672);
            sB(15, 216, 816);
            sB(16, 264, 744);
            sB(17, 312, 744);
            sB(18, 360, 768);
            sB(19, 408, 792);
            ss(0, 72, 624, 72, 72, 888, 624, 0, 1);
            ss(1, 120, 624, 120, 120, 888, 624, 0, 1);
            ss(2, 168, 624, 168, 168, 888, 624, 0, 2);
            ss(3, 216, 624, 216, 216, 888, 624, 0, 1);
            ss(4, 264, 624, 264, 264, 888, 624, 0, 2);
            ss(5, 312, 624, 312, 312, 888, 624, 0, 1);
            ss(6, 360, 624, 360, 360, 888, 624, 0, 2);
            ss(7, 408, 624, 408, 408, 888, 624, 0, 1);
            ss(8, 144, 72, 384, 144, 72, 72, 2, 0);
            ss(9, 384, 72, 384, 144, 72, 72, -2, 0);
            ss(10, 192, 360, 192, 192, 600, 360, 0, 2);
            ss(11, 264, 600, 192, 192, 600, 360, 0, -2);
            sOutSpike(0, 24, 72, 4);
            sOutSpike(1, 24, 144, 4);
            sOutSpike(2, 24, 216, 4);
            sOutSpike(3, 24, 288, 4);
            bc = 23;
            break;

        case 17: // '\021'
            p.setXY(24, 72);
            startSwitch(0, 432, 144);
            sB(0, 408, 252);
            sB(1, 72, 156);
            sB(2, 120, 156);
            sB(3, 168, 156);
            sB(7, 24, 324);
            sB(8, 48, 324);
            sB(9, 72, 324);
            sB(10, 96, 324);
            sB(11, 120, 324);
            sB(12, 144, 324);
            sB(13, 168, 324);
            sB(14, 96, 756);
            sB(15, 144, 756);
            sB(16, 192, 756);
            sB(17, 240, 756);
            sB(18, 288, 756);
            sB(19, 336, 756);
            sB(20, 384, 756);
            sB(21, 120, 756);
            sB(22, 168, 756);
            sB(23, 216, 756);
            sB(5, 264, 756);
            sB(6, 312, 756);
            sB(4, 360, 756);
            sLB(0, 196, 276, 196, 196, 0, 3);
            ss(0, 84, 384, 84, 84, 624, 384, 0, 2);
            ss(1, 156, 624, 156, 156, 624, 384, 0, -2);
            ss(2, 228, 384, 228, 228, 624, 384, 0, 2);
            ss(3, 300, 624, 300, 300, 624, 384, 0, -2);
            ss(4, 84, 624, 84, 84, 624, 384, 0, -2);
            ss(5, 156, 384, 156, 156, 624, 384, 0, 2);
            ss(6, 228, 624, 228, 228, 624, 384, 0, -2);
            ss(7, 300, 384, 300, 300, 624, 384, 0, 2);
            ss(8, 24, 216, 432, 24, 216, 216, 2, 0);
            ss(9, 240, 144, 432, 24, 144, 144, 2, 0);
            ss(10, 312, 72, 312, 312, 240, 72, 0, 2);
            bc = 25;
            break;

        case 18: // '\022'
            bc = 24;
            ss(0, 96, 216, 96, 96, 432, 48, 0, 1);
            ss(1, 96, 216, 96, 96, 432, 48, 0, -1);
            ss(2, 144, 216, 144, 144, 432, 48, 0, 1);
            ss(3, 144, 216, 144, 144, 432, 48, 0, -1);
            ss(4, 192, 216, 192, 192, 432, 48, 0, 1);
            ss(5, 192, 216, 192, 192, 432, 48, 0, -1);
            ss(6, 240, 216, 96, 96, 432, 48, 0, 1);
            ss(7, 240, 216, 96, 96, 432, 48, 0, -1);
            ss(8, 288, 216, 96, 96, 432, 48, 0, 1);
            ss(9, 288, 216, 96, 96, 432, 48, 0, -1);
            ss(10, 336, 216, 96, 96, 432, 48, 0, 1);
            ss(11, 336, 216, 96, 96, 432, 48, 0, -1);
            sB(0, 72, 84);
            sB(1, 120, 84);
            sB(2, 168, 84);
            sB(3, 216, 84);
            sB(4, 264, 84);
            sB(5, 312, 84);
            sB(6, 360, 84);
            sB(7, 72, 180);
            sB(8, 120, 180);
            sB(9, 216, 180);
            sB(10, 312, 180);
            sB(11, 360, 180);
            sB(12, 72, 276);
            sB(13, 120, 276);
            sB(14, 216, 276);
            sB(15, 264, 276);
            sB(16, 360, 276);
            sB(17, 72, 372);
            sB(18, 120, 372);
            sB(19, 168, 372);
            sB(20, 216, 372);
            sB(21, 264, 372);
            sB(22, 312, 372);
            sB(23, 360, 372);
            startBottom(0, 168, 168, 12, 0);
            startBottom(1, 264, 168, 9, 0);
            startBottom(2, 168, 264, 6, 0);
            startBottom(3, 264, 264, 3, 0);
            p.setXY(408, 72);
            break;

        case 19: // '\023'
            offsety = 120;
            scrolly = -120;
            p.setXY(228, 144);
            sB(0, 72, 84);
            sB(1, 72, 396);
            sB(2, 168, 372);
            sB(3, 288, 372);
            sB(4, 120, 516);
            sB(5, 336, 516);
            sB(6, 336, 228);
            sB(7, 120, 228);
            sB(8, 336, 300);
            sB(9, 120, 300);
            ss(0, 96, 72, 96, 96, 504, 72, 0, 1);
            ss(1, 144, 504, 144, 144, 504, 72, 0, -1);
            ss(2, 312, 72, 312, 312, 504, 72, 0, 1);
            ss(3, 360, 504, 360, 360, 504, 72, 0, -1);
            ss(4, 24, 216, 432, 24, 216, 216, 1, 0);
            ss(5, 432, 360, 432, 24, 360, 360, -1, 0);
            sOutSpike(0, 240, 24, 1);
            sOutSpike(1, 24, 288, 4);
            sOutSpike(2, 240, 552, 2);
            sOutSpike(3, 432, 288, 3);
            bc = 10;
            break;

        case 20: // '\024'
            offsety = 120;
            scrolly = -120;
            p.setXY(24, 72);
            int i = 0;
            do
            {
                sB(i, 48 + i * 24, 216);
            } while(++i < 16);
            sLB(0, 72, 360, 432, 72, 2, 18);
            sLB(1, 240, 360, 432, 72, 2, 18);
            sLB(2, 200, 360, 432, 72, 1, 18);
            bc = 19;
            break;
        }
        canvas.loadmap(maps.maps[level - 1]);
    }

    public void sB(int i, int j, int k)
    {
        int l = rn.nextInt() % 30 + 3;
        if(l < 0)
        {
            l = -l;
        }
        blobs[i][0] = 100;
        blobs[i][1] = blobs[i][3] = blobs[i][4] = j;
        blobs[i][2] = k;
        blobs[i][5] = blobs[i][6] = blobs[i][8] = blobs[i][9] = 0;
        blobs[i][7] = l;
    }

    public void doOut()
    {
        int i = 0;
        do
        {
            if(out[i])
            {
                switch(outd[i])
                {
                default:
                    break;

                case 1: // '\001'
                    if(canvas.checkCollision(outx[i] - 2, outy[i], 24, 24) == 100)
                    {
                        if(canvas.checkCollision(outx[i], outy[i] + 2, 24, 24) == 100)
                        {
                            outd[i] = 2;
                        } else
                        {
                            outd[i] = 4;
                        }
                        break;
                    }
                    outx[i] -= 2;
                    if(canvas.checkCollision(outx[i], outy[i] - 2, 24, 24) != 100)
                    {
                        outd[i] = 3;
                    }
                    break;

                case 2: // '\002'
                    if(canvas.checkCollision(outx[i] + 2, outy[i], 24, 24) == 100)
                    {
                        if(canvas.checkCollision(outx[i], outy[i] - 2, 24, 24) == 100)
                        {
                            outd[i] = 1;
                        } else
                        {
                            outd[i] = 3;
                        }
                        break;
                    }
                    outx[i] += 2;
                    if(canvas.checkCollision(outx[i], outy[i] + 2, 24, 24) != 100)
                    {
                        outd[i] = 4;
                    }
                    break;

                case 3: // '\003'
                    if(canvas.checkCollision(outx[i], outy[i] - 2, 24, 24) == 100)
                    {
                        if(canvas.checkCollision(outx[i] - 2, outy[i], 24, 24) == 100)
                        {
                            outd[i] = 4;
                        } else
                        {
                            outd[i] = 1;
                        }
                        break;
                    }
                    outy[i] -= 2;
                    if(canvas.checkCollision(outx[i] + 2, outy[i], 24, 24) != 100)
                    {
                        outd[i] = 2;
                    }
                    break;

                case 4: // '\004'
                    if(canvas.checkCollision(outx[i], outy[i] + 2, 24, 24) == 100)
                    {
                        if(canvas.checkCollision(outx[i] + 2, outy[i], 24, 24) == 100)
                        {
                            outd[i] = 3;
                        } else
                        {
                            outd[i] = 2;
                        }
                        break;
                    }
                    outy[i] += 2;
                    if(canvas.checkCollision(outx[i] - 2, outy[i], 24, 24) != 100)
                    {
                        outd[i] = 1;
                    }
                    break;
                }
                off.drawImage(imgspike, outx[i], outy[i] + scrolly, this);
                if(checkCollision(p.x, p.y, 24, 24, outx[i] + 2, outy[i] + scrolly + 2, 20, 20))
                {
                    startDeath();
                }
            }
        } while(++i < 4);
    }

    public void sB(int i, int j, int k, int l, int i1, int j1)
    {
        int k1 = rn.nextInt() % 30 + 3;
        if(k1 < 0)
        {
            k1 = -k1;
        }
        blobs[i][0] = 100;
        blobs[i][1] = j;
        blobs[i][2] = k;
        blobs[i][3] = l;
        blobs[i][4] = i1;
        blobs[i][5] = j1;
        blobs[i][7] = k1;
        blobs[i][6] = blobs[i][8] = blobs[i][9] = 0;
    }

    public void startPoints(int i, int j, int k)
    {
        int l = 0;
        do
        {
            if(points[l][0] != 100)
            {
                points[l][0] = 100;
                points[l][1] = i;
                points[l][2] = j;
                points[l][3] = k;
                points[l][4] = 0;
                return;
            }
        } while(++l < 10);
    }

    public void doPoints()
    {
        int i = 0;
        do
        {
            if(points[i][0] == 100)
            {
                off.setColor(Color.black);
                off.drawString("" + points[i][3], points[i][1], points[i][2]);
                off.setColor(Color.white);
                off.drawString("" + points[i][3], points[i][1] + 1, points[i][2] + 1);
                points[i][4]++;
                if(points[i][4] % 3 == 0)
                {
                    points[i][2]--;
                }
                if(points[i][4] > 30)
                {
                    points[i][0] = 0;
                }
            }
        } while(++i < 10);
    }

    public void startBottom(int i, int j, int k, int l, int i1)
    {
        bottom[i][0] = 100;
        bottom[i][1] = j;
        bottom[i][2] = k;
        bottom[i][3] = 0;
        bottom[i][4] = l;
    }

    public void doSwitches()
    {
        int i = 0;
        do
        {
            if(switches[i][0] == 100)
            {
                if(switches[i][3] == 100)
                {
                    if(switches[i][1] >= p.x && switches[i][1] <= p.x + 24 && switches[i][2] + scrolly + 5 >= p.y && switches[i][2] + scrolly + 5 <= p.y + 24)
                    {
                        switches[i][3] = 0;
                        switches[i][4] = 100;
                        score += 55L;
                        switchau.play();
                    }
                    if(switches[i][1] + 22 >= p.x && switches[i][1] + 22 <= p.x + 24 && switches[i][2] + scrolly + 5 >= p.y && switches[i][2] + scrolly + 5 <= p.y + 24)
                    {
                        switches[i][3] = 0;
                        switches[i][4] = 100;
                        score += 55L;
                        switchau.play();
                    }
                    if(switches[i][1] >= p.x && switches[i][1] <= p.x + 24 && switches[i][2] + 19 + scrolly + 5 >= p.y && switches[i][2] + 19 + scrolly + 5 <= p.y + 24)
                    {
                        switches[i][3] = 0;
                        switches[i][4] = 100;
                        score += 55L;
                        switchau.play();
                    }
                    if(switches[i][1] + 22 >= p.x && switches[i][1] + 22 < p.x + 24 && switches[i][2] + 19 + scrolly + 5 >= p.y && switches[i][2] + 19 + scrolly + 5 <= p.y + 24)
                    {
                        switches[i][3] = 0;
                        switches[i][4] = 100;
                        score += 55L;
                        switchau.play();
                    }
                    off.drawImage(imgswitch[0], switches[i][1], switches[i][2] + scrolly + 5, this);
                } else
                {
                    off.drawImage(imgswitch[1], switches[i][1], switches[i][2] + scrolly + 5, this);
                }
            }
        } while(++i < 8);
    }

    public void sOutSpike(int i, int j, int k, int l)
    {
        out[i] = true;
        outx[i] = j;
        outy[i] = k;
        outd[i] = l;
    }

    public void startExplosion(int i, int j)
    {
        int k = 0;
        do
        {
            if(explosion[k][0] == 0)
            {
                explosion[k][0] = 100;
                explosion[k][1] = i;
                explosion[k][2] = j;
                explosion[k][3] = 0;
                return;
            }
        } while(++k < 8);
    }

    public void levelspec()
    {
        switch(level)
        {
        default:
            break;

        case 1: // '\001'
            if(switches[0][4] == 100)
            {
                canvas.placetile(15, 12, 12);
                canvas.placetile(15, 13, 12);
                switches[0][4] = 0;
                return;
            }
            break;

        case 2: // '\002'
            if(switches[0][4] != 100)
            {
                break;
            }
            int i = 24;
            do
            {
                canvas.placetile(30, 11, i);
            } while(++i < 34);
            canvas.placetile(33, 11, 24);
            switches[0][4] = 0;
            return;

        case 3: // '\003'
            if(switches[0][4] != 100)
            {
                break;
            }
            int j = 0;
            do
            {
                canvas.placetile(44 + j, 14 + j, 14);
            } while(++j < 4);
            switches[0][4] = 0;
            return;

        case 4: // '\004'
            if(switches[0][4] == 100)
            {
                int k = 0;
                do
                {
                    canvas.placetile(30, 12, 10 + k);
                } while(++k < 3);
                canvas.placetile(33, 12, 9);
                switches[0][4] = 0;
            }
            if(switches[1][4] == 100)
            {
                int l = 0;
                do
                {
                    canvas.placetile(30, 12, 12 + l);
                } while(++l < 7);
                canvas.placetile(33, 12, 12);
                switches[1][4] = 0;
            }
            if(switches[2][4] != 100)
            {
                break;
            }
            int i1 = 0;
            do
            {
                canvas.placetile(30, 7, 9 + i1);
            } while(++i1 < 4);
            canvas.placetile(33, 7, 9);
            switches[3][4] = 0;
            return;

        case 6: // '\006'
            if(switches[0][4] == 100)
            {
                switches[0][4] = 0;
                canvas.placetile(30, 18, 8);
                canvas.placetile(30, 18, 7);
                canvas.placetile(30, 18, 6);
                canvas.placetile(30, 18, 5);
                canvas.placetile(33, 18, 4);
                canvas.placetile(17, 14, 7);
                canvas.placetile(45, 15, 7);
                canvas.placetile(46, 16, 7);
            }
            if(switches[1][4] == 100)
            {
                switches[1][4] = 0;
                canvas.placetile(46, 6, 7);
                canvas.placetile(47, 7, 7);
                canvas.placetile(48, 8, 7);
                canvas.placetile(30, 1, 8);
                canvas.placetile(30, 1, 7);
                canvas.placetile(30, 1, 6);
                canvas.placetile(30, 1, 5);
                canvas.placetile(33, 1, 4);
                return;
            }
            break;

        case 7: // '\007'
            if(switches[0][4] == 100)
            {
                switches[0][4] = 0;
                canvas.placetile(15, 10, 30);
                canvas.placetile(15, 9, 30);
                canvas.placetile(15, 8, 33);
                return;
            }
            break;

        case 10: // '\n'
            if(switches[0][4] == 100)
            {
                switches[0][4] = 0;
                canvas.placetile(15, 3, 19);
                canvas.placetile(15, 4, 19);
                canvas.placetile(15, 5, 19);
                canvas.placetile(39, 12, 13);
                canvas.placetile(39, 13, 13);
                canvas.placetile(39, 12, 14);
                canvas.placetile(39, 12, 15);
                canvas.placetile(39, 12, 16);
                canvas.placetile(39, 12, 17);
            }
            if(switches[1][4] == 100)
            {
                switches[1][4] = 0;
                canvas.placetile(31, 2, 19);
                canvas.placetile(31, 3, 19);
                canvas.placetile(31, 4, 19);
                canvas.placetile(31, 5, 19);
            }
            if(switches[2][4] == 100)
            {
                switches[2][4] = 0;
                canvas.placetile(39, 3, 9);
                canvas.placetile(39, 4, 9);
                canvas.placetile(39, 9, 10);
                canvas.placetile(39, 9, 11);
            }
            if(switches[3][4] != 100)
            {
                break;
            }
            switches[3][4] = 0;
            int j1 = 0;
            do
            {
                canvas.placetile(39, 13 + j1, 2);
            } while(++j1 < 6);
            return;

        case 11: // '\013'
            if(switches[0][4] != 100)
            {
                break;
            }
            switches[0][4] = 0;
            int k1 = 0;
            do
            {
                canvas.placetile(30, 1, 15 + k1);
            } while(++k1 < 11);
            canvas.placetile(33, 1, 15);
            return;

        case 12: // '\f'
            if(switches[0][4] == 100)
            {
                int l1 = 0;
                do
                {
                    canvas.placetile(39, 2, 1 + l1);
                } while(++l1 < 3);
                switches[0][4] = 0;
            }
            if(switches[1][4] == 100)
            {
                int i2 = 0;
                do
                {
                    canvas.placetile(39, 3, 1 + i2);
                } while(++i2 < 3);
                switches[1][4] = 0;
            }
            if(switches[2][4] == 100)
            {
                int j2 = 0;
                do
                {
                    canvas.placetile(39, 4, 1 + j2);
                } while(++j2 < 3);
                switches[2][4] = 0;
            }
            if(switches[3][4] == 100)
            {
                int k2 = 0;
                do
                {
                    canvas.placetile(39, 5, 1 + k2);
                } while(++k2 < 3);
                switches[3][4] = 0;
            }
            if(switches[4][4] == 100)
            {
                int l2 = 0;
                do
                {
                    canvas.placetile(39, 6, 1 + l2);
                } while(++l2 < 3);
                switches[4][4] = 0;
            }
            if(switches[5][4] == 100)
            {
                int i3 = 0;
                do
                {
                    canvas.placetile(39, 7, 1 + i3);
                } while(++i3 < 3);
                switches[5][4] = 0;
            }
            if(switches[6][4] != 100)
            {
                break;
            }
            int j3 = 0;
            do
            {
                canvas.placetile(39, 8, 1 + j3);
            } while(++j3 < 3);
            switches[6][4] = 0;
            return;

        case 15: // '\017'
            if(switches[0][4] == 100)
            {
                canvas.placetile(39, 4, 21);
                canvas.placetile(39, 4, 22);
                canvas.placetile(39, 1, 25);
                switches[0][4] = 0;
                return;
            }
            break;

        case 17: // '\021'
            if(switches[0][4] != 100)
            {
                break;
            }
            int k3 = 0;
            do
            {
                canvas.placetile(39, 15 + k3, 15);
            } while(++k3 < 4);
            switches[0][4] = 0;
            return;
        }
    }

    public void starteye2(int i, int j, int k)
    {
        eye2[i][0] = 100;
        eye2[i][1] = eye2[i][3] = j;
        eye2[i][2] = eye2[i][4] = k;
    }

    public void doeye2()
    {
        int i = 0;
        do
        {
            if(eye2[i][0] == 100)
            {
                if(checkCollision(p.x, p.y, 24, 24, eye2[i][1] + 2, eye2[i][2] + 2 + scrolly, 20, 20))
                {
                    startDeath();
                }
                if(p.y == eye2[i][2] + scrolly)
                {
                    if(direction == 1 && eye2[i][1] < p.x)
                    {
                        off.drawImage(imgeye2[1], eye2[i][1], eye2[i][2] + scrolly, this);
                        eye2[i][1] += 4;
                    } else
                    {
                        off.drawImage(imgeye2[0], eye2[i][1], eye2[i][2] + scrolly, this);
                        if(eye2[i][1] > eye2[i][3])
                        {
                            eye2[i][1]--;
                        }
                    }
                } else
                {
                    off.drawImage(imgeye2[0], eye2[i][1], eye2[i][2] + scrolly, this);
                    if(eye2[i][1] > eye2[i][3])
                    {
                        eye2[i][1]--;
                    }
                }
            }
        } while(++i < 4);
    }

    public void dolBlobs()
    {
        int i = 0;
        do
        {
            if(lblobs[i][0] == 100)
            {
                off.drawImage(imgblobs[0], lblobs[i][1], lblobs[i][2] + scrolly, 24 + lblobs[i][6] * 4, 24 + lblobs[i][6] * 4, this);
                collision = p.collision(lblobs[i][1], (lblobs[i][2] + scrolly) - 4, 24 + lblobs[i][6] * 4, 24 + lblobs[i][6] * 4);
                lblobs[i][1] += lblobs[i][5];
                if(lblobs[i][5] > 0 && lblobs[i][1] + lblobs[i][6] * 4 > lblobs[i][3])
                {
                    lblobs[i][5] *= -1;
                }
                if(lblobs[i][5] < 0 && lblobs[i][1] < lblobs[i][4])
                {
                    lblobs[i][5] *= -1;
                }
                if(collision && lblobs[i][2] + scrolly > p.y + 24)
                {
                    fall = false;
                    jump = destroying = true;
                    if(lblobs[i][6] > 0)
                    {
                        lblobs[i][6]--;
                        lblobs[i][1] += 2;
                        lblobs[i][2] += 4;
                    } else
                    {
                        lblobs[i][0] = 0;
                        startExplosion(lblobs[i][1] + 12, lblobs[i][2] + 12);
                        if(destroying)
                        {
                            if(lastpoints == 0)
                            {
                                lastpoints = 100;
                            } else
                            {
                                lastpoints += 100;
                            }
                        } else
                        {
                            lastpoints = 100;
                        }
                        score += lastpoints;
                        startPoints(lblobs[i][1], lblobs[i][2] + scrolly, lastpoints);
                        bc--;
                    }
                } else
                if(collision)
                {
                    startDeath();
                }
            }
        } while(++i < 4);
    }

    public void paint(Graphics g)
    {
        if(!tracker.checkAll())
        {
            g.setColor(Color.white);
            g.fillRect(0, 0, 480, 380);
            g.setColor(Color.black);
            g.drawString("Loading Data...", 10, 10);
            return;
        }
        switch(gamestate)
        {
        default:
            break;

        case 0: // '\0'
            gameoverdelay = 0;
            off.setColor(Color.black);
            off.fillRect(0, 0, 480, 380);
            doAll();
            off.drawImage(huh, 125, 70, this);
            off.setColor(Color.white);
            off.setFont(overfont);
            off.drawString("Press Space to Start!", 135, 340);
            lives = 3;
            right = false;
            left = false;
            up = false;
            down = false;
            gameoverdelay = 0;
            again.hide();
            send.hide();
            entryName.hide();
            alreadysent = false;
            Scoregameover = false;
            break;

        case 10: // '\n'
            off.drawImage(background, 0, scrolly, this);
            doAll();
            doBlobs();
            doeye();
            doeye2();
            doOut();
            dolBlobs();
            doPoints();
            doSwitches();
            p.display(off);
            displayBar();
            break;

        case 20: // '\024'
            off.drawImage(background, 0, scrolly, this);
            doPoints();
            doSwitches();
            p.display(off);
            off.setColor(Color.black);
            off.fillRect(100, 70, 280, 51);
            off.setColor(Color.white);
            off.setFont(big);
            off.drawString("Level Complete!", 160, 100);
            donedelay++;
            if(donedelay == 1)
            {
                startupau.play();
            }
            if(donedelay > 60)
            {
                gamestate = 30;
            }
            off.setFont(overfont);
            displayBar();
            break;

        case 30: // '\036'
            int i = 0;
            do
            {
                int j = 0;
                do
                {
                    off.drawImage(close[closestep], j * 24, i * 24, this);
                } while(++j < 20);
            } while(++i < 15);
            off.setColor(Color.black);
            off.fillRect(0, 360, 480, 20);
            break;

        case 40: // '('
            off.drawImage(background, 0, scrolly, this);
            int k = 0;
            do
            {
                int l = 0;
                do
                {
                    off.drawImage(close[closestep], l * 24, k * 24, this);
                } while(++l < 20);
            } while(++k < 15);
            closestep--;
            if(closestep < 0)
            {
                if(!gameover)
                {
                    gamestate = 10;
                } else
                {
                    gamestate = 110;
                }
            }
            off.setColor(Color.black);
            off.fillRect(0, 360, 480, 20);
            break;

        case 100: // 'd'
            off.drawImage(background, 0, scrolly, this);
            doAll();
            doBlobs();
            doeye();
            doeye2();
            doOut();
            doDeathExplosion();
            doSwitches();
            displayBar();
            break;

        case 110: // 'n'
            off.setColor(Color.black);
            off.fillRect(0, 0, 480, 380);
            off.setColor(Color.white);
            off.setFont(overfont);
            off.drawString("Game Over!", 160, 100);
            if(!alreadysent)
            {
                again.show();
                if(!Scoregameover)
                {
                    entryName.requestFocus();
                }
                Scoregameover = true;
                if(score >= 1000L)
                {
                    off.setColor(Color.white);
                    off.setFont(overfont);
                    off.drawString("High Score List", 230, 205);
                    off.drawString("Enter your name", 230, 220);
                    send.show();
                    entryName.show();
                    if(entryName.getText().equals(""))
                    {
                        send.disable();
                    } else
                    {
                        send.enable();
                    }
                }
            }
            if(gameoverdelay > 50)
            {
                requestFocus();
                gamestate = level = 0;
                resetEnemy();
                ss(0, 220, 320, 456, 0, 336, 0, 1, 1);
                ss(1, 216, 216, 456, 0, 336, 0, -1, -1);
                ss(2, 110, 120, 456, 0, 336, 0, 2, 2);
                ss(3, 120, 110, 456, 0, 336, 0, -2, -2);
                ss(4, 300, 300, 456, 0, 336, 0, 4, 4);
                ss(5, 400, 216, 456, 0, 336, 0, -4, -4);
                score = 0L;
            }
            break;
        }
        g.drawImage(offScreenImage, 0, 0, this);
    }

    public void doBlobs()
    {
        int i = 0;
        do
        {
            if(blobs[i][0] == 100)
            {
                blobs[i][8]++;
                if(blobs[i][8] > blobs[i][7])
                {
                    blobs[i][8] = 0;
                    blobs[i][9] = blobs[i][9] != 0 ? 0 : 1;
                }
                off.drawImage(imgblobs[blobs[i][9]], blobs[i][1], blobs[i][2] + scrolly, this);
                blobs[i][1] += blobs[i][5];
                if(blobs[i][5] > 0 && blobs[i][1] > blobs[i][3])
                {
                    blobs[i][5] *= -1;
                }
                if(blobs[i][5] < 0 && blobs[i][1] < blobs[i][4])
                {
                    blobs[i][5] *= -1;
                }
                collision = p.collision(blobs[i][1] + 3, (blobs[i][2] + scrolly) - 4, 18, 12);
                if(collision && blobs[i][2] + scrolly > p.y + 24)
                {
                    blobs[i][0] = 0;
                    startExplosion(blobs[i][1] + 10, blobs[i][2] + 6);
                    if(destroying)
                    {
                        if(lastpoints == 0)
                        {
                            lastpoints = 100;
                        } else
                        {
                            lastpoints += 100;
                        }
                    } else
                    {
                        lastpoints = 100;
                    }
                    score += lastpoints;
                    startPoints(blobs[i][1], blobs[i][2] + scrolly, lastpoints);
                    blobau.play();
                    bc--;
                    fall = false;
                    jump = destroying = true;
                    ladder = false;
                } else
                if(collision)
                {
                    startDeath();
                }
            }
        } while(++i < 24);
        if(bc == 0)
        {
            gamestate = 20;
            score += 500L;
            closestep = donedelay = 0;
        }
    }

    public WW_Infinite()
    {
        isexplosion = false;
        m_cfgfile = "";
        param = "";
        imgexplosion = null;
        bimg = new Image[6];
        imgeye = null;
        imgeye2 = null;
        imgblobs = null;
        imgspike = null;
        bigstar = null;
        tiles = null;
        background = null;
        close = null;
        huh = null;
        imgswitch = new Image[2];
        blobau = null;
        landau = null;
        dieau = null;
        stepau = null;
        switchau = null;
        startupau = null;
        level2au = null;
        explosion = new int[8][4];
        bottom = new int[8][5];
        blobs = new int[24][10];
        spike = new int[16][9];
        eye = new int[4][5];
        eye2 = new int[4][5];
        witch = new int[8][4];
        lblobs = new int[16][10];
        points = new int[20][5];
        switches = new int[8][5];
        climbframe = 1;
        climbdelay = 0;
        lastpoints = 10;
        out = new boolean[4];
        outx = new int[4];
        outy = new int[4];
        outd = new int[4];
        rn = new Random();
        big = null;
        overfont = null;
        barfont = null;
        gamestate = 0;
        donedelay = 0;
        offScreenImage = null;
        off = null;
        backgroundgraphics = null;
        p = null;
        canvas = null;
        maps = new MapArchive();
        score = 0L;
    }

    public void startDeath()
    {
        if(!death)
        {
            dieau.play();
            bigstarx = p.x;
            bigstary = p.y;
            bigstars = 0;
            death = true;
            gamestate = 100;
            destroying = false;
            lastpoints = 10;
        }
    }

    public void starteye(int i, int j, int k)
    {
        eye[i][0] = 100;
        eye[i][1] = eye[i][3] = j;
        eye[i][2] = eye[i][4] = k;
    }

    public void doeye()
    {
        int i = 0;
        do
        {
            if(eye[i][0] == 100)
            {
                if(checkCollision(p.x, p.y, 24, 24, eye[i][1] + 2, eye[i][2] + 2 + scrolly, 20, 20))
                {
                    startDeath();
                }
                if(p.y == eye[i][2] + scrolly)
                {
                    if(direction == 0 && eye[i][1] > p.x)
                    {
                        off.drawImage(imgeye[1], eye[i][1], eye[i][2] + scrolly, this);
                        eye[i][1] -= 4;
                    } else
                    {
                        off.drawImage(imgeye[0], eye[i][1], eye[i][2] + scrolly, this);
                        if(eye[i][1] < eye[i][3])
                        {
                            eye[i][1]++;
                        }
                    }
                } else
                {
                    off.drawImage(imgeye[0], eye[i][1], eye[i][2] + scrolly, this);
                    if(eye[i][1] < eye[i][3])
                    {
                        eye[i][1]++;
                    }
                }
            }
        } while(++i < 4);
    }

    public void dojump()
    {
        if(jumpstep < 10)
        {
            if(canvas.checkCollision(p.x, p.y + jumparray[jumpstep] + offsety, 24, 24) != 100)
            {
                if(p.y > 120 || offsety < 1)
                {
                    p.y += jumparray[jumpstep];
                } else
                {
                    scrolly -= jumparray[jumpstep];
                    offsety += jumparray[jumpstep];
                }
            }
            jumpstep++;
            return;
        } else
        {
            fall = true;
            jump = false;
            return;
        }
    }

    public void displayBar()
    {
        off.setColor(Color.black);
        off.fillRect(0, 360, 480, 20);
        off.setColor(Color.white);
        off.setFont(barfont);
        off.drawString("Level: " + level, 10, 374);
        off.drawString("Score: " + score, 100, 374);
        off.drawString("Lives: " + lives, 340, 374);
        off.drawString("Blobs: " + bc, 410, 374);
    }

    public void doAll()
    {
        int i = 0;
        do
        {
            if(spike[i][0] == 100)
            {
                if(checkCollision(p.x, p.y, 24, 24, spike[i][1] + 4, spike[i][2] + 4 + scrolly, 16, 16))
                {
                    startDeath();
                }
                off.drawImage(imgspike, spike[i][1], spike[i][2] + scrolly, this);
                spike[i][1] += spike[i][7];
                if(spike[i][7] > 0 && spike[i][1] > spike[i][3])
                {
                    spike[i][7] *= -1;
                }
                if(spike[i][7] < 0 && spike[i][1] < spike[i][5])
                {
                    spike[i][7] *= -1;
                }
                spike[i][2] += spike[i][8];
                if(spike[i][8] > 0 && spike[i][2] > spike[i][4])
                {
                    spike[i][8] *= -1;
                }
                if(spike[i][8] < 0 && spike[i][2] < spike[i][6])
                {
                    spike[i][8] *= -1;
                }
            }
        } while(++i < 16);
        i = 0;
        do
        {
            if(bottom[i][0] == 100)
            {
                bottom[i][3]++;
                if(bottom[i][3] > 0 && bottom[i][3] <= 3)
                {
                    bottom[i][4] = 0;
                } else
                if(bottom[i][3] > 3 && bottom[i][3] <= 6)
                {
                    bottom[i][4] = 1;
                } else
                if(bottom[i][3] > 6 && bottom[i][3] <= 9)
                {
                    bottom[i][4] = 2;
                } else
                if(bottom[i][3] > 9 && bottom[i][3] <= 12)
                {
                    bottom[i][4] = 3;
                } else
                if(bottom[i][3] > 12 && bottom[i][3] <= 15)
                {
                    bottom[i][4] = 4;
                } else
                if(bottom[i][3] > 15 && bottom[i][3] <= 68)
                {
                    bottom[i][4] = 5;
                } else
                if(bottom[i][3] > 68 && bottom[i][3] <= 71)
                {
                    bottom[i][4] = 4;
                } else
                if(bottom[i][3] > 71 && bottom[i][3] <= 74)
                {
                    bottom[i][4] = 3;
                } else
                if(bottom[i][3] > 74 && bottom[i][3] <= 77)
                {
                    bottom[i][4] = 2;
                } else
                if(bottom[i][3] > 77 && bottom[i][3] <= 80)
                {
                    bottom[i][4] = 1;
                } else
                if(bottom[i][3] > 80)
                {
                    bottom[i][3] = 0;
                }
                off.drawImage(bimg[bottom[i][4]], bottom[i][1], bottom[i][2] + scrolly, this);
                if(bottom[i][4] != 5 && checkCollision(p.x, p.y, 24, 24, bottom[i][1] + 6, bottom[i][2] + (24 - bottom[i][4] * 4) + scrolly, 12, 24))
                {
                    startDeath();
                }
            }
            if(explosion[i][0] == 100)
            {
                explosion[i][3]++;
                off.drawImage(imgexplosion, explosion[i][1], explosion[i][2] + scrolly + explosion[i][3] * 8, this);
                off.drawImage(imgexplosion, explosion[i][1] + explosion[i][3] * 8, explosion[i][2] + scrolly, this);
                off.drawImage(imgexplosion, explosion[i][1] - explosion[i][3] * 8, explosion[i][2] + scrolly, this);
                off.drawImage(imgexplosion, explosion[i][1], (explosion[i][2] + scrolly) - explosion[i][3] * 8, this);
                off.drawImage(imgexplosion, explosion[i][1] + explosion[i][3] * 4, (explosion[i][2] + scrolly) - explosion[i][3] * 7, this);
                off.drawImage(imgexplosion, explosion[i][1] - explosion[i][3] * 4, (explosion[i][2] + scrolly) - explosion[i][3] * 7, this);
                off.drawImage(imgexplosion, explosion[i][1] + explosion[i][3] * 7, (explosion[i][2] + scrolly) - explosion[i][3] * 4, this);
                off.drawImage(imgexplosion, explosion[i][1] - explosion[i][3] * 7, (explosion[i][2] + scrolly) - explosion[i][3] * 4, this);
                off.drawImage(imgexplosion, explosion[i][1] + explosion[i][3] * 4, explosion[i][2] + scrolly + explosion[i][3] * 7, this);
                off.drawImage(imgexplosion, explosion[i][1] - explosion[i][3] * 4, explosion[i][2] + scrolly + explosion[i][3] * 7, this);
                off.drawImage(imgexplosion, explosion[i][1] + explosion[i][3] * 7, explosion[i][2] + scrolly + explosion[i][3] * 4, this);
                off.drawImage(imgexplosion, explosion[i][1] - explosion[i][3] * 7, explosion[i][2] + scrolly + explosion[i][3] * 4, this);
                if(explosion[i][3] > 60)
                {
                    explosion[i][0] = explosion[i][3] = 0;
                }
            }
        } while(++i < 8);
    }

    public boolean action(Event event, Object obj)
    {
        if(event.target == again)
        {
            again.hide();
            send.hide();
            entryName.hide();
            gameoverdelay = 100;
            startupau.play();
        } else
        if(event.target == send && !alreadysent)
        {
            alreadysent = true;
            send.hide();
            entryName.hide();
            repaint();
            String s = "Wickywoo";
            String s1 = entryName.getText().replace('&', '_');
            String s2 = cgi.call("course=" + s + "&name=" + s1 + "&time=" + score);
            if(s2.equals("OK"))
            {
                send.hide();
                entryName.hide();
            } else
            {
                send.hide();
                entryName.hide();
            }
        }
        return false;
    }

    public void run()
    {
        startupau.play();
        do
        {
            do
            {
                tm = System.currentTimeMillis();
                if(gamestate == 10 || isexplosion)
                {
                    movement();
                    levelspec();
                } else
                if(gamestate == 30)
                {
                    closestep++;
                    if(closestep > 5)
                    {
                        closestep = 5;
                        if(!death)
                        {
                            level++;
                        }
                        levelSetup();
                        gamestate = 40;
                        jump = fall = death = false;
                    }
                }
                repaint();
                try
                {
                    delay = 30L - (System.currentTimeMillis() - tm);
                    if(delay < 0L)
                    {
                        delay = 10L;
                    }
                    Thread.sleep(delay);
                }
                catch(InterruptedException _ex) { }
                lastTime = System.currentTimeMillis();
            } while(lastTime - startTime <= 1000L);
            startTime = lastTime;
        } while(true);
    }

    public void init()
    {
        int k = 0;
        again = new Button("Play Again");
        again.reshape(110, 190, 100, 30);
        add(again);
        overfont = new Font("Serif", 1, 24);
        barfont = new Font("Serif", 1, 14);
        send = new Button("Send Record");
        send.reshape(110, 230, 100, 30);
        add(send);
        entryName = new TextField(10);
        entryName.reshape(230, 230, 100, 30);
        add(entryName);
        again.hide();
        send.hide();
        entryName.hide();
        alreadysent = false;
        Scoregameover = false;
        param = getParameter("Scorepath");
        if(param != null)
        {
            m_cfgfile = param;
        }
        if(m_cfgfile != "")
        {
            readcfgFile();
        }
        if(URLName == null)
        {
            URLName = "http://www.FreeArcade.com";
        }
        URLName = URLName + "/cgi-bin/wickywoo_record.cgi";
        cgi = new CGIcall(URLName);
        jump = fall = collision = false;
        direction = frame = running = scrolly = 0;
        standing = true;
        blobau = LoadAudioClip("sound1.au");
        landau = LoadAudioClip("sound3.au");
        dieau = LoadAudioClip("plosion.au");
        stepau = LoadAudioClip("step.au");
        switchau = LoadAudioClip("switch.au");
        startupau = LoadAudioClip("level.au");
        level2au = LoadAudioClip("level2.au");
        tracker = new MediaTracker(this);
        huh = getImage(getDocumentBase(), "title.gif");
        tracker.addImage(huh, 0);
        Image image = getImage(getDocumentBase(), "eye.gif");
        tracker.addImage(image, 0);
        imgeye = new Image[2];
        imgeye2 = new Image[2];
        CropImageFilter cropimagefilter = new CropImageFilter(0, 0, 24, 24);
        imgeye[0] = createImage(new FilteredImageSource(image.getSource(), cropimagefilter));
        tracker.addImage(imgeye[0], 0);
        cropimagefilter = new CropImageFilter(24, 0, 24, 24);
        imgeye[1] = createImage(new FilteredImageSource(image.getSource(), cropimagefilter));
        tracker.addImage(imgeye[1], 0);
        cropimagefilter = new CropImageFilter(48, 0, 24, 24);
        imgeye2[1] = createImage(new FilteredImageSource(image.getSource(), cropimagefilter));
        tracker.addImage(imgeye2[1], 0);
        cropimagefilter = new CropImageFilter(72, 0, 24, 24);
        imgeye2[0] = createImage(new FilteredImageSource(image.getSource(), cropimagefilter));
        tracker.addImage(imgeye2[0], 0);
        cropimagefilter = new CropImageFilter(96, 0, 24, 24);
        bigstar = createImage(new FilteredImageSource(image.getSource(), cropimagefilter));
        tracker.addImage(bigstar, 0);
        Image image1 = getImage(getDocumentBase(), "switch.gif");
        tracker.addImage(image1, 0);
        cropimagefilter = new CropImageFilter(0, 0, 22, 19);
        imgswitch[0] = createImage(new FilteredImageSource(image1.getSource(), cropimagefilter));
        tracker.addImage(imgswitch[0], 0);
        cropimagefilter = new CropImageFilter(22, 0, 22, 19);
        imgswitch[1] = createImage(new FilteredImageSource(image1.getSource(), cropimagefilter));
        tracker.addImage(imgswitch[1], 0);
        Image image2 = getImage(getDocumentBase(), "tiles.gif");
        tracker.addImage(image2, 0);
        Image image3 = getImage(getDocumentBase(), "character.gif");
        tracker.addImage(image3, 0);
        p = new Player(image3, playercrop, this, tracker);
        big = new Font("Serif", 2, 24);
        Image image4 = getImage(getDocumentBase(), "spike2.gif");
        tracker.addImage(image4, 0);
        int i = 0;
        do
        {
            cropimagefilter = new CropImageFilter(i * 24, 0, 24, 24);
            bimg[i] = createImage(new FilteredImageSource(image4.getSource(), cropimagefilter));
            tracker.addImage(bimg[i], 0);
        } while(++i < 6);
        tiles = new Image[60];
        i = 0;
        do
        {
            int j = 0;
            do
            {
                cropimagefilter = new CropImageFilter(j * 24, i * 24, 24, 24);
                tiles[k] = createImage(new FilteredImageSource(image2.getSource(), cropimagefilter));
                tracker.addImage(tiles[k], 0);
                k++;
            } while(++j < 10);
        } while(++i < 6);
        imgspike = getImage(getDocumentBase(), "spike.gif");
        tracker.addImage(imgspike, 0);
        imgexplosion = getImage(getDocumentBase(), "star.gif");
        tracker.addImage(imgexplosion, 0);
        Image image5 = getImage(getDocumentBase(), "close.gif");
        tracker.addImage(image5, 0);
        close = new Image[6];
        i = 0;
        do
        {
            cropimagefilter = new CropImageFilter(i, 0, 24, 24);
            close[i / 24] = createImage(new FilteredImageSource(image5.getSource(), cropimagefilter));
            tracker.addImage(close[i / 24], 0);
        } while((i += 24) < 144);
        imgblobs = new Image[2];
        Image image6 = getImage(getDocumentBase(), "blob.gif");
        tracker.addImage(image6, 0);
        cropimagefilter = new CropImageFilter(0, 0, 24, 12);
        imgblobs[0] = createImage(new FilteredImageSource(image6.getSource(), cropimagefilter));
        tracker.addImage(imgblobs[0], 0);
        cropimagefilter = new CropImageFilter(24, 0, 24, 12);
        imgblobs[1] = createImage(new FilteredImageSource(image6.getSource(), cropimagefilter));
        tracker.addImage(imgblobs[1], 0);
        try
        {
            tracker.waitForAll();
        }
        catch(InterruptedException _ex) { }
        if(offScreenImage == null)
        {
            offScreenImage = createImage(getSize().width, getSize().height);
            off = offScreenImage.getGraphics();
        }
        if(background == null)
        {
            background = createImage(getSize().width, 1080);
            backgroundgraphics = background.getGraphics();
        }
        startTime = System.currentTimeMillis();
        lastTime = startTime;
        secondsPassed = 0L;
        enableEvents(8L);
        requestFocus();
        ss(0, 220, 320, 456, 0, 336, 0, 1, 1);
        ss(1, 216, 216, 456, 0, 336, 0, -1, -1);
        ss(2, 110, 120, 456, 0, 336, 0, 2, 2);
        ss(3, 120, 110, 456, 0, 336, 0, -2, -2);
        ss(4, 300, 300, 456, 0, 336, 0, 4, 4);
        ss(5, 400, 216, 456, 0, 336, 0, -4, -4);
        p.x = p.y = -100;
        canvas = new Map(this, tiles, backgroundgraphics);
    }

    private void readcfgFile()
    {
        try
        {
            URL url = new URL(getCodeBase(), m_cfgfile);
            try
            {
                DataInputStream datainputstream = new DataInputStream(url.openStream());
                if(datainputstream != null)
                {
                    String s = datainputstream.readLine();
                    if(s != null)
                    {
                        URLName = s;
                        return;
                    }
                }
            }
            catch(IOException _ex)
            {
                return;
            }
        }
        catch(MalformedURLException _ex)
        {
            System.err.println("Could not open config file.");
        }
    }
}