I did not understand one line of your post. Sorry. You should post a capture or two, so we can see what you are talking about. If your code is too long, you could provide a link to a file online.

To me, it sounds like you don't keep it simple. It's hard to tell, but I think you could find a simpler way, without "reverse" flags or things like that. A train has carriages, OK. But why would you change the order of drawing? Again, please provide a link to some code or screen captures.

This image should illustrate why I need to change the order of drawing. As for making things simpler: if anything, I'm afraid it's too simple at the moment and about to get more complicated. Thanks for the input!

"push into ArrayList, sort by Y, draw in the order of the arraylist" That just popped into my head as i was reading...

Maybe i've totally misunderstood your problem and if that is the case just ignore this but:
Assuming are carriages are stored in some kind of object that holds it's X and Y position you could have a array or arraylist with all of your carriages that you every frame sort in a order so that the carriage with the lowest Y is first and highest last and then draw them out in the sorted order, this way they should always stay on top of each other. Also you might want to sort all carriages with the same Y by their X.

dunno if this helps, your posts were kinda confusing to me (like im unsure of why they end up in reverse order to begin with...)

depth sorting an array (or arraylist or anything like that) using the Y axis should solve your problem then...

depth sorting a array (or arraylist or anything like that) using the Y axis should solve your problem then...

I wonder whether it might not be easier to have different images for the carriages, that do not overlap, i.e. you draw one type of image (for all but the last carriage) without the back and one full image just for the last carriage (well, you might need a special image for the first too, depending on what exactly you want to do). Then you just have to decide which image to use rather than reverse arrays and all that.

Andreas

I didnt read through all the posts here but just a quick thought.
why dont you just draw them in different order

so instead of
for (int z=0; z< 5; z++) {

do
for (int z=5; z> 0; z--) {

Andreas - That would indeed work. I have everything in place to supply a different graphic for each angle the carriage might be facing. The reason I don't want to do this is that the train I'm making has to be very dynamic and takes a lot of variables. I need to be able to change the distance between carriages on demand at certain intervals in time. It's all being fed from an xml file that lays out the path and suggests speeds at various moments etc. Thanks for the suggestion.

So I guess my current predicament is solving:

i still think that depth sorting is the obvious answer... but hey, maybe i'm wrong...
anyways i made this code to show what i am talking about.

1. class Carriage implements Comparable{
     float x;
     float y;
     public Carriage(float _x,float _y){
       x = _x;
       y = _y;
     }
     int compareTo(Object o){
       Carriage c =  (Carriage)o;
       int dy = int(y-c.y);
       if(dy == 0){
         return int(x-c.x);
       }
       return dy;   
     }
   }
   ArrayList carriages;
   ArrayList renderList;
   void setup(){
     size(600,600);
     stroke(0);
     fill(0,120,200);
     smooth();
     carriages = new ArrayList();
     renderList = new ArrayList();
   }
   void draw(){
     background(255);
     renderList.clear();
     renderList = (ArrayList)carriages.clone();
     Collections.sort(renderList);
     for(int i = 0; i< renderList.size();i++){
      Carriage c = (Carriage)renderList.get(i);
      rect(c.x,c.y,50,50);
     }
   }
   void mousePressed(){
    carriages.add(new Carriage(mouseX,mouseY));
   }
   

i still think that depth sorting is the obvious answer... but hey, maybe i'm wrong...

Ok, I'm lost. I kept feeling so close today but something would backfire. Bjordal, I love your example but I wasn't sure if it was possible to incorporate into mine with the way my train system is worked out before I get onto the problem of drawing order. If I was good at all of this I'd understand exactly what you wrote and be able to tweak it but I'm not familiar with comparing classes and a few other bits (I was trying to read up on it there).

here's a "train" moving along a wave path.
works on top of the code from bjorgal. it is a problem of z sorting (order or drawing)
another thing is the texture swapping. you have different textures for different train directions right? that you will need to handle somehow.

1. import processing.opengl.*;
   
   class Carriage implements Comparable{
     float x;
     float y;
     public Carriage(float _x,float _y){
       x = _x;
       y = _y;
     }
    
     public void set( float x, float y )
     {
         this.x = x;
         this.y = y;
     }
    
     int compareTo(Object o){
       Carriage c =  (Carriage)o;
       int dy = int(y-c.y);
       if(dy == 0){
         return int(x-c.x);
       }
       return dy;  
     }
   }
   
   
   float carriageSpace = 30;
   ArrayList carriages;
   ArrayList renderList;
   
   void setup()
   {
     size(600,600, OPENGL);
     stroke(0);
     fill(0,120,200);
     smooth();
     carriages = new ArrayList();
     renderList = new ArrayList();
   
       for( int i=0; i<10; i++ )
        carriages.add( new Carriage( 20+i*carriageSpace, height/2) );
       
       rectMode( CENTER );
   }
   
   
   void draw()
   {
     background(255);
   //  renderList.clear();
   //  renderList = (ArrayList)carriages.clone();
   //  Collections.sort( renderList );
   
       // draw connections
     for(int i = 0; i< carriages.size()-1; i++)
     {
       Carriage c = (Carriage)carriages.get(i);
       Carriage c2 = (Carriage)carriages.get(i+1);
       line( c.x, c.y, c2.x, c2.y );
     }
   
       // draw carriages
     for(int i = 0; i<carriages.size()-1; i++)
     {
      Carriage c = (Carriage)carriages.get( (carriages.size()-1) - i );
      Carriage c2 = (Carriage)carriages.get( (carriages.size()-1) - i-1 );
   //   Carriage c = (Carriage)renderList.get(i);
       float dx = c2.x - c.x;
       float dy = c2.y - c.y;
       float angle = atan2( dy, dx );
       pushMatrix();
       translate( c.x, c.y );
       rotateZ( angle );
       rect( 0, 0, carriageSpace, carriageSpace );
       popMatrix();
     }
    
     float time = millis() * 0.001f;
     update( (width*0.5)+cos(time*0.4)*300f, (height*0.5)+sin(time*0.7)*300f );
   //  update( mouseX, mouseY );
   }
   
   
   void update( float headX, float headY )
   {
           ((Carriage)carriages.get(0) ).set( headX, headY );
           for( int i=1; i<carriages.size(); i++ )
           {
               Carriage curr = (Carriage)carriages.get(i);
               Carriage prev = (Carriage)carriages.get(i-1);
               float dx = curr.x - prev.x;
               float dy = curr.y - prev.y;
               float d = (float) Math.sqrt( dx*dx + dy*dy );
               float invD = 1.0f / d;
               curr.x = (prev.x + ((dx * carriageSpace) * invD));
               curr.y = (prev.y + ((dy * carriageSpace) * invD));
           }
   }
   
   

Thanks pixelnerve, that's a really nice example. Unfortuantely, like bjordal's example, the way I've set up my train to work before I even get to needing to sort the depths has left it extremely hard for me to put this type of approach into my own model (largely due to my own inexperience). But, in good news...

Just a couple quick comments... I'm not sure it's sure it's good practice to compare strings with the == operator... shouldn't you use  slope[currentSection[z]].equals("some string")? Because otherwise I think it's checking if the string object is equal to the string litteral object, or atleast that was my understanding.