Richtige Tiefen bei Iso-Spiel mit unterschiedlich Großen Objekten

[K-Grabowski]

Hi,

hab gerade ein dickes Problem bei der Zeichenreihenfolge von Elementen bei einer Iso-Engine. Ich hoffe es gibt überhaupt eine Lösung.

Also ich möchte verschiedene Objekte darstellen, welche völlig unterschiedliche Breiten und Größen haben, unabhängig von der Tile-Size. Auch die Positionierung ist soll völlig unabhängig sein. Leider kommt es bei mir immer wieder zu aussetzern wo etwas nicht passt.

Vielleicht hat ja jemand ein paar Tipps für mich.

hier mal ne Skizze:

[K-Grabowski]

Im Moment Vergleiche ich folgendermaßen, was allerdings das ergebnis aus einem verzweifelten Montag war:

import com.bb.zdf.einszweidrei.models.ingame.IMapObject;
import com.bb.zdf.einszweidrei.Logger;
/**
 * @author potq
 */
class com.bb.zdf.einszweidrei.models.ingame.DepthComparator {
    
    public function DepthComparator() {
        
    }
    
    public function compare (o1:IMapObject, o2:IMapObject):Number {
        
        // returns the object which is drawn first to screen
        
        
        
        var xPos1:Number = o1.getX();
        var xPos2:Number = o2.getX();
        
        var xSize1:Number = o1.getSizeX();
        var xSize2:Number = o2.getSizeX();
        
        var ySize1:Number = o1.getSizeY();
        var ySize2:Number = o2.getSizeY();
        
        var yPos1:Number = o1.getY();
        var yPos2:Number = o2.getY();
        
        var yMax1:Number = yPos1 + ySize1;
        var yMax2:Number = yPos2 + ySize2;
         
        var xMax1:Number = xPos1 + xSize1;
        var xMax2:Number = xPos2 + xSize2;
        
        var zSize1:Number = o1.getSizeZ();
        var zSize2:Number = o2.getSizeZ();
        
        var sameXRegion:Boolean;
        if ((xMax1 > xPos2 && xPos1 < xPos2) || (xMax2 > xPos1 && xPos2 < xPos1)) { 
            sameXRegion = true;
        } else {
            sameXRegion = false;
        }
        
        var sameYRegion:Boolean;
        if ((yMax1 > yPos2 && yPos1 < yPos2) || (yMax2 > yPos1 && yPos2 < yPos1)) { 
            sameYRegion = true;
        } else {
            sameYRegion = false;
        }
        
        if (sameXRegion) {
            if (yPos1 < yPos2) {
                
                return -1;
            } else if (yPos1 > yPos2) {
                
                return 1;
            } else {
                
                if (xPos1 < xPos2) {
                    return -1;
                } else if (xPos1 > xPos2) {
                    return 1;
                }
                return 0;
            }
        } else if (sameYRegion) {
            
                if (xPos1 < xPos2) {
                    return -1;
                } else if (xPos1 > xPos2) {
                    return 1;
                } else {
                    if (yMax1 < yMax2) {
                        return -1;
                    } else if (yMax1 > yMax2) {
                        return 1;
                    }
                }
                return 0;
        } else {
            if (yPos1 <= yPos2) {
                return -1;
            } else if (yPos1 > yPos2) {
                return 1;
            } else {
                
                return 0;
            }
        }
        
    
         
    }
    
     
    
     
     
} 

[Omega Psi]

Nur so eine Idee, wenn der Registrierungspunkt eines Objektes "ganz unten" ist, dann müsste man nur noch die _y vergleichen und das Objekt, das den größten _y Wert hat, ist ganz vorne.

Der Boden liegt komplett unt den Objekten.

Eine andere Möglichkeit wäre, sich am Boden zu orientieren und die Kacheln für Tiefenwertberechnungen zu nutzen in dem man die kacheln intdiziert und dann vergleich, auf welcher Kachel sich ein Objekt befindet, daraus wird dann die Tiefe (z-Koordinate) ermittelt.

[K-Grabowski]

habs inzwischen gelöst.

Die untere linke ecke alleine reicht nicht bei verschieden großen Objekten. Das Geheimniss ist erstmal nachzuschauen ob die beiden objekte einen gemeinsamen x bereich haben. danach den mittelpunkt der beiden objekte für diesen bereich ausrechnen, und dann schauen welcher dieser beiden mittelpunkte den größeren abstand zum ursprung hat. Der größere Abstand wird zuletzt gezeichnet. Falls sie keinen gemeinsamen x-bereich haben, einfach das objekt zuerst zeichen das den kleineren x-wert hat.

import com.bb.zdf.einszweidrei.models.ingame.IMapObject;
import com.bb.zdf.einszweidrei.Logger;
import flash.geom.Point;
/**
 * @author potq
 */
class com.bb.zdf.einszweidrei.models.ingame.DepthComparator {
    
    public function DepthComparator() {
        
    }
    
    public function compare (o1:IMapObject, o2:IMapObject):Number {
        
        // returns the object which is drawn first to screen
        
        /*
        var tl1:Point = o1.getIsoRect().topLeft.clone();
        var tl2:Point = o2.getIsoRect().topLeft.clone();
        
        var bl1:Point = new Point(o1.getIsoRect().left + o1.getSizeX()/2 ,o1.getIsoRect().bottom);
        var bl2:Point = new Point(o1.getIsoRect().left + o1.getSizeX()/2 ,o1.getIsoRect().bottom);
         
        var xMin1:Number = o1.getX();
        var xMin2:Number = o2.getX();
        
        var xMax1:Number = xMin1 + o1.getSizeX();
        var xMax2:Number = xMin2 + o2.getSizeX();
        */
        
        
        var x1:Number = o1.getX();
        var x2:Number = o2.getX();
        
        var xMax1:Number = x1 + o1.getSizeX();
        var xMax2:Number = x2 + o2.getSizeX();
        
        var intersectionMinX:Number;
        var intersectionMaxX:Number;
        
        var p1:Point;
        var p2:Point;
        
        var dist1:Number;
        var dist2:Number;
        
        
        var intersectsX:Boolean = (x2 >= x1 && x2 < xMax1) || (x1 >= x2 && x1 < xMax2);
        if (intersectsX) {
            // calc intersection
            intersectsX = true;
            intersectionMinX = Math.max(x1,x2);
            intersectionMaxX = Math.min(xMax1, xMax2);
            p1 = new Point(intersectionMinX + (intersectionMaxX - intersectionMinX)/2, o1.getY() + o1.getSizeY()/2);
            p2 = new Point(intersectionMinX + (intersectionMaxX - intersectionMinX)/2, o2.getY() + o2.getSizeY()/2);
            
            dist1 = Math.sqrt(p1.x * p1.x + p1.y * p1.y);
            dist2 = Math.sqrt(p2.x * p2.x + p2.y * p2.y);
            
            
            // return value dependent on Intersection
            if (dist1 < dist2) {
                
                return -1;
            } else if (dist1 > dist2) {
                
                return 1;
            }
            
            return 0;
        }
        
        
        // no intersection X
        if (x1 > x2) {
            
            return 1;
        } else if (x1 < x2) {
            
            return -1;
        }
        
        return 0;
        
        
        
        
         
    }
    
     
    
     
     
}