Java4K - Minimum Games, Maximum Fun!

View Game: 4Khords

4Khords
By Russell A Spitzer, submitted on Feb 11, 2012
Min JRE version: 1.6
1820 downloads.
This game was submitted in the Java4K 2012 Competition.
Source code available! Show source code
(Click on game for focus)

You need Java installed to play this game.
You may use the button below to get it.
Description

4Khords asks you to create beautiful music with the majestic silver power orb. Unfortunately and evil wizard has made it so that only a specific pattern of colors will make beautiful music! Only the pure of heart can see what this pattern may be in the upper left hand corner of the world. Follow the pattern, make the music, BE A CHAMPION.
Instructions

Bounce left = Left Arrow
Bounce right = Right Arrow

Advance Level = A
User Comments

Total 1 comments:
#1	By Ivaxlar	Feb 11, 2012 at 23:43:47
Wow, really amazing work and super fun game!
You need be logged in to write comments. If you need to register click here.
Source code

Note: We recommend you copy+paste this to a better editor. Some special character encoding may have been lost.
import java.applet.Applet;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;
import javax.sound.sampled.DataLine;

/**
 *
 * @author Russ and Maggie
 */
public class a extends Applet implements Runnable {

    final int BOTTOM = 480;
    final int EDGE = 510;
    final int[] defCints = {
        (0xFFEB3F3F),
        (0xFFFFE524),
        (0xFF9CFF24),
        (0xFF36C96F),
        (0xFF45FFEC),
        (0xFF2A85A3),
        (0xFF346FCF),
        (0xFF4B34CF),
        (0xFFAC6FDE),
        (0xFFFA25E8),
        (0xFFF20C7F),
        (0xFFD9D9D9),
        (0xFFD9FFD9)
    };
    final int color_n = 17;
    private Color[] defC;
    private Color[] defbC;
    private Color[][] defCS;
    final float player_radius = 7;
    final Ellipse2D player = new Ellipse2D.Float(-player_radius, -player_radius, player_radius * 2.f, player_radius * 2.f);
    final Line2D velocity = new Line2D.Float(0, 0, 0, 0);
    private Line2D templine2d = new Line2D.Float();
    private Line2D projection2d = new Line2D.Float();
    float px = 255, py = 100, scx = 1.0f, scy = 1.0f;
    float vx = 0, vy = 0, ax = 0.f;
    private int i, level = -1;
    private int levelinit = 1;
    //StartX,StartY,EndX,EndY,Color,Movement?
    final int[][][] LEVELS = {
        {{10, 440, 230, 440, 0}, {265, 440, 500, 440, 0}}, //Level 1- Intro Just bounce
        {{30, 440, 130, 440, 0}, {140, 375, 240, 375, 4}, {250, 325, 350, 325, 7}, {360, 275, 460, 275, 9}}, //Level 2- Stairs
        {{80, 440, 180, 440, 0}, {170, 370, 230, 370, 3}, {220, 440, 280, 440, 5}, {250, 370, 310, 370, 7}, {320, 440, 420, 440, 0}}, //Level 3- BluesRiff
        {{40, 440, 150, 440, 1}, {220, 370, 300, 370, 3}, {40, 300, 130, 300, 5}, {240, 250, 300, 250, 7}, {20, 180, 60, 230, 9}, {220, 100, 300, 100, 11}, {350, 460, 420, 460, 6}}, //Level 4- Hi Dive
        {{40, 300, 200, 400, 0}, {300, 400, 440, 300, 3}, {220, 210, 280, 210, 5}}, // Level 5
        {{10, 300, 230, 380, 1}, {265, 380, 500, 300, 2}}, //Level 6- Moving Bounces
        {{40, 425, 200, 425, 1}, {230, 325, 450, 325, 5}, {100, 325, 220, 325, 8}}, // Level 7- Wrap around
        {{30, 430, 80, 430, 1}, {130, 430, 180, 430, 5}, {80, 330, 130, 330, 3}, {180, 330, 230, 330, 0}, {130, 230, 180, 230, 1}, {230, 230, 280, 230, 8}, {360, 260, 385, 260, 12}}, // Level 8- Back and forth
        {{25, 450, 92, 450, 0}, {118, 165, 181, 165, 4}, {225, 460, 292, 460, 8}, {366, 163, 440, 163, 10}},
        {{23, 444, 83, 444, 7}, {91, 313, 145, 313, 2}, {150, 222, 224, 222, 4}, {430, 101, 430, 224, 4}, {216, 255, 214, 403, 11}, {284, 454, 362, 421, 9}},
        {{33, 444, 92, 444, 0}, {122, 331, 191, 331, 1}, {228, 332, 295, 332, 2}, {334, 216, 396, 216, 3}, {475, 56, 474, 178, 4}},
        {{277,394,373,466,0},{380,470,484,398,11},{29,265,113,317,3},{185,267,115,318,4}}
    };
    final int[][][] PLAT_MOVE = {
        {}, //1
        {}, //2
        {}, //3
        {}, //4
        {}, //5
        {{0, 100}, {0, -100}}, //6
        {}, //7
        {}, //8
        {{0, -290}, {0, 290}, {0, -290}, {0, 290}},
        {},
        {{0, -110}, {0, 102}, {0, -101}, {0, 85}, {1, 0}},
        {{0,1},{0,1},{0,175},{0,175}}
                
        };
    final int[][] PATTERN = {
        {0, 0, 0}, //1
        {0, 4, 7, 9, 7, 4, 0}, //2
        {0, 3, 5, 7, 0}, //3
        {1, 3, 5, 7, 9, 11, 6}, //4
        {0, 3, 0, 3, 5}, //5
        {1, 2, 1, 2, 1}, //6
        {1, 1, 5, 5, 1, 5, 8}, //7
        {1, 5, 3, 0, 1, 8, 12},
        {0, 8, 4, 10, 4, 0},
        {7, 2, 4, 4, 11, 9},
        {1, 2, 3, 4, 3, 2, 0},
        {0,11,3,4,11,0}
    }; //8
    final int[][] WINCHORD = {
        {0}, //1
        {0, 7}, //2
        {0, 7, 3}, //3
        {3, 11},
        {0, 3, 5},
        {3}, //4
        {1, 5, 8}, //5
        {10, 6},
        {4, 10, 0},
        {9, 12, 2},
        {5, 8, 10},
        {3,6,8}}; //6
    final Rectangle2D patrec = new Rectangle2D.Float(-20, -20, 40, 40);
    final Ellipse2D spark = new Ellipse2D.Float(0.0f, 0.0f, 3, 3);
    //final Polygon = new Polygon(xpoints, ypoints, i)
    private Line2D[] curPla;
    private int pnpat = 0;
    // Particle engine parts
    final int s_n = 200;
    final int s_lt = 40;
    private float[] s_px = new float[s_n];
    private float[] s_py = new float[s_n];
    private float[] s_vx = new float[s_n];
    private float[] s_vy = new float[s_n];
    private float[] s_rot = new float[s_n];
    private float[] s_vrot = new float[s_n];
    private int[] s_color = new int[s_n];
    private int[] s_t = new int[s_n];
    private int s_cur = 0; // The current particle space to be filled
    // Soundy Pie
    final float samrat = 44100;
    final float sampi = (float) (2.f * Math.PI / samrat);
    final int bitDepth = 16;
    final int bytesPerSample = bitDepth / 8;
    final AudioFormat format = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED, samrat, bitDepth, 1, bytesPerSample, samrat, false);//AudioFormat(samrat,8,1,false,false);
    final DataLine.Info dlinfo = new DataLine.Info(Clip.class, format, (int) (20 * samrat));
    private Clip clip = null;
    //Some Drawing Junk
    final BasicStroke pstroke = new BasicStroke(10, BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND);
    final BasicStroke dstroke = new BasicStroke(2, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL);
    final GradientPaint ggrad = new GradientPaint(0, -20, Color.black, 0, 20, Color.white);
    //Key log
    private boolean[] a = new boolean[2];
    //Platform Movement
    private float[][] curPlaOffset;
    private float[][] curPlaVeloc;
    private boolean[] curPlaMotion;
    private float[][] curPlaOrtho;
    //Key Constants
    final double COLLISION_DIST = 5.0;
    final double BOUNCEBOOST = 5.0;
    final float MAXVX = 3.25f;
    final float MAXVY = 5.0f;
    final float MAXAX = 0.07f;
    //Level init delay
    int delay = 0;

    @Override
    public void start() {
        enableEvents(8);
        new Thread(this).start();

    }

    public void run() {



        
        //SOUND CREATION
        final int MISSNOTE = 12;
        final int cliplength = (int) (samrat / 2); // .5 seconds
        byte[][] SOUNDS = new byte[13][(cliplength) * bytesPerSample];
        byte[] Song = new byte[(int) samrat * 100];
        int mr;
        final int attack = (int) (cliplength / 15);
        final int rest = (int) (cliplength - (cliplength / 2f));
        final float maxVol = 0.3f;
        final float a440 = 440.f;
        final float Silent = 0;
        final float a_temp = 1.0594630943f;
        final float sustainVol = 0.2f;
        float volume = 0;
        float volumeScale = (float) Math.pow(2, (bitDepth - 1)) - 1.f;
        float freq;

        for (i = 0; i < 13; i++) {
            volume = 0;
            freq = (float) (a440 * Math.pow(a_temp, i));
            if (i == MISSNOTE) {
                freq = a440 / 8.f;
            }
            for (int j = 0; j < cliplength; j++) {
                if (j < attack) {
                    volume = ((float) maxVol / attack) * j;
                } else if (j > rest) {
                    volume = sustainVol - sustainVol / (cliplength - rest) * (j - rest);
                } else {
                    volume = maxVol - (maxVol - sustainVol) * (j - attack) / (float) j;
                }
                // if (i==MISSNOTE) volume=volume*3;
                // I don\'t know anything about music, but i do know something about waveforms and harmonics are awesome
//            mr = (int)( volume * volumeScale * (Math.sin( freq * j * sampi)) );
//            if( i == 3 )
//              System.out.println(\"mr[\"+j+\"]=\"+mr+\" vol=\"+volume);
                mr = (int) (volume * volumeScale
                        * (0.05 * (Math.sin(j * sampi * (freq * 0.5)))
                        + 0.75 * (Math.sin(j * sampi * (freq)))
                        + 0.15 * (Math.sin(j * sampi * (2 * freq)))
                        + 0.05 * (Math.sin(j * sampi * (4 * freq)))));
                byte lowByte = (byte) (mr);
                byte highByte = (byte) (mr >> 8);
//            if( i == 0 ){
//                System.out.println(\"mr[\"+j+\"]=\"+Integer.toHexString(mr) );
//                System.out.println(\"lowByte[\"+j+\"]=\"+Integer.toHexString(lowByte));
//                System.out.println(\"highByte[\"+j+\"]=\"+Integer.toHexString(highByte));
//            }
                SOUNDS[i][bytesPerSample * j] = lowByte;
                SOUNDS[i][bytesPerSample * j + 1] = highByte;

            }

        }

        /*
         * try {
         *
         * Clip clip = (Clip) AudioSystem.getLine(dlinfo); clip.open(format,
         * SOUNDS[0], 0, (int) (cliplength*bytesPerSample));
         * //clip.setLoopPoints(2*attack, rest);
         * clip.loop(Clip.LOOP_CONTINUOUSLY); clip.start(); clip = (Clip)
         * AudioSystem.getLine(dlinfo); clip.open(format, SOUNDS[4], 0, (int)
         * (cliplength)); clip.start(); clip = (Clip)
         * AudioSystem.getLine(dlinfo); clip.open(format, SOUNDS[7], 0, (int)
         * (cliplength)); clip.start(); clip = (Clip)
         * AudioSystem.getLine(dlinfo); clip.open(format, SOUNDS[11], 0, (int)
         * (cliplength)); clip.start(); }catch (Exception e) {
         * e.printStackTrace(); return ; }
         */


        // COLOR CREATION for SHADOWS
        defC  = new Color[color_n];
        defbC = new Color[color_n];
        defCS = new Color[color_n][40];
        for (i = 0; i < defC.length; i++) {
            defC[i] = new Color(defCints[i]);
            defbC[i] = defC[i].darker().darker().darker();
            defCS[i] = new Color[40];
            defCS[i][39] = defC[i];
            for (int j = 38; j >= 0; j--) {
                defCS[i][j] = new Color(defCS[i][j + 1].getRed(), defCS[i][j + 1].getGreen(), defCS[i][j + 1].getBlue(), (255 / 40) * j);
            }
        }

        BufferedImage image = new BufferedImage(EDGE, BOTTOM, 1);
        Graphics2D g = (Graphics2D) image.getGraphics();
        Graphics2D g2 = null;
        //g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
        long nextFrameStartTime = System.nanoTime();
        while (true) {
            //System.out.println(\"FrameStart\");

            do {//Game Logic

                nextFrameStartTime += 9000000;

                /**
                 * * LEVEL INIT ***
                 */
                //IF we are on a  new level initilize
                if (levelinit == 1 && delay == 0) {
                    level++;
                    if (level == LEVELS.length) {
                        level = 0;
                    }
                    curPla = new Line2D[LEVELS[level].length];
                    curPlaOffset = new float[LEVELS[level].length][2];
                    curPlaVeloc = new float[LEVELS[level].length][2];
                    curPlaMotion = new boolean[LEVELS[level].length];
                    curPlaOrtho = new float[LEVELS[level].length][2];

                    px = 246;
                    py = 100;
                    vx = vy = 0;
                    pnpat = 0;
                    for (i = 0; i < curPla.length; i++) {
                        curPla[i] = new Line2D.Float(LEVELS[level][i][0], LEVELS[level][i][1], LEVELS[level][i][2], LEVELS[level][i][3]);

                        curPlaOrtho[i][1] = (-LEVELS[level][i][2] + LEVELS[level][i][0]);
                        curPlaOrtho[i][0] = LEVELS[level][i][3] - LEVELS[level][i][1];
                        double mag = curPlaOrtho[i][0] * curPlaOrtho[i][0] + curPlaOrtho[i][1] * curPlaOrtho[i][1];
                        mag = Math.sqrt(mag);
                        curPlaOrtho[i][0] /= mag;
                        curPlaOrtho[i][1] /= mag;

                        if (PLAT_MOVE[level].length > i) {
                            vx = PLAT_MOVE[level][i][0];
                            vy = PLAT_MOVE[level][i][1];
                            mag = vx * vx + vy * vy;
                            mag = Math.sqrt(mag);
                            vx /= 2.0 * mag;
                            vy /= 2.0 * mag;


                        }
                        curPlaVeloc[i][0] = vx;
                        curPlaVeloc[i][1] = vy;
                        curPlaMotion[i] = true;
                        //curPlaOffset[i][0]=cur ;
                        vx = vy = 0;
                    }
                    levelinit = 0;
                }
                /**
                 * * END LEVEL INIT ****
                 */
                delay--;

                // Platform Movement
                for (i = 0; i < curPla.length; i++) {
                    if (PLAT_MOVE[level].length <= i) {
                        break;
                    }
                    curPlaOffset[i][0] += (curPlaMotion[i]) ? curPlaVeloc[i][0] : -curPlaVeloc[i][0];
                    curPlaOffset[i][1] += (curPlaMotion[i]) ? curPlaVeloc[i][1] : -curPlaVeloc[i][1];
                    if (Math.abs(curPlaOffset[i][0] - PLAT_MOVE[level][i][0]) < 1.0 && Math.abs(curPlaOffset[i][1] - PLAT_MOVE[level][i][1]) < 1.0) {
                        curPlaMotion[i] = false;
                    } else if (Math.abs(curPlaOffset[i][0]) < 1.2 && Math.abs(curPlaOffset[i][1]) < 1.2) {
                        curPlaMotion[i] = true;
                    }
                }

                // Player movement
                if (a[1]) {
                    ax = MAXAX;
                } else if (a[0]) {
                    ax = -MAXAX;
                } else {
                    ax = -vx / 150.0f; // First order drag
                }
                px += vx;
                py += vy;
                scx = 1.0f + (vx * vx + vy * vy) / 35.f;
                vy += .1;
                vx += ax;

                if (vx > MAXVX) {
                    vx = MAXVX;
                }
                else if (vx < -MAXVX) {
                    vx = -MAXVX;
                }
                if (vy > MAXVY) {
                    vy = MAXVY;
                }
                else if (vy < -MAXVY) {
                    vy = -MAXVY;
                }
                velocity.setLine(0, 0, vx * 10.f, vy * 10.f);


                // Particle updates
                for (i = 0; i < s_n; i++) {
                    if (s_t[i] < 0) {
                        continue;
                    }
                    s_t[i]--;
                    s_px[i] += s_vx[i];
                    s_py[i] += s_vy[i];
                    s_rot[i] += s_vrot[i];
                }

                /**
                 * **** COLLISION ***
                 */
                //Check for Collisions with all current boundaries
                if (py >= BOTTOM) {
                    vy = -(vy + 1.f);
                    py = (BOTTOM - (py - BOTTOM));
                }
                if (px >= EDGE) {
                    px %= EDGE;
                }
                if (px <= 0) {
                    px = px + EDGE;
                }

                for (i = 0; i < curPla.length; i++) {

                    double px1 = curPla[i].getX1() + curPlaOffset[i][0];
                    double px2 = curPla[i].getX2() + curPlaOffset[i][0];
                    double py1 = curPla[i].getY1() + curPlaOffset[i][1];
                    double py2 = curPla[i].getY2() + curPlaOffset[i][1];
                    double pnx = curPlaOrtho[i][0];
                    double pny = curPlaOrtho[i][1];
                    double pdx = px2 - px1;
                    double pdy = py2 - py1;
                    double pmag = (pdx * pdx + pdy * pdy);
                    double rx = px - px1, ry = py - py1; // Line from one point on the
                    // platform to the ball
                    double r = (rx * pdx + ry * pdy) / pmag; // Dot product of that line
                    // against the delta of the
                    // line
                    //System.out.println(\"RFactor :\" + r);
                    if (r > 1 || r < 0) // If the dot product is not between 0 and 1
                    // then there is no component of r along the
                    // platform
                    {
                        continue;// Got to next platform
                    }
                    // In other words if we thickened the line segement of the platform
                    // infinitely the ball is in this seg

                    double dist = Math.abs(rx * pnx + ry * pny); // Now the dot product
                    // against the normal
                    // vector tells us the
                    // the shortest distance
                    // from the ball to platform

                    if (dist < COLLISION_DIST) {
                        //System.out.println(i + \": DistFactor :\" + dist);
                        double cosa = vx * pnx + vy * pny;
                        double mag = Math.sqrt(vx * vx + vy * vy);
                        cosa /= mag * Math.sqrt(pnx * pnx + pny * pny);
                        //System.out.println(\"(\" + vx + \",\" + vy + \") Velocity before\");
                        vy = (float) (-(mag + BOUNCEBOOST) * (pny) * cosa);// *(cosa > 0 ? -1 : 1));
                        vx = vx + (float) (-(mag + BOUNCEBOOST) * (pnx) * cosa);// * (cosa > 0 ? -1 : 1));
                        //System.out.println(\"(\" + vx + \",\" + vy + \") Velocity After\");
                        while (Math.abs(rx * pnx + ry * pny) < COLLISION_DIST) {
                            rx = px - px1;
                            ry = py - py1;
                            // ease out
                            px -= (pnx * 0.1) * (cosa > 0 ? 1 : -1);
                            py -= (pny * 0.1) * (cosa > 0 ? 1 : -1);
                            // px -= (vx+b.ex) ;
                            // py -= (vy) ;
                            // ge.draw();
                        }





                        //vy=(py<templine2d.getY1())?-Math.abs(vy+1.f):Math.abs(vy+1.f);
                        //py=(py>templine2d.getY1())?py+2.f:py-2.f;
                        // If the platform color matches the pattern color
                        if (levelinit != 1 && LEVELS[level][i][4] == PATTERN[level][pnpat]) {
                            try {
                                clip = (Clip) AudioSystem.getLine(dlinfo);
                                clip.open(format, SOUNDS[PATTERN[level][pnpat]], 0, (int) (cliplength * bytesPerSample)); //Thud sound
                                clip.start();
                            } catch (Exception e) {
                            }

                            pnpat++;
                            double tempvx, tempvy;
                            for (int j = 0; j < 100; j++) {
                                //Overwrite particles if we have too ..

                                if (s_n == s_cur) {
                                    s_cur = 0;
                                }
                                s_t[s_cur] = 30;
                                s_px[s_cur] = px;
                                s_py[s_cur] = py;
                                s_rot[s_cur] = 0;
                                s_vrot[s_cur] = 0;
                                s_color[s_cur] = LEVELS[level][i][4];
                                tempvx = (Math.random() * .25) - .125;
                                tempvy = Math.random() - .5;
                                mag = 1 / Math.sqrt(tempvx * tempvx + tempvy * tempvy);
                                mag *= Math.random() * 4;
                                s_vx[s_cur] = (float) (tempvx * mag);
                                tempvy *= mag;
                                s_vy[s_cur] = (float) ((vy < 0) ? (Math.abs(tempvy) + 1) : -(Math.abs(tempvy) + 1));

                                s_cur++;
                            }


                            // Level Beaten
                            if (pnpat == PATTERN[level].length) {

                                levelinit = 1;
                                delay = 300;
                                try {
                                    for (int j = 0; j < WINCHORD[level].length; j++) {
                                        clip = (Clip) AudioSystem.getLine(dlinfo);
                                        clip.open(format, SOUNDS[WINCHORD[level][j]], 0, (int) (cliplength * bytesPerSample)); //Thud sound
                                        clip.start();
                                    }
                                } catch (Exception e) {
                                }
                                break;
                            }
                        } else // The wrong platform was hit
                        {
                            pnpat = 0;
                            if (LEVELS[level][i][4] == PATTERN[level][pnpat]) {
                                pnpat += 1;
                            }
                            if (delay < 0) // If the pattern is complete no sound
                            {
                                try {
                                    clip = (Clip) AudioSystem.getLine(dlinfo);
                                    clip.open(format, SOUNDS[MISSNOTE], 0, (int) (cliplength * bytesPerSample)); //Thud sound
                                    clip.start();
                                } catch (Exception e) {
                                }
                            }

                        }







                    }
                }
                /**
                 * **** END COLLISION ****
                 */
            } while (nextFrameStartTime < System.nanoTime());
            //Now Render
            // Draw Background
            g.setColor(Color.DARK_GRAY);

            g.fillRect(0, 0, EDGE, BOTTOM);
            // Draw Level Number
            //g.setColor(Color.white);
            //g.drawString(Integer.toString(level), 460, 30);

            //Draw Ball
            g.setPaint(ggrad);
            g.translate(px, py);
            g.rotate(Math.atan(vx / -vy));
            g.scale(1, scx);
            g.fill(player);
            g.scale(1, 1 / scx);
            g.rotate(-Math.atan(vx / -vy));

            //Draw Velocity Vector (DEBUG)
      /*
             *
             *
             * g.setColor(Color.red); g.draw(velocity); g.setColor(Color.GREEN);
             * g.drawString(\"(\" + vx + \",\" + vy + \")\", 0, 0);
             *
             *
             */
            g.translate(-px, -py);

            //Draw bars
            g.setStroke(pstroke);
            for (i = 0; i < curPla.length; i++) {
                g.translate(curPlaOffset[i][0], curPlaOffset[i][1]);
                g.translate(-3, 3);
                g.setColor(defbC[LEVELS[level][i][4]]);
                g.draw(curPla[i]);
                g.translate(3, -3);
                g.setColor(defC[LEVELS[level][i][4]]);
                g.draw(curPla[i]);
                //Ortho Feel freee to get rid of this
                //g.drawLine((int)curPla[i].getX1(), (int)curPla[i].getY1(), (int)curPla[i].getX1()+(int)curPlaOrtho[i][0]*7, (int)curPla[i].getY1()+(int)curPlaOrtho[i][1]*7);
                g.translate(-curPlaOffset[i][0], -curPlaOffset[i][1]);
            }
            g.setStroke(dstroke);
            //Draw Current pattern
            g.translate(0, 40);
            for (i = 0; i < PATTERN[level].length; i++) {
                g.translate(50, 0);
                g.setColor(defC[PATTERN[level][i]]);

                if (i < pnpat) {
                    g.fill(patrec);
                }
                if (delay > 0) // Level beaten
                {
                    g.setColor(defCS[PATTERN[level][i]][((delay) % 40)]);
                    g.fill(patrec);
                } else if (pnpat == i) {
                    g.setStroke(pstroke);
                    g.setColor(defC[PATTERN[level][i]]);
                } else {
                    g.setColor(defbC[PATTERN[level][i]]);
                }
                g.draw(patrec);
                g.setStroke(dstroke);

            }
            g.translate(-50 * (i), -40);

            //Draw Sparkplosion
            Color temp;
            for (i = 0; i < s_n; i++) {
                if (s_t[i] < 0) {
                    continue;
                }
                g.translate(s_px[i], s_py[i]);
                temp = defC[s_color[i]];
                g.setColor(defCS[s_color[i]][s_t[i]]);

                g.fill(spark);
                g.translate(-s_px[i], -s_py[i]);



            }


            // And draw
            if (g2 == null) {
                g2 = (Graphics2D) getGraphics();
                requestFocus();
            } else {
                g2.drawImage(image, 0, 0, 512, 480, null);
            }

            while (nextFrameStartTime - System.nanoTime() > 0) {
                //System.out.println(nextFrameStartTime + \" \" + System.nanoTime() + \" = \" + (nextFrameStartTime-System.nanoTime()));
                Thread.yield();
            }

        }
    }

    @Override
    public void processKeyEvent(KeyEvent keyEvent) {
        final int VK_LEFT = 0x25;
        final int VK_RIGHT = 0x27;
        //final int VK_A = 0x41;
       // final int VK_D = 0x44;

        int k = keyEvent.getKeyCode();
        if (keyEvent.getID() == keyEvent.KEY_PRESSED) {
            if (k == VK_LEFT) {
                a[0] = true;
            }
            else if (k == VK_RIGHT) {
                a[1] = true;
            }
            //if (k == VK_A) {
            //    levelinit = 1;
            //    delay = 0;
            //}
        }
        if (keyEvent.getID() == keyEvent.KEY_RELEASED) {
            if (k == VK_LEFT) {
                a[0] = false;
            }
            else if (k == VK_RIGHT) {
                a[1] = false;
            }
        }
    }
}
Java4K.com

View Game: 4Khords

Description

Instructions

User Comments

Source code
