Java-Gaming.org    
Featured games (91)
games approved by the League of Dukes
Games in Showcase (579)
games submitted by our members
Games in WIP (500)
games currently in development
News: Read the Java Gaming Resources, or peek at the official Java tutorials
 
   Home   Help   Search   Login   Register   
  Show Posts
Pages: [1] 2 3 ... 13
1  Discussions / General Discussions / Re: [LIBGDX] Particles disappearing and then reappearing on: 2014-04-05 23:27:27
Thanks for the help Phil. I have the code looking similar to what you put, but I kept it closer to my original way so that the transition looks better.

1  
2  
3  
4  
5  
6  
if(counter == 10) {
         for(int i=0;i<RANDOM.nextInt(1800) + 120;i++) { newParticle(new Color(red/255f, green/255f, blue/255f, 1.0f), RANDOM.nextInt(8) + 2, 40); }
         counter = 0;
      } else {
         counter++;
      }



Working for up to 200k particles, when I hit 300k it slows down to a snails crawl.
2  Discussions / General Discussions / Re: [LIBGDX] Particles disappearing and then reappearing on: 2014-04-05 23:03:59
You should have between 120 to 1920 particles every time the counter hits 10. They all use the same color object so 1 color.

Annnd after a second I thought that since they were all referring to the same color object then I just changed it to create a new color object for every single particle and it was fixed. Never had this bug with the non-libGDX version.
3  Discussions / General Discussions / Re: [LIBGDX] Particles disappearing and then reappearing on: 2014-04-05 22:54:00
I have the code modified to test with a single snowflake on the screen. The numbers just reduce down to almost 0.0, and before it can get to 0.0 it's removed just as it should be.

http://pastebin.com/WsGXAp4K

I assume that you're testing with the unmodified code which would have a ton of snowflakes falling at once and not show the numbers going straight down.
4  Discussions / General Discussions / Re: [LIBGDX] Particles disappearing and then reappearing on: 2014-04-05 22:47:45
Had it slightly different. Yeah, the values are always the same when I change it to how you've written it. Still looks like it's working properly.

5  Discussions / General Discussions / Re: [LIBGDX] Particles disappearing and then reappearing on: 2014-04-05 22:37:06
No idea what a quad is, just started with libGDX a few hours ago.

May I direct you to the recent OGL tut by SHC outlining the basics of what goes on 'under the covers' of libGDX:
http://www.java-gaming.org/topics/lwjgl-tutorial-series-the-opengl-rendering-pipeline/32661/view.html

Thanks, I'll check it out in a few minutes.
6  Discussions / General Discussions / Re: [LIBGDX] Particles disappearing and then reappearing on: 2014-04-05 22:28:56
It took me 1.3 hours to find it, I love debugging. Indeed I just hate to not know the solution  Roll Eyes
So I will go for a quizz  Grin
(No that's not because I am evil, that's just how some other guy helped me and you learn most)
First hint:
You create an object but you don't use it every time you create it.


The Color object in the update() method of the RainbowSnow class? Moving that within the if statement gives no change.
7  Discussions / General Discussions / Re: [LIBGDX] Particles disappearing and then reappearing on: 2014-04-05 22:23:44
What do you think that rectangle is? A quad perhaps? Hmm...

A point combined with a width and height that's sent somewhere as an instruction for which pixels on the screen to color. No idea what a quad is, just started with libGDX a few hours ago.
8  Discussions / General Discussions / Re: [LIBGDX] Particles disappearing and then reappearing on: 2014-04-05 22:15:40
Disable all texturing and coloring and see if the actual geometry disappears. That way you can rule out a lot of stuff.

Huh? There are no textures or geometry. I'm just drawing rectangles on the screen using rgba colors and a ShapeRenderer object.
9  Discussions / General Discussions / Re: [LIBGDX] Particles disappearing and then reappearing on: 2014-04-05 20:48:12
Fading out and them removing I guess?

If the rgb color values go < 0, they reset to 1.

This could be it.

The rgb colors should never go below 0 with the way I have it set up. I'll double check that though.

Edit:
It doesn't seem to be related to the rgb values as far as I've seen in my tests.
10  Discussions / General Discussions / [LIBGDX] Particles disappearing and then reappearing on: 2014-04-05 20:13:09
Hey,

I've just, hopefully, finished converting my particle system from pure Java to libGDX. Everything seems to be working properly, except for the 'death' of the particles. The particles die and then reappear, or so it seems, for some reason unknown to me.

Each particle starts with a certain lifetime, and each update to the particle decreases the remaining lifetime. The alpha of the particle is calculated using (float)(remainingLife/totalLife). When the lifeTime reaches 0 then the particle is deleted because it's alpha is 0.

Here's the compiled project, you can see how the particles disappear and reappear. Exit with Alt+F4.
https://mega.co.nz/#!IstGjR6b!VZCkZ9ClDBUedZLHIPnchx9thb4Gs_asFvnlZpX7qo8



I'm thinking that the error is in how I setup libGDX in the Driver/Main classes, but it could also be with how I set the color/alpha in the RainbowSnow/Particle classes. Normally I'd be able to figure this kind of thing out pretty quickly, but I barely know how to use libGDX atm. Thanks for any ideas.

Driver:
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
package core.desktop;

import java.awt.Dimension;
import java.awt.Toolkit;

import com.badlogic.gdx.backends.lwjgl.LwjglApplication;
import com.badlogic.gdx.backends.lwjgl.LwjglApplicationConfiguration;

import core.Main;

public class DesktopLauncher {
   public static void main (String[] arg) {
      Dimension screenDimensions = Toolkit.getDefaultToolkit().getScreenSize();
     
      LwjglApplicationConfiguration config = new LwjglApplicationConfiguration();
      config.title = "Particle System";
      config.width = (int)screenDimensions.getWidth();
      config.height = (int)screenDimensions.getHeight();
      config.fullscreen = true;
      config.useGL30 = true;
     
        new LwjglApplication(new Main(), config);
   }
}


Main:
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
package core;

import com.badlogic.gdx.ApplicationAdapter;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer;

import effect.Effect;
import effect.RainbowSnow;

public class Main extends ApplicationAdapter {
   Effect e;
   ShapeRenderer shapeRenderer;

   @Override
   public void create() {
      e = new RainbowSnow(0.0, Gdx.graphics.getHeight() + 50, Gdx.graphics.getWidth());
      shapeRenderer = new ShapeRenderer();
   }

   @Override
   public void render() {
      ((RainbowSnow)e).update();
     
      Gdx.gl.glClearColor(0, 0, 0, 0);
      Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
     
      ((RainbowSnow)e).render(shapeRenderer, e.getIsOval());
   }

   @Override
   public void resize(int width, int height) {
   }
   
   @Override
   public void pause() {
   }

   @Override
   public void resume() {
   }

   @Override
   public void dispose() {
   }
}


Effect:
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
package effect;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Random;

import particle.Particle;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.GL30;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer.ShapeType;

public class Effect {
   protected final static Random RANDOM = new Random();
   /** A collection of particles that make up the snow.*/
   protected final List<Particle> PARTICLES = new ArrayList<Particle>();
   /** The origin of this snow on the X-axis.*/
   protected final double ORIGIN_X;
   /** The origin of this snow on the Y-axis.*/
   protected final double ORIGIN_Y;
   /** Whether or not to render the particles as ovals. If not then render as squares. Ovals are extremely CPU intensive for large effects*/
   protected final boolean IS_OVAL;
   protected Iterator<Particle> iterator;
   protected int counter = 0;
   
   public Effect(final double ORIGIN_X, final double ORIGIN_Y, final boolean IS_OVAL) {
      this.ORIGIN_X = ORIGIN_X;
      this.ORIGIN_Y = ORIGIN_Y;
      this.IS_OVAL = IS_OVAL;
   }
   
   /**
    * Updates the effect.
    */

   public void Update() {}
   
   /**
    *  Renders the snow to the screen.
    * @param g Graphics object with which to draw.
    */

   public void render(final ShapeRenderer SHAPE_RENDERER, final boolean IS_OVAL) {
      if(counter == 0) { System.out.println(PARTICLES.size()); }
     
      Gdx.gl.glEnable(GL30.GL_BLEND);
      Gdx.gl.glBlendFunc(GL30.GL_SRC_ALPHA, GL30.GL_ONE_MINUS_SRC_ALPHA);
      SHAPE_RENDERER.begin(ShapeType.Filled);
      iterator = PARTICLES.iterator();
      while(iterator.hasNext()) {
         iterator.next().render(SHAPE_RENDERER, IS_OVAL);
      }
      SHAPE_RENDERER.end();
      Gdx.gl.glDisable(GL30.GL_BLEND);
   }
   
   /** @return Whether or not to render the particles as ovals. If not then render as squares. */
   public boolean getIsOval() { return IS_OVAL; }
}


RainbowSnow:
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
60  
61  
62  
63  
64  
65  
66  
67  
68  
69  
70  
71  
72  
73  
74  
75  
76  
77  
78  
79  
80  
81  
82  
83  
84  
85  
86  
87  
package effect;


import com.badlogic.gdx.graphics.Color;

import particle.Particle;

/**
 * Represents rainbow snow fall.
 * @author Valkryst
 * --- Last Edit 05-Apr-2014
 */

public class RainbowSnow extends Effect {
   /** The length (x-axis) of the screen. */
   private final double SCREEN_LENGTH;
   private final double COLOR_CHANGE_CONSTANT = 0.25;
   private float red = 255, green = 0, blue = 0;
   private boolean isRed = false, isGreen = true, isBlue = false;
   
   /**
    * Constructs a new Snow object.
    */

   public RainbowSnow(final double ORIGIN_X, final double ORIGIN_Y, final double SCREEN_LENGTH) {
      super(ORIGIN_X, ORIGIN_Y - 50, false);
      this.SCREEN_LENGTH = SCREEN_LENGTH;
   }
   
   /**
    * Updates the snow.
    */

   public void update() {
      Color c = new Color();
      c.set(red/255f, green/255f, blue/255f, 1.0f);

      if(counter == 10) {
         for(int i=0;i<RANDOM.nextInt(1800) + 120;i++) { newParticle(c, RANDOM.nextInt(8), 40); }
         counter = 0;
      } else {
         counter++;
      }
     
      if(isRed) {
         if(blue > 0) { blue -= COLOR_CHANGE_CONSTANT; }

         if(red < 255) {
            red += COLOR_CHANGE_CONSTANT;
         } else if(red == 255 && blue == 0) {
            isRed = false;
            isGreen = true;
         }
      } else if(isGreen) {
         if(red > 0) { red -= COLOR_CHANGE_CONSTANT; }
         
         if(green < 255) {
            green += COLOR_CHANGE_CONSTANT;
         } else if(green == 255 && red == 0) {
            isGreen = false;
            isBlue = true;
         }
      } else if(isBlue) {
         if(green > 0) { green -= COLOR_CHANGE_CONSTANT; }
         
         if(blue < 255) {
            blue += COLOR_CHANGE_CONSTANT;
         } else if(blue == 255 && green == 0) {
            isBlue = false;
            isRed = true;
         }
      }

      iterator = PARTICLES.iterator();
      while(iterator.hasNext()) {
         if(iterator.next().update()) {
            iterator.remove();
         }
      }
   }
   
   /**
    * Creates a new Particle object.
    * @param sizeIn The size, in pixels^2, of the new Particle.
    * @param decayTimeIn The number of movements before the new Particle decays.
    */

   public void newParticle(final Color COLOR, int SIZE, int LIFE) {
      PARTICLES.add(new Particle(RANDOM.nextInt((int)SCREEN_LENGTH), super.ORIGIN_Y, RANDOM.nextDouble() * (RANDOM.nextBoolean() ? -2 : 2), RANDOM.nextDouble() * -2.5, 0.0050 *(RANDOM.nextBoolean() ? -1 : 1), 0.0, SIZE + RANDOM.nextInt(8), LIFE + RANDOM.nextInt(800), COLOR));
   }
}


Particle:
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
60  
61  
62  
63  
64  
65  
66  
67  
68  
69  
70  
71  
72  
73  
74  
75  
76  
77  
78  
79  
80  
81  
82  
83  
84  
85  
86  
87  
88  
89  
90  
91  
92  
93  
94  
95  
package particle;

import java.awt.Dimension;
import java.awt.Toolkit;

import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer;

/**
 * Represents a particle in 2D space.
 * @author Valkryst
 * --- Last Edit 05-Apr-2014
 */

public class Particle {
   private final static Dimension SCREEN_DIMENSIONS = Toolkit.getDefaultToolkit().getScreenSize();
   /** The location of the particle on the X-axis. */
   private double x;
   /** The location of the particle on the Y-axis. */
   private double y;
   /** The change in X, per update, of the particle. */
   private double dx;
   /** The change in Y, per update, of the particle. */
   private double dy;
   /** The gravitational pull to the left (negative) and right (positive) acting on this particle. */
   private final double GRAVITY_X;
   /** The gravitational pull to the up (negative) and down (positive) acting on this particle. */
   private final double GRAVITY_Y;
   /** The size in pixels^2 of the particle. */
   private final int SIZE;
   /** The remaining lifetime of the particle. */
   private double currentLife;
   /** The total lifetime of the particle. */
   private final double TOTAL_LIFE;
   /** The color of the particle. */
   private Color color;
   
   /**
    * Constructs a new particle with the specified data.
    * @param X The location of the particle on the X-axis.
    * @param Y The location of the partivcle on the Y-axis.
    * @param DX The change in X, per update, of the particle.
    * @param DY The change in Y, per update, of the particle.
    * @param GRAVITY_X The gravitational pull to the left (negative) and right (positive) acting on this particle.
    * @param GRAVITY_Y The gravitational pull to the up (negative) and down (positive) acting on this particle.
    * @param SIZE The size in pixels^2 of the particle.
    * @param LIFE The remaining lifetime of the particle.
    * @param COLOR The color of the particle.
    */

   public Particle(final double X, final double Y, final double DX, final double DY, final double GRAVITY_X, final double GRAVITY_Y, final int SIZE, final double LIFE, final Color COLOR) {
      x = X;
      y = Y;
      dx = DX;
      dy = DY;
      this.GRAVITY_X = GRAVITY_X;
      this.GRAVITY_Y = GRAVITY_Y;
      this.SIZE = SIZE;
      currentLife = LIFE;
      TOTAL_LIFE = LIFE;
      color = COLOR;
   }
   
   /**
    * Updates the particle's position, change in x, change in y,
    * remaining lifetime, and color.
    * @return Whether the particle is 'dead' or not.
    */

   public boolean update() {
      if(x > SCREEN_DIMENSIONS.width + 32 || x < -32 || y > SCREEN_DIMENSIONS.height + 32) {
         return true;
      } else {
         x += dx;
         y += dy;
         dx += GRAVITY_X;
         dy += GRAVITY_Y;
         currentLife--;
         color.set(color.r, color.g, color.b, (float)(currentLife/TOTAL_LIFE));
         return (currentLife <= 0 ? true : false);
      }
   }
   
   /**
    * Renders the particle to the screen.
    * @param G The shaperenderer object to render with.
    * @param IS_OVAL Whether or not to render the particle as an oval.
    */

   public void render(final ShapeRenderer SHAPE_RENDERER, final boolean IS_OVAL) {
      SHAPE_RENDERER.setColor(color);

      if(IS_OVAL) {
         SHAPE_RENDERER.circle((int)x-(SIZE / 2), (int)y-(SIZE / 2), SIZE, SIZE); //x-(size/2) & y-(size/2) make sure the particle is rendered at (x, y).
     } else {
         SHAPE_RENDERER.rect((int)x-(SIZE / 2), (int)y-(SIZE / 2), SIZE, SIZE); //x-(size/2) & y-(size/2) make sure the particle is rendered at (x, y).
     }
   }
}



Edit:
Ignore the JavaDocs if they don't make sense. I haven't updated them recently.
11  Game Development / Newbie & Debugging Questions / Re: Problem with Writing text to a File on: 2014-03-31 02:28:14
To print to text file:
1  
2  
3  
4  
5  
6  
7  
8  
9  
public static void writeText(String[] text) {
   try {
       PrintWriter out = new PrintWriter((new FileWriter("blahblahblah.txt", false));
       for(String s : text) { out.println(s); }
       out.close();
   } catch (IOException e) {
       e.printStackTrace();
   }
}


There is also a 1 liner to read an entire text file at once into a String array, but I can't seem to find it atm. Something to do with NIO.
12  Game Development / Newbie & Debugging Questions / Re: Troubles Implementing Map Scrolling on: 2014-03-30 16:58:28
=O

I was just messing around with the code while writing a reply about it almost working and it worked. I just combined the ideas in ctomni's code and what Liquid said in his comment and now it works perfectly!
13  Game Development / Newbie & Debugging Questions / Re: Troubles Implementing Map Scrolling on: 2014-03-29 19:57:41
Why do you "set back" player position, if you didn't change it in the first place?

Because it just updates the player's position after figuring out how much to scroll the map so that the player's position won't change on the map when it scrolls to show the next bit of the map. The user controls the player's movement.
14  Game Development / Newbie & Debugging Questions / Re: Troubles Implementing Map Scrolling on: 2014-03-29 19:23:41
I don't.

Whenever the player's x position is greater than half of the screen it does (playerX - halfScreenWidth) to find the difference. Then subtracts that from the xOffset. Next, the player's position is set back to halfScreenWidth so that it lines up with where it was before the map was moved back by the xOffset.

15  Game Development / Newbie & Debugging Questions / Re: Troubles Implementing Map Scrolling on: 2014-03-29 19:09:37
You just said in your post that player gets thrown into tiles and cannot move. I assume you said it, because that didn't happen before you implemented map scrolling. That means your map scroll affects how player moves.

Yes, and that has nothing to do with rendering. The problem is in the map scrolling code in the OP which is part of the updating and not the rendering. If you look at the code it simply moves the player backwards, or at least it should, so that it lines up to it's position from before the scroll.
16  Game Development / Newbie & Debugging Questions / Re: Troubles Implementing Map Scrolling on: 2014-03-29 18:57:10
If a player is thrown into a tile, because of how you're rendering things, you must be doing something wrong.

It has nothing to do with the rendering.
17  Game Development / Newbie & Debugging Questions / [SOLVED] Troubles Implementing Map Scrolling on: 2014-03-29 17:11:57
Hey,

I'm currently attempting to add in map scrolling to a basic platformer I'm working on. I worked out a good idea of how it works, but every time I try to implement map scrolling it never works properly.

The player is 32 pixels wide and 64 pixels tall.

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
///////// WIP - Screen scrolling code.
     double playerX = ((Player)ENTITIES.get(0)).getX();
      double halfScreenWidth = (SCREEN_DIMENSIONS.getWidth()/2);

      if(playerX > halfScreenWidth) {
         double distanceFromHalfScreenWidth = playerX - halfScreenWidth;
         offsetX -= distanceFromHalfScreenWidth;
         ((Player)ENTITIES.get(0)).setX(halfScreenWidth - distanceFromHalfScreenWidth); // Rest works, no idea what to set X to atm.
     } else {
         offsetOldX = offsetX;
      }
      /////// End of WIP


This is what I'm currently using. It does scroll the map to the left, but it does this:



I've modified the code above in many ways, but only the current code has resulted in anything close to working properly.  The screen seems to scroll too far and the player is often thrown inside of a tile where it's not allowed to move. If anyone has an idea of what I may have messed up on in the code that would help a lot.
18  Discussions / General Discussions / Re: How to make a JFrame's background transparent? on: 2014-03-23 19:40:50
I've looked into something like this before. There's a way to do it, but it's very buggy and just not worth using at all.
19  Games Center / Contests / Re: Closed Nobody Joined as i know on: 2014-03-22 15:29:20
Done

1  
2  
3  
4  
5  
6  
7  
public class Driver {
    public static void main(String args[]) {
        while(true) {
            System.out.println("You're terrible at this game, quit already.");
        }
    }
}
20  Game Development / Game Play & Game Design / Re: Best 2D library to use. on: 2014-03-15 19:11:11
Points to Roquen's answer.
21  Games Center / WIP games, tools & toy projects / Re: Rpg Landia on: 2014-03-06 14:27:28
Two images and no description... So what are you making?
22  Game Development / Newbie & Debugging Questions / Re: [Collision Detection] Thinks it's colliding even though it isn't on: 2014-03-05 16:14:14
Hmm... Now that you mention it, I do think that it could do that. I'll rework things if I do come across that issue in the future, but at the moment I should be able to prevent it with carefully chosen values for the gravitational pull, movement speeds, etc...
23  Game Development / Newbie & Debugging Questions / Re: [Collision Detection] Thinks it's colliding even though it isn't on: 2014-03-05 03:26:41
=O I've been going over it for hours and that was my only problem... Wow. Thanks for the information, now I'll know for next time and it works perfectly now!

You can just use JBox2D and chill...  Cool

I never use a library unless I either can't code what I need or it's necessary. Collision is simple, when I don't mess up a piece of code as UprightPath has shown me, so I don't use a library for it. =P
24  Game Development / Newbie & Debugging Questions / [Collision Detection] Thinks it's colliding even though it isn't on: 2014-03-04 21:53:41
Hey,

I've been trying to solve this little bug in my code for a while now, but I can't seem to figure it out yet. When running my program the player entity correctly falls to the ground due to the gravitational pull, but if he walks off of the ground then he doesn't fall.

As far as I can tell, the two collision checking if-else statements or something regarding them is probably messing up. The game seems to think that the player is colliding with something and therefore won't allow it to fall anymore.

If someone cares to check out the code and see if you can figure out a possible solution, thanks.

Link to the two classes I believe are causing/are related to this issue:
https://github.com/MackProgramming/SideScroller/tree/master/src/entity

Here is the compiled game:
https://mega.co.nz/#!wg11xJgb!PAbhBae2qjtM_N8Ka036_Me4f0p686n4AmV6nAv9vsM
25  Game Development / Newbie & Debugging Questions / Re: [Particle System] - Particle "Plateauing" problem on: 2014-01-16 02:10:35
Hmm...

What exactly is the destination code supposed to do? Usually you'd just spawn a particle with a certain position, velocity and life time, and then update the velocity based on gravity (could be upwards for fire) and wind and position based on velocity. Then you'd remove it when it life ends.

In the Fire class, when a particle is being created there are 20 points(destinations) randomly created for it. When a particle reaches it's current destination then it is told to go towards the next destination. The Fire is just an effect which I'm creating using the particle system so it uses destinations instead of just sending the particle to go it's course. The code related to destinations in the Particle class will only be used when the particle actually has destinations. (Haven't written that part yet.)

@Gjallar
Here is the project folder:
https://mega.co.nz/#!zA8x3aiJ!NN6ZkXRzHGiKIwoFoo3X2QxxMldjYzOqsgdZ0MHrvLQ

@Damocles
Using random.nextInt(20) does seem to make the lines harder to see, but they're still visible when looking at the fire.



I've had to modify the code before posting this to see fi I could fix a few things. The download link to the eclipse project folder doesn't have this edited code.

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
public void newParticle(int redIn, int greenIn, int blueIn, int alphaIn, int sizeIn, int decayTimeIn, int maximumXAxisMovement) {
      int totalPoints = random.nextInt(20) + 1;
      double x = originX;
      Point[] points = new Point[totalPoints];
     
      for(int i=0;i<totalPoints;i++) {
         x -= (random.nextBoolean() ? -1 : 1) * random.nextInt(maximumXAxisMovement);
         points[i] = new Point(x, originY - (i*15 + (i==0 ? 0: random.nextInt(40))));
         x = originX;
      }
     
      particles.addParticle(new Particle(redIn, blueIn, greenIn, alphaIn, 1, 1, 1, originX, originY, points, sizeIn, decayTimeIn * 10, true));
   }


Edit: The lines aren't as visible on the image for some reason, but I notice them when running it.
26  Game Development / Newbie & Debugging Questions / Re: [Particle System] - Particle "Plateauing" problem on: 2014-01-15 21:42:04
Float coordinates?

They're already doubles. I made a custom Point class while editing the code. It works the exact same as the normal Point class, but with doubles.
27  Game Development / Newbie & Debugging Questions / Re: [Particle System] - Particle "Plateauing" problem on: 2014-01-15 19:05:30
I've tried using your example with the threshold both before the movement and after. I've also tried my original way of doing it both before and after the movement. The final thing I did was to remove the destination check.

The first two cases gave no change no matter where they were or what the threshold was set to. As expected, when I remove the check, the particles just stay at the bottom of the screen. I think it *may* be safe to say that the destination check (seen below) is what's causing this plateauing bug somehow.

1  
2  
3  
4  
// If the particle has reached it's current destination then set it on-course for the next one. If it has reached the final destination then set it to be removed.
  if(destinationX == xCoord && destinationY == yCoord && destinationsReached < destinations.length - 1) {
         destinationsReached++;
   }



Edit:
I've been changing every single thing I can think of and no matter what the plateaus never change.

Edit 2:
The spacing of the plateaus is thanks to "points = new Point(x, originY - (i*20));" the i * 20 on this line of the Fire class. Still searching for anything that could cause the particles to stay on those 20 pixel intervals.
28  Game Development / Newbie & Debugging Questions / Re: [Particle System] - Particle "Plateauing" problem on: 2014-01-15 17:12:17
I'm guessing that you're shooting all particles upwards at the exact same speed (X pixels per frame), making them all move X pixels each frame. Since they all line up you get that effect. Try randomizing the starting velocity of the particle.

I've just tried randomizing the rise, run, speed, rise & run, rise & speed, and run & speed.
The first three had no effect on the plateaus.
Randomizing both the rise & run at the same time, using random.nextInt(3), on line 98 of the Fire class caused a lot of the particles to become stuck on either the first or second plateau and for the later plateaus to have less and less particles on them.
Everything else had no affect on the plateaus.

Rise & Run:


From this test I'm beginning to think that there may be something wrong with the movement part of the update() method for the particles on line 103 of the Particle class. I don't see anything that looks like it could cause this though.
29  Game Development / Newbie & Debugging Questions / [Particle System] - Particle "Plateauing" problem on: 2014-01-15 07:22:01
Hey,

I've been working on a particle system from scratch off-and-on for the past three days and I've got it working quite nicely (most of the time). At the moment I'm working on a little fire effect and in doing so I've found a strange bug which I haven't been able to fix.

As you can see in this image:


A lot of the particles seem to "plateau" at equal intervals. I've changed values and modified code all over the place while tying to fix this problem, but I can't explain it nor fix it.

If anyone has some suggestions or the cause, and hopefully (fingers crossed) a way to fix this problem that would be great.

The Screen class. This is where the game-loop along with the update and render methods are.

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
60  
61  
62  
63  
64  
65  
66  
67  
68  
69  
70  
71  
72  
73  
74  
75  
76  
77  
78  
79  
80  
81  
82  
83  
84  
85  
86  
87  
88  
89  
90  
91  
92  
93  
94  
95  
96  
97  
98  
99  
100  
101  
102  
103  
104  
105  
106  
107  
108  
109  
110  
111  
112  
113  
114  
115  
116  
117  
118  
119  
120  
121  
122  
123  
124  
125  
126  
127  
128  
129  
130  
131  
package core;

import java.awt.Canvas;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.image.BufferStrategy;

import javax.swing.JFrame;
import javax.swing.SwingUtilities;

import fire.Fire;

/**
 * Represents a screen on which to draw.
 * @author Valkryst
 * --- Last Edit 14-Jan-2014
 */

public class Screen extends Canvas implements Runnable {
   private static final long serialVersionUID = 4532836895892068039L;
   
   private final JFrame frame;
   private Thread gameThread;
   private boolean isGameRunning = true;
   
   private BufferStrategy BS = getBufferStrategy();
   
   // Testing Stuff:
  private Fire fire = new Fire(256.0, 512.0);
   // End Testing Stuff.
 
   public Screen() {
      frame = new JFrame();
      frame.setTitle("Particle Test");
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.setSize(new Dimension(512, 544));
      frame.setResizable(false);
      frame.setLocationRelativeTo(null);
      frame.requestFocus();
     
      setSize(new Dimension(512, 544));
      setFocusable(true);
      setVisible(true);
     
      frame.add(this);
      frame.setVisible(true);
     
      start();
   }

   public void run() {
      long lastLoopTime = System.nanoTime();
       final int TARGET_FPS = 60;
      final long OPTIMAL_TIME = 1000000000 / TARGET_FPS;  
      double delta = 0;
     
      // Keep looping until the game ends.
     while(isGameRunning) {
            long now = System.nanoTime();
            long updateLength = now - lastLoopTime;
            lastLoopTime = now;
             delta += updateLength / ((double)OPTIMAL_TIME); // Work out how long its been since the last update. This will be used to calculate how far the entities should move this loop.
           
             //Update the game's logic and then render the screen.
            while(delta >= 1) {
                updateLogic(delta);
                delta--;
             }
             
             render();
               
             // we want each frame to take 10 milliseconds, to do this
            // we've recorded when we started the frame. We add 10 milliseconds
            // to this and then factor in the current time to give
            // us our final value to wait for
            // remember this is in ms, whereas our lastLoopTime etc. vars are in ns.
            try {
                long tempLong = (lastLoopTime-System.nanoTime() + OPTIMAL_TIME)/1000000;
                if(tempLong <= 0) { continue; } // Skips the sleep()
              Thread.sleep(tempLong);
            } catch (InterruptedException e) {
               continue;
            }
      }
     
      stop();
   }
   
   public synchronized void start() {
      setBackground(Color.black);
      isGameRunning = true;
      gameThread = new Thread(this, "Display");
      gameThread.start();
   }

   public synchronized void stop() {
      try {
         gameThread.join();
      } catch(InterruptedException e) {
         Logger.writeError(e.getMessage());
      }
   }

   // When called this updates all of the game's logic.
  public void updateLogic(double delta) {
      fire.update();
   }

   // When called this updates the screen.
  public void render() {
      // Forces the canvas to use triple buffering.
     BS = getBufferStrategy();
        if (BS == null) {
           SwingUtilities.invokeLater(new Runnable() {
               public void run() {
                   createBufferStrategy(3);
               }
           });
           return;
        }
     
        // Creates the graphics object and then clears the screen.
       Graphics g = BS.getDrawGraphics();
        g.clearRect(0, 0, getWidth(), getHeight());
       
        fire.render(g);
       
        g.dispose();
      BS.show();
   }
}


The Fire class. This just handles a fire object and all that:
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
60  
61  
62  
63  
64  
65  
66  
67  
68  
69  
70  
71  
72  
73  
74  
75  
76  
77  
78  
79  
80  
81  
82  
83  
84  
85  
86  
87  
88  
89  
90  
91  
92  
93  
94  
95  
96  
97  
98  
99  
100  
package fire;

import java.awt.Graphics;
import java.awt.Point;
import java.util.Iterator;
import java.util.Random;

import particle.Particle;
import particle.ParticleList;

/**
 * Represents a fire.
 * @author Valkryst
 * --- Last Edit 14-Jan-2014
 */

public class Fire {
   private static Random random = new Random();
   /** A collection of particles that make up the fire.*/
   private ParticleList particles;
   /** The origin of this fire on the X-axis.*/
   private double originX;
   /** The origin of this fire on the Y-axis.*/
   private double originY;
   private int counter = 0;
   
   /**
    * Constructs a new Fire object.
    */

   public Fire(double originXIn, double originYIn) {
      particles = new ParticleList();
     
      originX = originXIn;
      originY = originYIn;
   }
   
   /**
    * Updates the fire.
    */

   public void update() {
      particles.removeDecayedParticles();

      if(counter == 10) {
         for(int i=0;i<50;i++) { newParticle(159, 70, 24, 100, 4, 30, 40); }
         for(int i=0;i<40;i++) { newParticle(208, 117, 29, 100, 4, 20, 30); }
         for(int i=0;i<25;i++) { newParticle(246, 206, 72, 100, 2, 10, 20); }
         for(int i=0;i<10;i++) { newParticle(251, 239, 169, 100, 2, 5, 10); }
         counter = 0;
      } else {
         counter++;
      }

      Iterator<Particle> it = particles.getParticles().iterator();
      while(it.hasNext()) {
         it.next().update();
      }
   }
   
   /**
    *  Renders the fire to the screen.
    * @param g Graphics object with which to draw.
    */

   public void render(Graphics g) {
      Iterator<Particle> it = particles.getParticles().iterator();
     
      while(it.hasNext()) {
         it.next().render(g);
      }
   }
   
   /**
    * Creates a new Particle object.
    * @param redIn The red color value of the new Particle.
    * @param greenIn The green color value of the new Particle.
    * @param blueIn The blue color value of the new Particle.
    * @param alphaIn The alpha value of the new Particle.
    * @param movementSpeedIn The movement speed of the new Particle.
    * @param riseIn The number of pixels, up or down, that the new Particle will move per movement.
    * @param runIn The number of pixels, left or right, that the new Particle will move per movement.
    * @param xCoordIn The location of the new Particle on the X-axis.
    * @param yCoordIn The location of the new Particle on the Y-axis.
    * @param sizeIn The size, in pixels^2, of the new Particle.
    * @param decayTimeIn The number of movements before the new Particle decays.
    * @param maximumXAxisMovement The maximum distance, left or right, that the particle can move.
    */

   public void newParticle(int redIn, int greenIn, int blueIn, int alphaIn, int sizeIn, int decayTimeIn, int maximumXAxisMovement) {
      int totalPoints = random.nextInt(20) + 1;
      double x = originX;
      boolean isNegative;
      Point[] points = new Point[totalPoints];
     
      for(int i=0;i<totalPoints;i++) {
         isNegative = random.nextBoolean();
         x -= (isNegative ? -1 : 1) * random.nextInt(maximumXAxisMovement);
         points[i] = new Point((int)x, (int)originY - (i*20));
         x = originX;
      }
     
      particles.addParticle(new Particle(redIn, blueIn, greenIn, alphaIn, 1, 1, 1, originX, originY, points, sizeIn, decayTimeIn * 10, true));
   }
}


The Particle class:
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
60  
61  
62  
63  
64  
65  
66  
67  
68  
69  
70  
71  
72  
73  
74  
75  
76  
77  
78  
79  
80  
81  
82  
83  
84  
85  
86  
87  
88  
89  
90  
91  
92  
93  
94  
95  
96  
97  
98  
99  
100  
101  
102  
103  
104  
105  
106  
107  
108  
109  
110  
111  
112  
113  
114  
115  
116  
117  
118  
119  
120  
121  
122  
123  
124  
125  
126  
127  
128  
129  
130  
131  
132  
133  
134  
135  
136  
137  
138  
139  
140  
141  
142  
143  
144  
145  
146  
147  
148  
149  
150  
151  
152  
153  
154  
155  
156  
157  
158  
159  
160  
161  
162  
163  
164  
165  
166  
167  
168  
169  
170  
171  
172  
173  
174  
175  
176  
177  
178  
179  
180  
181  
182  
183  
184  
185  
186  
187  
188  
189  
190  
191  
192  
193  
194  
195  
196  
197  
198  
199  
200  
201  
202  
203  
204  
205  
206  
207  
208  
209  
210  
211  
212  
213  
214  
215  
216  
217  
218  
219  
220  
221  
222  
223  
224  
225  
226  
227  
228  
229  
230  
231  
232  
233  
234  
235  
236  
237  
238  
239  
240  
241  
242  
243  
244  
245  
246  
247  
248  
249  
250  
251  
252  
253  
254  
255  
256  
257  
258  
259  
260  
261  
262  
263  
264  
265  
266  
267  
268  
269  
270  
271  
272  
273  
274  
275  
276  
277  
278  
279  
280  
281  
282  
283  
284  
285  
286  
287  
288  
289  
290  
291  
292  
293  
294  
295  
296  
297  
298  
299  
300  
301  
302  
303  
304  
305  
306  
307  
308  
309  
310  
311  
312  
313  
314  
315  
316  
317  
318  
319  
320  
321  
322  
323  
324  
325  
326  
327  
328  
329  
330  
331  
332  
333  
334  
335  
336  
337  
338  
339  
340  
341  
342  
343  
344  
345  
346  
347  
348  
package particle;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Point;

import core.Logger;

/**
 * Represents a particle.
 * @author Valkryst
 * --- Last Edit 14-Jan-2014
 */

public class Particle {
   /** A color value. 0-255. */
   private int red, green, blue;
   /** The color of this pixel.*/
   private Color color;
   /** Alpha value. 0-100. */
   private int alpha;
   /** How many pixels/second this particle is moving. */
   private double movementSpeed;
   /** How many pixels up or downwards this particle moves per movement. */
   private double rise;
   /** How many pixels left or right this particle moves per movement. */
   private double run;
   /** Location of this particle on the X-axis. */
   private double xCoord;
   /** Location of this particle on the Y-axis. */
   private double yCoord;
   /** The destinations of this particle. */
   private Point[] destinations;
   /** The number of destinations reached by this particle. */
   private int destinationsReached = 0;
   /** The size of this particle in pixels^2.*/
   private int size;
   /** The number of movements before the particle decays. */
   private int decayTime;
   /** The number of times this particle has moved. */
   private int movementsTaken;
   /** Whether or not to draw this particle as a rectangle or filled rectangle. */
   private boolean isFilled;
   
   /**
    * Constructs a new Particle object.
    * @param redIn The red color value of the new Particle.
    * @param greenIn The green color value of the new Particle.
    * @param blueIn The blue color value of the new Particle.
    * @param alphaIn The alpha value of the new Particle.
    * @param movementSpeedIn The movement speed of the new Particle.
    * @param riseIn The number of pixels, up or down, that the new Particle will move per movement.
    * @param runIn The number of pixels, left or right, that the new Particle will move per movement.
    * @param xCoordIn The location of the new Particle on the X-axis.
    * @param yCoordIn The location of the new Particle on the Y-axis.
    * @param sizeIn The size, in pixels^2, of the new Particle.
    * @param decayTimeIn The number of movements before the new Particle decays.
    */

   public Particle(int redIn, int greenIn, int blueIn, int alphaIn, int movementSpeedIn, double riseIn, double runIn, double xCoordIn, double yCoordIn, Point[] destinationsIn,  int sizeIn, int decayTimeIn, boolean isFilledIn) {
      if(isColorValueValid(redIn) && isColorValueValid(greenIn) && isColorValueValid(blueIn) && isAlphaValueValid(alphaIn)) {
         red = redIn;
         green = greenIn;
         blue = blueIn;
         alpha = alphaIn;
      } else {
         Logger.writeError("Invalid color or alpha value. Using default values.");
         red = 255;
         blue = 255;
         green = 255;
         alpha = 0;
      }
     
      color = new Color(red, blue, green, alpha);
      movementSpeed = movementSpeedIn;
      rise = riseIn;
      run = runIn;
      xCoord = xCoordIn;
      yCoord = yCoordIn;
      destinations = destinationsIn;
      size = sizeIn;
      decayTime = decayTimeIn;
      isFilled = isFilledIn;
   }
   
   /**
    * @param colorValue The color value to check.
    * @return Whether or not the specified color value is within the range of 0-255.
    */

   public boolean isColorValueValid(int colorValue) {
      return (colorValue >= 0 && colorValue <= 255 ? true : false);
   }
   
   /**
    * @param alphaValue The alpha value to check.
    * @return Whether or not the specified alpha value is within the range of 0-100.
    */

   public boolean isAlphaValueValid(int alphaValue) {
      return (alphaValue >= 0 && alphaValue <= 100 ? true : false);
   }
   
   /**
    * Updates the position and alpha of the particle.
    */

   public void update() {
      double destinationX = destinations[destinationsReached].getX();
      double destinationY = destinations[destinationsReached].getY();
      double movementX = (rise * movementSpeed);
      double movementY = (run * movementSpeed);
     
      // If the particle has reached it's current destination then set it on-course for the next one. If it has reached the final destination then set it to be removed.
     if(destinationX == xCoord && destinationY == yCoord && destinationsReached < destinations.length - 1) {
            destinationsReached++;
      }
     
      // Update position:
     if(xCoord < destinationX) {
         xCoord += movementX;
      } else if (xCoord > destinationX) {
         xCoord -= movementX;
      }
     
      if(yCoord < destinationY) {
         yCoord += movementY;
      } else if (yCoord > destinationY) {
          yCoord -= movementY;
      }
     
      // Update alpha:
     int newAlpha = (int)(((double)movementsTaken / (double)decayTime) * 100);
      newAlpha = 100 - newAlpha;
      color = new Color(red, blue, green, newAlpha);
     
      movementsTaken++;
   }
   
   /**
    * Renders this Particle onto the screen.
    * @param g Graphics object with which to draw.
    */

   public void render(Graphics g) {
      g.setColor(color);
      if(isFilled) {
         g.fillRect((int)xCoord, (int)yCoord, size, size);
      } else {
         g.drawRect((int)xCoord, (int)yCoord, size, size);
      }
   }

   //////////////////////////////////// Get methods:
  /**
    * @return The red value of this Particle.
    */

   public int getRed() {
      return red;
   }
   
   /**
    * @return The blue value of this Particle.
    */

   public int getBlue() {
      return blue;
   }
   
   /**
    * @return The green value of this Particle.
    */

   public int getGreen() {
      return green;
   }
   
   /**
    * @return The alpha value of this Particle.
    */

   public int getAlpha() {
      return alpha;
   }
   
   /**
    * @return The movement speed of this Particle.
    */

   public double getMovementSpeed() {
      return movementSpeed;
   }
   
   /**
    * @return The rise of this Particle.
    */

   public double getRise() {
      return rise;
   }
   
   /**
    * @return The run of this Particle.
    */

   public double getRun() {
      return run;
   }
   
   /**
    * @return The location of this Particle on the X-axis.
    */

   public double getXCoord() {
      return xCoord;
   }
   
   /**
    * @return The location of this Particle on the Y-axis.
    */

   public double getYcoord() {
      return yCoord;
   }
   
   /**
    * @return The destinations of this Particle.
    */

   public Point[] getDestinations() {
      return destinations;
   }
   
   /**
    * @return The size of this Particle in pixels^2.
    */

   public int getSize() {
      return size;
   }
   
   /**
    * @return The number of moves before this Particle decays.
    */

   public int getDecayTime() {
      return decayTime;
   }
   
   /**
    * @return The number of movements taken so-far by this Particle.
    */

   public int getMovementsTaken() {
      return movementsTaken;
   }
   
   /**
    * @return Whether or not to draw this particle as a rectangle or filled rectangle.
    */

   public boolean getIsFilled() {
      return isFilled;
   }
   
   //////////////////////////////////// Set methods:
  /**
    * @param redIn The red color value to set to this Particle.
    */

   public void setRed(int redIn) {
      if(isColorValueValid(redIn)) {
         red = redIn;
      } else {
         Logger.writeError("Invalid color value. Using default value.");
         red = 255;
      }
      color = new Color(red, blue, green, alpha);
   }
   
   /**
    * @param blueIn The blue color value to set to this Particle.
    */

   public void setBlue(int blueIn) {
      if(isColorValueValid(blueIn)) {
         blue = blueIn;
      } else {
         Logger.writeError("Invalid color value. Using default value.");
         blue = 255;
      }
      color = new Color(red, blue, green, alpha);
   }
   
   /**
    * @param greenIn The blue color value to set to this Particle.
    */

   public void setGreen(int greenIn) {
      if(isColorValueValid(greenIn)) {
         green = greenIn;
      } else {
         Logger.writeError("Invalid color value. Using default value.");
         green = 255;
      }
      color = new Color(red, blue, green, alpha);
   }
   
   /**
    * @param alphain The alpha value to set to this Particle.
    */

   public void setTransparency(int alphaIn) {
      if(isAlphaValueValid(alphaIn)) {
         alpha = alphaIn;
      } else {
         Logger.writeError("Invalid alpha value. Using default value.");
         alpha = 255;
      }
      color = new Color(red, blue, green, alpha);
   }
   
   /**
    * @param movementSpeedIn The movement speed to set to this Particle.
    */

   public void setMovementSpeed(double movementSpeedIn) {
      movementSpeed = movementSpeedIn;
   }
   
   /**
    * @param destinationIn The destination to set to this Particle.
    */

   public void setDestinations(Point[] destinationsIn) {
      destinations = destinationsIn;
   }
   
   /**
    * @param riseIn The rise to set to this Particle.
    */

   public void setRise(double riseIn) {
      rise = riseIn;
   }
   
   /**
    * @param runIn The run to set to this Particle.
    */

   public void setRun(double runIn) {
      run = runIn;
   }
   
   /**
    * @param sizeIn The size to set to this Particle.
    */

   public void setSize(int sizeIn) {
      size = sizeIn;
   }
   
   /**
    * @param decayTimeIn The decayTime to set to this Particle.
    */

   public void setDecayTime(int decayTimeIn) {
      decayTime = decayTimeIn;
   }
   
   /**
    * @param isFilledIn The isFilled to set to this Particle.
    */

   public void setIsFilled(boolean isFilledIn) {
      isFilled = isFilledIn;
   }
}


Hopefully whoever takes a look at this can understand the code. I've added way more comments than I need just for that purpose. =)

Thanks for any help.
30  Game Development / Newbie & Debugging Questions / Re: Java Security BS, Can I Get Around It? on: 2014-01-04 01:09:42
=_____________________________________________________________________________________________________________________________________________________________________=

That is the only thing that has ever made me hate Google...
Pages: [1] 2 3 ... 13
 

Add your game by posting it in the WIP section,
or publish it in Showcase.

The first screenshot will be displayed as a thumbnail.

xsi3rr4x (34 views)
2014-04-15 18:08:23

BurntPizza (30 views)
2014-04-15 03:46:01

UprightPath (45 views)
2014-04-14 17:39:50

UprightPath (28 views)
2014-04-14 17:35:47

Porlus (45 views)
2014-04-14 15:48:38

tom_mai78101 (66 views)
2014-04-10 04:04:31

BurntPizza (126 views)
2014-04-08 23:06:04

tom_mai78101 (226 views)
2014-04-05 13:34:39

trollwarrior1 (191 views)
2014-04-04 12:06:45

CJLetsGame (199 views)
2014-04-01 02:16:10
List of Learning Resources
by SHC
2014-04-18 03:17:39

List of Learning Resources
by Longarmx
2014-04-08 03:14:44

Good Examples
by matheus23
2014-04-05 13:51:37

Good Examples
by Grunnt
2014-04-03 15:48:46

Good Examples
by Grunnt
2014-04-03 15:48:37

Good Examples
by matheus23
2014-04-01 18:40:51

Good Examples
by matheus23
2014-04-01 18:40:34

Anonymous/Local/Inner class gotchas
by Roquen
2014-03-11 15:22:30
java-gaming.org is not responsible for the content posted by its members, including references to external websites, and other references that may or may not have a relation with our primarily gaming and game production oriented community. inquiries and complaints can be sent via email to the info‑account of the company managing the website of java‑gaming.org
Powered by MySQL Powered by PHP Powered by SMF 1.1.18 | SMF © 2013, Simple Machines | Managed by Enhanced Four Valid XHTML 1.0! Valid CSS!