flash hittest

if (_root.racerbil.hittest(_root.vejkant))
    STOOOOP!!!
end if

....noget i den retning :)

....ja, noget i den retning ;)

her er et hurtigt eksempel på noget lignende:

onClipEvent (load) {
xspeed = 4;
}
onClipEvent (enterFrame) {
this._x += xSpeed
if (this.hitTest(_root.box)) {
xSpeed = 0;
}
}

her defineres vel at mærke kun en retning på x-aksen, box er banden (vejkanten).

det virker ikke, kan i ikke lave en fla.fil? jeg kan godt smide point oven i, hvis i vil have det.

Send din fla til mig, så sætter jeg gerne actionen på
mvh geo

geo@lingoman.dk

http://www.gizom.com/flash/col_detect.fla
Det er MAT\'s kode og biler kommer også som sedan model:)

Her er et lille pingpong/squash-spil som basicly kun benytter hittest-metoden:

http://www.mallernet.subnet.dk/hitTestpingpong.fla

detsværre. det er ikke hvad jeg leder efter

Nej, jeg regnede heller ikke med at du ville have et pingpongspil, når du snakker om et racerspil ;)

Det var ligesom meningen at du skulle pille den kodedel ud du kunne bruge, eller bruge den til at se hvordan hitTest kan bruges.

Blev du tilfred med hittestet jeg sendte dig ?
mvh geo

You\'ve got mail...

Ny udgave med aktioner der ikke kun tjekker for hitTest med vægge men også styrer bilen
mvh geo

lingoman> øv øv jeg ville da også gerne se hvad du fik udarbejdet?
willi@gizom.com

Jeg kopi-paster vægMC og racerMC actionerne her hvis e-man ikke har noget imod det

//////////////////////////////////////// racer MC (auto) Action ////////////////////////////////////////////////////////////

onClipEvent (load) {
    this.disableFrontLeft = 0;
    this.disableFrontRight = 0;
    this.disableRearLeft = 0;
    this.disableRearRight = 0;
}
onClipEvent (enterFrame) {
    FrontL = new Object();
    FrontL.x = -50;
    FrontL.y = -125;
    FrontR = new Object();
    FrontR.x = 50;
    FrontR.y = -125;
    RearL = new Object();
    RearL.x = -50;
    RearL.y = 125;
    RearR = new Object();
    RearR.x = 50;
    RearR.y = 125;
    this.localToGlobal(FrontL);
    this.localToGlobal(FrontR);
    this.localToGlobal(RearL);
    this.localToGlobal(RearR);
    // trace (\" _root.z= \"+_root.z);
    // Disable Forward Motion
    if (_root.z>0 && (disableFrontLeft || disableFrontRight)) {
        _root.z = 0;
    }
    // Disable Backward Motion
    if ((_root.z<0) && (disableRearLeft || disableRearRight)) {
        _root.z = 0;
    }
    // Forward LEFT Turn
    if (Key.isDown(Key.LEFT) && Key.isDown(Key.UP) && (disableFrontLeft == 0)) {
        // trace (\"Forward LEFT Turn\");
        this._rotation -= 2.6;
    }
    // Forward RIGHT turn
    if (Key.isDown(Key.RIGHT) && Key.isDown(Key.UP) && (disableFrontRight == 0)) {
        // trace (\"Forward RIGHT turn\");
        this._rotation += 2.6;
    }
    // turn Left while Forward Motion
    if (Key.isDown(Key.LEFT) && _root.z>0.1 && (!Key.isDown(Key.UP)) && (!Key.isDown(Key.DOWN))) {
        // trace (\"turn Left while Forward Motion\");
        this._rotation -= 2.6;
    }
    // turn Right while Forward Motion
    if (Key.isDown(Key.RIGHT) && _root.z>0.1 && (!Key.isDown(Key.UP)) && (!Key.isDown(Key.DOWN))) {
        this._rotation += 2.6;
        // trace (\"turn Right while Forward Motion\");
    }
    // Reverse LEFT turn
    if (Key.isDown(Key.LEFT) && Key.isDown(Key.DOWN) && (disableRearLeft == 0)) {
        this._rotation += 2.6;
        // trace (\"Reverse LEFT turn\");
    }
    // Reverse RIGHT turn
    if (Key.isDown(Key.RIGHT) && Key.isDown(Key.DOWN) && (disableRearRight == 0)) {
        this._rotation -= 2.6;
        // trace (\"Reverse RIGHT turn\");
    }
    // Forward Constant Speed
    if (Key.isDown(Key.UP) && (disableFrontLeft == 0) && (disableFrontRight == 0)) {
        this._y -= (Math.cos(Math.PI/180*this._rotation))*_root.z;
        this._x += (Math.sin(Math.PI/180*this._rotation))*_root.z;
        // trace (\"Forward Constant Speed Z = \"+_root.z);
    }
    // Reverse Constant Speed
    if (Key.isDown(Key.DOWN) && (disableRearLeft == 0) && (disableRearRight == 0)) {
        this._y -= Math.cos(Math.PI/180*this._rotation)*_root.z;
        this._x += Math.sin(Math.PI/180*this._rotation)*_root.z;
        // trace (\"Reverse Constant Speed Z = \"+_root.z);
    }
    // Speed UP
    if (Key.isDown(Key.UP) && !(Key.isDown(Key.DOWN)) && _root.z>-2 && _root.z<3 && !(disableFrontLeft || disableFrontRight)) {
        // accelerate
        if ((disableRearLeft || disableRearRight) && (_root.z<0)) {
            _root.z = 0;
        }
        _root.z += 0.08;
        //trace (\"Speed UP Z = \"+_root.z);
    }
    // Slow DOWN
    // decelerate
    if (Key.isDown(Key.DOWN) && !(Key.isDown(Key.UP)) && _root.z>-2 && _root.z<3 && !(disableRearLeft || disableRearRight)) {
        if ((disableFrontLeft || disableFrontRight) && (_root.z>0)) {
            _root.z = 0;
        }
        _root.z -= 0.08;
        // trace (\"decelerate Z = \"+_root.z);
    }
    // cruising forward, slow down, keys released
    if ((_root.z>0.1) && (!Key.isDown(Key.UP)) && (!Key.isDown(Key.DOWN)) && !(disableFrontLeft || disableFrontRight)) {
        this._y -= (Math.cos(Math.PI/180*this._rotation))*_root.z;
        this._x += (Math.sin(Math.PI/180*this._rotation))*_root.z;
        _root.z -= 0.04;
        //trace (\"cruising forward, slow down, keys released Z = \"+_root.z);
    }
    // cruising backward, slow down,keys released
    if ((_root.z<-0.1) && (!Key.isDown(Key.UP)) && (!Key.isDown(Key.DOWN)) && !(disableRearLeft || disableRearRight)) {
        this._y -= (Math.cos(Math.PI/180*this._rotation))*_root.z;
        this._x += (Math.sin(Math.PI/180*this._rotation))*_root.z;
        // trace (\"cruising backward, slow down,keys released Z = \"+_root.z);
        _root.z += 0.04;
    }
    // Halt Forward Motion
    if ((_root.z<0.08) && (!Key.isDown(Key.UP)) && (!Key.isDown(Key.DOWN)) && _root.z>=0) {
        _root.z = 0;
        // trace (\"Halt forward Motion Z = \"+_root.z);
    }
    // Halt Reverse Motion
    if ((_root.z>-0.08) && (!Key.isDown(Key.UP)) && (!Key.isDown(Key.DOWN)) && _root.z<=0) {
        _root.z = 0;
        // trace (\"Halt backward Motion\");
    }
    // Reduce Motion
    if (Key.isDown(Key.UP) && (Key.isDown(Key.DOWN))) {
        _root.z /= 1.1;
        // trace (\"Reduce Motion\");
    }


/////////////////////////////// væg MC Action ///////////////////////////////////////////////////////

onClipEvent (enterFrame) {
    // Check if any of the points FrontL, FrontR, RearL, RearR of the car are inside the visible region of the walls
    // Her testes om bilens 4 hjørner rammer vægen. hvis du gerne vil have flere punkter testet behøver du kun at specificere disse i racer MC
    FrontLeftHit = this.hitTest(_root.auto.FrontL.x, _root.auto.FrontL.y, true);
    FrontRightHit = this.hitTest(_root.auto.FrontR.x, _root.auto.FrontR.y, true);
    RearLeftHit = this.hitTest(_root.auto.RearL.x, _root.auto.RearL.y, true);
    RearRightHit = this.hitTest(_root.auto.RearR.x, _root.auto.RearR.y, true);
    _root.auto.disableFrontLeft = FrontLeftHit;
    _root.auto.disableFrontRight = FrontRightHit;
    _root.auto.disableRearLeft = RearLeftHit;
    _root.auto.disableRearRight = RearRightHit;
}

////////////////////////////////////////////////////////////////////////////////////////////////7

du kan paste lisså tosset du vil! vi er jo til for at hjælpe hinanden.

e-man >> Nu har lingoman givet dig kilden, men hvis du er interesseret i hvordan koden bag racerbilens fungerer, så kommer der en kort forklaring her (der er sikkert også andre, som er interesserede):

Når vi bruger hhv. venstre og højre piletast, så roterer vi bilen omkring dens registreringspunkt. Dette gør vi ganske simpelt ved enten at lægge en værdi til bilens rotation (_rotation) eller trække den fra. Når vi så bruger piletasterne op og ned, så ønsker vi at enten at sætte bilens hastighed op (accelere positivt ved pil op) eller sætte bilens hastighed ned (accelere negativt ved pil ned). Husk her på, at acceleration blot er en ændring i hastighed. Problemet er så, hvordan vi får bilen til at accelere i den retning, som den peger.

For at løse dette problem, bliver vi nødt til at kigge på lidt grundlæggende geometri. Vi betragter en retvinklet trekant, hvor trekantens lodrette katete kaldes y og den vandrette kaldes x (grunden til dette kommer vi til senere). Hypotenusen kalder vi for a, og den er så den værdi, vi ønsker at accelerere med. Vinklen mellem hypotenusen og x er vores rotation. I Flash kan vi ikke blot fortælle programmet, at vi peger i en vis retning (vores rotation) og ønsker at accelere så og så meget. I stedet har vi et koordinatsystem med en x-akse og en y-akse, og vi bliver så nødt til at fortælle programmet, hvor meget vi ønsker at accelerere med i vandret plan (x) og lodret plan (y). Ifølge definitionen på cosinus gælder der følgende:

cos(x) = x/a

Vi ønsker at beregne, hvor meget vi skal lægge til den vandrette hastighed (x), så vi isolerer x:

x = a*cos(x)

Vi gør så det samme for den lodrette hastighed (y) ved at bruge definitionen for sinus:

sin(x) = y/a          <=>

y = a*sin(x)

Værdien af x skal så lægges til den vandrette hastighed, mens y skal lægges til den lodrette hastighed (hvis a > 0 betyder det, at vi sætter hastighed op og accelerer dermed). Da en bil i virkeligheden vil stoppe før eller siden som følge af friktionen (f.eks. gnidningen mellem bilen og underlaget, luftmodstanden og bilens bevægelige dele), vil det være bedst, hvis vi også gør det her. I Flash kan vi illustrere friktionen ved at gange hastigheden med en eller anden værdi, der er mindre end 0 (dermed bliver hastigheden hele tiden mindre og mindre, hvis vi lader være med at lægge noget til den, og vi vil stoppe, når hastigheden er 0).

Mvh Morten

gotcha>>
Selve styring af bilen er e-man\'s kode. Jeg har kun tilføjet hitTest() og resultaternes inflydelse på tilladte styreretninger ;)
mvh geo

Fint nok, jeg ville bare uddybe koden, for jeg bryder mig ikke selv om at få leveret noget kode, uden at der følger en forklaring med :)