2dim-array benachbarte felder im radius x [formel]

[Ghanji]

dies sei ein zweidimensionales array

0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 c 0 0 0 0 0 0 0
0 0 0 0 0 c b c 0 0 0 0 0 0
0 0 0 0 c b a b c 0 0 0 0 0
0 0 0 c b a P a b c 0 0 0 0
0 0 0 0 c b a b c 0 0 0 0 0
0 0 0 0 0 c b c 0 0 0 0 0 0
0 0 0 0 0 0 c 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 ^y
x ->

auf jede (x/y) koordinate wird ein movieclip attached.
nun möchte ich, ausgehend von einem bekannten punkt (Px/Py) die tranzparenz der benachbarten clips mit veränderbarem radius (im beispiel r=3) nach aussen verringern.

hat jemand eine idee wie ich das elegant hinbekomme?
hab´ mal wieder ein brett vorm kopf...

danke,
Ghanji

[purewhite]

du könntest jedem MC ein clipevent zuordnen,
set alpha z.b. ... dann ne routine bei mouseOver auf MC_x
(x=irgendein MC), irgendsowas wie getPosition i von MC_i auf koordinaten
x und koordinaten y...
nur ne idee

[Ghanji]

die koordinaten vom ausgangs mc sind ja bekannt,
ich bekomm bloss diese routine zum checken der angrenzenden felder mit abnahme nicht hin...

[gaspode]

sofern der radius nicht variabel ist,
würde ich ihn einfach manuel vordefinieren.

z.B.
 
         [x][y-1]
[x-1][y] [x][y]   [x+1][y]
         [x][y+1] 

x und y sind hierbei die werte des mittelpunktes.


[x][y] alpha = 100
[x][y-1],[x-1][y],[x+1][y],[x][y+1] alpha = 75

usw. ...

gruß, gaspode

[EDIT: mir fällt gerade auf, daß das eigentlich nicht wirklich
funktioniert :-( aber vielleicht ist's ein ansatz]

[Ghanji]

in die richtung hab´ ich auch zuerst gedacht, aber das ist zu wenig variabel...

[gaspode]

wie variabel muß das ganze denn sein?
wie groß ist das feld (2d-array)?
ist seine größe vordefiniert?
in wie weit ändert sich der radius?
in wie weit willst du eine kreisform erreichen (von wegen radius),
denn so wie du es am anfang beschrieben hast, wird es mehr
und mehr zur raute werden?!

sprich: wie flexibel muß das ganze sein?

gruß, gaspode

[gaspode]

hab nochmal was gebastelt.

vielleicht eine etwas ungewöhnliche vorgehensweise ...
und sie funktioniert auch nur bedingt ...
aber vielleicht ein ansatz.

gruß, gaspode

[Ghanji]

hi gaspode, danke schonmal für die fla
ich schaus mir gerade an, glaube das hilft mir schon ein stück weiter.
danke dir,
ghanji

[rendner[i]]

Hmm, wenn Du die mc's attached, solltest Du den Namen der mc in ein Array speichern, damit hast Du immer vollen Zugriff auf die mc's (hat sich der André Michelle einfallen lassen).

//wenn du ein Feld mit 18x18 mc's hättest, die die grösse 20x20haben
MC_arr = new Array();
var deep = 0;
for(var i=0; i<18; i++){
	MC_arr[i] = new Array();
	for(var j=0; j<18; j++){
		MC_arr[i][j] = this.attachMovie("mc", "mc"+deep, deep++,{_x: i*20, _y: j*20});
	}
}

Somit brauchst Du dann auch nicht jeden MC manipulieren, sondern setzt alle auf _alpha = 0 (oder welchen Wert Du haben willst).
Und nur die Mc's die im Radius liegen, von denen änderst Du dann den Alpha-Wert (erhöhst ihn), ist besser als jeden ne "Prüfroutine" mitzugeben.
Am besten wäre wenn die Schrittgrösse deiner Figur (wieviel Pixel sie sich bewegt) so gross ist wie ein MC (Figur sollte dann immer mittig in dem MC stehen), somit brauchst Du keine for-Schleife durch das ganze Array.
Du speicherst einfach in 2 Variablen die momentane Position (wenn Deine Figur auf den Punkt (0,0) startet, also ganz links-oben, dann sind deine 2 Variablen posX=0 und posY=0), und jenachdem welche (Richtungs)Taste gedrückt wurde werden diese um eins vermindert oder erhöht.

Bsp.: Figur startet an Stelle (0,0) geht 3 "Schritte" nach rechts, posX ist jetzt 3 (posY noch 0), somit brauchst du bei einem Radius von 1 mc nur diese manipulieren:

MC_arr[posX][posY] //der wo deine Figur drauf steht
MC_arr[posX-1][posY]
MC_arr[posX+1][posY]
MC_arr[posX][posY-1]
MC_arr[posX][posY+1]

Spart einen haufen Rechenaufwand, vor allem wenns komplexer wird (keine for-Schleife und nicht jeder mc hat onRollover und onRollout).

[Ghanji]

ahoi rendner,
ja genau diesen ansatz habe ich jetzt auch verfolgt!
es geht tatsächlich um eine spielfigur, woher wusstest du das?
ist ein tilebased game, und alle felder im umkreis von x sollen zur mitte hin tranzparenter werden... genau.

PHP-Code:

moveSight = function () {
    var tileName;
    var radius = 3;
    var alphawert = 40;
    for (var i=radius; i>=0; i--) {
        for(var j=0; j<=radius-i; j++){
        tileName = "dayLight_mc"+(xTile+i)+"|"+(yTile-j);
        _root[tileName ]._alpha = alphawert;
        tileName = "dayLight_mc"+(xTile-i)+"|"+(yTile+j);
        _root[tileName ]._alpha = alphawert;
        tileName = "dayLight_mc"+(xTile+j)+"|"+(yTile+i);
        _root[tileName ]._alpha = alphawert;            
        tileName = "dayLight_mc"+(xTile-j)+"|"+(yTile-i);
        _root[tileName ]._alpha = alphawert;
            }
        alphawert-=5;
        trace("alphawert = "+alphawert);
    }
    tileName = "dayLight_mc"+(xTile)+"|"+(yTile); // alpha des aktuellen spielfigurfeldes auf 0 setzen
    _root[tileName ]._alpha = 0;
}; 


die x/y pos der figur ist bekannt, wie in deinem beispiel (bei mir xTile und yTile).

nuja, die richtigen felder bekomm ich schon, aber nicht in der richtigen reihenfolge...
Es sind halt nicht nur die direkt benachbarten felder, ich brauche eine funktion, die diese auch noch von aussen nach innen (oder vice versa) bestimmt.
die logik der schleife will nicht in meinen brett vorm kopp
ghanji

[rendner[i]]

Da bin ich etwas Überfragt, hab da ne Idee aber ob die funtzt weis ich nicht.
Ansonsten halt ein Ansatz .

Fängt von innen an den alphawert der mc's zu manipulieren.
Bei einem Radius von 3 , macht er alle im die genau imRadius 1 liegen, dann alle im Radius 2, ....

PHP-Code:

//hier "j = 1", weil Du auf der 0 stehst
for(var j = 1; j <= r; j++){
   alphaWert = (r - j) * 5;
   for(var i = j; i >= 0; i--){
      //obere mc's
      tileName = "dayLight_mc" + (xTile - i) + "|" + (yTile - j);
      _root[tileName]._alpha -= alphaWert;
      tileName = "dayLight_mc" + (xTile + i) + "|" + (yTile - j);
      _root[tileName]._alpha -= alphaWert;

      //untere mc's
      tileName = "dayLight_mc" + (xTile - i) + "|" + (yTile + j);
      _root[tileName]._alpha -= alphaWert;
      tileName = "dayLight_mc" + (xTile + i) + "|" + (yTile + j);
      _root[tileName]._alpha -= alphaWert;

      //linke mc's
      tileName = "dayLight_mc" + (xTile - j) + "|" + (yTile - i);
      _root[tileName]._alpha -= alphaWert;
      tileName = "dayLight_mc" + (xTile - j) + "|" + (yTile + i);
      _root[tileName]._alpha -= alphaWert;

      //rechte mc's
      tileName = "dayLight_mc" + (xTile + j) + "|" + (yTile - i);
      _root[tileName]._alpha -= alphaWert;
      tileName = "dayLight_mc" + (xTile + j) + "|" + (yTile + i);
      _root[tileName]._alpha -= alphaWert;
   }
}
tileName = "dayLight_mc"+(xTile)+"|"+(yTile);
_root[tileName ]._alpha = 0; 


Zumindest war das so mein Gedanke, ob das hier auch das macht weis ich nicht.

[rendner[i]]

Habs noch mal umgeschrieben, waren Denkfehler mit drin. Musste mal sagen wies funktioniert. Und um die anderen mc's wieder auf alpha 100 zu setzen würde ich ne switch-case-Anweisung schreiben, die abhängig von der gedrückten Taste ist.

PHP-Code:

//hier "j = 1", weil Du auf der 0 stehst 
for(var j = 1; j <= r; j++){ 
   alphaWert = (r - j) * 5; 
   //oben-rechts 
   set("dayLight_mc" + (xTile - j) + "|" + (yTile - j) + "._alpha", _alpha - alphawert);
   //oben-links 
   set("dayLight_mc" + (xTile - j) + "|" + (yTile + j) + "._alpha", _alpha - alphawert);
   //unten-links 
   set("dayLight_mc" + (xTile + j) + "|" + (yTile - j) + "._alpha", _alpha - alphawert);
   //unten-rechts 
   set("dayLight_mc" + (xTile + j) + "|" + (yTile + j) + "._alpha", _alpha - alphawert);
   //die mc’s zwischen den Eckpunkten 
   for(var i = 1; i <= (r * 2) – 1; i++){ 
      set("dayLight_mc" + (xTile – j + i) + "|" + (yTile - j) + "._alpha", _alpha - alphawert);
      set("dayLight_mc" + (xTile – j + i) + "|" + (yTile + j) + "._alpha", _alpha - alphawert);
      set("dayLight_mc" + (xTile + j) + "|" + (yTile – j +i) + "._alpha", _alpha - alphawert);
      set("dayLight_mc" + (xTile - j) + "|" + (yTile –j + i) + "._alpha", _alpha - alphawert);
   } 
}
set("dayLight_mc" + (xTile) + "|" + (yTile) + "._alpha", 0); 


PHP-Code:

set("dayLight_mc" + (xTile - j) + "|" + (yTile –j + i) + "._alpha", _alpha - alphawert); 


macht das gleiche wie:

PHP-Code:

tileName = "dayLight_mc" + (xTile – j) + "|" + (yTile - j + i); 
      _root[tileName]._alpha -= alphaWert; 


Sag einfach mal bescheid.

[Ghanji]

hallo rendner,
hab´ das jetzt so gelöst (ähnlich deinem ersten ansatz) und funktioniert wunderbar

PHP-Code:

function sight(radius){
    resetSight();
    changedSight = new Array();
    var alphawert=40;
    var tileName;
    var count=0;
    var faktor= alphawert/radius;
    for (var currRadius=radius; currRadius>=1; currRadius--){
    for(var count=0; count<=currRadius;count++){
        tileName = "dayLight_mc"+(xTile+currRadius-count)+"|"+(yTile-count);
        _root[tileName]._alpha = alphawert;
        changedSight.push(tileName);
        tileName = "dayLight_mc"+(xTile+currRadius-count)+"|"+(yTile+count);
        _root[tileName]._alpha = alphawert;
        changedSight.push(tileName);
        tileName = "dayLight_mc"+(xTile-currRadius+count)+"|"+(yTile+count);
        _root[tileName]._alpha = alphawert;
        changedSight.push(tileName);
        tileName = "dayLight_mc"+(xTile-currRadius+count)+"|"+(yTile-count);
        _root[tileName]._alpha = alphawert;
        changedSight.push(tileName);
        }
        alphawert-=faktor;
    }
    tileName = "dayLight_mc"+xTile+"|"+yTile;
    _root[tileName]._alpha = 0;
    changedSight.push(tileName);
};

function resetSight() {
   for (i=0;i<changedSight.length;i++) {
        _root[changedSight[i]]._alpha=40;
      } 
} ; 


danke für deine hilfe,
gruß,
ghanji

[rendner[i]]

Sieht nicht schlecht aus, aber bei Deiner Variante weist Du manchen mc's auch 2 mal den alphaWert zu (das Problem hatt ich nämlich auch bei meiner ersten Version festgestellt) is nicht so schlimm, könnte man aber noch optimieren.
Und bei Deiner Funktion resetSight(), änderst Du ja nur den alphaWert und die Teile bleiben drinn. Das heist ja, wenn Du dich ne weile in Deinem Spiel bewegst, das Du irgendwann vielleicht mal alle Teile da 3x drinne hast.
Besser wäre da:

PHP-Code:

function resetSight() {
    var i;
    while(changedSight.length){
        //entfernt das erste Element im Array
        i = changedSight.shift();
        i._alpha = 40; 
    }
} 


Weis nicht ob das funtzt, aber auf jeden Fall must Du die mc's da wieder austragen!

EDIT:
Hab gerade gesehen, das Du das Array ja immer neu anlegst, so kann mans auch machen .

[Ghanji]

ich dacht ich initialisier das array einfach jedes mal neu mit
changedSight = new Array();
damit es nicht volläuft.

das prob mit der doppelten aplhawertzuweisung muss ich mir nochmal anschauen, ist natürlich performancetechnisch ungünstig

Edit: grad erst deinen edit gesehen *glglgl*