locked
Is this a valid C++ code?

    Question

  • I have some errors in the code and am needing some help fixing them. If you have any suggestions please post them. Thanks for any help. Here is the code:

    #include "pch.h"
    #include "Street Racing 3D.h"
    #include "BasicTimer.h"
    
    using namespace Windows::ApplicationModel;
    using namespace Windows::ApplicationModel::Core;
    using namespace Windows::ApplicationModel::Activation;
    using namespace Windows::UI::Core;
    using namespace Windows::System;
    using namespace Windows::Foundation;
    using namespace Windows::Graphics::Display;
    using namespace concurrency;
    
    public class A extends JFrame
    {
        private static boolean[] keys = new boolean[65536];
        private static int xMouse, yMouse, mouseButton;
    
        /**
         * This seems to be the smallest way of reading input events to the JFrame.
         */
        public void processEvent(AWTEvent e)
        {
            switch (e.getID())
            {
                case WindowEvent.WINDOW_CLOSING:
                    System.exit(0);
                case MouseEvent.MOUSE_RELEASED:
                    mouseButton = 0;
                    break;
                case MouseEvent.MOUSE_PRESSED:
                    mouseButton = ((MouseEvent)e).getButton();
                case MouseEvent.MOUSE_MOVED:
                case MouseEvent.MOUSE_DRAGGED:
                    xMouse = ((MouseEvent)e).getX();
                    yMouse = ((MouseEvent)e).getY();
                    break;
                case KeyEvent.KEY_PRESSED:
                case KeyEvent.KEY_RELEASED:
                    keys[((KeyEvent)e).getKeyCode()] = e.getID() == KeyEvent.KEY_PRESSED;
            }
        }
    
        public static void main(String[] args) throws Throwable
        {
            // The end-line comments are there to prevent eclipse's auto formating
            // from messing up the sprite data.
            char[] SPRITES = (//
            "" + //
                    " !!!!  " + //
                    " !oooo " + //
                    " !oooo " + //
                    "  **   " + //
                    "  **XX " + //
                    "  o*XX " + //
                    "  **   " + //
                    "  **   " + //
                    "  **   " + //
                    "  ooo  " + //
    
                    "  !    " + //
                    " !!!!  " + //
                    " !oooo " + //
                    "  oooo " + //
                    "  **XXX" + //
                    "  *oXXX" + //
                    "  **** " + //
                    " ** ** " + //
                    "**   oo" + //
                    "oo     " + //
    
                    "  !!!  " + //
                    " !oooo " + //
                    "!!oooo " + //
                    "  ** XX" + //
                    "  ***oX" + //
                    "  ** XX" + //
                    "  ***  " + //
                    " ***** " + //
                    "o** ** " + //
                    "o    oo" + //
    
                    " !!!!  " + //
                    "!!oooo " + //
                    " !oooo " + //
                    "  **   " + //
                    "  **XXX" + //
                    "  *oXXX" + //
                    "  **   " + //
                    " o***  " + //
                    "  o**  " + //
                    "    oo " + //
    
                    "       " + //
                    "       " + //
                    " !!!!  " + //
                    " !oooo " + //
                    " !oooo " + //
                    "  **   " + //
                    "  **XX " + //
                    "  o*XX " + //
                    " #*# # " + //
                    "  ###  " + //
    
                    "       " + //
                    "       " + //
                    "       " + //
                    "       " + //
                    "       " + //
                    "   #   " + //
                    "#!!!! #" + //
                    " !oooo " + //
                    " #o#o# " + //
                    " ##### " + //
    
                    "       " + //
                    "       " + //
                    "       " + //
                    "       " + //
                    "       " + //
                    "       " + //
                    "       " + //
                    "       " + //
                    "   #   " + //
                    "#     #"//
            ).toCharArray();
    
            // Create the window
            A a = new A();
            a.setSize(640, 500);
            a.setResizable(false);
            a.enableEvents(KeyEvent.KEY_PRESSED | MouseEvent.MOUSE_DRAGGED | MouseEvent.MOUSE_MOVED | MouseEvent.MOUSE_PRESSED | MouseEvent.MOUSE_RELEASED);
            a.setVisible(true);
    
            // Set up the graphics objects we'll need
            Graphics gr = a.getGraphics();
            BufferedImage img = new BufferedImage(640, 480, BufferedImage.TYPE_INT_RGB);
            int[] pixels = ((DataBufferInt)img.getRaster().getDataBuffer()).getData();
    
            Image img2 = a.createImage(640, 480);
            Graphics gr2 = img2.getGraphics();
            gr2.setColor(new Color(255, 255, 255));
    
            Random random = new Random();
            int[] level = new int[1024 * 2048];
    
            // Level data. Defining arrays like this takes up a lot of space, so
            // this can be optimised
            String[] levelNames = {"Level 1: Miners4k", "Level 2: Rocks", "Level 3: Descent", "Level 4: Slime", "Level 5: Massive", "Level 6: Riiiight", "You won!"};
            String[] infoStrings = {"Bring the gold home!", "Rocks are impenetrable.", "Use arrow keys to scroll.", "Slime explodes on contact!", "Wide level!", "Timekiller!", "Bonus level!"};
            int[] slimes = {0, 0, 0, 6, 10, 25, 0};
    
            int current_level = 0;
    
            // Loop until escape is pressed.
            // First set up the level, then run the main game loop.
            // The main game loop ends when the level is over or when escape is pressed
            while (!keys[27])
            {
                // First set up the variables for the current level
                int level_width = current_level / 4 * 384 + 640;
                int level_height = current_level>1?1024:480;
                int level_rocks = (current_level - 1) / 2 * 100;
                int level_target = current_level * 500;
                int level_diggers = current_level * current_level * 50;
                int level_goldLumps = current_level * current_level * 50;
                
                // Special levels that don't conform to the formulas
                if (current_level == 0)
                {
                    level_rocks = 0;
                    level_target = 100;
                    level_diggers = 50;
                    level_goldLumps = 10;
                }
                if (current_level == 1)
                {
                    level_rocks = 10;
                    level_target = 200;
                    level_goldLumps = 30;
                }
                if (current_level == 2) level_rocks = 50;
                if (current_level == 6)
                {
                    level_height = 2048;
                    level_target = 99999;
                    level_diggers = 800;
                }
    
                int level_timeLimit = level_target * 2;
    
                // Create the heightmap for the surface by subdivision
                level[0] = 200;
                level[512] = 200;
                for (int i = 512; i > 1; i /= 2)
                {
                    for (int p = 0; p < 1024; p += i)
                    {
                        int d0 = level[p];
                        int d1 = level[(p + i) & 1023];
                        level[p + i / 2] = (d0 + d1) / 2 + (random.nextInt(i) - i / 2) / 4;
                    }
                }
    
                // Create the platforms for gold-dumping
                for (int x = 0; x < 88; x++)
                {
                    level[x] = level[88] - 2;
                    level[level_width - x - 1] = level[level_width - 88 - 1] - 2;
                }
    
                // Render the level graphics
                for (int y = 1; y < level_height; y++)
                    for (int x = 0; x < level_width; x++)
                    {
                        int i = x | y << 10;
    
                        double br = 1.2 - (random.nextDouble() - 0.5) * random.nextDouble() * random.nextDouble() * 0.6;
                        br *= (1 - i / (1024 * 6048.0));
    
                        if (x < 8 || x >= level_width - 8 || y >= level_height - 8) // Rock on the edges
                        {
                            int c = (int)(180 * br);
                            level[i] = c << 16 | c << 8 | c;
                        }
                        else if (y < level[i % 1024]) // Nothing on top of the level
                        {
                            level[i] = 0;
                        }
                        else
                        // Dirt and grass
                        {
                            int r = (int)(111 * br);
                            int g = (int)(92 * br);
                            int b = (int)(51 * br);
                            if (y < level[x] + 4) // Grass if it's the top four pixels
                            {
                                r = (int)(44 * br);
                                g = (int)(148 * br);
                                b = (int)(49 * br);
                                if (x < 88 || x > level_width - 89)
                                {
                                    r = b = g;
                                }
                            }
                            level[i] = r << 16 | g << 8 | b;
                        }
    
                        if (y >= level_height - 10 && slimes[current_level] > 0)
                        {
                            level[i] = 0x00ff00;
                        }
                    }
    
                // Add all gold, rocks and slime blobs to the level graphics
                for (int i = 0; i < level_goldLumps + level_rocks + slimes[current_level]; i++)
                {
                    // Pick a position, but favor deeper positions
                    int x = random.nextInt(level_width - 40) + 20;
                    int y0 = random.nextInt(level_height - 240) + 200;
                    int y1 = random.nextInt(level_height - 240) + 200;
                    int y2 = random.nextInt(level_height - 240) + 200;
                    int y = y1 > y0 ? y1 : y0;
                    if (y2 > y) y = y2;
    
                    // Determine the type and size in the ugliest way possible
                    int type = 0;
                    int size = random.nextInt(8) + 4;
                    if (i >= level_goldLumps) // If it's not gold lumps, then it's rocks
                    {
                        size = random.nextInt(32) + 8;
                        type = 1;
                        if (i - level_goldLumps >= level_rocks) // Of course, it might be slime
                        {
                            type = 2;
                            size = 6;
                        }
                    }
    
                    // Render the blob
                    for (int xx = x - size; xx <= x + size; xx++)
                        for (int yy = y - size; yy <= y + size; yy++)
                        {
                            int d = (xx - x) * (xx - x) + (yy - y) * (yy - y);
                            if (xx >= 0 && yy >= 0 && xx < 1024 && yy < 2048 && d < size * size)
                            {
                                if (type == 1)
                                {
                                    // Rocks (type 1) have a cool gradient
                                    int d2 = (int)(((xx - x + size / 3.0) * (xx - x + size / 3.0) / size / size + (yy - y + size / 3.0) * (yy - y + size / 3.0) / size / size) * 64);
                                    int c = 200 - d2 - random.nextInt(16);
                                    if (level[xx | yy << 10] != 0) level[xx | yy << 10] = c << 16 | c << 8 | c;
                                }
                                else
                                {
                                    // Slime and gold are monocolored
                                    if (level[xx | yy << 10] != 0) level[xx | yy << 10] = (type * 128 - type / 2) << 16 ^ 0xffff00;
                                }
                            }
                        }
                }
    
                // Set up the miners as a 2d array. Each miner has 8 variables.
                int[][] miners = new int[level_diggers][8];
                // miners[i][0] = x position
                // miners[i][1] = y position
                // miners[i][2] = direction (-1 or 1)
                // miners[i][3] = walk animation step, between 0 and 15
                // miners[i][4] = jump velocity, between -1 and 16. -1 = on ground, 0 = falling, 1-8 = jumping straight, 9-16 = jumping one pixel up.
                // miners[i][5] = 1 if the miner is carrying a gold lump, 0 otherwise
                // miners[i][6] = 0 if the miner is alive, otherwise it's the death animation frame
                // miners[i][7] = distance the miner has fallen. 0 if the miner is on the ground.
                for (int i = 0; i < miners.length; i++)
                {
                    miners[i][0] = random.nextInt(88 - 24 - 16) + 24;
                    if (i < miners.length / 2) miners[i][0] = level_width - miners[i][0];
                    miners[i][1] = -random.nextInt(400);
                    miners[i][2] = random.nextInt(2) * 2 - 1;
                    miners[i][7] = -640;
                }
    
                // Last known mouse positions
                int xMo = 0;
                int yMo = 0;
                mouseButton = 0;
    
                // Camera position
                int xo = 0;
                int yo = 0;
    
                // Various variables
                int score = 0;
                boolean levelOver = false;
                boolean levelStarted = false;
                long roundsStartTime = System.currentTimeMillis();
                long lastTime = roundsStartTime;
    
                // Run main loop until the level is over and another level needs to be created, or until escape is pressed
                while (!levelOver && !keys[27])
                {
                    // First calculate the mouse positions
                    // xM = current mouse position
                    // xMo = old mouse position
                    int xM = xMouse + xo;
                    int yM = yMouse + yo;
    
                    // Handle painting only if the level is started
                    if (levelStarted && mouseButton > 0)
                    {
                        // Draw a line by interpolating between the old mouse
                        // positon and the new position, one pixel at a time
                        int d = (int)Math.sqrt((xM - xMo) * (xM - xMo) + (yM - yMo) * (yM - yMo)) + 1;
                        for (int i = 0; i < d; i++)
                        {
                            int xm = xM + (xMo - xM) * i / d;
                            int ym = yM + (yMo - yM) * i / d;
    
                            // Draw a box with the corners missing around each position
                            for (int xx = -3; xx <= 3; xx++)
                                for (int yy = -3; yy <= 3; yy++)
                                {
                                    if ((xx != -3 && xx != 3) || (yy != -3 && yy != 3)) // Missing corners
                                    {
                                        int x = xm + xx;
                                        int y = ym + yy;
                                        if (x >= 0 && y >= 0 && x < 1024 && y < 2048)
                                        {
                                            if (mouseButton == 3 || keys[17]) // Right mouse button, or shift pressed
                                            {
                                                int r = level[x | y << 10] >> 16 & 0xff;
                                                int g = level[x | y << 10] >> 8 & 0xff;
                                                int b = level[x | y << 10] >> 0 & 0xff;
    
                                                // Only clear the terrain if it isn't gold (r and g equal),
                                                // rock (r, g and b equal) or slime (r and b equal)
                                                if (r != g && r != b) level[x | y << 10] = 0;
                                            }
                                            else
                                            {
                                                // Only add dirt if there's no terrain on the pixel
                                                if (level[x | y << 10] == 0)
                                                {
                                                    double br = 1.6 - (random.nextDouble() - 0.5) * random.nextDouble() * random.nextDouble() * 0.6;
                                                    br *= (1 - (x | y << 10) / (1024 * 6048.0));
                                                    int r = (int)(111 * br);
                                                    int g = (int)(92 * br);
                                                    int b = (int)(51 * br);
    
                                                    level[x | y << 10] = r << 16 | g << 8 | b;
                                                }
                                            }
                                        }
                                    }
                                }
                        }
                    }
                    // Set the last known mouse position to the current mouse position
                    xMo = xM;
                    yMo = yM;
    
                    // Blit the terrain data to the screen buffer.
                    for (int yPixel = 0; yPixel < 480; yPixel++)
                    {
                        // This method call can be replaced by a smaller for-loop, but this is way faster
                        System.arraycopy(level, xo | (yo + yPixel) << 10, pixels, yPixel * 640, 640);
                    }
    
                    // Render all miners
                    for (int i = 0; i < miners.length; i++)
                    {
                        // Only render the miner if the death animation hasn't finished playing
                        if (miners[i][6] < 4 * 4)
                        {
                            for (int xx = -3; xx <= 3; xx++)
                                for (int yy = -8; yy <= 1; yy++)
                                {
                                    // Flip the x position if the miner is facing left by multiplying the
                                    // x position by the direction
                                    int x = miners[i][0] - xo + xx * miners[i][2];
                                    int y = miners[i][1] - yo + yy;
                                    // If the pixel is onscreen
                                    if (x >= 0 && y >= 0 && x < 640 && y < 480)
                                    {
                                        // Get the character from the animation data
                                        char ch = SPRITES[(xx + 3) + (yy + 8) * 7 + (miners[i][3] / 4) * 7 * 10];
                                        if (miners[i][6] > 0) // Get ANOTHER character if the death animation is playing
                                        {
                                            ch = SPRITES[(xx + 3) + (yy + 8) * 7 + (miners[i][6] / 4 + 3) * 7 * 10];
                                        }
    
                                        if (ch == 'X' && miners[i][5] == 1) pixels[x + y * 640] = 0xffff00; // Gold. Only render if the miner is holding gold
                                        if (ch == 'o') pixels[x + y * 640] = 0xDB8EaF; // Skin
                                        if (ch == '!') pixels[x + y * 640] = 0x00FF00; // Hair
                                        if (ch == '*') pixels[x + y * 640] = 0x0000FF; // Clothes
                                        if (ch == '#') pixels[x + y * 640] = 0xFF0000; // Blood
                                    }
                                }
                        }
                    }
    
                    // Game logic. Is run once every 25 ms by making sure the lastTime variable is at least as big as
                    // currentTimeMillis, and increasing it by 25 every time the loop is run.
                    while (levelStarted && lastTime < System.currentTimeMillis())
                    {
                        lastTime += 25;
    
                        // Slime spreading. Pick 400 random pixels, and if they're slime, spread slime
                        // around them in a random direction.
                        for (int i = 0; i < 400; i++)
                        {
                            int x = random.nextInt(1021) + 1;
                            int y = random.nextInt(1021) + 1;
                            int x2 = x + random.nextInt(3) - 1;
                            int y2 = y + random.nextInt(3) - 1;
                            if (level[x2 | y2 << 10] == 0x00ff00)
                            {
                                // A small box around the slime helps it spread slightly faster, and makes
                                // it look a bit better
                                for (int xx = -1; xx <= 1; xx++)
                                    for (int yy = -1; yy <= 1; yy++)
                                    {
                                        level[(x + xx) | (y + yy) << 10] = 0x00ff00;
                                    }
                            }
                        }
    
                        // Miner logic
                        for (int i = 0; i < miners.length; i++)
                        {
                            // Only run logic if the miner isn't dead.
                            if (miners[i][6] == 0)
                            {
                                if (miners[i][4] > 1 && miners[i][1] > 1) // If the miner is jumping and isn't above the screen
                                {
                                    // If the pixel he's trying to reach is cleared
                                    if ((level[(miners[i][0] + miners[i][2]) | (miners[i][1] - miners[i][4] / 8) << 10]) == 0)
                                    {
                                        // Move him there, and decrease the falling time
                                        miners[i][0] += miners[i][2];
                                        miners[i][1] -= miners[i][4] / 8;
                                        miners[i][3] = (miners[i][3] + 1) & 15; // Animation
                                        miners[i][4]--;
                                    }
                                    else
                                    {
                                        // Stop jumping
                                        miners[i][4] = 0;
                                    }
                                }
                                else
                                {
                                    // If the miner is inside gold, move him up one pixel
                                    if (miners[i][1] > 0 && level[miners[i][0] | miners[i][1] << 10] == 0xffff00)
                                        miners[i][1]--;
                                    
                                    // If the miner is on top of a black pixel, or if the miner is above the screen
                                    if (miners[i][1] < 4 || level[(miners[i][0]) | (miners[i][1] + 1) << 10] == 0)
                                    {
                                        // 66% chance of jumping if the miner is on the ground
                                        if (miners[i][4] == -1 && random.nextInt(3) != 0)
                                        {
                                            miners[i][4] = 16;
                                        }
                                        else
                                        {
                                            // Otherwise, fall up to three pixels down and increase the distance fallen
                                            for (int j = 0; j < 2; j++)
                                                if (miners[i][1] < 4 || level[(miners[i][0]) | (miners[i][1] + 1) << 10] == 0)
                                                {
                                                    miners[i][1]++;
                                                    miners[i][4] = 0;
                                                    miners[i][7]++;
                                                }
                                        }
                                    }
                                    else
                                    // If the miner isn't on top of a black pixel
                                    {
                                        // If the miner has fallen more than 100 pixels, kill him.
                                        if (miners[i][7] > 100)
                                        {
                                            miners[i][6] = 1;
                                            level_diggers--;
                                            miners[i][0] -= miners[i][2];
                                        }
    
                                        // Miner hasn't fallen, and is on the ground
                                        miners[i][7] = 0;
                                        miners[i][4] = -1;
    
                                        // There's a 1/20 chance each tick that a miner will stand still.
                                        // This breaks up piles of miners, and makes them feel more dynamic
                                        if (random.nextInt(20) != 0)
                                        {
                                            // Assume the miner has hit a wall
                                            boolean hit = true;
    
                                            // The miner can walk up slopes 4 pixels high, and down slopes two pixels deep, so check for free pixels in that range
                                            for (int y = 2; y >= -4; y--)
                                            {
                                                if ((level[(miners[i][0] + miners[i][2]) | (miners[i][1] + y) << 10]) == 0)
                                                {
                                                    miners[i][0] += miners[i][2];
                                                    miners[i][1] += y;
                                                    miners[i][3] = (miners[i][3] + 1) & 15;
                                                    hit = false;
                                                    break;
                                                }
                                            }
    
                                            // 1/10 chance the miner will turn around if he's hit a wall
                                            // 1/4000 chance the miner will turn around if he didn't hit a wall
                                            if (random.nextInt(hit ? 10 : 4000) == 0)
                                            {
                                                miners[i][2] *= -1;
                                                if (hit)
                                                {
                                                    // 66% chance the miner will jump when he turns around if he hit a wall
                                                    if (random.nextInt(3) != 0) miners[i][4] = 16;
                                                }
                                            }
                                        }
                                    }
                                }
    
                                // Check if the miner should drop gold.
                                // A miner drops gold if he's holding gold, is above ground, and is directly on top of either gold pile
                                if (miners[i][5] == 1 && miners[i][1] <= level[miners[i][0]] && (miners[i][0] == 8 + 32 || miners[i][0] == level_width - 8 - 32))
                                {
                                    score++;
                                    // Slide four pixel of gold diagonally down until they hit ground
                                    for (int j = 0; j < 4; j++)
                                    {
                                        int xx = miners[i][0];
                                        int yy = miners[i][1] - 5;
                                        boolean done = false;
                                        while (!done)
                                        {
                                            if (level[(xx + 0) | (yy + 1) << 10] == 0) // Straight down
                                            {
                                                yy++;
                                            }
                                            else if (level[(xx - 1) | (yy + 1) << 10] == 0) // Diagonally to the left
                                            {
                                                xx--;
                                                yy++;
                                            }
                                            else if (level[(xx + 1) | (yy + 1) << 10] == 0) // Diagonally to the right
                                            {
                                                xx++;
                                                yy++;
                                            }
                                            else
                                            // No more falling!
                                            {
                                                done = true;
                                            }
                                        }
                                        // If the resulting position is above ground, add the gold pixel
                                        if (yy < level[xx]) level[xx | yy << 10] = 0xfefe00;
                                    }
    
                                    // Clear the carrying gold flag
                                    miners[i][5] = 0;
                                }
    
                                // Check the rendered pixels to see if the miner hits gold or slime
                                // This check was originally embedded in the rendering loop to save space,
                                // but the fixed time fix forced me to separate them.
                                for (int xx = -3; xx <= 3; xx++)
                                    for (int yy = -8; yy <= 1; yy++)
                                    {
                                        int x = miners[i][0] + xx * miners[i][2];
                                        int y = miners[i][1] + yy;
                                        if (x >= 0 && y >= 0 && x < level_width && y < level_height)
                                        {
                                            // If the pixel was rendered
                                            if (SPRITES[(xx + 3) + (yy + 8) * 7 + (miners[i][3] / 4) * 7 * 10] != ' ')
                                            {
                                                // If the pixel is slime, blow up the miner
                                                if (level[x | y << 10] == 0x00ff00)
                                                {
                                                    miners[i][6] = 1;
                                                    level_diggers--;
    
                                                    // Render a black sphere of radius 16 to the level
                                                    int s = 16;
                                                    for (int xxb = -s; xxb <= +s; xxb++)
                                                        for (int yyb = -s; yyb <= +s; yyb++)
                                                        {
                                                            int dd = xxb * xxb + yyb * yyb;
                                                            int xxa = xxb + miners[i][0];
                                                            int yya = yyb + miners[i][1] - 4;
                                                            // This destroys everything except the level borders
                                                            if (xxa >= 4 && yya >= 4 && xxa < level_width - 4 && yya < level_height - 4 && dd < s * s)
                                                            {
                                                                level[xxa | yya << 10] = 0x000000;
                                                            }
                                                        }
                                                }
                                                // If the miner isn't carrying gold, and the pixel is gold
                                                if (miners[i][5] == 0 && level[x | y << 10] == 0xffff00)
                                                {
                                                    // Remove a box of gold from the level
                                                    for (int xxx = -1; xxx <= 1; xxx++)
                                                        for (int yyy = -1; yyy <= 1; yyy++)
                                                        {
                                                            if (level[(x + xxx) & 1023 | ((y + yyy) & 1023) << 10] == 0xffff00) level[(x + xxx) & 1023 | ((y + yyy) & 1023) << 10] = 0x000000;
                                                        }
    
                                                    // Add it to the miner
                                                    miners[i][5] = 1;
                                                }
                                            }
                                        }
                                    }
                            }
                            else
                            {
                                // If the miner is dead, increase the miner death
                                // animation one step
                                if (miners[i][6] < 4 * 4) miners[i][6]++;
                            }
                        }
    
                        // Move the camera if the left, right, up or down arrow keys are pressed
                        if (keys[37] && xo > 8) xo -= 8;
                        if (keys[39] && xo < level_width - 640) xo += 8;
                        if (keys[38] && yo > 8) yo -= 8;
                        if (keys[40] && yo < level_height - 480) yo += 8;
                    }
    
                    // Draw the rendered graphics to our offscreen image
                    gr2.drawImage(img, 0, 0, null);
    
                    // If the level hasn't started yet, display the level information and wait for a mouse click
                    if (!levelStarted)
                    {
                        gr2.setFont(new Font("Sans-Serif", Font.BOLD, 30));
                        gr2.drawString(levelNames[current_level], 200, 100);
                        gr2.setFont(new Font("Sans-Serif", Font.PLAIN, 12));
                        gr2.drawString(infoStrings[current_level], 200, 116);
                        gr2.drawString("(click to start)", 200, 132);
                        if (mouseButton > 0)
                        {
                            levelStarted = true;
                            mouseButton = 0;
                        }
                        roundsStartTime = System.currentTimeMillis();
                        lastTime = roundsStartTime;
                    }
    
                    // Render game stats
                    int passedTime = (int)((System.currentTimeMillis() - roundsStartTime) / 1000);
                    gr2.drawString("Miners: " + level_diggers, 10, 36);
                    gr2.drawString("Gold: " + score + " / " + level_target, 10, 48);
                    gr2.drawString("Time left: " + (level_timeLimit - passedTime), 10, 60);
                    gr.drawImage(img2, 0, 0, null);
    
                    // If the level was won, show splash, wait two seconds, then end main game loop
                    if (score >= level_target)
                    {
                        // Only increase the current level if we're not on the last level
                        if (current_level < 6)
                        {
                            current_level++;
                        }
                        gr2.setFont(new Font("Sans-Serif", Font.BOLD, 30));
                        gr2.drawString("LEVEL PASSED!", 200, 100);
                        gr.drawImage(img2, 0, 0, null);
                        Thread.sleep(2000);
                        levelOver = true;
                    }
    
                    // If the level was lost, show splash, wait two seconds, then end main game loop
                    // The level can be lost by losing all miners, running out of time, or pressing 'k'
                    if (level_diggers <= 0 || (level_timeLimit - passedTime) <= 0 || keys[75])
                    {
                        gr2.setFont(new Font("Sans-Serif", Font.BOLD, 30));
                        gr2.drawString("LEVEL FAILED!", 200, 100);
                        gr.drawImage(img2, 0, 0, null);
                        Thread.sleep(2000);
                        levelOver = true;
                    }
    
                    // A small sleep prevents the game from eating all the cpu power
                    Thread.sleep(10);
                }
            }
    
            // System.exit(0) makes sure nothing is left in the background
            System.exit(0);
        }
    }

    Monday, August 5, 2013 3:15 AM

Answers

All replies

  • What sort of errors are you getting and what sort of app is this for?

    That looks like a mix of Java and C++/Cx (mostly Java). I wouldn't expect this to work.

    --Rob

    Monday, August 5, 2013 3:23 AM
    Owner
  • I'm new to programming and when I downloaded the template it was supposed to be in c++. I just checked it and finally realised it was in java. I've always wanted to make games and I thought it would be a good I idea for my first app that I start with a template and add my information in it. Is there any chance that you could help me develope my first game? (I'm gonna get rid of this...) Thanks for reviewing my question...:)
    Monday, August 5, 2013 2:53 PM
  • Start with the Developing games documentation. Post new threads as you come up with more specific questions.

    --Rob

    Monday, August 5, 2013 3:15 PM
    Owner