[C#] variabele in een andere klasse gebruiken

[V1ncam]

Hallo,

sorry als ik de vorige keer te kort door de bocht ging, ik zal dit keer mijn best te doen om een zo duidelijk mogelijke vraag op te stellen.

Het is trouwens in XNA game studio 3.1

Ik heb een klasse speler:

C#:

 class Speler
{
    public Texture2D sprite;
    public Vector2 positie, snelheid, scherm;
    private int xPositie;

    public Speler(Texture2D geladenSprite, Vector2 s, Keys tu, Keys td)
    {
        this.sprite = geladenSprite;
        this.scherm = s;
        this.positie.Y = (s.Y/2) - (this.sprite.Height/2);
    }

    public void Update(GameTime gameTime, int xPositie)
    {
        
        Vector2 vorigePositie = positie;
        positie += snelheid;

        positie = new Vector2((float)Math.Round(positie.Y));

        this.positie.X = xPositie;
        this.positie.Y = MathHelper.Clamp(this.positie.Y, 0.0f, this.scherm.Y - this.sprite.Height);
    }
}

Ook heb ik de klasse Bal:

C#:

class Bal
{
    private Texture2D sprite;
    private Vector2 positie, snelheid, scherm;

    public Rectangle box
    {
        get
        {
            return new Rectangle((int)(Speler.positie.X),
              (int)(Speler.positie.Y),
              Speler.sprite.Width,
              Speler.sprite.Height);
        }
    }

    public bool botsing (Rectangle box)
    {
        float straal = Math.Max(sprite.Width / 2, sprite.Height / 2) / 2;

        Vector2 dichtstbij = new Vector2(MathHelper.Clamp(middelPunt.X, box.Left, box.Right),
              MathHelper.Clamp(middelPunt.Y, box.Top, box.Bottom));
              
        float afstand = (dichtstbij - middelPunt).Length();
              
        return afstand < straal;
    }

    public void Update(GameTime gameTime)
    {

        if (botsing(box) == true)
        {
            this.snelheid.X *= -1;
            this.snelheid.Y *= -1;
        }
}

UIteraard kan ik box niet maken omdat hij helemaal geen idee heeft van de positie van Speler. Nu zullen jullie zeggen als je die box wilt, zet dan heel die public Rectangle box in klasse Speler, maar dat kan niet want dan moet ik aan public void Update een parameter meegeven, dat moet dan ook waar ik hem update, maar Update kan maar 1 parameter meegeven.

C#:

protected override void Update(GameTime gameTime, hier zou ik Rectangle box moeten plaatsen)
    {
        this.rodeSpeler.Update(gameTime, 785);
        this.blauweSpeler.Update(gameTime, 0);
        this.bal.Update(gameTime);
    }

Mijn vraag is dus hoe kan ik Speler positie en Speler sprite gebruiken in de Klasse bal.

Ik hoop dat het zo duidelijk is, bij voorbaat dank.

[whoami]

Waarom wil je dat de bal weet waar de speler is ? Dat is IMHO niet de verantwoordelijkheid van de bal.

Wat je wel kan doen, is die 'Botsing' method gaan aanpassen; daar voeg je een parameter 'speler' aan toe, zodanig dat de bal kan weten of hij botst met een gegeven speler. (Althans, ik denk dat je dat wilt bekomen ? )

[Grijze Vos]

Je wilt alle objecten die kunnen botsen een interface laten implementeren die een functie heeft die de bounding box terug geeft. Dan kun je in je update loop bekijken of objecten botsen op tijd X en hoe je daarmee omgaat.

[Davio]

Ik vind je benadering verkeerd.

Je wilt een interactie tussen 2 klasses implementeren in één van de klasses, ik denk dat je daarvoor beter een extra (overkoepelende) klasse kunt toevoegen.

Maak je gewoon een klasse Botsing met daarin als objecten Spelers en een Bal.

[Haan]

Davio schreef op dinsdag 28 september 2010 @ 15:56:
Ik vind je benadering verkeerd.

Je wilt een interactie tussen 2 klasses implementeren in één van de klasses, ik denk dat je daarvoor beter een extra (overkoepelende) klasse kunt toevoegen.

Maak je gewoon een klasse Botsing met daarin als objecten Spelers en een Bal.

Of een Botsing class nou zo'n goed idee is weet ik niet. Ik ben niet zo'n game-expert, maar volgens mij heb je inderdaad wel een overkoepelende class 'World' o.i.d. nodig, die de state van alle objecten (classes) in die wereld regelt.

[whoami]

Davio schreef op dinsdag 28 september 2010 @ 15:56:
Ik vind je benadering verkeerd.

Je wilt een interactie tussen 2 klasses implementeren in één van de klasses, ik denk dat je daarvoor beter een extra (overkoepelende) klasse kunt toevoegen.

Maak je gewoon een klasse Botsing met daarin als objecten Spelers en een Bal.

Lijkt me ook geen goed idee, aangezien 'Botsing' eerder een gebeurtenis is, dan een object.

[Davio]

whoami schreef op dinsdag 28 september 2010 @ 16:24:
[...]

Lijkt me ook geen goed idee, aangezien 'Botsing' eerder een gebeurtenis is, dan een object.

Ja, ik besefte me dat Botsing niet echt goed gekozen was, maar kon zo snel even niets beters verzinnen. Neem maar gewoon World.

[TJHeuvel]

Of in het geval van XNA kan je ook gewoon je Game klasse gebruiken, in de Update roep je eerst de Update's van Speler en Bal aan, en kan je daarna andere logica toepassen.

[stoofpeer]

Ik denk dat als je een botsing wilt detecteren je een klasse gameMethods ofzo moet maken, dan geef je twee objecten mee. Een bal en een speler object. Hierin vergelijkt hij de posities, en wanneer er een collision is geef je true terug of je rased een event.

Maar XNA is een game georiënteerd framework. Lijkt me raar dat ze standaard geen collision detection methoden mee geven?

[BikkelZ]

Je moet inderdaad je collision detection op het zelfde niveau implementeren als je nu al die update routines aanspreekt. Dus je update de posities, en daarna ga je kijken of er een collision optreedt. Overigens lijkt het me heel sterk dat collision detection wat een Commodore 64 al standaard kon opeens bij een super de luxe ontwikkelomgeving als XNA zou ontbreken.

Wil je het toch op jouw manier 'softwarematig' oplossen, moet je een interface die je bijvoorbeeld ICollidable noemt implementeren die een bool DoesCollide(ICollidable otherObject) afdwingt, die er ongeveer zo uit kunnen zien als je nu botsing geschreven hebt. (overigens zou je botsing HeeftBotsing moeten noemen, of nog beter: HasCollision)

[ Voor 32% gewijzigd door BikkelZ op 29-09-2010 10:25 ]

[roy-t]

Je moet je collision sowieso opbreken in meerdere stukken.

Geef ieder object wat een fysieke representatie heeft een interface zoals dit

C#:

public interface IPhysicsObject
{
      Rectangle GetBoundingBox();  //Beter doe je dit allemaal met properties maar zo snap je iig wat ik bedoel
      Vector2 GetDirection();
      float GetSpeed();
      int GetMass():
}

Maak dan een manager class die alle physics objecten in een lijst heeft opgeslagen.

Eens per update check je alle objecten (via boundingBox.Contains(...), dit is echter een O(n^2) operatie als je naief implementeert, beter kun je iets als spatialpartitioning toepassen om niet alles tegen alles te hoeven checken).

Voor elk object dat een collide met een ander object stop je de volgende struct in een nieuwe lijst:

C#:

public struct Collision
{
    public IPhysicsObject a, b;
}

Nu heb je het collision detection gedeelte gedaan.

Hiernaa ga je de hele lijst met door waar alle collisions in staan en resolve je ze 1 voor 1. Dit is het lastigste gedeelte en hier komt veel natuurkunde bij kijken, dit is het collision response gedeelte.


Je kunt natuurlijk ook gewoon FarseerPhysics gebruiken (gratis), waar ik zelfs hier een tutorial voor XNA over heb geschreven.


Edit: overigens leuk om nog een XNA-er te zien hier op tweakers.net, kom ook eens langs op #xna op Efnet (irc). Verder zou ik als ik jou was even een modje schoppen (handje naast je topic) om de titel van het topic te laten veranderen, want die dekt de lading absoluut niet.

[ Voor 9% gewijzigd door roy-t op 29-09-2010 10:34 ]

[R4gnax]

whoami schreef op dinsdag 28 september 2010 @ 16:24:
[...]

Lijkt me ook geen goed idee, aangezien 'Botsing' eerder een gebeurtenis is, dan een object.

Lijkt mij eerlijk gezegd wel een goed idee. Waar dacht je dat bijv. de IComparer en IEqualityComparer classes voor zijn? Deze zijn net heel handig om een comparison functie extern van een klasse te houden en bijv. bij factory patronen te injecteren via de constructor. Met name handig wanneer een comparison niet-triviaal of afwijkend v/d standaard is. (Kijk maar eens naar de constructors van Dictionary<TKey, TValue>...)

Juist daarom zou ik hier expliciet niet kiezen om een ICollidable interface te definiëren. Collision detection is namelijk niet zo eenvoudig onder één algemene aanpak te vangen en moet daarnaast vaak op verschillende vormen van bounding structure kunnen werken. (Bounding sphere, bounding box, bounding box tree, bounding polygon, etc.)

Je zit dus altijd vast aan het opzetten van speciale scenarios. Bij uitstek het domein voor een generieke ICollisionComparer<TFirst,TSecond> interface en klasse-specifieke implementaties:

C#:

public interface ICollisionComparer<TFirst, TSecond>
{
  bool Collides(TFirst first, TSecond second);
}

Wil je ook de mate van penetratie weten (wat wèl een terugkerende factor voor veel collision detection methodes is), dan kun je ook een uitgebreidere interface definiëren:

C#:

public interface IPenetrationComparer<TFirst, TSecond> : ICollisionComparer<TFirst, TSecond>
{
  bool Collides(TFirst first, TSecond second);
  Vector2 MeasurePenetration(TFirst first, TSecond second);
}

Daarbij hoeft de Collides() method niets anders te doen dan te kijken of de lengte v/d Vector2 die terug komt uit MeasurePenetration(), groter dan 0 is.

[ Voor 17% gewijzigd door R4gnax op 29-09-2010 11:40 ]

[V1ncam]

Sorry voor de late reactie,

ik heb opgelost door inderdaad niet de bal de botsing te laten detecteren, maar de klasse waarin de klasse bal en speler aangemaakt worden, de botsing heb ik gedetecteerd met de methode rectangle.intersect de rest was daarna niet meer zo moeilijk, bedankt!