Dynamische Labyrinth-Sicht

[SaKiN]

Hi,

hab den Thread vom AS1-Forum mal hierher verschoben, wo er wahrscheinlich mehr Sinn macht.

für nen Freund, der seine Leidenschaft in DND-Rollenspielen sieht, wollte ich ein kleines Tool basteln, mit dem man eine Spielfigur auf einer Karte mit Mauern bewegen kann und dass dabei aber gecheckt wird, was diese Figur sehen kann und was nicht. Es soll eine Art "Fog of War" entstehen.

EDIT: Bisschen was konnte ich noch rausholen...
Hier mein Ansatz: http://www.sakin-online.de/map002.swf
Die Figur kann mit dem Pfeiltasten bewegt werden. Kollisionsabfrage ist jetzt mal noch keine drin.

Das Teil klappt zwar einigermaßen, is aber extrem lahm und arg unperformant. Wie es auf langsameren Rechnern läuft will ich gar nicht wissen

Jedenfalls wollt ich mal fragen, wie ihr dieses Problem angehen würdet, rein vom Algorithmus. Ich habs nu so versucht:

Vom Player gehen "Strahlen" kreisförmig aus, die entweder gegen eine Wand stoßen oder seinen Sichtradius überschreiten und dann verpuffen. Wenn eines dieser beiden Fälle eintritt, wird sich der letzte Punkt des Strahls gemerkt und in einem Array gespeichert. Ganz am Ende werden alle Punkte verbunden, was die Form generiert (Diese sollte nun noch gefüllt werden und die Map maskieren).

Leider is der Ansatz sicherlich arg umständlich und unperformant: Für jeden Strahl wird ein sich bewegender MovieClip benutzt, der sich in ner while-Schleife nach außen bewegt. Je mehr Strahlen den Kreis beschreiben, desto höher die Genauigkeit, desto katastrophaler die Performance

Hier der Code des Ganzen:

PHP-Code:


import flash.geom.*;

class Player extends MovieClip
{
    //später nach Map auslagern
    public static var tile_size:Number = 40;
    
    private var sight:Number;
    private var color:Number;
    
    public var mask_mc:MovieClip;
    public var counter:Number = 10;
    
    public var sight_points:Array;
    
    public function Player()
    {
        sight = 5*tile_size;
        drawLineView();
    }
    
    public function drawLineView():Void 
    {
        this.sight_points = new Array();
        this.mask_mc = createEmptyMovieClip("mask_mc",5);
        
        var from:Point = new Point(0,0);
        var to:Point;
        
        // "aussenden" der sichtstahlen und speichern der endpunkte im array
        for(var i=0; i<=2*Math.PI; i+=Math.PI/32)
        {
            // neuer strahl
            _root.attachMovie("ray","ray"+counter,counter);
            _root["ray"+counter]._x = this._x;
            _root["ray"+counter]._y = this._y;
            // bewegungsrichtung
            _root["ray"+counter].a = Math.sin(i) *5;  //hier beschleunigen, damit Performance besser *5
            _root["ray"+counter].b = Math.cos(i) *5; //hier beschleunigen, damit Performance besser *5
            
            // solange bewegen bis wand getroffen oder sichtradius überschritten
            do 
            {
                _root["ray"+counter]._x += _root["ray"+counter].a;
                _root["ray"+counter]._y += _root["ray"+counter].b;
                
                to = new Point(_root["ray"+counter]._x, _root["ray"+counter]._y);
                mask_mc.globalToLocal(to);
                                
                if(_root.wt.hitTest(_root["ray"+counter]._x,_root["ray"+counter]._y,true))
                {
                    sight_points.push(to);
                    break;
                }
                
            }while(Point.distance(from , to) < this.sight)
            
            _root["ray"+counter].removeMovieClip();
            sight_points.push(to);
            counter++;
        }
        this.mask_mc.lineStyle(4, 0x00FF00);    
        
        // zeichen der umrisslinie - verbinden der endpunkte im array
        for(var i=0; i<sight_points.length-1; i++)
        {
            this.mask_mc.moveTo(sight_points[i].x, sight_points[i].y);
            this.mask_mc.lineTo(sight_points[i+1].x, sight_points[i+1].y);
        }
    }
    
    public function setSight(value:Number):Void
    {
        this.sight = value;
        drawLineView();
    }
    
    public function moveUp():Void
    {
        this._y -= tile_size;
        drawLineView();
    }
    
    public function moveDown():Void
    {
        this._y += tile_size;
        drawLineView();
    }
    
    public function moveLeft():Void
    {
        this._x -= tile_size;
        drawLineView();
    }
    
    public function moveRight():Void
    {
        this._x += tile_size;
        drawLineView();
    }
} 


Toll wäre es halt, wenn ich per AS Drawing API Schnittpunkte von Geraden abfragen könnte, dann könnte ich mir den ganzen Quatsch mit den MCs sparen. Ein hitTest fragt eben nur Intersection oder nicht, aber nicht wo genau diese stattfindet.

Irgendwelche Ideen, wie man das ganze anders angehen könnte, dass es vor allem performanter läuft? Eigentlich sollte sich der Player nämlich smooth bewegen können, später mal

Danke für die Tips!

[Janoscharlipp]

Guck mal hier: kollision