Spellen programmeren in C. Zelfstudie

Dit is de eerste van verschillende games die Tutorials programmeren in C voor complete beginners. In plaats van zich te concentreren op het lesgeven van C en vervolgens voorbeeldprogramma's te laten zien, leren ze C door je complete programma's (games) in C te bieden

De eerste game in de serie is een console (d.w.z. tekstgebaseerde game genaamd Star Empires). Star Empires is een eenvoudig spel waarbij je alle 10 systemen in de Galaxy moet vastleggen terwijl je AI-tegenstander hetzelfde doet.

Je begint systeem 0 te bezitten, terwijl je vijand systeem 9 bezit. De resterende acht systemen (1-8) beginnen allemaal neutraal. Alle systemen starten binnen een vierkant van 5 parsec x 5 parsec, dus geen enkel systeem staat meer dan 6 parsecs uit elkaar. De verste twee punten zijn (0,0) en (4,4). Volgens de stelling van Pythagoras is de grootste afstand tussen twee systemen de vierkantswortel ((4)² + (4)²) wat de vierkantswortel van 32 is die ongeveer 5.657 is.

Let op, dit is niet de definitieve versie en zal worden gewijzigd. Laatste wijziging: 21 augustus 2011.

De game is turn-based en elke turn die je geeft, geef opdracht om een ​​willekeurig aantal vloten te verplaatsen van elk systeem dat je bezit naar een ander systeem. Als u meer dan één systeem bezit, kunt u vloten opdracht geven om van al uw systemen naar het doelsysteem te gaan. Dit gebeurt pro rata naar boven afgerond, dus als u drie systemen (1,2,3) bezit met 20, 10 en 5 vloten aanwezig en je bestelt 10 vloten om naar systeem 4 te gaan, dan gaan 6 van systeem 1, 3 van systeem 2 en 1 van systeem 3. Elke vloot verplaatst 1 parsec per beurt.

Elke beurt duurt 5 seconden, hoewel je de snelheid kunt wijzigen om het te versnellen of te vertragen door de 5 in deze coderegel te wijzigen in 3 of 7 of wat je maar wilt. Zoek naar deze coderegel:

onesec = clock () + (5 * CLOCKS_PER_SEC);

Deze game is geprogrammeerd en gaat ervan uit dat je geen C-programmering kent. Ik zal C-programmeerfuncties in deze en de volgende twee of drie tutorials introduceren naarmate ze vorderen. Maar eerst heb je een compiler voor Windows nodig. Hier zijn twee gratis:

• Proberen CC386
• Of Visual C ++ 2010 Express

Het CC386-artikel begeleidt u bij het maken van een project. Als u die compiler installeert, hoeft u alleen het Hello World-programma te laden zoals beschreven, de broncode te kopiëren en in het voorbeeld te plakken, op te slaan en vervolgens op F7 te drukken om het te compileren en uit te voeren. Evenzo maakt het Visual C ++ 2010-artikel een hallo wereldprogramma. Overschrijf het en druk op F7 om Star Empires te bouwen., F5 om het uit te voeren.

Op de volgende pagina - Star Empires laten werken

We moeten informatie over vloten en systemen in de game opslaan. Een vloot is een of meer schepen met een opdracht om van het ene systeem naar het andere te gaan. Een sterrenstelsel is een aantal planeten, maar is meer een abstracte entiteit in dit spel. We moeten de volgende informatie bewaren voor een vloot.

• Origin-systeem (1-10).
• Bestemmingssysteem (1-10)
• Hoeveel schepen (1-veel)
• Blijkt te komen
• Wiens vloot is het? 0 = speler, 9 = vijand

We zullen een struct in C gebruiken om dit vast te houden:

Een struct is een verzameling gegevens, in dit geval 5 getallen die we als één manipuleren. Elk nummer heeft een naam, bijvoorbeeld fromsystem, tosystem. Deze namen zijn variabelenamen in C en kunnen onderstrepingstekens zoals deze hebben, maar geen spaties. In C zijn getallen een geheel getal; hele getallen zoals 2 of 7 dit worden ints genoemd, of getallen met decimale delen zoals 2.5 of 7.3333 en deze worden floats genoemd. In heel Star Empires gebruiken we slechts één keer drijvers. In een stuk code dat de afstand tussen twee plaatsen berekent. Elk ander nummer is een int.

Dus fleet is de naam voor een gegevensstructuur met vijf int-variabelen. Nu is dat voor één vloot. We weten niet hoeveel vloten we moeten aanhouden, dus we zullen royale ruimte voor 100 toewijzen met behulp van een array. Zie een struct als een eettafel met ruimte voor vijf personen (int.). Een array is als een lange rij eettafels. 100 tafels betekent dat het 100 x 5 personen kan bevatten.

Als we die 100 eettafels zouden serveren, zouden we moeten weten welke tafel welke was en we doen dit door nummering. In C tellen we altijd elementen van arrays die beginnen bij 0. De eerste eettafel (vloot) is nummer 0, de volgende is 1 en de laatste is 99. Ik herinner me het altijd als zijnde hoeveel eettafels deze tafel vanaf het begin is? De eerste is aan het begin, dus is 0 mee.

Zo verklaren we de vloten (dwz onze eettafels).

Lees dit van links naar rechts. Struct vloot verwijst naar onze structuur voor één vloot. De naam vloten is de naam die we aan alle vloten geven en [100] vertelt ons dat er 100 x struct vloot in de vloten variabel is. Elke int bezet 4 locaties in het geheugen (bytes genoemd), dus één vloot neemt 20 bytes in en 100 vloten is 2000 bytes. Het is altijd een goed idee om te weten hoeveel geheugen ons programma nodig heeft om zijn gegevens te bewaren.

In de struct-vloot heeft elk van de int's een geheel getal. Dit nummer wordt opgeslagen in 4 bytes en het bereik hiervan is van -2.147.483.647 tot 2.147.483.648. Meestal gebruiken we kleinere waarden. Er zijn tien systemen, dus zowel fromsystem als tosystem hebben waarden 0 tot 9.

Op de volgende pagina: Systemen en willekeurige nummers

Elk van de neutrale systemen (1-8) begint met 15 schepen (een aantal dat ik uit de lucht heb gekozen!) Om mee te beginnen en de andere twee (die van jou: systeem 0 en je computertegenstander bij systeem 9) hebben elk 50 schepen. Elke beurt wordt het aantal schepen in een systeem met 10% naar beneden afgerond. Dus als je ze na één beurt niet beweegt, wordt je 50 55 en elk van de neutrale systemen heeft er 16 (15 + 1,5 naar beneden afgerond). Merk op dat vloten die naar een ander systeem verhuizen, niet in aantallen toenemen.

Het op deze manier vergroten van het aantal schepen lijkt misschien een beetje vreemd, maar ik heb het gedaan om het spel gaande te houden. In plaats van deze tutorial te veel te maken over ontwerpbeslissingen, schreef ik een apart artikel over de ontwerpbeslissingen van Star Empires.

In het begin moeten we alle systemen genereren en op de kaart zetten, met maximaal één systeem erin elke locatie, aangezien er 25 locaties op ons 5 x 5-raster zijn, hebben we tien systemen en 15 lege locaties. We genereren ze met de functie GenMapSystems () die we op de volgende pagina zullen bekijken.

Een systeem wordt opgeslagen in een struct, met de volgende 4 velden die allemaal int zijn.

De Melkweg (alle 10 systemen) wordt opgeslagen in een andere array, net als bij vloten, behalve dat we 10 systemen hebben.

Alle spellen hebben willekeurige getallen nodig. C heeft een ingebouwde functie rand () die een willekeurige int retourneert. We kunnen dit binnen een bereik forceren door het maximale aantal in te geven en de% -operator te gebruiken. (Modulus). Dit is hetzelfde als klokberekening, behalve dat we in plaats van 12 of 24 een int-nummer met de naam max doorgeven.

Dit is een voorbeeld van een functie die een stuk code is dat in een container is verpakt. De eerste regel hier die / * en einde * / start, is een opmerking. Het zegt wat de code doet, maar wordt genegeerd door de compiler die de C-instructies leest en deze omzet in instructies die de computer begrijpt en zeer snel kan uitvoeren.

• Benieuwd wat een compiler is? Lezen Wat is een compiler? (Artikel)

Een functie is als een wiskundige functie zoals Sin (x). Deze functie bestaat uit drie delen:

De int zegt welk type nummer het retourneert (meestal int of float). Willekeurig is de naam van de functie en (int max) zegt dat we een int-nummer doorgeven. We kunnen het zo gebruiken:

De lijn:

Op de volgende pagina: Een willekeurige startkaart genereren

Deze onderstaande code genereert de startkaart. Dat is het hierboven weergegeven.

Systemen genereren is een kwestie van het toevoegen van de speler en de systemen van de tegenstander (op 0,0) en (4,4) en vervolgens willekeurig 8 systemen toevoegen op de resterende 23 lege locaties.

De code gebruikt drie int-variabelen die door de regel worden gedefinieerd

Een variabele is een locatie in het geheugen met een int-waarde. De variabelen x en y bevatten de coördinaten van de systemen en hebben een waarde in het bereik 0-4. De variabele i wordt gebruikt voor het tellen van lussen.

Om de 8 willekeurige systemen in het 5x5-raster te plaatsen, moeten we weten of een locatie al een systeem heeft en voorkomen dat een ander op dezelfde locatie wordt geplaatst. Hiervoor gebruiken we een eenvoudige tweedimensionale reeks tekens. Het type char is een ander type variabele in C en bevat een enkel teken zoals 'B' of 'x'.

Het fundamentele type variabelen in C zijn int (gehele getallen zoals 46), char (een enkel teken zoals 'A') en float (voor het houden van getallen met een floating point zoals 3.567). Arrays [] zijn bedoeld voor het bijhouden van lijsten met hetzelfde element. Dus char [5] [5] definieert een lijst met lijsten; een tweedimensionale reeks tekens. Zie het als 25 Scrabble-stukken gerangschikt in een 5 x 5-raster.

Elk teken wordt aanvankelijk ingesteld op een spatie in een dubbele lus met twee voor instructies. Een for-statement bestaat uit drie delen. Een initialisatie, een vergelijkingsgedeelte en een wijzigingsgedeelte.

• x = 0; Dit is het initialisatiegedeelte.
• X
• x ++. Dit is het veranderdeel. Het voegt 1 toe aan x.

Dus (voor (x = 0; x

Binnen de for (x lus is een for y lus die hetzelfde doet voor y. Deze y-lus vindt plaats voor elke waarde van X. Wanneer X 0 is, zal Y een lus maken van 0 tot 4, als X 1 is, zal Y een lus maken enzovoort. Dit betekent dat elk van de 25 locaties in de layout-array wordt geïnitialiseerd naar een spatie.

Na de for-lus wordt de functie InitSystem aangeroepen met vijf int-parameters. Een functie moet worden gedefinieerd voordat deze wordt aangeroepen, anders weet de compiler niet hoeveel parameters deze moet hebben. InitSystem heeft deze vijf parameters.

Op de volgende pagina: Het genereren van een willekeurige startkaart gaat verder ...

Dit zijn de parameters voor InitSystem.

• systemindex - een waarde van 0 -9.
• x en y - coördinaten van het systeem (0-4).
• aantal - hoeveel schepen zijn er op dit systeem.
• eigenaar. Van wie is een systeem. 0 betekent de speler, 9 betekent de vijand.

Dus de lijn InitSystem (0,0,0,50,0) initialiseert systeem 0 op locaties x = -0, y = 0 met 50 schepen naar eigenaar 0.

C heeft drie soorten lussen, terwijl lussen, voor lussen en do-lussen en we gebruiken voor en doen in de functie GenMapSystems. Hier moeten we de resterende 8 systemen ergens in de Melkweg plaatsen.

Er zijn twee geneste lussen in deze code. De buitenste lus is een for-instructie die de variabele i telt van een beginwaarde van 1 tot een eindwaarde van 8. We zullen i gebruiken om naar het systeem te verwijzen. Onthoud dat we systeem 0 en 9 al hebben geïnitialiseerd, dus nu initialiseren we systemen 1-8.

Alles van de do {tot de while (layout [x] [y] is de tweede lus. Het is syntaxis is doen {iets} terwijl (voorwaarde is waar); We wijzen dus willekeurige waarden toe aan x en y, elke waarde in het bereik 0-4. Random (5) retourneert een waarde in het bereik van 1 tot 5, aftrekken van 1 krijgt het bereik 0-4.

We willen niet twee systemen op dezelfde coördinaten plaatsen, dus deze lus is op zoek naar een willekeurige locatie met een spatie erin. Als daar een systeem is, zal de layout [x] [y] geen spatie zijn. Als we InitSystem aanroepen, heeft dat daar een andere waarde. BTW! = Betekent niet gelijk aan en == betekent gelijk aan.

Wanneer de code na een tijdje het InitSystem bereikt (layout [x] [y]! = ''), Verwijzen x en y zeker naar een plaats in de layout die een spatie bevat. We kunnen dus InitSystem aanroepen en vervolgens de for-lus rondlopen om een ​​willekeurige locatie voor het volgende systeem te vinden totdat alle 8 systemen zijn geplaatst.

De eerste oproep naar InitSystem stelt systeem 0 in op locatie 0,0 (linksboven in het rooster) met 50 vloten en werd door mij gewonnen. De tweede oproep initialiseert systeem 9 op locatie 4,4 (rechtsonder) met 50 vloten en is eigendom van speler 1. We zullen in de volgende tutorial aandachtig kijken naar wat InitSystem eigenlijk doet.

Deze lijnen geven letterlijke waarden aan. Het is gebruikelijk om ze in hoofdletters te plaatsen. Overal waar de compiler MAXFLEETS ziet, gebruikt hij de waarde 100. Verander ze hier en het is overal van toepassing:

• #define WIDTH 80
• #define HOOGTE 50
• #define MAXLEN 4
• #define MAXFLEETS 100
• #define MAXSYSTEMEN 10
• #define FIGHTMARKER 999

In deze tutorial hebben we variabelen behandeld en het gebruik van int, char en struct om ze te groeperen plus array om een ​​lijst te maken. Gebruik vervolgens eenvoudig looping voor en doen. Als u de broncode onderzoekt, worden dezelfde structuren keer op keer gezien.

• voor (i = 0; i
• voor (i = 0; i

Tutorial Twowill kijken naar aspecten van C genoemd in deze tutorial.