Kies een kaart

Introductie

Een subroutine lijkt op een functie: het is een zwarte doos die we kunnen gebruiken. Het berekent echter niets. We gebruiken het meestal om dingen samen te stellen die we later willen hergebruiken, of wanneer we gewoon onze code beter willen organiseren. Net zoals je een boek organiseert in hoofdstukken, en hoofdstukken in paragrafen. Een subroutine kan andere subroutines aanroepen (gebruiken).

Op deze manier voorkomen we dat programma's te groot en onleesbaar worden als we meer code toevoegen. De vuistregel is dat de code op één scherm moet passen en anders moet het worden gescheiden in een subroutine of functie.

Als we naar alle subroutines (en functies) in een programma kijken, kunnen we een zogenaamd aanroepdiagram (call graph) tekenen. Dit is een diagram dat alle subroutines toont en hoe ze worden genoemd. Hier is een voorbeeld voor Boter-Kaas-En-Eieren (tic-tac-toe).
boter kaas en eieren
Je kunt nu zien waarom subroutines zo handig zijn: DrawBoard is op drie verschillende plaatsen aangeroepen. Op die manier hoeven we de code niet opnieuw te maken om het bord elke keer te tekenen.

Bereik (Scope)
Er is nog een probleem op te lossen: hoe weet de ene subroutine over de variabelen in een andere? Soms kunnen we daarvoor argumenten gebruiken. Op andere momenten willen we in veel subroutines dezelfde variabele gebruiken. In dat geval maken we meestal een globale variabele. Sommige programmeurs zijn net zo tegen globale variabelen als tegen GOTO, omdat ze een programma complexer kunnen maken. Maar als ons programma klein is, hoeven we ons er (nog) geen zorgen over te maken.

Een globale variabele kan overal in het programma worden gebruikt, terwijl een lokale variabele alleen in zijn zogenaamde scope (bereik) kan worden gebruikt. Dat is de subroutine waarin het is gedefinieerd of gebruikt. Een algemene regel is: als je het alleen op één plaats nodig hebt, maak het dan niet een globale variabele.

Een globale variabele in BASIC heet SHARED en de declaratie ziet er als volgt uit:
DIM SHARED MIJN_VARIABLE
En wanneer het een array is, als volgt:
DIM SHARED MIJN_VARIABELEN(10)

In games

Zelfs zeer eenvoudig uitziende games kunnen groot worden, honderden of zelfs duizenden regels code. Om alles georganiseerd te houden heb je subroutines nodig. Vaak worden deze subroutines weer verpakt in zogenaamde modules. Een voorbeeld kan zijn dat je de volgende modules hebt: speler, vijand, controle en kogel.

Moderne programmeertalen gaan nog een stapje verder en noemen deze modules objecten of klassen. In een object deel je niet alleen de functies, maar ook de variabelen. Op die manier kan een speler bijvoorbeeld de variabelen snelheid en richting hebben, en de vijand kan dezelfde variabelen hebben. In feite kan je tientallen vijanden hebben met allemaal hun eigen snelheid, richting, health, sterkte, enz.

Opdracht

Je gaat het begin van een kaartspel maken. Hiervoor maak je 5 subroutines:
DECLARE SUB MAAK_KLEUR(NAME$, INDEX)
DECLARE SUB MAAK_KAARTEN()
DECLARE SUB KIES_KAART()
DECLARE SUB TOON_KAARTEN()
DECLARE SUB HOOFDPROGRAMMA()

DIM SHARED KAARTEN$(52)
Ik geef je het begin van het bestand al: de declaraties. Je ziet ook een globale (SHARED) variabele, een array die alle kaarten vasthoudt. HOOFDPROGAMMA (MAIN) is meestal de naam van de subroutine die je programma begint en beëindigt. Zorg ervoor dat je het 1 keer aanroept als laatste regel van je programma.

Laten we eens kijken wat er in die functies moet worden gedaan:
  • MAAK_PAK
Hier vul je de KAARTEN$ -variabele met waarden voor 1 kleur, zeg "HARTEN". Je moet code maken om bijvoorbeeld te krijgen "2 OF HEARTS", dan "3 OF HEARTS", enz. Tot "ACE OF HEARTS". Merk op dat dit teksten zijn, geen getallen. Je kunt het ook in 13 regels doen of als je een uitdaging wilt, kan je een lus maken voor de genummerde kaarten. Wees voorzichtig met wat je met INDEX doet, omdat het het beginpunt in de array is.

  • MAAK_KAARTEN
In deze subroutine maak je vier kleuren (harten, ruiten, schoppen, klaver), door elke keer MAAK_KLEUR aan te roepen met verschillende argumenten.

  • KIES_KAART
In deze routine maak je een willekeurige index en toon je de kaart met die index. Natuurlijk moeten de kaarten al gemaakt zijn om dit te kunnen doen.

  • TOON_KAARTEN
Dit noemen we een test-routine. Het helpt ons om te laten zien of het programma goed werkt, maar we hebben het niet direct nodig in een spel. De routine laat alle kaarten zien.

  • HOOFDPROGRAMMA
Hier roep je de routine aan die de kaarten maakt, en de routine die de kaart kiest.

Verwacht resultaat

Voorbeelden:
> HARTEN 5
> SCHOPPEN BOER
> KLAVER 6

Veelgemaakte fouten

  1. Als je het HOOFDPROGRAMMA niet aanroept, doet het programma niets
  2. Problemen met INDEX, zodat kaarten worden overgeslagen, of je gaat voorbij de grenzen van de array
  3. TOON_KAARTEN aanroepen voordat ze worden aangemaakt

Extra uitdaging

Kan je het programma zo maken dat er een 'hand' van 8 kaarten wordt gedeeld?

Bronnen


(Er zijn nog geen discussies in dit forum)