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.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.Voeg voorts een * operator toe die breuken vermenigvuldigen mogelijk maakt (ook hier wordt het resultaat vereenvoudigd teruggegeven).
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.Genereren van een Deck-object en de kaarten op het scherm tonen via DrawCards
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.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!