You could use an array or object-oriented programming (a simple xyz-class) to store the coordinates.

Also it's not a good idea to use a low frameRate to slow down your moving objects. You'll notice moving the camera doesn't work well. Instead have a normal frameRate and either decrease the speed or, since you want a jump each time, only add to the position once every nth frame.

Code Example

1. import peasy.*;
2. PeasyCam cam;
3. int t;
4. 
   
5. void setup() {
6.   size(600,600,P3D);
7.   cam = new PeasyCam(this, 0);
8.   cam.setMinimumDistance(200);
9.   cam.setMaximumDistance(1000);
10. }
11. 
    
12. void draw() {
13.   lights();
14.   background(0);
15.   fill(255,0,0);
16.   box(10);
17. 
    
18.   if (frameCount % 30 == 0) { // every 30th frame
    
19.     t+=10;
20.   }
21. 
    
22.   pushMatrix();
23.   translate(0,t,0);
24.   fill(0,0,255);
25.   box(10);
26.   popMatrix();
27. }

Hi,

Ok, here is a commented example of an array, actually two arrays, that each hold 50 numbers in memory. One for the X and one for the Y positions. See the code for an explanation. Remember arrays start at zero.

1. // hold 50 numbers in memory
2. int[] xpos = new int[50];
3. int[] ypos = new int[50];
4. 
   
5. void setup() {
6.   size(800,800);
7.   smooth();
8. }
9. 
   
10. void draw() {
11.   background(255);
12. 
    
13.   // move all the coordinates one place down
14.   for (int i=0; i<xpos.length-1; i++) {
15.     xpos[i] = xpos[i+1];
16.     ypos[i] = ypos[i+1];
17.   }
18. 
    
19.   // set the last coordinates at mouseX,mouseY
20.   xpos[xpos.length-1] = mouseX;
21.   ypos[ypos.length-1] = mouseY;
22. 
    
23.   // for all the coordinates show a circle => xpos[i]. ypos[i]
    
24.   // the fill and size depend on the place in the array
    
25.   // newer (aka higher i) are bigger and darker
26.   // older (aka lower i) are smaller and lighter
27.   for (int i=0; i<xpos.length; i++) {
28.     noStroke();
29.     fill(255-i*5);
30.     ellipse(xpos[i],ypos[i],i*5,i*5);
31.   }
32. }

And here is a commented example of a class to store coordinates.

1. // arrayList to hold all the coordinates (or technically the coordinate objects)
   
2. ArrayList coordinates = new ArrayList();
3. 
   
4. void setup() {
5.   size(800,800);
6.   smooth();
7. }
8. 
   
9. void draw() {
10.   background(255,0,100);
11. 
    
12.   // display circles at all the coordinates
13.   for (int i=0; i<coordinates.size(); i++) {
14.     Coordinate c = (Coordinate) coordinates.get(i);
15.     float radius = noise(i + frameCount * 0.05) * 60;
16.     ellipse(c.x,c.y,radius,radius);
17.   }
18. 
    
19.   // removes coordinates if there are more than 150, comment this out to keep all coordinates
20.   if (coordinates.size() > 150) { coordinates.remove(0); }
21. }
22. 
    
23. void mouseDragged() {
24.   // while dragging, add coordinates at the mouse location
25.   coordinates.add(new Coordinate(mouseX,mouseY));
26. }
27. 
    
28. // the extremely basic coordinate class
29. class Coordinate {
30.   int x,y;
31.   Coordinate(int x, int y) {
32.     this.x = x;
33.     this.y = y;
34.   }
35. }

Hi,

All right. Both are valid ways to store coordinates. Here is your original code with the array implemented. All the previous positions have a small box. I'll leave the other one for you to figure out then.

1. import peasy.*;
2. PeasyCam cam;
3. int[] position = new int[50];
4. 
   
5. void setup() {
6.   size(600,600,P3D);
7.   cam = new PeasyCam(this, 0);
8.   cam.setMinimumDistance(200);
9.   cam.setMaximumDistance(1000);
10. }
11. 
    
12. void draw() {
13.   lights();
14.   background(0);
15.   fill(255,0,0);
16.   box(10);
17. 
    
18.   if (frameCount % 30 == 0) {
19.     for (int i=0; i<position.length-1; i++) {
20.       position[i] = position[i+1];
21.     }
22.     position[position.length-1] = position[position.length-2] + 10;
23.   }
24. 
    
25.   for (int i=0; i<position.length-1; i++) {
26.     pushMatrix();
27.     translate(0,position[i],0);
28.     fill(0,0,255);
29.     box(5);
30.     popMatrix();
31.   }
32.  
33.     pushMatrix();
34.     translate(0,position[position.length-1],0);
35.     fill(0,0,255);
36.     box(10);
37.     popMatrix();
38. }

Great. Objects are a fantastic way to store information. Not only xyz, but basically everything you need. So there is a lot of potential in using them. Sticking to those, especially in an example like yours, is a good option if you feel more comfortable with a class and an arraylist. With regard to an array. It's basically a list of that type of data instead of just one. The list can hold 1, 100 or 1000 things on it. That doesn't really matter. Some examples:

int oneInt versus int[] multipleInts = new int[50]
String oneWord versus String[] multipleWords = new String[50]
color oneColor versus color[] multipleColors = new color[50]
PImage oneImage versus PImage[] multipleImages = new PImage[50]

To get the number, image, word at that point in the list you use the index. For a list of 50. The data is in position 0 to 49.

Just like a very neat and structured grocery list.

String[] groceries = new String[3]
groceries[0] = bread;
groceries[1] = butter;
groceries[2] = cheeeeeese;

Ok I tried to implement the method to store a box coordinates in kind of 3D conway game of life but I didnt succeed. The idea is to have a 2D game of life which at each framrate draw the next state on a new Z level instead of the same plane.

Well, it's hard because there are a few things running through each other. On the one hand there is a two-dimensional array of booleans. On the other hand there are the 3D coordinates. It's possible to go fully with coordinates. But since you already have the boolean array in place -and this is a pretty efficient way to store this kind of info- you can also just adapt the class to store the boolean array (instead of coordinates). In the sketch below you can move a round with peasycam, press c to clear everything and press space to add a new state.

Code Example:

1. ArrayList states = new ArrayList();
2. 
   
3. import processing.opengl.*;
4. import peasy.*;
5. PeasyCam cam;
6. 
   
7. int xNum = 20;
8. int yNum = 20;
9. int cellSize = 30;
10. int z;
11. 
    
12. void setup() {
13.   size(800,800,OPENGL);
14.   cam = new PeasyCam(this, 300,300,0, 1000);
15.   cam.setMinimumDistance(1);
16.   cam.setMaximumDistance(100000);
17.   noStroke();
18.   fill(160);
19.   initialState();
20. }
21. 
    
22. void draw() {
23.   background(255);
24.   ambientLight(95,95,95);
25.   directionalLight(51, 102, 126, 0, 0, -1);
26.   directionalLight(60, 60, 60, 1, 60, 0);
27.   directionalLight(20, 20, 20, 0, -5, 0);
28.   lightSpecular(0, 50, 0);
29.   lightFalloff(1,0,0);
30.   displayStates();
31.   if (frameCount % 30 == 0) { nextState(); } // autoplay
    
32. }
33. 
    
34. void keyPressed() {
35.   if (key == 'c') { states.clear(); z=0; initialState(); } // clear
    
36.   if (key == ' ') { nextState(); } // add a new state manually
    
37. }
38. 
    
39. void initialState() {
40.   boolean[][] state = new boolean[xNum][yNum];
41.   for(int i=0; i<xNum; i++) {
42.     for (int j=0; j<yNum; j++) {
43.       int a = int(random(2));
44.       if (a==0) { state[i][j] = false; }
45.       else      { state[i][j] = true;  }
46.     }
47.   }
48.   states.add(new SavedState(state,z));
49.   z += cellSize;
50. }
51. 
    
52. void displayStates() {
53.   for (int i=0; i<states.size(); i++) {
54.     SavedState s = (SavedState) states.get(i);
55.     s.display();
56.   }
57. }
58. 
    
59. void nextState() {
60.   SavedState s = (SavedState) states.get(states.size()-1);
61.   boolean[][] nextState = new boolean[xNum][yNum];
62.   for(int i=0; i<xNum; ++i) {
63.     for (int j=0; j<yNum; ++j) {
64.       int liveCells =0;
65.       for(int m=-1; m<=1; ++m) {
66.         for(int k=-1; k<=1; ++k) {
67.           if(! (m==0 && k==0)) {
68.             if(s.savedState[(i+m+xNum)%xNum][(j+k+yNum)%yNum] == true) {
69.               liveCells++;
70.             }
71.           }
72.         }
73.       }
74.       if(liveCells<2 || liveCells>3) {
75.         nextState[i][j] = false;
76.       } else if(liveCells==3) {
77.         nextState[i][j] = true;
78.       } else {
79.         nextState[i][j] = s.savedState[i][j];
80.       }
81.     }
82.   }
83.   states.add(new SavedState(nextState,z));
84.   z += cellSize;
85. }
86. 
    
87. class SavedState {
88.   boolean[][] savedState;
89.   float z;
90.   SavedState(boolean[][] savedState, float z) {
91.     this.savedState = savedState;
92.     this.z = z;
93.   }
94.  
95.   void display() {
96.     for(int i=0; i<xNum; ++i) {
97.       for (int j=0; j<yNum; ++j) {
98.         if(savedState[i][j]) {
99.           pushMatrix();
100.           translate(i*cellSize,j*cellSize,-z);
101.           box(cellSize);
102.           popMatrix();
103.         }
104.       }
105.     }
106.   }
107. }

I found your answers not only enlightening but also very educational. Endless thanks!