[C#] Vijanden in game laten schieten

[WernerL]

Hallo mensen,

Moet op school een duffe game programmeren, enkel lukt het me niet helemaal.
Ik heb 2 classes, 1 voor de vijand, 1 voor kogel..

Vijand class overruled de class picturebox dus ik kan niet zomaar een instantie van bullet aanmaken in de class vijand en hem laten bewegen. Ik zou het toevoegen aan het formulier en het bewegen van de kogel in deze situatie in de game class moeten afhandelen. Maar kan dit niet netter ? Dat ik het schieten helemaal afhandel in de class vijand ?

Het is verder gewoon een 2d game met picturebox-en als game objecten. :-)

kogel is dus ook een picturebox en wil deze bijv om de seconden 1 in beeld hebben en naar beneden laten bewegen. (nee zit geen briljante AI in de game. )

Vraag mezelf alleen af hoe ik dit netjes OOP kan doen. Hoe zouden jullie dit doen ? :-)

[BtM909]

Een huiswerkvraag en dan ook nog geen enkele regel code?

Geef even netjes aan (met relevante code) hoe je het hebt opgezet, wat je waar wilt gebruiken, welke zoekopdrachten je hebt uitgevoerd en waarom eventuele gevonden oplossingen niet wenselijk waren

[WernerL]

Ok ik heb het zo gedaan..

In de gameclass maak ik in een timer event elke 1 seconde een vijand aan. De vijand verplaatst zich van boven naar beneden (via een timer in de class vijand zelf), alle vijanden gooi ik in een ArrayList. Nu heb ik in de gameclass zelf ook nog een speler welke ik kan verplaatsen met pijltjestoetsen, en ik kan schieten. Vliegtuigen kan ik uit de lucht knallen, zover werkt het al.

Nu heb ik ook nog een class vijand en kogel. Ik wil dat de vijand naast het verplaatsen naar beneden ook nog kogels schiet, de vijand moet dus ook nog om de zoveel seconden een instantie van de kogel aanmaken, en doe dit het liefst in de class vijand en niet in de gameclass.

Totnutoe ziet mijn class er zo uit:

C#:

class vijand : PictureBox {

public vijand (int x, int y) { // x en y voor positie }
private void timer_tick() { // hier beweeg ik vijand }
public void isCollision (PictureBox speler) { // controlleren of vijand de speler raakt, deze method roep ik vanuit de gameclass}
public void shoot() { //deze method weet ik niet hoe ik die moet vullen. 
Hier wil ik namelijk nieuwe instanties maken van de class kogel, en deze moeten bewegen. 
Maar weet niet hoeik dat moet doen zonder code toe te voegen aan gameclass }

}

class is beetje lang om helemaal te posten. :-)
maar zo is mijn class dus. shoot() kan ik dan wel aanroepen in een timer maar ik weet niet hoe de code er daarin uit moet komen te zien. bullet kogel = new bullet(); zal niet gaan gok ik. Of ik moet de return waarde op bullet zetten en alles afhandelen in gameclass.

Hoop dat ik niet te wazig ben.

//edit
heel simpel gezegd wil ik vanuit een class iets op het formulier zetten EN kunnen bewegen. En niet 1 maar meerdere keren achter elkaar. :-)

[ Voor 4% gewijzigd door WernerL op 26-09-2008 10:50 ]

[martijnve]

Volgens mij ben je het jezelf door makkelijk te willen doen veel te moeilijk aan het maken
Als je die classes gewoon eens niet afleidt van picture box maar gewoon een nieuw object maakt, vervolgens maak je een grote picturebox (of iets waar je op kunt tekenen iig) waar je alle classes zichzelf elke frame op laat tekenen. op deze manier heb je veel meer flexibiliteit.

Als je het helemaal leuk wilt doen kun je alles afleiden van een abstracte classe GameObject en dan kun je alle objecten in een array gameobjecten bewaren, en elke frame met een loop alle gameobjecten een tick() geven. als iemand dan schiet kan hij gewoon een kogel aan de array van gameobjecten toevoegen, en klaar is kees.

[ Voor 30% gewijzigd door martijnve op 26-09-2008 10:55 ]

[WernerL]

Dat kan idd ook, en dat zou mezelf vast wel gaan lukken als ik de tijd had.
Het probleem is alleen dat we op school nog niet zover gevorderd zijn en de leraar wil dat we alles met pictureboxen doen. :-) En het is niet dat ik de tijd heb om opnieuw te beginnen.

[TJHeuvel]

Ik denk dat je het beter zo kan opzetten.

C#:

void Load() //Form laad method
{
    Picturebox.onPaint += new Draw();
}

void Draw()
{
    foreach(GameObject gObj in gObjects)
    {
        gObj.Draw(Picturebox.Graphics);
    }

 Picturebox.Invalidate();
}

class GameObject
{
    abstract void Draw(Graphics Graph);
}

Al je game objecten worden dus inherit door GameObject.
Vijand class zou er dus zo uit kunnen zien:

C#:

class Vijand : GameObject
{
   public Point Position;   

   public Vijand(int X, int Y)
   {
       Position = new Point(X,Y);
   }

   public override void Draw(Graphics g)
   {
       g.fillEclipse(Brushes.Red, new Rectangle(Position.X,Position.Y, 20,20));
   }

}

Dit laat een rode stip zien op de Position.
Alles uit m'n hoofd, dus het werkt waarsch niet gelijk.

[remyblok]

Naar mijn idee is zodra de vijand de kogel heeft geschoten, de kogel een onderdeel van de game en niet meer van de vijand. De Shoot() zou de game moeten moeten vertellen dat er een kogel geschoten is, de game kan dan verder het gedoe (instancieren etc) met de kogel afhanden. Dus ik zie het probeem niet om de game-klasse verder uit te breiden.

[TJHeuvel]

remyblok schreef op vrijdag 26 september 2008 @ 11:03:
Naar mijn idee is zodra de vijand de kogel heeft geschoten, de kogel een onderdeel van de game en niet meer van de vijand. De Shoot() zou de game moeten moeten vertellen dat er een kogel geschoten is, de game kan dan verder het gedoe (instancieren etc) met de kogel afhanden. Dus ik zie het probeem niet om de game-klasse verder uit te breiden.

Dat is niet helemaal waar, want als die kogel iemand raakt wil je misschien wel weten wie hem geschoten heeft. Om zo scores te bepalen.

[remyblok]

True, maar dat zou dan een eigenschap van de kogel kunnen zijn. De game weet wie de kogel heeft afgeschoten en kan zodoende de propery juist zetten op de vijand. Of de vijand maakt alsnog de instalntie en geeft zichzelf mee aan de kogel en geeft de instantie van de kogel aan de game.

[TJHeuvel]

Kan, maar je kan ook alle vijanden een Array van kogels meegeven.

't is hoe je het zelf wilt.

[roy-t]

Je kan beter met een soort van event structuur gaan werken, 1 globale timer die elke 15ms ticked (60FPS) en dan objecten die op dit timer event reageren en hun eigen afhandeling hieraan geven.

Verder kun je de kogel denk ik het beste helemaal los maken van alles, met gewoon een ref naar de speler die schoot. Zo heeft de kogel een eigen behaviour. Door een collision check vanuit de game (zo check je in 1x alles) kan de kogel een event gestuurd wordne met als argument wat hij raakt. Dan kan hij naar aanleiding van zijn eigen stats dat object bewerken (Obj.health -= 10) Ook kan de kogel zelf dan checken of de persoon dood gaat die geraakt is en dan weer een event triggeren waardoor de scores juist uitgedeeld kunnen worden, of direct de persoon uit zijn ref een hogere score geven. (Ligt een beetje aan de manier waarop je dat op zet).

edit: die structuur heet vaak een messaging structuur, een beetje zoeken op indie gamedeveloper websites zal je ook een stuk helpen, of kijk alvast is naar XNA, wat speciaal gemaakt is om games te maken voor C# (een spritebacht is imho niet moeilijker dan een picturebox tekenen) en daar zijn ook veel tutorials over dit soort problemen. Link: http://www.creators.xna.com

[ Voor 18% gewijzigd door roy-t op 26-09-2008 11:20 ]

[WernerL]

Dat ga ik straks zo eens proberen uit te werken roy-t !
Klinkt briljant iig. :-)

Nu heb ik echt een kogel die bij speler hoort, en een kogel die bij vijand hoort. Beetje erg krom...
Ze hebben beide ook een aparte sprite vandaar, maar dat moet wel op te lossen zijn.
Ga straks verder prutsen.

[roy-t]

WernerL schreef op vrijdag 26 september 2008 @ 11:20:
Dat ga ik straks zo eens proberen uit te werken roy-t !
Klinkt briljant iig. :-)

Nu heb ik echt een kogel die bij speler hoort, en een kogel die bij vijand hoort. Beetje erg krom...
Ze hebben beide ook een aparte sprite vandaar, maar dat moet wel op te lossen zijn.
Ga straks verder prutsen.

Die apparte sprite kun je wel oplossen door ze af te vuren van zeg maar een ander soort geweer, die wat properties zet op de sprite en die dan pas de kogel overgeeft aan de game.

[TJHeuvel]

Gdi gaat nogal flickeren als je veel frames per second hebt.

Dit kan je (gedeeltelijk) tegengaan door Control.Setstyle, en het tekenen naar een 'backbuffer'.

Een backbuffer eigenlijk gewoon een nieuwe Image waar je op tekent, en als je daar klaar mee bent deze image op de Picturebox plakken.

[Janoz]

CyCloneNL schreef op vrijdag 26 september 2008 @ 11:16:
Kan, maar je kan ook alle vijanden een Array van kogels meegeven.

't is hoe je het zelf wilt.

Wat maakt een kogel van vijand X anders dan de kogel van vijand Y? Voor de game logic (collision detection en verplaatsing) lijkt het me juist veel meer voor de hand liggen dat er in het game object 1 lijst van kogels bestaat waar doorheen geïtereerd kan worden.

[ Voor 3% gewijzigd door Janoz op 26-09-2008 11:44 ]

[Woy]

Janoz schreef op vrijdag 26 september 2008 @ 11:44:
[...]
Wat maakt een kogel van vijand X anders dan de kogel van vijand Y? Voor de game logic (collision detection en verplaatsing) lijkt het me juist veel meer voor de hand liggen dat er in het game object 1 lijst van kogels bestaat waar doorheen geïtereerd kan worden.

Ik zou het nog wat algemener doen en gewoon een lijst van GameObjecten bijhouden. Elk GameObject heeft dan een Draw en een Update methode.

je krijgt dan dit idee

C#:

public class Game
{
    private List<IGameObject> objects;
    private void GameLoop()
    {
        while(Running)
        {
            UpdateGameTime();
            foreach (IGameObject gameObject in objects)
            {
                gameObject.Update(currentGameTime);
            }
            foreach (IGameObject gameObject in objects)
            {
                gameObject.Draw(drawContext);
            }
        }
    }

    public bool Running {
        get;
        set;
    }
}

public interface IGameObject
{
    void Draw(DrawContext context);
    void Update(GameTime time);
}
public class Vijand : IGameObject
{
    private readonly Game game;

    public Vijand(Game game)
    {
        this.game = game;
    }

    public void Draw(DrawContext context)
    {
        context.Draw(sprite, location);
    }

    public void Update(GameTime time)
    {
        if(buttonDown)
        {
            game.AddObject(new Kogel(game));
        }
    }
}

public class Kogel : IGameObject
{
    private readonly Game game;

    public Kogel(Game game)
    {
        this.game = game;
    }

    public void Draw(DrawContext context)
    {
        context.Draw(sprite, location);
    }

    public void Update(GameTime time)
    {
        position += direction * speed * time;
    }
}

[ Voor 23% gewijzigd door Woy op 26-09-2008 12:02 ]

[Janoz]

Uiteraard, helemaal met je eens. Ik ging echter alleen even in op het 'waar sla ik de kogels op'-issue.

[Woy]

Janoz schreef op vrijdag 26 september 2008 @ 12:01:
Uiteraard, helemaal met je eens. Ik ging echter alleen even in op het 'waar sla ik de kogels op'-issue.

Ok ik dacht dat je bedoelde een aparte lijst kogels bij te houden.

[roy-t]

Dit wordt langzaam SEA ipv prog . Wel leuk om weer is een gamedesign vraag te zien op tweakers.

[TJHeuvel]

roy-t schreef op vrijdag 26 september 2008 @ 12:21:
Dit wordt langzaam SEA ipv prog . Wel leuk om weer is een gamedesign vraag te zien op tweakers.

SEA? Sea Education Association?

[Creepy]

SEA: Software Engineering & Architecture

[TJHeuvel]

Oh, ik begon al naar Nintendocore dingen te zoeken

[Janoz]

rwb schreef op vrijdag 26 september 2008 @ 12:04:
[...]

Ok ik dacht dat je bedoelde een aparte lijst kogels bij te houden.

Op zich is daar nog wel iets voor te zeggen (wanneer het afhandelen van kogels te veel afwijkt van de rest), maar waar mijn posting vooral over ging was dat je die lijst met kogels zeker niet in het vijand object moet bijhouden.

[Woy]

Janoz schreef op vrijdag 26 september 2008 @ 12:47:
[...]


Op zich is daar nog wel iets voor te zeggen (wanneer het afhandelen van kogels te veel afwijkt van de rest), maar waar mijn posting vooral over ging was dat je die lijst met kogels zeker niet in het vijand object moet bijhouden.

Nee die zou hooguit een lijst met kogels die nog niet afgeschoten zijn bij moeten houden