Oefeningen kerkhof
Op deze pagina vind je alle briljante en minder briljante oefeningen terug die niet meer bij een bepaald hoofdstuk staan. Meestal staan deze oefeningen hier omdat ze leerstof behandelen die niet meer bij de verplichte leerstof hoort.

Alledaags

Zoek een foto naar keuze (nieuws, privé, etc) waarop meer dan één element opstaat (dus geen pasfoto of foto van blauwe lucht zonder wolken). Tracht de nodige klassen te verzinnen en verzin minstens 1 auto-property en 1 methode per klasse. Maak in een console-applicatie vervolgens objecten van deze klassen aan en test ze. Voeg de foto aan je solution-folder toe.
Bijvoorbeeld: een foto van een betoging. Je zou minstens 3 klassen kunnen verzinnen (gebouw, politie, betoger). Van ieder van deze klassen maak je dan objecten aan zoals je ze op de foto ziet (uiteraard gaan we geen 30 betoger-instanties maken, enkele zijn genoeg, als voorbeeld).

Binaire god

Deze leerstof werd niet in het hoorcollege gezien. NEem zelf het hoofdstuk "Bitwise operators" door.
Vraag een getal aan de gebruiker (als int). Gebruik enkel bitwise operators om:
  • het getal te verdubelen: onderzoek zelf hoe je binair verdubbelt (wat is de binaire voorstelling van 1,2,4, 8 bijvoorbeeld? Zie je het?)
  • het getal te halveren: merk op dat dit enkel werkt voor even getallen
  • het getal van teken te veranderen
Doe hetzelfde maar vraag nu aan de gebruiker een string met de binaire voorstelling van een getal (bv "0011") en zit dit eerst om naar een int. Toon telkens het resultaat zowel als int en als een binaire string voorstelling.

APCenture-Job Agency

Opgave is niet erg duidelijk.
Maak een klasse Job. Deze klasse heeft vier private fields
  • Description (string) bijvoorbeeld "ruiten wassen"
  • Duration (int) , stelt tijd voor die nodig is om job uit te voeren
  • RatePerHour (int), stelt kostprijs per uur voor van deze job
  • TotalFee (int), stelt totale prijs voor zijnde Duration * RatePerHour
Voorzie properties voor deze 4 velden, echter de TotalFee heeft geen ‘set’ daar deze een berekening van andere properties is en dus een read-only property is.
Telkens de Duration of RatePerHour wordt aangepast (set) wordt de TotalFee herberekend (je zal dus een private totalFee nodig hebben waar de public property TotalFee z’n waarde van krijgt).
Voorzie 2 constructors:
  • Default constructor: stelt de description in op "onbekend" en zet duration en rateperhour op 0.
  • Overloaded constructor: waarbij je de 3 velden (behalve TotalFee) kan aanpassen tijdens de constructie van een Job-object.
Toon de werking van je klasse aan door enkele objecten aan te maken met zowel de default als de overloaded constructor. Toon vervolgens dat TotalFee correct werkt.

APCenture-Job Agency, deel 2: Operator Overloading

Pas de klasse Job aan zodat de + operator kan gebruikt worden om 2 job-objecten bij elkaar op te tellen. Bv:
1
Job epicDuoJob= jobOne+jobTwo; //jobOne en jobTwo zijn ook van het type Job
Copied!
De som van 2 job-objecten gaat als volgt te werk:
  • Description: beide description worden na elkaar geplakt, waarbij het voegwoord ‘en’ tussen beide wordt gezet.
  • Duration: som van beide durations
  • RatePerHour: gemiddelde de rateperhourvan beide objecten
Toon in je main aan dat je nieuwe klasse werkt en dat je 2 jobs kan samenvoegen. Toon ook aan dat je vervolgens deze nieuwe samenvoeging op zijn beurt kan samenvoegen met een andere job (of zelfs met een andere samengevoegde job!).

Breuk

Maak een klasse Breuk dat dus een breuk zal voorstellen met een noemer en teller.
Voorzie properties voor noemer en teller, waarbij de noemer niet 0 mag zijn (zet deze op 1 indien de gebruiker dit toch probeert).
Voeg 2 constructors toe:
  • Default constructor: de breuk wordt ingesteld op 0/1
  • Overloaded constructor: zowel de noemer als teller worden als parameter meegegeven
Voorts:
  1. 1.
    Voeg een + operator toe die het mogelijk maakt om 2 breuken bij elkaar op te tellen. Wanneer de + operatie is toegepast wordt ook automatisch de Vereenvoudig-methode aangeroepen (zie verder) voor het resultaat wordt teruggegeven. Belangrijk: je dient aan operator overloading te doen. We willen dus dat je bijvoorbeeld kan schrijven Breuk breuksom= breuk1 + breuk2;
  2. 2.
    Voeg voorts een * operator toe die breuken vermenigvuldigen mogelijk maakt (ook hier wordt het resultaat vereenvoudigd teruggegeven).
  3. 3.
    Voeg een methode AlsString toe die de breuk als string teruggeeft, waarbij de breuklijn als slash wordt voorgesteld.
Maak een array van 4 breuken in je main en laat de gebruiker deze alle 4 invullen. Toon vervolgens de som en vermenigvuldiging van deze 4 breuken als strings op het scherm.
Pro: Voeg een methode Vereenvoudig toe. Deze zal de breuk vereenvoudigen indien mogelijk. Als dus de breuk op 2/4 staat dan wordt deze na het uitvoeren van deze methode 1/2.

Heroes of AP

Volgende opgave komt uit een examen van augustus 2018 van deze cursus
Opgelet: deze opgave is erg brak en niet conform mijn gewoonlijke standaard.Waarvoor excuses

Inleiding

Heroes of AP is een single-player kaartspel dat we als consolespel spelenwaarbij de speler in zo weinig mogelijk beurten maximaal punten wil scoren. Het spel is een combinatie van geluk en strategie. Spelregels Heroes of AP bestaat uit een deck van tien kaarten met drie soorten kaarten:
  • Landen: deze genereren mana
    • Per beurt dat een kaart gedekt ligt verhoogt z’n mana-waarde (=COST)
  • Centrales:
    • Per beurt genereert een centrale 1 punt indien deze zichtbaar is
  • Helden: deze gebruiken mana om punten te genereren
    • Per beurt dat een kaart gedekt ligt verlaagt z’n mana-waarde (=COST), maar nooit onder 1
    • Een held genereert een willekeurig aantal punten indien hij zichtbaar is afhankelijk van wat de gebruiker aan Mana betaald:
      • Om 1 punten te genereren moet de speler de Cost van de held in mana betalen
      • Het overschot aan mana dat de speler betaald zal ervoor zorgen dat de held mogelijk meer punten maakt, namelijk tussen 1 en het extra aan mana.

Opzetten spel

  • De speler krijgt 10 willekeurige kaarten voor zich die gedekt blijven liggen.
  • Vijf kaarten zijn landkaarten,3 kaarten zijn centrales, 2 kaarten zijn helden
    • Iedere kaart heeft een willekeurige kost tussen 5 en 10

Spelen spel

Zolang de speler geen 10 punten heeft zal de speler steeds een beurt spelen bestaande uit 4 fasen:
  • Fase 0 - Upkeep:
    • alle landen die gedekt liggen zullen hun Cost met 1 verhogen (deze landen kunnen dus meer mana genereren van zodra de speler ze omdraait)
    • alle helden die nog gedekt zijn hun Cost verlaagt met 1 (maar nooit lager dan 1)
    • alle centrale die zichtbaar zijn genereren 1 punt (hun Cost wordt niet gebruikt)
  • Fase 1 - FlipCard: de speler kiest een kaart die moet omgekeerd worden.
    • Enkel kaarten die nog niet omgekeerd werden kunnen uiteraard omgekeerd worden.
  • Fase 2 - GenerateMana: De speler kiest welke land mana genereert (enkel mogelijk indien er zichtbare landen zijn)
    • Een land genereert evenveel mana als de Cost van de kaart
  • Fase 3 - GeneratePoint: De speler kiest welke held punten genereert (enkel mogelijk indien er zichtbare helden zijn)
    • De speler betaald hiervoor de cost van de held in mana. De held genereert vervolgens een willekeurig aantal punten tussen 1 en de cost van de held.

Basisspel maken

Deel 1 (8 punten)

Gebruik de gegeven klassen (onderaan de opgave) in je project en pas ze aan waar nodig
Vul de 3 klassen aan klassen om aan bovenstaand schema te voldoen:
  • Land:
    • Land is een Card
    • Heeft een methode GenerateMana die mana zal returnen gelijk aan de Cost van het land, maar enkel indien het land zichtbaar is (IsHidden==false)
    • Heeft als Name altijd "Land"
    • Zal bij de DrawCard methode zichzelf in groene tekst op het scherm zetten, namelijk z’n Name, gevolgd door z’n Cost (bv "Land 5")
    • Verhoogt z’n Cost met 1 wanneer UpdateCost wordt aangeroepen
  • Centrale:
    • Centrale is een Card
    • Heeft als Name altijd "Centrale"
    • Zal bij de DrawCard methode zichzelf in geel tekst op het scherm zetten, namelijk z’n Name (bv "Centrale")
    • Heeft de interface IPointGenerator
    • Zal steeds 1 punt genereren bij GeneratePoints (de parameter die wordt meegegeven wordt niet gebruikt).
  • Hero:
    • Hero is een Card
    • Heeft als Name altijd "Hero"
    • Heeft de interface IPointGenerator
    • Zal bij de DrawCard methode zichzelf in gele tekst op het scherm zetten, namelijk z’n Name, gevolgd door z’n Cost (bv "Hero 6")
    • Heeft een methode GeneratePoints die 1 parameter aanvaardt van het type int. Indien de parameter gelijk is aan Cost zal de methode een willekeurig getal tussen 1 en Cost teruggeven als punten.
  • Deck:
    • Deck heeft een lijst van kaarten genaamd Kaarten, van het type List<Card>
    • Deck heeft een default constructor: wanneer deze aangeroepen wordt zullen er 10 willekeurige kaarten (3 Centrale, 2 Hero, 5 Land) in de Kaarten-list geplaatst worden
    • Deck heeft een methode DrawCards: deze zal de DrawCard van alle Kaarten aanroepen
    • Deck heeft een methode UpdateCosts: deze zal de UpdateCost van alle Kaarten aanroepen die dat kunnen.
    • Deck heeft een methode GeneratePoints: deze zal de GeneratePoints van alle Kaarten aanroepen die dat kunnen.
    • Kaarten-list is beschikbaar vanuit een readonly-property

Deel 2: Basis game loop (8 punten)

Maak een basis-versie van het spel.
  1. 1.
    Genereren van een Deck-object en de kaarten op het scherm tonen via DrawCards
  2. 2.
    Een loop die blijft herhalen tot de gebruiker 10 punten heeft
    • Alle interactie met de kaarten gebeurt uiteraard via het Deck-object
    • Bestaat uit de 4 fasen die al dan niet vragen aan de gebruiker wat er moet gebeuren
      • Fase 0: update costs van verborgen kaarten + Genereer punt per zichtbare Centrale
      • Fase 1: vraag aan gebruiker welke kaart moet omgekeerd worden
      • Fase 2: vraag aan gebruiker welk land mana moet genereren
      • Fase 3: vraag aan gebruiker welke held punten moet genereren
    • Na iedere fase ververs je het beeld (Console.Clear()) en herteken je de kaarten en toon je de volgende extra info aan de gebruiker, namelijk Mana, Punten en Beurt
  3. 3.
    Na de loop wordt getoond hoeveel beurten de gebruiker heeft nodig gehad

Deel 3 Extras

  • 1 punt: Gebruik een enum om bij te houden in welke fase van een beurt je bent.
  • 2 punten: plaats alle spel-logica in deck zodat de gameloop enkel nog maar bestaat uit de aanroep van een SpeelBeurt()-methode en een check of de loop moet gestopt worden.

Voorbeeld spelverloop:

Start klasen

Card

1
abstract class Card
2
{
3
public Card(string naamin)
4
{
5
Name = naamin;
6
}
7
8
public abstract void DrawCard();
9
protected int cost;
10
11
private string name;
12
13
public string Name
14
{
15
get { return name; }
16
private set { name = value; }
17
}
18
}
Copied!

IPointGenerator

1
interface IPointGenerator
2
{
3
int GeneratePoints(int payedmana);
4
}
Copied!

Oplossing

1
abstract class Card
2
{
3
public Card(string naamin)
4
{
5
Name = naamin;
6
}
7
public bool IsHidden { get; set; }
8
public abstract void DrawCard();
9
public abstract void UpdateCost();
10
protected int cost;
11
12
private string name;
13
14
public string Name
15
{
16
get { return name; }
17
private set { name = value; }
18
}
19
}
20
21
class Centrale : Card, IPointGenerator
22
{
23
public Centrale() : base("Centrale")
24
{
25
26
}
27
28
29
30
public override void DrawCard()
31
{
32
Console.ForegroundColor = ConsoleColor.Yellow;
33
Console.WriteLine(Name);
34
Console.ResetColor();
35
}
36
37
public int GeneratePoints(int payedmana)
38
{
39
return 1;
40
}
41
42
public override void UpdateCost()
43
{
44
//Do nothing
45
}
46
}
47
48
class Deck
49
{
50
private List<Card> cards = new List<Card>();
51
52
public List<Card> Cards
53
{
54
get { return cards; }
55
private set { cards = value; }
56
}
57
58
public Deck()
59
{
60
for (int i = 0; i < 3; i++)
61
{
62
Centrale nieuweCentrale = new Centrale();
63
Cards.Add(nieuweCentrale);
64
}
65
for (int i = 0; i < 2; i++)
66
{
67
Hero nieuweHero = new Hero();
68
Cards.Add(nieuweHero);
69
}
70
for (int i = 0; i < 5; i++)
71
{
72
Land nieuwLand = new Land();
73
Cards.Add(nieuwLand);
74
}
75
}
76
77
internal int GenerateLandPoint(int keuzeland)
78
{
79
if (Cards[keuzeland] is Land)
80
return (Cards[keuzeland] as Land).GenerateMana();
81
return 0; //Dit is geen land!
82
83
84
}
85
86
internal int GenerateHeroPoint(int keuzehero, int mana)
87
{
88
if (Cards[keuzehero] is Hero)
89
return (Cards[keuzehero] as Hero).GeneratePoints(mana);
90
return 0; //Dit is geen hero!
91
}
92
93
public void DrawCards()
94
{
95
int teller = 1;
96
foreach (var elem in Cards)
97
{
98
Console.Write(teller);
99
elem.DrawCard();
100
teller++;
101
}
102
}
103
104
public void UpdateCost()
105
{
106
foreach (var elem in Cards)
107
{
108
if (elem is Land)
109
{
110
Land temp = elem as Land;
111
if (temp.IsHidden)
112
temp.UpdateCost();
113
}
114
115
if (elem is Hero)
116
{
117
Hero temp = elem as Hero;
118
if (temp.IsHidden)
119
temp.UpdateCost();
120
}
121
}
122
}
123
124
public void GenerateCentralePoints()
125
{
126
foreach (var elem in Cards)
127
{
128
if (elem is Centrale)
129
{
130
if (!((Centrale)elem).IsHidden)
131
{
132
((Centrale)elem).GeneratePoints(1);
133
}
134
}
135
}
136
}
137
}
138
139
class Hero : Card, IPointGenerator
140
{
141
public Hero() : base("Hero")
142
{
143
144
}
145
146
public override void DrawCard()
147
{
148
Console.ForegroundColor = ConsoleColor.Yellow;
149
Console.WriteLine(Name + " " + cost);
150
Console.ResetColor();
151
}
152
static Random generator = new Random();
153
public int GeneratePoints(int payedmana)
154
{
155
if (payedmana == cost)
156
{
157
return generator.Next(1, cost);
158
}
159
return 0;
160
}
161
public override void UpdateCost()
162
{
163
if (cost - 1 > 0)
164
cost--;
165
}
166
}
167
168
class Land : Card
169
{
170
public Land() : base("Land")
171
{
172
}
173
174
public override void DrawCard()
175
{
176
177
Console.ForegroundColor = ConsoleColor.Green;
178
Console.WriteLine(Name + " " + cost);
179
Console.ResetColor();
180
181
}
182
183
public int GenerateMana()
184
{
185
if (!IsHidden)
186
{
187
return cost;
188
}
189
else
190
{
191
return 0;
192
}
193
}
194
195
public override void UpdateCost()
196
{
197
cost++;
198
}
199
}
Copied!
1
static void Main(string[] args)
2
{
3
//deck genereren
4
Deck deck = new Deck();
5
int points = 0;
6
int mana = 0;
7
int tries = 0;
8
while (points <= 10)
9
{
10
tries++;
11
Console.WriteLine(quot;Mana:{mana} Points:{points} Tries:{tries}");
12
deck.DrawCards();
13
14
//Fase 0
15
deck.UpdateCost();
16
deck.GenerateCentralePoints();
17
//Fase 1
18
Console.WriteLine("Welke kaart omdraaien?");
19
int keuze = Convert.ToInt32(Console.ReadLine());
20
deck.Cards[keuze].IsHidden = false;
21
22
//Fase 2
23
Console.WriteLine("Welke land genereert punten?");
24
int keuzeland = Convert.ToInt32(Console.ReadLine());
25
mana += deck.GenerateLandPoint(keuzeland);
26
27
//Fase 3
28
Console.WriteLine("Welke hero genereert punten?");
29
int keuzehero = Convert.ToInt32(Console.ReadLine());
30
Console.WriteLine("Hoeveel mana ga je betalen?");
31
int manac = Convert.ToInt32(Console.ReadLine());
32
points += deck.GenerateHeroPoint(keuzehero,manac);
33
mana -= manac;
34
Console.ReadLine();
35
Console.Clear();
36
}
37
}
Copied!