Java-Gaming.org    
Featured games (81)
games approved by the League of Dukes
Games in Showcase (483)
Games in Android Showcase (110)
games submitted by our members
Games in WIP (550)
games currently in development
News: Read the Java Gaming Resources, or peek at the official Java tutorials
 
    Home     Help   Search   Login   Register   
Pages: [1]
  ignore  |  Print  
  Complex Angles, you don't need trig  (Read 2430 times)
0 Members and 1 Guest are viewing this topic.
Offline delt0r

JGO Knight


Medals: 27
Exp: 18 years


Computers can do that?


« Posted 2013-03-14 16:45:31 »

So I offered some of my code and was called on it. Turns out my core code is now all 3d with Quaternions etc. However 2d is even easier to avoid trig and even inverse trig. Done right you don't need all that many sqrts, but even then they are pretty fast.

The idea is simple. A complex number simply represents a unit vector in the direction the angle represents. Turns out complex multiplication is the same as adding angles and complex division is the same as subtracting angles. Since if we start with normalized values we end up with normalized values. Sure there is a little error. You can see that with the java2d demo that is included. You can even compare angles to see which is larger or smaller. Like atan2 angles are implied to be signed +-PI.

In the example the sweeping line is red when smaller than angle to the mouse and blue when larger. It turns green when its in the "acceptance cone", in this case +-8deg. Finally the funny cyan lines demonstrate interpolation.

Sorry i can't work out how to put this in a scroll box.

This code has not been unit tested. Use any way you want. I take no responsibility for this code, use at your own risk. And its in the public domain.

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  
import static java.lang.Math.*;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.awt.geom.AffineTransform;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Point2D;
import javax.swing.JFrame;
import javax.swing.JPanel;
/**
 * other code has too much noise. This is suppose to be clean and make it easy for the jgo use. I use a demo java2d example. We use the convention that x is the
 * real axis and y is the imaginary axis.
 *
 * Note that i assume things are normalized a lot. Since this always represents an angle then this should always have unit length.
 *
 * Numerical errors for doubles are rather low. But they will eventrually accumulate. But its not like you need to normalize after every operation.
 *
 * Some degen cases are not checked. In particular you can create a NaN,NaN angle if you create an angle with 0,0.
 *
 * @author bob
 *
 */

public class ComplexAngle implements Comparable<ComplexAngle> {
   /**
    * Warning these are mutatable.
    */

   public static final ComplexAngle DELTA_ANGLE = createAngle(PI * 2 / 720);//1/2 def
  public static final ComplexAngle RIGHT_ANGLE=createAngle(PI/2);
                                                                                   
   private double real = 1;
   private double imag = 0;

   private ComplexAngle(double r, double i) {
      real = r;
      imag = i;
   }

   public static ComplexAngle angleTo(Point2D from, Point2D to) {
      return createAngle(to.getX() - from.getX(), to.getY() - from.getY());
   }

   public static ComplexAngle createAngle(double x, double y) {
      ComplexAngle ca = new ComplexAngle(x, y);
      ca.normalize();
      return ca;
   }
   
   public static ComplexAngle createAngle(double rad) {
      ComplexAngle ca = new ComplexAngle(Math.cos(rad), Math.sin(rad));
     
      return ca;
   }

   public ComplexAngle addAngleThis(ComplexAngle c) {
      return multiplyThis(c);
   }

   public ComplexAngle addAngle(ComplexAngle c) {
      return multiply(c);
   }

   /**
    * adds angles.
    *
    * @param c
    */

   public ComplexAngle multiplyThis(ComplexAngle c) {
      double nr = real * c.real - imag * c.imag;
      double ni = real * c.imag + imag * c.real;
      real = nr;
      imag = ni;
      // Normalized since both should be length 1. This adds the angles.
     return this;
   }

   public ComplexAngle multiply(ComplexAngle c) {
      double nr = real * c.real - imag * c.imag;
      double ni = real * c.imag + imag * c.real;
      return new ComplexAngle(nr, ni);
   }

   public ComplexAngle subtractAngleThis(ComplexAngle c) {
      return divideThis(c);
   }

   public ComplexAngle subtractAngle(ComplexAngle c) {
      return divide(c);
   }

   /**
    * subtracts angles.
    *
    * @param c
    */

   public ComplexAngle divideThis(ComplexAngle c) {
      double nr = real * c.real + imag * c.imag;
      double ni = c.real * imag - c.imag * real;
      // since we assume normalized we don't need to divide by
     // c.real*c.real+c.imag*c.imag, since that is 1.
     real = nr;
      imag = ni;
      return this;
   }

   public ComplexAngle divide(ComplexAngle c) {
      double nr = real * c.real + imag * c.imag;
      double ni = c.real * imag - c.imag * real;
      return new ComplexAngle(nr, ni);
   }

   /**
    * compare the angle. If o is bigger that means its a bigger angle. Note this is signed angles.
    *
    * So we are comparing y/x >=<  y'/x'. To avoid degenrancy with x->0 we rearange for y*x' >=< y'*x
    */

   @Override
   public int compareTo(ComplexAngle o) {
      double a = imag*o.real;
      double b = o.imag*real;
      if (a > b)
         return 1;
      if (a < b)
         return -1;
      return 0;
   }

   /**
    * note that we are using signed angles +-PI
    *
    * @param coneHalfAngle
    * @param from
    * @param to
    * @return
    */

   public boolean isInConeAngle(ComplexAngle coneHalfAngle, ComplexAngle angle) {
      // need to "rotate" our gun to match the ship
     ComplexAngle larger = this.addAngle(coneHalfAngle);
      ComplexAngle smaller = this.subtractAngle(coneHalfAngle);
      return larger.compareTo(angle) > 0 && smaller.compareTo(angle) < 0;// signed angles

   }

   /**
    * to show the round of errors.
    *
    * @return
    */

   public double length() {
      return sqrt(real * real + imag * imag);
   }

   /**
    * I hope this is normalized... Or there will be trouble.
    *
    * @return
    */

   public double cos() {
      return real;
   }

   /**
    * we are normlaized... Right!
    *
    * @return
    */

   public double sin() {
      return imag;
   }

   public double tan() {
      return imag / real;
   }

   /**
    *
    * @return a rotation matrix
    */

   public AffineTransform getRotationTransform() {
      double cos = real;
      double sin = -imag;//for the left handed coords for java2d. Note that a gl matrix would have this +
     return new AffineTransform(new double[] { cos, -sin, sin, cos});
   }

   /**
    * degenrate cases when angles are PI apart.
    * @param c
    * @param t
    * @return
    */

   public ComplexAngle interpolate(ComplexAngle c, double t) {
      double oneMinusT = 1 - t;
      double r = real * oneMinusT + c.real * t;
      double i = imag * oneMinusT + c.imag * t;
      ComplexAngle ca = new ComplexAngle(r, i);
      ca.normalize();// typically required here.
     return ca;
   }

   public void normalize() {
      double n = 1.0 / Math.sqrt(real * real + imag * imag);
      real *= n;
      imag *= n;
   }
   
   @Override
   public String toString() {
      return "ComplexAngle("+real+","+imag+"):"+length();
   }
   
   public static class Example extends JPanel implements MouseMotionListener{
     
      Point2D mouse=new Point2D.Double(0,0);
      ComplexAngle sweep=ComplexAngle.createAngle(1, 0);
      Point2D center=new Point2D.Double(100,100);
      ComplexAngle cone=ComplexAngle.createAngle(PI*2/45);//8 deg
     double t=.5;
      double dt=.02;
     
      public Example() {
         addMouseMotionListener(this);
         setBackground(Color.white);
         
      }
     
      @Override
      protected void paintComponent(Graphics g) {
         super.paintComponent(g);
         Graphics2D g2d=(Graphics2D)g;
     
         t+=dt;
         if(t>1){
            t=1;
            dt=-dt;
         }else if(t<0){
            t=0;
            dt=-dt;
         }
         
         ComplexAngle lookAt=ComplexAngle.angleTo(center, mouse);
   
         AffineTransform rotation=lookAt.getRotationTransform();
         AffineTransform af=AffineTransform.getTranslateInstance(center.getX(), center.getY());
         af.concatenate(rotation);
         
         AffineTransform oldTransform=g2d.getTransform();
         g2d.setTransform(af);
         g2d.setColor(Color.BLACK);
         paintDude(g2d);
         
         //now for sweeper.
        if(sweep.compareTo(lookAt)<0){
            sweep.addAngleThis(ComplexAngle.DELTA_ANGLE);
            g2d.setColor(Color.RED);
         }else{
            sweep.subtractAngleThis(ComplexAngle.DELTA_ANGLE);
            g2d.setColor(Color.BLUE);
         }
         if(lookAt.isInConeAngle(cone, sweep)){
            g2d.setColor(Color.GREEN);
         }
         
         System.out.println(sweep);
         
         g2d.setTransform(oldTransform);
         
         drawLine(g2d,center,sweep,200);
         
         g2d.setColor(Color.GRAY);
         drawLine(g2d,center,lookAt.addAngle(cone),100);
         drawLine(g2d,center,lookAt.subtractAngle(cone),100);
         
         g2d.setColor(Color.CYAN);
         drawLine(g2d,center,sweep.interpolate(sweep.addAngle(ComplexAngle.RIGHT_ANGLE),t),50);
         drawLine(g2d,center,sweep.interpolate(sweep.subtractAngle(ComplexAngle.RIGHT_ANGLE),t),50);
         
      }
     
      /**
       * paints a circle with a line from 0,0 to 10,0
       */

      private void paintDude(Graphics2D g2d){
         g2d.draw(new Ellipse2D.Double(-10,-5,20,10));
         g2d.drawLine(0, 0, 30, 0);
         
      }
     
      private void drawLine(Graphics2D g2d,Point2D from,ComplexAngle angle,double l){
         //here we use the example that a complex number can just be interpreted as a unit vector in the direction its pointing.
        //this is why, if we are normalized cos and sin are just the real and imag parts respectively.
        g2d.drawLine((int)from.getX(),(int)from.getY(),(int)(l*angle.cos()+from.getX()), (int)(l*angle.sin()+from.getY()));
         
      }
     
      @Override
      public void mouseDragged(MouseEvent e) {
         center=new Point2D.Double(e.getX(),e.getY());
         
      }
     
      @Override
      public void mouseMoved(MouseEvent e) {
         mouse=new Point2D.Double(e.getX(),e.getY());
         
      }
     
   }

   public static void main(String[] args) {
      JFrame frame=new JFrame();
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     
      frame.setSize(500,500);
     
      Example example=new Example();
      frame.add(example);
      frame.setVisible(true);
      ((Graphics2D)example.getGraphics()).addRenderingHints(new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON));
      while(true){
         try {
            Thread.sleep(16);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
         example.repaint();
      }
   }
}

I have no special talents. I am only passionately curious.--Albert Einstein
Offline relminator
« Reply #1 - Posted 2013-05-22 02:25:20 »

This is quite cool! 
Offline DrZoidberg

Senior Member


Medals: 15



« Reply #2 - Posted 2013-05-23 21:24:57 »

What you call a ComplexAngle, is also known as the left column of a 2D rotation Matrix.
http://en.wikipedia.org/wiki/Rotation_matrix

The API doc of AffineTransform calls it a rotation vector,
http://docs.oracle.com/javase/7/docs/api/java/awt/geom/AffineTransform.html#rotate(double, double)

Anyway, that's some nice code you got there. However I wanted to offer an alternative implementation.

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  
class Vector {
    public static final Vector X_AXIS = new Vector(1,0);
    public static final Vector Y_AXIS = new Vector(0,1);
   
    public final double x, y;
    public Vector(double x, double y) {
        this.x = x;
        this.y = y;
    }
    //creates a Vector from polar coordinates
   public Vector fromPolar(double length, double angle) {
        return new Vector(Math.cos(angle)*length, Math.sin(angle)*length);
    }
    public Vector add(Vector v) {
        return new Vector(x+v.x, y+v.y);
    }
    public Vector sub(Vector v) {
        return new Vector(x-v.x, y-v.y);
    }
    public Vector mul(double d) {
        return new Vector(x*d, y*d);
    }
    public Vector neg() {
        return new Vector(-x, -y);
    }
    public double dotProduct(Vector v) {
        return x*v.x + y*v.y;
    }
    public double crossProduct(Vector v) {
        return x*v.y - y*v.x;
    }
    public double length() {
        return Math.sqrt(x*x+y*y);
    }
    public Vector normalize() {
        return mul(1/length());
    }
    public Vector rotate90() {
        return new Vector(-y, x);
    }
    public Vector rotate(Angle a) {
        return a.rotate(this);
    }
    public Vector rotateAround(Vector center, Angle angle) {
        return sub(center).rotate(angle).add(center);
    }
    public Vector rotateOpposite(Angle a) {
        return a.rotateOpposite(this);
    }
    public Vector rotate(double angle) {
        return new Angle(angle).rotate(this);
    }
    public Angle angle() {
        return Angle.fromVector(this);
    }
    public Angle angleTo(Vector v) {
        return v.angle().sub(angle());
    }
    @Override
    public String toString() {
        return "Vector("+x+", "+y+")";
    }
}

class Angle {
    public final double cos, sin;
   
    public Angle(double angle) {
        cos = Math.cos(angle);
        sin = Math.sin(angle);
    }
    private Angle(double cos, double sin) {
        this.cos = cos;
        this.sin = sin;
    }
    public static Angle fromVector(Vector v) {
        double length = v.length();
        return new Angle(v.x/length, v.y/length);
    }
    public Angle inverse() {
        return new Angle(cos, -sin);
    }
    public Angle add(Angle a) {
        return new Angle(cos*a.cos - sin*a.sin,
                         cos*a.sin + sin*a.cos);
    }
    public Angle sub(Angle a) {
        return add(a.inverse());
    }
    public Vector rotate(Vector v) {
        return new Vector(v.x*cos - v.y*sin,
                          v.x*sin + v.y*cos);
    }
    public Vector rotateOpposite(Vector v) {
        return new Vector( v.x*cos + v.y*sin,
                          -v.x*sin + v.y*cos);
    }
    public double toRadians() {
        return Math.atan2(sin,cos);
    }
    public double toDegrees() {
        return Math.toDegrees(toRadians());
    }
    @Override
    public String toString() {
        return "Angle " + toDegrees() + " degrees";
    }
}

class Camera {
    Vector pos;
    Angle orientation;
    double zoom;

    public Camera(Vector pos, Angle orientation, double zoom) {
        this.pos = pos;
        this.orientation = orientation;
        this.zoom = zoom;
    }
    public Camera(Vector pos, double orientation, double zoom) {
        this(pos, new Angle(orientation), zoom);
    }
    public Camera() {
        this(new Vector(0,0), 0, 1);
    }
    public Vector toScreenCoordinates(Vector v) {
        return v.sub(pos).rotateOpposite(orientation).mul(zoom);
    }
    public Vector toGameCoordinates(Vector v) {
        return pos.mul(1/zoom).rotate(orientation).add(pos);
    }
    public void zoom(double zoom) {
        zoom *= zoom;
    }
    public void rotate(Angle angle) {
        orientation = orientation.add(angle);
    }
    public void rotate(double angle) {
        rotate(new Angle(angle));
    }
    public void rotateAround(Vector center, Angle angle) {
        pos = pos.sub(center).rotate(angle).add(center);
        orientation = orientation.add(angle);
    }
    public void rotateAround(Vector center, double angle) {
        rotateAround(center, new Angle(angle));
    }
    public AffineTransform affineTransform() {
        AffineTransform at = AffineTransform.getScaleInstance(zoom, zoom);
        at.rotate(orientation.cos, -orientation.sin);
        at.translate(-pos.x, -pos.y);
        return at;
    }
}
Games published by our own members! Check 'em out!
Legends of Yore - The Casual Retro Roguelike
Offline Riven
« League of Dukes »

JGO Overlord


Medals: 781
Projects: 4
Exp: 16 years


Hand over your head.


« Reply #3 - Posted 2013-05-23 21:30:09 »

1  
2  
3  
4  
    public void zoom(double zoom) {
-        zoom *= zoom;
+        this.zoom *= zoom;
    }

Hi, appreciate more people! Σ ♥ = ¾
Learn how to award medals... and work your way up the social rankings
Offline Roquen
« Reply #4 - Posted 2013-05-24 11:16:20 »

If I were ever to do 2D stuff I'd just abuse the mathematical types and merge complex numbers and vectors into a single type.  I can't think of any situations where the difference in symmetry would cause a problem.  Something like this, but not immutable.
Online pjt33
« Reply #5 - Posted 2013-05-24 13:56:44 »

However 2d is even easier to avoid trig and even inverse trig.
A pedant might say that you're not avoiding trig, just concealing it via de Moivre's theorem.
Offline Roquen
« Reply #6 - Posted 2013-05-24 14:49:37 »

That's one way of looking at it (starting from Euler's might be easier though...haven't thought this through).  The other is that when you're using angles and directly trig ops & identities that you're working in an exponential or log mapped space when you could be working in linear.

Offline HeroesGraveDev

JGO Kernel


Medals: 246
Projects: 11
Exp: 2 years


┬─┬ノ(ಠ_ಠノ)(╯°□°)╯︵ ┻━┻


« Reply #7 - Posted 2013-05-24 20:36:47 »

This looks like trig to me. Just with different variable names and concealment of trig operations.

Offline ags1

JGO Ninja


Medals: 48
Projects: 2
Exp: 5 years


Make code not war!


« Reply #8 - Posted 2013-05-24 20:48:59 »

If it walks like a trig and quacks like a trig, it's a duck.

Offline Roquen
« Reply #9 - Posted 2013-05-25 12:32:56 »

@HeroesGraveDev: It's superficial. Most problems you don't need to consider the angle or trig ops or identities...they're magically built in to the negative signature (fancy way of saying e*e = -1).  The "real" benefit here is not only cheaper operations but the fact that you're adding a bunch of tools that allow you to look at the same problem in more ways.
Games published by our own members! Check 'em out!
Legends of Yore - The Casual Retro Roguelike
Offline Riven
« League of Dukes »

JGO Overlord


Medals: 781
Projects: 4
Exp: 16 years


Hand over your head.


« Reply #10 - Posted 2013-05-25 15:39:50 »

My only concern is that handling these objects is putting both stress on the GC (stack allocation is not perfect yet) and on code verbosity (due to the lack of operator overloading). To me it feels like I'm forced to do 'boxing and unboxing' that angle every time I access it. I think that solely for that reason I'd stick to 'float angle' in most of the cases. In C++ it'd be a lot less of a burden to make the switch.

Hi, appreciate more people! Σ ♥ = ¾
Learn how to award medals... and work your way up the social rankings
Offline Roquen
« Reply #11 - Posted 2013-05-26 06:14:16 »

Yeap.  A very real concern which is avoidable in C++: no GC (well by default), new abuse, custom allocators and...umm...oh yeah! structures!  Golly wouldn't that be nice.  Of course the same holds for all small object allocations.  But that's really a different subject to my brain.
Offline DrZoidberg

Senior Member


Medals: 15



« Reply #12 - Posted 2013-05-26 08:59:07 »

Well, you could switch to Scala. Then you have operator overloading. Also modern JVMs can optimize this kind of stuff really well. On the Java 7 server VM there is no performance difference between boxing the values in objects all over the place and keeping them unboxed as doubles. All the object allocations are optimized away where possible, Data is automatically put on the stack instead of the heap, etc.
Offline Roquen
« Reply #13 - Posted 2013-05-26 11:46:19 »

For the time being all JVM languages are in the same boat w/r to the GC/cache-coherency issue.  The only choice to to flatten the state data into a container and perform code replication and/or create synthetically methods to eliminate the operations.  So you either do that, or wait for the invokedynamic framework to evolve enough to give the equivalent of limited pointer manipulation...ala some stuff mentioned in that arrays 2.0 presentation.
Pages: [1]
  ignore  |  Print  
 
 
You cannot reply to this message, because it is very, very old.

 

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

The first screenshot will be displayed as a thumbnail.

CopyableCougar4 (15 views)
2014-08-22 19:31:30

atombrot (28 views)
2014-08-19 09:29:53

Tekkerue (25 views)
2014-08-16 06:45:27

Tekkerue (23 views)
2014-08-16 06:22:17

Tekkerue (15 views)
2014-08-16 06:20:21

Tekkerue (22 views)
2014-08-16 06:12:11

Rayexar (61 views)
2014-08-11 02:49:23

BurntPizza (39 views)
2014-08-09 21:09:32

BurntPizza (31 views)
2014-08-08 02:01:56

Norakomi (38 views)
2014-08-06 19:49:38
List of Learning Resources
by Longor1996
2014-08-16 10:40:00

List of Learning Resources
by SilverTiger
2014-08-05 19:33:27

Resources for WIP games
by CogWheelz
2014-08-01 16:20:17

Resources for WIP games
by CogWheelz
2014-08-01 16:19:50

List of Learning Resources
by SilverTiger
2014-07-31 16:29:50

List of Learning Resources
by SilverTiger
2014-07-31 16:26:06

List of Learning Resources
by SilverTiger
2014-07-31 11:54:12

HotSpot Options
by dleskov
2014-07-08 01:59:08
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!