Relintai/programming_tutorials
1
0
Fork 0
mirror of https://github.com/Relintai/programming_tutorials.git synced 2025-05-11 22:52:11 +02:00
Code Issues Packages Projects Releases Wiki Activity

Split the txts. Now one txt only has one exercise.

Browse Source
This commit is contained in:
Relintai 2021-04-05 15:39:08 +02:00
parent 47b9d65596
commit 480f91b56e
21 changed files with 833 additions and 838 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

305
01_alapok.txt
View File

@ -1,305 +0,0 @@
1. Implementáld az alábbi 2ds matematikai vektor osztályt:
------------------------------------------------|
| class Vector2 |
|-----------------------------------------------|
| + x : float | -> Nincs getter, és szetter, mert azok lassítanának. (Függvényhívásnak van minimális erőforrás igénye)
| + y : float | -> Ilyen matematikai osztályoknál, érdemes ilyeneket kioptimalizálni. PLussz leírni is sok. getx(), setx() etc.
| + abs() : Vector2 | -> visszaadja egy új vektorba ennek a vektornak az abszolút értékét. (x, y abszolút értékét veszi)
| | Abszolút érték képlet: ha egy a < 0 ret -a, else ret a;
| + angle() float | -> atan2(x, y)
| + angle_to(b : Vector2) : float | -> atan2(cross(b), dot(b));
| + cross(b : Vector2) : float | -> Cross product -> x * b.y - y * b.x;
| + clamped(len : float) : Vector2 | -> normalized() * len
| + direction_to(b : Vector2) : Vector2 | -> Visszaad egy normalizált vektort ami ebből b be mutat. (A képlet: (b - a).normalized()) (operator-)
| + distance_to_squared(b : Vector2) : float | -> (x - b.x) * (x - b.x) + (y - b.y) * (y - b.y);
| + distance_to(b : Vector2) : float | -> sqrt((x - b.x) * (x - b.x) + (y - b.y) * (y - b.y));
| + dot(b : Vector2) : float | -> dot product -> Ha a 2 vektor 90 fokosz szöget zár be, akkor 0.
| | Pozitív, ha a 2 vektor által bezárt szög kisebb mint 90 fok, negatív, ha nagyobb.
| | képlet: x * b.x + y * b.y.
| + is_equal_approx(b : Vector2) : bool | -> nagyjából egyenlőek-e a vektorok. A max különbség legyen 0.00001 (Epszilon).
| + length() : float | -> sqrt(x * x + y * y)
| + length_squared() : float | -> A hossz a gyökvonás nélkül. (A gyökvonás relatíve lassú, és ha csak össze kell
| | hasonlítani hosszakat, akkor elég így)
| + lerp(b : Vector2, t : float) : Vector2 | -> Linear interpolate -> a jelenlegi vektor és b közötti átmenetvektort adja vissza t paraméter felhasználásával.
| | A t 0 és 1 közötti. Képlet: newx = x + (t * (b.x - x)); és newy = y + (t * (b.y - y));
| + normalized() : Vector2 | -> A vektor normalizálva. Normalizált vektor = a hossza 1.
| | float l = length_squared(); ha nem 0, gyököt kell vonni belőle, és le kell osztani x, y-t is vele
| + normalize() | -> Maga a vektor normalizálódik.
| + add(b: Vector2) | -> x += b.x, y += b.y
| + sub(b: Vector2) | -> x -= b.x, y -= b.y
| + operator+=(b: Vector2) | etc
| + operator-=(b: Vector2) |
| + operator+(a: Vector2, b: Vector2) : Vector2 |
| + operator-(a: Vector2, b: Vector2) : Vector2 |
| + operator*=(b: float) | -> x és y-t is megszorozzuk b-vel.
| + operator*(Vector2 a, float b) : Vector2 | -> x és y-t is megszorozzuk b-vel.
| + operator==(b: Vector2, b: Vector2) : bool |
| + operator!=(b: Vector2, b: Vector2) : bool |
| + Vector2() |
| + Vector2(b : Vector2) |
| + Vector2(x : float, y : float) |
------------------------------------------------|
2. Implementáld az alábbi 3ds matematikai vektor osztályt.
------------------------------------------------|
| class Vector3 |
|-----------------------------------------------|
| + x : float | -> Nincs getter, és szetter, mert azok lassítanának. (Függvényhívásnak van minimális erőforrás igénye)
| + y : float | -> Ilyen matematikai osztályoknál, érdemes ilyeneket kioptimalizálni. PLussz leírni is sok. getx(), setx() etc.
| + z : float |
| + abs() : Vector3 | -> visszaadja egy új vektorba ennek a vektornak az abszolút értékét. (x, y, y abszolút értékét veszi)
| | Abszolút érték képlet: ha egy a < 0 ret -a, else ret a;
| + angle_to(b : Vector3) : float | -> atan2(cross(b).length(), dot(b));
| + cross(b : Vector3) : Vector3 | -> Cross product -> x = (y * b.z) - (z * b.y), y = (z * b.x) - (x * b.z), z = (x * b.y) - (y * b.x)
| + clamped(len : float) : Vector3 | -> normalized() * len
| + direction_to(b : Vector3) : Vector3 | -> Visszaad egy normalizált vektort ami ebből b be mutat. (A képlet: (b - a).normalized())
| + distance_to_squared(b : Vector3) : float | -> return (b - *this).length_squared(); -> *this -> dereferencia operátor -> a this alapba mutató
| + distance_to(b : Vector3) : float | -> return (b - *this).length();
| + dot(b : Vector3) : float | -> dot product -> Ha a 2 vektor 90 fokosz szöget zár be, akkor 0.
| | Pozitív, ha a 2 vektor által bezárt szög kisebb mint 90 fok, negatív, ha nagyobb.
| | képlet: x * b.x + y * b.y + z * b.z.
| + is_equal_approx(b : Vector3) : bool | -> nagyjából egyenlőek-e a vektorok. A max különbség legyen 0.00001 (Epszilon).
| + length() : float | -> sqrt(x * x + y * y + z * z)
| + length_squared() : float | -> A hossz a gyökvonás nélkül. (A gyökvonás relatíve lassú, és ha csak össze kell
| | hasonlítani hosszakat, akkor elég így)
| + lerp(b : Vector3, t : float) : Vector3 | -> Linear interpolate -> a jelenlegi vektor és b közötti átmenetvektort adja vissza t paraméter felhasználásával.
| | A t 0 és 1 közötti. Képlet: newx = x + (t * (b.x - x)); és newy = y + (t * (b.y - y));
| | newy = z + (t * (b.z - z));
| + normalized() : Vector3 | -> A vektor normalizálva. Normalizált vektor = a hossza 1.
| | float l = length_squared(); ha nem 0, gyököt kell vonni belőle, és le kell osztani x, y, z-t is vele
| + normalize() | -> A vektor normalizálódik.
| + add(b: Vector3) | -> x += b.x, y += b.y, z += b.z
| + sub(b: Vector3) | -> x -= b.x, y -= b.y, z -= b.z
| + operator+=(b: Vector3) | etc.
| + operator-=(b: Vector3) |
| + operator+(a: Vector3, b: Vector3) : Vector3 |
| + operator-(a: Vector3, b: Vector3) : Vector3 |
| + operator*=(b: float) | -> x,y és z-t is megszorozzuk b-vel.
| + operator*(Vector2 a, float b) : Vector2 | -> x,y és z-t is megszorozzuk b-vel.
| + operator==(b: Vector3, b: Vector2) : bool |
| + operator!=(b: Vector3, b: Vector2) : bool |
| + Vector3() |
| + Vector3(b : Vector3) |
| + Vector3(x : float, y : float, z : float) |
------------------------------------------------|
3. Implementáld az alábbi matematikai négyzet osztályt.
------------------------------------------------------|
| class Rect2 |
|-----------------------------------------------------|
| + x : float |
| + y : float |
| + w : float |
| + h : float |
| + get_area() : float | -> Terület (w * h)
| + intersects(b : Rect2) : bool | -> Lejjebb
| + intersects_include_borders(b : Rect2) : bool | -> Lejjebb
| + encloses(b : Rect2) : bool | -> Lejjebb
| + has_no_area() : bool |
| + has_point(x : float, y : float) : bool |
| + is_equal_approx(b : Rect2) : bool |
| + grow(by : float) | -> x, y, csökkent, w,h növel by-al
| + shrink(by : float) | -> x, y, növel, w,h csökkent by-al
| + operator+=(b: Rect2) |
| + operator-=(b: Rect2) |
| + operator+(a: Rect2, b: Rect2) : Rect2 |
| + operator-(a: Rect2, b: Rect2) : Rect2 |
| + operator==(b: Rect2) : bool |
| + operator!=(b: Rect2) : bool |
| + Rect2() |
| + Rect2(b : Rect2) |
| + Rect2(x : float, y : float) |
| + Rect2(x : float, y : float, w : float, h : float) |
------------------------------------------------------|
intersects:
if (x >= (b.x + b.w))
return false;
if ((x + w) <= b.x)
return false;
if (y >= (b.y + b.h))
return false;
if ((y + h) <= b.y)
return false;
return true;
intersects_include_borders:
if (x > (b.x + b.w))
return false;
if ((x + w) < b.x)
return false;
if (y > (b.y + b.h))
return false;
if ((y + h) < b.y)
return false;
return true;
Encloses:
return (b.x >= x) && (b.y >= y) &&
((b.x + b.w) <= (x + w)) &&
((b.y + b.h) <= (y + h));
4. Implementáld az alábbi int-eket tároló vektor osztályt:
------------------------------------------------------|
| class IntVector |
|-----------------------------------------------------|
| + push_back(element : int) |
| + pop_back() | -> utolsó elem törlése
| + remove(index : int) |
| + erase(element : int) |
| + clear() |
| + empty() : bool |
| + get(index : int) : int |
| + get(index : int) : const &int, (const) | -> 5. feladatban már hasznos optimalizáció lesz,
| | amúgy igazából nincs értelme const referenciaként visszaadni intet
| + set(index : int, value : int) |
| + size() : int |
| + capacity() : int |
| + ensure_capacity(capacity : int) |
| + resize(size : int) |
| + append_array(other : IntVector) |
| + find(val : int) : int | -> Megkeresi az adott értéket, és visszaadja az indexét, illetve ha nem található -1 et
| + dataw() : int* | -> Visszaadja az adatokat tároló tömböt -> ki lehet optimalizálni vele függvényhívásokat, amikor fontos.
| + data() : const int*, (const) | -> Visszaadja az adatokat tároló tömböt, de ez konstans verzió.
| + operator[](index: int) : const &int, (const) | -> 5. feladatban már hasznos optimalizáció
| + operator[](index: int) : &int | -> Ha esetleg összeakad az eggyel fejlebb lévővel, akkor hagyjátok ki az egyiket, majd később kipróbálom én is
| + IntVector() |
| + IntVector(prealloc : int) |
| + IntVector(prealloc : int, grow_by : int) |
|-----------------------------------------------------|
| - _data : int* | -> Maga a tároló tömb
| - _actual_size : int | -> ekkora a tömb
| - _size : int | -> size() ezt adja vissza / ennyi elem van eltárolva a vektorban
| - _grow_by : int | -> Ha növelni kell a _data tömböt, akkor ennyivel legyen megnövelve
------------------------------------------------------|
5. A 4. feladatban elékszített IntVektor osztályból csinálj egy templatekkel általánosított Vector osztályt.
Fontos! A templatelt tagfüggvényeket implementációját vector.h-ba kell rakni! Vagy bele az osztályba, vagy a vector.h aljára!
Enélkül undefined reference hibákat fog dobmi a fordító!
Eddíg pl:
class IntVector {
int get(int index);
set(int index, int val);
void push_back(int val);
//etc...
IntVector();
private:
int *_data;
};
int main() {
IntVector a;
a.push_back(1);
a.push_back(2);
a.push_back(3);
a.push_back(4);
cout << a.get(1);
a.set(1, 4);
cout << a.get(1);
//etc...
return 0;
}
Most:
template <class T>
class Vector {
T get(int index);
set(int index, T val);
//etc...
Vector();
private:
T *_data;
};
int main() {
Vector<int> a; //Mindenhol ahol T-van, ki lessz replacelve int-re a compiler által!
a.push_back(1);
a.push_back(2);
a.push_back(3);
a.push_back(4);
cout << a.get(1);
a.set(1, 4);
cout << a.get(1);
//etc...
//de így már lehet:
Vector<float> b;
Vector<string> c;
//...
return 0;
}
7. Valamelyik vektor osztályból készíts egy saját String osztályt. (Vector<char> -al ekvivalens), de készítsd el
template nélkül, illetve adj hozzá általad hasznosnak ítélt függvényeket.
néhány ötlet: to_float(), to_double(), to_int(), trim(), replace(), find(val : String), begins_with(str : String) : bool, ends_with(),
sub_str(int from, int num = -1), c_str(), operator==, operator!=, operator=, operator+=, operator+, remove(str : String),
print(), format(), etc.
Megj: Ha implementáljátok a c_str() függvényt: Ez egy c/c++ on tömböt ad vissza (char *), és nyilván már tudjátok,
hogy egy ilyen tömbnek nem lehet megmondani a méretét. A trükk az, hogy ezek a c stringek nul termináltak.
Azaz az utolsó karakterük a 0 kontroll karaktert tartalmazza! Kódban: '\0' azza a 0. ASCII karakter.
Például, hogy egy ilyen char* es konstruktort szeretnétek csinálni, az valahogy így fog kinézni:
String::String(const char *p_c_str) {
_data = nullptr;
_actual_size = 0;
_size = 0;
_grow_by = 100;
int i = 0;
while (p_c_str[i] != '\0') {
push_back(p_c_str[i]);
++i;
}
}
8. Az előző feladatokban sok helyen meg lehet jelölni paramétereket konstansként, illetve pl. konstans referenciává lehet alakítani őket.
Menj végig az előző osztályokon, és mindenhol, ahol van értelme, ezeket add hozzá.
(int-eket/float okat csak konstanssá érdemes átrakni, referenciává tenni őket nincs értelme!)
(Érdemes másolatot csinálni, vagy pl. egy git commitban eltárolni az eredetieket, és csak úgy szerkesztgetni őket!)

43
01_vector2.txt Executable file
View File

@ -0,0 +1,43 @@
Implementáld az alábbi 2ds matematikai vektor osztályt:
------------------------------------------------|
| class Vector2 |
|-----------------------------------------------|
| + x : float | -> Nincs getter, és szetter, mert azok lassítanának. (Függvényhívásnak van minimális erőforrás igénye)
| + y : float | -> Ilyen matematikai osztályoknál, érdemes ilyeneket kioptimalizálni. PLussz leírni is sok. getx(), setx() etc.
| + abs() : Vector2 | -> visszaadja egy új vektorba ennek a vektornak az abszolút értékét. (x, y abszolút értékét veszi)
| | Abszolút érték képlet: ha egy a < 0 ret -a, else ret a;
| + angle() float | -> atan2(x, y)
| + angle_to(b : Vector2) : float | -> atan2(cross(b), dot(b));
| + cross(b : Vector2) : float | -> Cross product -> x * b.y - y * b.x;
| + clamped(len : float) : Vector2 | -> normalized() * len
| + direction_to(b : Vector2) : Vector2 | -> Visszaad egy normalizált vektort ami ebből b be mutat. (A képlet: (b - a).normalized()) (operator-)
| + distance_to_squared(b : Vector2) : float | -> (x - b.x) * (x - b.x) + (y - b.y) * (y - b.y);
| + distance_to(b : Vector2) : float | -> sqrt((x - b.x) * (x - b.x) + (y - b.y) * (y - b.y));
| + dot(b : Vector2) : float | -> dot product -> Ha a 2 vektor 90 fokosz szöget zár be, akkor 0.
| | Pozitív, ha a 2 vektor által bezárt szög kisebb mint 90 fok, negatív, ha nagyobb.
| | képlet: x * b.x + y * b.y.
| + is_equal_approx(b : Vector2) : bool | -> nagyjából egyenlőek-e a vektorok. A max különbség legyen 0.00001 (Epszilon).
| + length() : float | -> sqrt(x * x + y * y)
| + length_squared() : float | -> A hossz a gyökvonás nélkül. (A gyökvonás relatíve lassú, és ha csak össze kell
| | hasonlítani hosszakat, akkor elég így)
| + lerp(b : Vector2, t : float) : Vector2 | -> Linear interpolate -> a jelenlegi vektor és b közötti átmenetvektort adja vissza t paraméter felhasználásával.
| | A t 0 és 1 közötti. Képlet: newx = x + (t * (b.x - x)); és newy = y + (t * (b.y - y));
| + normalized() : Vector2 | -> A vektor normalizálva. Normalizált vektor = a hossza 1.
| | float l = length_squared(); ha nem 0, gyököt kell vonni belőle, és le kell osztani x, y-t is vele
| + normalize() | -> Maga a vektor normalizálódik.
| + add(b: Vector2) | -> x += b.x, y += b.y
| + sub(b: Vector2) | -> x -= b.x, y -= b.y
| + operator+=(b: Vector2) | etc
| + operator-=(b: Vector2) |
| + operator+(a: Vector2, b: Vector2) : Vector2 |
| + operator-(a: Vector2, b: Vector2) : Vector2 |
| + operator*=(b: float) | -> x és y-t is megszorozzuk b-vel.
| + operator*(Vector2 a, float b) : Vector2 | -> x és y-t is megszorozzuk b-vel.
| + operator==(b: Vector2, b: Vector2) : bool |
| + operator!=(b: Vector2, b: Vector2) : bool |
| + Vector2() |
| + Vector2(b : Vector2) |
| + Vector2(x : float, y : float) |
------------------------------------------------|

45
02_vector3.txt Executable file
View File

@ -0,0 +1,45 @@
Implementáld az alábbi 3ds matematikai vektor osztályt.
------------------------------------------------|
| class Vector3 |
|-----------------------------------------------|
| + x : float | -> Nincs getter, és szetter, mert azok lassítanának. (Függvényhívásnak van minimális erőforrás igénye)
| + y : float | -> Ilyen matematikai osztályoknál, érdemes ilyeneket kioptimalizálni. PLussz leírni is sok. getx(), setx() etc.
| + z : float |
| + abs() : Vector3 | -> visszaadja egy új vektorba ennek a vektornak az abszolút értékét. (x, y, y abszolút értékét veszi)
| | Abszolút érték képlet: ha egy a < 0 ret -a, else ret a;
| + angle_to(b : Vector3) : float | -> atan2(cross(b).length(), dot(b));
| + cross(b : Vector3) : Vector3 | -> Cross product -> x = (y * b.z) - (z * b.y), y = (z * b.x) - (x * b.z), z = (x * b.y) - (y * b.x)
| + clamped(len : float) : Vector3 | -> normalized() * len
| + direction_to(b : Vector3) : Vector3 | -> Visszaad egy normalizált vektort ami ebből b be mutat. (A képlet: (b - a).normalized())
| + distance_to_squared(b : Vector3) : float | -> return (b - *this).length_squared(); -> *this -> dereferencia operátor -> a this alapba mutató
| + distance_to(b : Vector3) : float | -> return (b - *this).length();
| + dot(b : Vector3) : float | -> dot product -> Ha a 2 vektor 90 fokosz szöget zár be, akkor 0.
| | Pozitív, ha a 2 vektor által bezárt szög kisebb mint 90 fok, negatív, ha nagyobb.
| | képlet: x * b.x + y * b.y + z * b.z.
| + is_equal_approx(b : Vector3) : bool | -> nagyjából egyenlőek-e a vektorok. A max különbség legyen 0.00001 (Epszilon).
| + length() : float | -> sqrt(x * x + y * y + z * z)
| + length_squared() : float | -> A hossz a gyökvonás nélkül. (A gyökvonás relatíve lassú, és ha csak össze kell
| | hasonlítani hosszakat, akkor elég így)
| + lerp(b : Vector3, t : float) : Vector3 | -> Linear interpolate -> a jelenlegi vektor és b közötti átmenetvektort adja vissza t paraméter felhasználásával.
| | A t 0 és 1 közötti. Képlet: newx = x + (t * (b.x - x)); és newy = y + (t * (b.y - y));
| | newy = z + (t * (b.z - z));
| + normalized() : Vector3 | -> A vektor normalizálva. Normalizált vektor = a hossza 1.
| | float l = length_squared(); ha nem 0, gyököt kell vonni belőle, és le kell osztani x, y, z-t is vele
| + normalize() | -> A vektor normalizálódik.
| + add(b: Vector3) | -> x += b.x, y += b.y, z += b.z
| + sub(b: Vector3) | -> x -= b.x, y -= b.y, z -= b.z
| + operator+=(b: Vector3) | etc.
| + operator-=(b: Vector3) |
| + operator+(a: Vector3, b: Vector3) : Vector3 |
| + operator-(a: Vector3, b: Vector3) : Vector3 |
| + operator*=(b: float) | -> x,y és z-t is megszorozzuk b-vel.
| + operator*(Vector2 a, float b) : Vector2 | -> x,y és z-t is megszorozzuk b-vel.
| + operator==(b: Vector3, b: Vector2) : bool |
| + operator!=(b: Vector3, b: Vector2) : bool |
| + Vector3() |
| + Vector3(b : Vector3) |
| + Vector3(x : float, y : float, z : float) |
------------------------------------------------|

533
03_monopoly.txt
View File

@ -1,533 +0,0 @@
Írni fogunk egy leegyszerűsített Monopoly szerűséget.
Ebben a példában már használni fogunk öröklődést, és polimorfizmust is!
----------------------------------------------------------------------
Ahol csak lehet, használd fel az előzőleg megírt osztályaidat!
Ha szükséged van egy függvényre, amely nem található meg még a már
kész osztályodban, akkor azt add hozzá.
Például ha a Math osztályodba a te megoldásodhoz hiányzik valamilyen
függvény, akkor oda írd meg, ne csak direktbe felhasználd valamelyik
beépített header-ből!
Ha a vektorod remove() függvénye nem tartja meg a sorrendet, akkor
adj hozzá egy remove_keep_order() függvényt.
Egyéb:
Kicsit kiegyszerűsítettem az UML diagramokat, már gyakorlatilag c++
kódként néznek ki. Az előző feladatokban a tárgy által elvárt módon
voltak írva, de mostantól nem fogom annyira átszerkeszteni.
----------------------------------------------------------------------
A játékszabályok, amiket implementálni fogunk:
A játék n db ját;kossal indul. Mindenkinek van valamennyi pénze
(legyen egyenként megadható). És van egy játékmező. (Mint a valódi
monopolyban kb).
A játékmezőn vannak mezők. Ezeknek a típusai:
- TaxTile - Amikor a játékos rálép ennyi adót kell fizetnie.
- OwnableTile - Ez olyan mező, amit meg lehet venni. Van vátelára,
illetve egy belépési költsége. Ha egy játékos rálép, és még senkié,
akkor az a játékos megveheti a vételárért cserébe. Ha nem veszi meg,
nem kell fizetnie semmit. Ha valaki megveszi, akkor mindenki másnak,
aki rálép meg kell fizetnie a tulajdonosnak a belépési díjat.
Ha a tulajdonos kiesik a játékból, akkor az összes tulajdona
felszabadul.
- GainTile - Aki rálép az egy meghatározott összeget kap.
- LuckTile - Aki rálép kaphat megadott %-nyi eséllyel,
két megadott érték közötti pénzt.
- JailTile - Aki rálép, a megadott környi ideig börtönbe kerül, azaz
annzi körig nem léphet.
Egy játékos akkor esik ki, ha elfogyott minden pénze.
Az nyer, aki a legutoljára bent marad.
A játékosok előre meghatározott, fix sorrendben jönnek egymás után,
a körük elején dobnak 1db 6 oldalú dobókockával, majd annyit lépnek,
amennyit dobtak, és a mező amire érkeztek hattásal lesz rájuk.
A játékosok a játékmezőn körbe-körbe haladnak.
A játékot úgy fogjuk megírni, hogy legyenek különböző személyiségü
gépi játékosok:
Agresszív: Mindent megvesz, amíg van rá pénze.
Konzervatív: Ha a mező ára kevesebb, mint a pénzének a fele, akkor megveszi,
Ügyeskedő: 50% eséllyel megveszi a mezőt, ha van rá lehetősége.
Emberi: Megkérdezi a felhasználót, hogy mit akar tenni.
Csaló: Mindent megvesz, amit csak tud. (csak 4, 5, 6-okat dobhat)
A játékosok beállításait, és a mezőket is fájlból töltsük be.
Konzolos program lesz, szóval mindent ami fontos, a konzolra kell
majd kiírnunk, és a konzolról kell beolvasni, ha kérdezni szeretnénk a
felhasználótól.
A feladat, hogy ezt implementáljuk.
Kezdjük a játékos osztályokkal:
|--------------------------------------------------------------------------|
| class Player |
|--------------------------------------------------------------------------|
| + String get_name(); |
| + void set_name(const String &name); |
| |
| + int get_tile_index() const; |
| + void set_tile_index(const int val); |
| |
| + int get_money() const; |
| + void set_money(const int val); |
| |
| + int get_jail_time() const; |
| + void set_jail_time(const int val); |
| |
| + bool get_lost() const; |
| + void set_lost(const bool val); |
| |
| + virtual bool want_buy(const String &tile_name, int price); |
| + virtual int throw_dice(); |
| + virtual void on_lose(); |
| |
| + virtual void print(); |
| |
| + virtual String get_class_name(); |
| |
| + Player(); |
| + virtual ~Player(); |
| |
| - String _name; |
| - int _tile_index; |
| - int _money; |
| - int _jail_time; |
| - bool _lost; |
|--------------------------------------------------------------------------|
Amik nem nyilvánvalók:
set_money, set_jail_time -> írjon üzenetet a konzolra.
set_lost(val) -> ha a val true, hívja meg az on_lost() függvényt.
want_buy() függvénnyel fogja megkérdezni a rendszer, hogy meg akarja-e
venni a játékos a jelenlegi mezőt.
Megj.: nagy programban valószínűleg érdemes lenne a magát a Tile osztályt
odaadni pointerkénkt, viszont a Tile osztálynak is kelleni fog majd, a
Player osztály.
Ezt aműgy meg lehet oldani, méghozzá úgy, hogy a Tile osztály a Player
headerje tetején előre van deklarálva (class Tile;), a Player osztály
a Tile headerje tetején van előre deklarálva (class Player;), és csak a
.cpp fájlokoban vannak maguk a headerek beincludeolva.
Hogy könnyítsek a dolgotokon, ezt kihagytam, viszont ha valaki elég erőt
érez magában, az mindenképp csinálja így!
Ekkor így fog kinézni a függvény:
virtual bool want_buy(Tile *tile);
(A volt paraméterek elérhetők a Tile osztály gettereivel.)
int throw_dice(); Kockadobás 1-6 ig.
on_lose() A játékos kiírja a konzolra, hogy vesztett. Mindegyik típus
kicsit máshogy.
print() Kiírja magát a játékos a konzolra.
get_class_name() Visszaadja a játékos osztályának a nevét.
pl itt return "Player";
A kényelem miatt van bent, a print()-hez.
|--------------------------------------------------------------------------|
| class AgressivePlayer : public Player |
|--------------------------------------------------------------------------|
| + bool want_buy(const String &tile_name, int price); |
| + void on_lose(); |
| |
| + String get_class_name(); |
| |
| + AgressivePlayer(); |
|--------------------------------------------------------------------------|
Agresszív: Mindent megvesz, amíg van rá pénze.
|--------------------------------------------------------------------------|
| class ConservativePlayer : public Player |
|--------------------------------------------------------------------------|
| + bool want_buy(const String &tile_name, int price); |
| + void on_lose(); |
| |
| + String get_class_name(); |
| |
| + ConservativePlayer(); |
|--------------------------------------------------------------------------|
Konzervatív: Ha a mező ára kevesebb, mint a pénzének a fele, akkor megveszi,
|--------------------------------------------------------------------------|
| class TrickyPlayer : public Player |
|--------------------------------------------------------------------------|
| + bool want_buy(const String &tile_name, int price); |
| + void on_lose(); |
| |
| + String get_class_name(); |
| |
| + TrickyPlayer(); |
|--------------------------------------------------------------------------|
Ügyeskedő: 50% eséllyel megveszi a mezőt, ha van rá lehetősége.
|--------------------------------------------------------------------------|
| class HumanPlayer : public Player |
|--------------------------------------------------------------------------|
| + bool want_buy(const String &tile_name, int price); |
| + void on_lose(); |
| |
| + String get_class_name(); |
| |
| + HumanPlayer(); |
|--------------------------------------------------------------------------|
Emberi: Megkérdezi a felhasználót, hogy mit akar tenni.
|--------------------------------------------------------------------------|
| class CheatingPlayer : public Player |
|--------------------------------------------------------------------------|
| + bool want_buy(const String &tile_name, int price); |
| + int throw_dice(); |
| + void on_lose(); |
| |
| + String get_class_name(); |
| |
| + CheatingPlayer(); |
|--------------------------------------------------------------------------|
Csaló: Mindent megvesz, amit csak tud. (és csak 4, 5, 6-okat dobhat)
|--------------------------------------------------------------------------|
| class PlayerLoader |
|--------------------------------------------------------------------------|
| + static Vector<Player *> load_player_file(const String &file_name); |
|--------------------------------------------------------------------------|
Segít betölteni egy játékosok leírását tartalmaző filet.
(Java-ban valószínűleg PlayerFactory lenne a neve.)
Mindegy, hogy a file hogy néz ki. De itt egy példa:
Player 10000 AA
AgressivePlayer 20000 BC
ConservativePlayer 20000 DA
TrickyPlayer 20000 FA
HumanPlayer 20000 RR
CheatingPlayer 20000 AF
|--------------------------------------------------------------------------|
| class Tile |
|--------------------------------------------------------------------------|
| + String get_name(); |
| + void set_name(const String &name); |
| |
| + virtual void on_player_arrived(Player *p); |
| |
| + virtual void reset(); |
| |
| + virtual void print(); |
| + virtual String get_class_name(); |
| |
| + Tile(); |
| + virtual ~Tile(); |
| |
| - String _name; |
|--------------------------------------------------------------------------|
A Mező osztály.
A rendszer majd az on_player_arrived() függvényt hívja meg, miután egy
játékos dobott, és rálép a következő mezőre.
Ez a függvény mindent releváns információt írjon a konzolra.
Itt maja a Mező fogja pl növelni a játékos pénzét, vagy börtönbe tenni,
vagy megkérdezni, hogy meg akarja-e venni meg át a mezőt.
reset() csak a OwnableTile fog itt valamit csinálni, ugyanis ebben
ki fogja nullázni a tulajdonosát. (Ez két játék közötti kinullázásra való)
A többit, ami esetleg nem triviális, lásd a player-nél.
|--------------------------------------------------------------------------|
| class TaxTile : public Tile |
|--------------------------------------------------------------------------|
| + int get_tax() const; |
| + void set_tax(const int tax); |
| |
| + void on_player_arrived(Player *p); |
| + void print(); |
| + String get_class_name(); |
| |
| + TaxTile(); |
| |
| - int _tax; |
|--------------------------------------------------------------------------|
- TaxTile - Amikor a játékos rálép ennyi adót kell fizetnie.
|--------------------------------------------------------------------------|
| class OwnableTile : public Tile |
|--------------------------------------------------------------------------|
| + int get_price() const; |
| + void set_price(const int val); |
| |
| + int get_enter_price() const; |
| + void set_enter_price(const int val); |
| |
| + Player *get_owner() const; |
| + void set_owner(Player *val); |
| |
| + void on_player_arrived(Player *p); |
| + void print(); |
| + void reset(); |
| |
| + String get_class_name(); |
| |
| + OwnableTile(); |
| |
| - int _price; |
| - int _enter_price; |
| - Player *_owner; |
|--------------------------------------------------------------------------|
- OwnableTile - Ez olyan mező, amit meg lehet venni. Van vételára,
illetve egy belépési költsége. Ha egy játékos rálép, és még senkié,
akkor az a játékos megveheti a vételárért cserébe. Ha nem veszi meg,
nem kell fizetnie semmit. Ha valaki megveszi, akkor mindenki másnak,
aki rálép meg kell fizetnie a tulajdonosnak a belépési díjat.
Ha a tulajdonos kiesik a játékból, akkor az összes tulajdona
felszabadul.
|--------------------------------------------------------------------------|
| class GainTile : public Tile |
|--------------------------------------------------------------------------|
| + int get_gain() const; |
| + void set_gain(const int val); |
| |
| + void on_player_arrived(Player *p); |
| + void print(); |
| + String get_class_name(); |
| |
| + GainTile(); |
| |
| - int _gain; |
|--------------------------------------------------------------------------|
- GainTile - Aki rálép az egy meghatározott összeget kap.
|--------------------------------------------------------------------------|
| class LuckTile : public Tile |
|--------------------------------------------------------------------------|
| + int get_chance() const; |
| + void set_chance(const int val); |
| |
| + int get_gain_min() const; |
| + void set_gain_min(const int val); |
| |
| + int get_gain_max() const; |
| + void set_gain_max(const int val); |
| |
| + void on_player_arrived(Player *p); |
| + void print(); |
| + String get_class_name(); |
| |
| + LuckTile(); |
| |
| - int _chance; |
| - int _gain_min; |
| - int _gain_max; |
|--------------------------------------------------------------------------|
- LuckTile - Aki rálép kaphat megadott %-nyi eséllyel,
két megadott érték közötti pénzt.
|--------------------------------------------------------------------------|
| class JailTile : public Tile |
|--------------------------------------------------------------------------|
| + int get_jail_time() const; |
| + void set_jail_time(const int val); |
| |
| + void on_player_arrived(Player *p); |
| + void print(); |
| + String get_class_name(); |
| |
| + JailTile(); |
| |
| - int _jail_time; |
|--------------------------------------------------------------------------|
- JailTile - Aki rálép, a megadott környi ideig börtönbe kerül, azaz
annyi körig nem léphet.
|--------------------------------------------------------------------------|
| class TileLoader |
|--------------------------------------------------------------------------|
| + static Vector<Tile *> load_tile_file(const String &file_name); |
|--------------------------------------------------------------------------|
Ugyanolyan betöltő osztály, mint a játékos estében.
Példa file szerkezet:
Tile A
TaxTile B 3433
TaxTile C 3433
OwnableTile D 222 22
OwnableTile E 222 22
OwnableTile F 222 22
GainTile G 100
TaxTile H 3433
LuckTile I 50 100 200
TaxTile J 3433
JailTile K 3
TaxTile L 3433
TaxTile M 3433
TaxTile N 3433
|--------------------------------------------------------------------------|
| class Board |
|--------------------------------------------------------------------------|
| + Player *get_current_player(); |
| + Player *get_previous_player(); |
| |
| + int get_turn() const; |
| + void set_turn(const int turn); |
| |
| + Vector<Tile *> get_tiles() const; |
| + void set_tiles(const Vector<Tile *> &tiles); |
| |
| + Vector<Player *> get_active_players() const; |
| + void set_active_players(const Vector<Player *> &players); |
| |
| + Vector<Player *> get_lost_players() const; |
| + void set_lost_players(const Vector<Player *> &players); |
| |
| + void load(const String &tile_file, const String &player_file); |
| + void load_players(const String &file); |
| + void load_tiles(const String &file); |
| |
| + void step(); |
| + void run(); |
| |
| + void on_game_finished(); |
| |
| + void clear(); |
| + void clear_players(); |
| + void reset(); |
| |
| + void print(); |
| |
| + Board(); |
| + Board(const String &tile_file, const String &player_file); |
| + virtual ~Board(); |
| |
| - Vector<Tile *> _tiles; |
| - Vector<Player *> _active_players; |
| - Vector<Player *> _lost_players; |
| - |
| - Player *_previous_player; |
| - int _current_player_index; |
| - int _turn; |
|--------------------------------------------------------------------------|
on_game_finished() a játékról kiír a konzolra mindenféle információt,
miután véget ért.
run() a fő ciklus, a step() függvényt hívogatja, amíg több mint 1
aktív játékos van. Esetleg kiléphet nagy _turn szám után is.
Ha a ciklus kilépett, hívja meg az on_game_finished()-et.
clear() Minden vektort kiürít.
clear_players() csak a 2 játékos vektort üríti ki.
ne felejtsétek ez felszabadítani a memóriát! (delete).
step():
Egy játékos körének a kezelése.
Az algoritmus:
1. Fogjuk meg az aktív játékost.
2. Ha börtönben van, vonjunk le egy kört a börtönének számából, és kész.
3. Dobassunk vele kockát.
4. Számoljuk ki (modulo), hogy melyik mezőre érkezett. (player get_tile_index())
5. Állítsuk be az új mező indexét neki (set_tile_index()).
6. kérjük ki a megfelelő mezőt a _tiles vektorból, és hívjuk meg a
on_player_arrived(p); függvényét, a játékost adjuk be paraméternek.
7. Állítsuk be a _previous_player osztályváltozót a jelenlegi játékosra.
8. Ha ajátékos vesztett (get_lost()), akkor rakjuk ár a _lost_players
veektorba, majd ellenőrizzük, hogy a _current_player_index nem indexel-e
túl a játékosok vektorán. Ha igen, akkor állítsuk a
_current_player_index-et 0-ra. (ugye eggyel csökkent a vektor mérete.)
9. Egyébként növeljük meg a _current_player_index-et 1-el, és ugyanúgy
ellenűrizzük, hogy a _current_player_index nem indexel-e
túl a játékosok vektorán, ha igen, akkor állítsuk a
_current_player_index-et 0-ra.
main.cpp + int main() :
A main függvénybe csak ennyi legyen:
Math::randomize();
Board b;
b.load("tiles.config", "players.config");
b.run();
b.print();
return 0;
Nyilvánvalóan a "tiles.config", "players.config" fájlokat hozzátok létre.

67
03_rect2.txt Executable file
View File

@ -0,0 +1,67 @@
Implementáld az alábbi matematikai négyzet osztályt.
------------------------------------------------------|
| class Rect2 |
|-----------------------------------------------------|
| + x : float |
| + y : float |
| + w : float |
| + h : float |
| + get_area() : float | -> Terület (w * h)
| + intersects(b : Rect2) : bool | -> Lejjebb
| + intersects_include_borders(b : Rect2) : bool | -> Lejjebb
| + encloses(b : Rect2) : bool | -> Lejjebb
| + has_no_area() : bool |
| + has_point(x : float, y : float) : bool |
| + is_equal_approx(b : Rect2) : bool |
| + grow(by : float) | -> x, y, csökkent, w,h növel by-al
| + shrink(by : float) | -> x, y, növel, w,h csökkent by-al
| + operator+=(b: Rect2) |
| + operator-=(b: Rect2) |
| + operator+(a: Rect2, b: Rect2) : Rect2 |
| + operator-(a: Rect2, b: Rect2) : Rect2 |
| + operator==(b: Rect2) : bool |
| + operator!=(b: Rect2) : bool |
| + Rect2() |
| + Rect2(b : Rect2) |
| + Rect2(x : float, y : float) |
| + Rect2(x : float, y : float, w : float, h : float) |
------------------------------------------------------|
intersects:
if (x >= (b.x + b.w))
return false;
if ((x + w) <= b.x)
return false;
if (y >= (b.y + b.h))
return false;
if ((y + h) <= b.y)
return false;
return true;
intersects_include_borders:
if (x > (b.x + b.w))
return false;
if ((x + w) < b.x)
return false;
if (y > (b.y + b.h))
return false;
if ((y + h) < b.y)
return false;
return true;
Encloses:
return (b.x >= x) && (b.y >= y) &&
((b.x + b.w) <= (x + w)) &&
((b.y + b.h) <= (y + h));

35
04_int_vector.txt Executable file
View File

@ -0,0 +1,35 @@
Implementáld az alábbi int-eket tároló vektor osztályt:
------------------------------------------------------|
| class IntVector |
|-----------------------------------------------------|
| + push_back(element : int) |
| + pop_back() | -> utolsó elem törlése
| + remove(index : int) |
| + erase(element : int) |
| + clear() |
| + empty() : bool |
| + get(index : int) : int |
| + get(index : int) : const &int, (const) | -> 5. feladatban már hasznos optimalizáció lesz,
| | amúgy igazából nincs értelme const referenciaként visszaadni intet
| + set(index : int, value : int) |
| + size() : int |
| + capacity() : int |
| + ensure_capacity(capacity : int) |
| + resize(size : int) |
| + append_array(other : IntVector) |
| + find(val : int) : int | -> Megkeresi az adott értéket, és visszaadja az indexét, illetve ha nem található -1 et
| + dataw() : int* | -> Visszaadja az adatokat tároló tömböt -> ki lehet optimalizálni vele függvényhívásokat, amikor fontos.
| + data() : const int*, (const) | -> Visszaadja az adatokat tároló tömböt, de ez konstans verzió.
| + operator[](index: int) : const &int, (const) | -> 5. feladatban már hasznos optimalizáció
| + operator[](index: int) : &int | -> Ha esetleg összeakad az eggyel fejlebb lévővel, akkor hagyjátok ki az egyiket, majd később kipróbálom én is
| + IntVector() |
| + IntVector(prealloc : int) |
| + IntVector(prealloc : int, grow_by : int) |
|-----------------------------------------------------|
| - _data : int* | -> Maga a tároló tömb
| - _actual_size : int | -> ekkora a tömb
| - _size : int | -> size() ezt adja vissza / ennyi elem van eltárolva a vektorban
| - _grow_by : int | -> Ha növelni kell a _data tömböt, akkor ennyivel legyen megnövelve
------------------------------------------------------|

82
05_vector.txt Executable file
View File

@ -0,0 +1,82 @@
A 4. feladatban elékszített IntVektor osztályból csinálj egy templatekkel általánosított Vector osztályt.
Fontos! A templatelt tagfüggvényeket implementációját vector.h-ba kell rakni! Vagy bele az osztályba, vagy a vector.h aljára!
Enélkül undefined reference hibákat fog dobmi a fordító!
Eddíg pl:
class IntVector {
int get(int index);
set(int index, int val);
void push_back(int val);
//etc...
IntVector();
private:
int *_data;
};
int main() {
IntVector a;
a.push_back(1);
a.push_back(2);
a.push_back(3);
a.push_back(4);
cout << a.get(1);
a.set(1, 4);
cout << a.get(1);
//etc...
return 0;
}
Most:
template <class T>
class Vector {
T get(int index);
set(int index, T val);
//etc...
Vector();
private:
T *_data;
};
int main() {
Vector<int> a; //Mindenhol ahol T-van, ki lessz replacelve int-re a compiler által!
a.push_back(1);
a.push_back(2);
a.push_back(3);
a.push_back(4);
cout << a.get(1);
a.set(1, 4);
cout << a.get(1);
//etc...
//de így már lehet:
Vector<float> b;
Vector<string> c;
//...
return 0;
}

25
06_string.txt Executable file
View File

@ -0,0 +1,25 @@
Valamelyik vektor osztályból készíts egy saját String osztályt. (Vector<char> -al ekvivalens), de készítsd el
template nélkül, illetve adj hozzá általad hasznosnak ítélt függvényeket.
néhány ötlet: to_float(), to_double(), to_int(), trim(), replace(), find(val : String), begins_with(str : String) : bool, ends_with(),
sub_str(int from, int num = -1), c_str(), operator==, operator!=, operator=, operator+=, operator+, remove(str : String),
print(), format(), etc.
Megj: Ha implementáljátok a c_str() függvényt: Ez egy c/c++ on tömböt ad vissza (char *), és nyilván már tudjátok,
hogy egy ilyen tömbnek nem lehet megmondani a méretét. A trükk az, hogy ezek a c stringek nul termináltak.
Azaz az utolsó karakterük a 0 kontroll karaktert tartalmazza! Kódban: '\0' azza a 0. ASCII karakter.
Például, hogy egy ilyen char* es konstruktort szeretnétek csinálni, az valahogy így fog kinézni:
String::String(const char *p_c_str) {
_data = nullptr;
_actual_size = 0;
_size = 0;
_grow_by = 100;
int i = 0;
while (p_c_str[i] != '\0') {
push_back(p_c_str[i]);
++i;
}
}

6
07_consts.txt Executable file
View File

@ -0,0 +1,6 @@
Az előző feladatokban sok helyen meg lehet jelölni paramétereket konstansként, illetve pl. konstans referenciává lehet alakítani őket.
Menj végig az előző osztályokon, és mindenhol, ahol van értelme, ezeket add hozzá.
(int-eket/float okat csak konstanssá érdemes átrakni, referenciává tenni őket nincs értelme!)
(Érdemes másolatot csinálni, vagy pl. egy git commitban eltárolni az eredetieket, és csak úgy szerkesztgetni őket!)

0
02_math_osztaly.txt → 08_math.txt
View File

77
09_monopoly.txt Normal file
View File

@ -0,0 +1,77 @@
Írni fogunk egy leegyszerűsített Monopoly szerűséget.
Ebben a példában már használni fogunk öröklődést, és polimorfizmust is!
----------------------------------------------------------------------
Ahol csak lehet, használd fel az előzőleg megírt osztályaidat!
Ha szükséged van egy függvényre, amely nem található meg még a már
kész osztályodban, akkor azt add hozzá.
Például ha a Math osztályodba a te megoldásodhoz hiányzik valamilyen
függvény, akkor oda írd meg, ne csak direktbe felhasználd valamelyik
beépített header-ből!
Ha a vektorod remove() függvénye nem tartja meg a sorrendet, akkor
adj hozzá egy remove_keep_order() függvényt.
Egyéb:
Kicsit kiegyszerűsítettem az UML diagramokat, már gyakorlatilag c++
kódként néznek ki. Az előző feladatokban a tárgy által elvárt módon
voltak írva, de mostantól nem fogom annyira átszerkeszteni.
----------------------------------------------------------------------
A játékszabályok, amiket implementálni fogunk:
A játék n db ját;kossal indul. Mindenkinek van valamennyi pénze
(legyen egyenként megadható). És van egy játékmező. (Mint a valódi
monopolyban kb).
A játékmezőn vannak mezők. Ezeknek a típusai:
- TaxTile - Amikor a játékos rálép ennyi adót kell fizetnie.
- OwnableTile - Ez olyan mező, amit meg lehet venni. Van vátelára,
illetve egy belépési költsége. Ha egy játékos rálép, és még senkié,
akkor az a játékos megveheti a vételárért cserébe. Ha nem veszi meg,
nem kell fizetnie semmit. Ha valaki megveszi, akkor mindenki másnak,
aki rálép meg kell fizetnie a tulajdonosnak a belépési díjat.
Ha a tulajdonos kiesik a játékból, akkor az összes tulajdona
felszabadul.
- GainTile - Aki rálép az egy meghatározott összeget kap.
- LuckTile - Aki rálép kaphat megadott %-nyi eséllyel,
két megadott érték közötti pénzt.
- JailTile - Aki rálép, a megadott környi ideig börtönbe kerül, azaz
annzi körig nem léphet.
Egy játékos akkor esik ki, ha elfogyott minden pénze.
Az nyer, aki a legutoljára bent marad.
A játékosok előre meghatározott, fix sorrendben jönnek egymás után,
a körük elején dobnak 1db 6 oldalú dobókockával, majd annyit lépnek,
amennyit dobtak, és a mező amire érkeztek hattásal lesz rájuk.
A játékosok a játékmezőn körbe-körbe haladnak.
A játékot úgy fogjuk megírni, hogy legyenek különböző személyiségü
gépi játékosok:
Agresszív: Mindent megvesz, amíg van rá pénze.
Konzervatív: Ha a mező ára kevesebb, mint a pénzének a fele, akkor megveszi,
Ügyeskedő: 50% eséllyel megveszi a mezőt, ha van rá lehetősége.
Emberi: Megkérdezi a felhasználót, hogy mit akar tenni.
Csaló: Mindent megvesz, amit csak tud. (csak 4, 5, 6-okat dobhat)
A játékosok beállításait, és a mezőket is fájlból töltsük be.
Konzolos program lesz, szóval mindent ami fontos, a konzolra kell
majd kiírnunk, és a konzolról kell beolvasni, ha kérdezni szeretnénk a
felhasználótól.
A feladat, hogy ezt implementáljuk.

170
10_monopoly_players.txt Normal file
View File

@ -0,0 +1,170 @@
Kezdjük a játékos osztályokkal:
|--------------------------------------------------------------------------|
| class Player |
|--------------------------------------------------------------------------|
| + String get_name(); |
| + void set_name(const String &name); |
| |
| + int get_tile_index() const; |
| + void set_tile_index(const int val); |
| |
| + int get_money() const; |
| + void set_money(const int val); |
| |
| + int get_jail_time() const; |
| + void set_jail_time(const int val); |
| |
| + bool get_lost() const; |
| + void set_lost(const bool val); |
| |
| + virtual bool want_buy(const String &tile_name, int price); |
| + virtual int throw_dice(); |
| + virtual void on_lose(); |
| |
| + virtual void print(); |
| |
| + virtual String get_class_name(); |
| |
| + Player(); |
| + virtual ~Player(); |
| |
| - String _name; |
| - int _tile_index; |
| - int _money; |
| - int _jail_time; |
| - bool _lost; |
|--------------------------------------------------------------------------|
Amik nem nyilvánvalók:
set_money, set_jail_time -> írjon üzenetet a konzolra.
set_lost(val) -> ha a val true, hívja meg az on_lost() függvényt.
want_buy() függvénnyel fogja megkérdezni a rendszer, hogy meg akarja-e
venni a játékos a jelenlegi mezőt.
Megj.: nagy programban valószínűleg érdemes lenne a magát a Tile osztályt
odaadni pointerkénkt, viszont a Tile osztálynak is kelleni fog majd, a
Player osztály.
Ezt aműgy meg lehet oldani, méghozzá úgy, hogy a Tile osztály a Player
headerje tetején előre van deklarálva (class Tile;), a Player osztály
a Tile headerje tetején van előre deklarálva (class Player;), és csak a
.cpp fájlokoban vannak maguk a headerek beincludeolva.
Hogy könnyítsek a dolgotokon, ezt kihagytam, viszont ha valaki elég erőt
érez magában, az mindenképp csinálja így!
Ekkor így fog kinézni a függvény:
virtual bool want_buy(Tile *tile);
(A volt paraméterek elérhetők a Tile osztály gettereivel.)
int throw_dice(); Kockadobás 1-6 ig.
on_lose() A játékos kiírja a konzolra, hogy vesztett. Mindegyik típus
kicsit máshogy.
print() Kiírja magát a játékos a konzolra.
get_class_name() Visszaadja a játékos osztályának a nevét.
pl itt return "Player";
A kényelem miatt van bent, a print()-hez.
|--------------------------------------------------------------------------|
| class AgressivePlayer : public Player |
|--------------------------------------------------------------------------|
| + bool want_buy(const String &tile_name, int price); |
| + void on_lose(); |
| |
| + String get_class_name(); |
| |
| + AgressivePlayer(); |
|--------------------------------------------------------------------------|
Agresszív: Mindent megvesz, amíg van rá pénze.
|--------------------------------------------------------------------------|
| class ConservativePlayer : public Player |
|--------------------------------------------------------------------------|
| + bool want_buy(const String &tile_name, int price); |
| + void on_lose(); |
| |
| + String get_class_name(); |
| |
| + ConservativePlayer(); |
|--------------------------------------------------------------------------|
Konzervatív: Ha a mező ára kevesebb, mint a pénzének a fele, akkor megveszi,
|--------------------------------------------------------------------------|
| class TrickyPlayer : public Player |
|--------------------------------------------------------------------------|
| + bool want_buy(const String &tile_name, int price); |
| + void on_lose(); |
| |
| + String get_class_name(); |
| |
| + TrickyPlayer(); |
|--------------------------------------------------------------------------|
Ügyeskedő: 50% eséllyel megveszi a mezőt, ha van rá lehetősége.
|--------------------------------------------------------------------------|
| class HumanPlayer : public Player |
|--------------------------------------------------------------------------|
| + bool want_buy(const String &tile_name, int price); |
| + void on_lose(); |
| |
| + String get_class_name(); |
| |
| + HumanPlayer(); |
|--------------------------------------------------------------------------|
Emberi: Megkérdezi a felhasználót, hogy mit akar tenni.
|--------------------------------------------------------------------------|
| class CheatingPlayer : public Player |
|--------------------------------------------------------------------------|
| + bool want_buy(const String &tile_name, int price); |
| + int throw_dice(); |
| + void on_lose(); |
| |
| + String get_class_name(); |
| |
| + CheatingPlayer(); |
|--------------------------------------------------------------------------|
Csaló: Mindent megvesz, amit csak tud. (és csak 4, 5, 6-okat dobhat)
|--------------------------------------------------------------------------|
| class PlayerLoader |
|--------------------------------------------------------------------------|
| + static Vector<Player *> load_player_file(const String &file_name); |
|--------------------------------------------------------------------------|
Segít betölteni egy játékosok leírását tartalmaző filet.
(Java-ban valószínűleg PlayerFactory lenne a neve.)
Mindegy, hogy a file hogy néz ki. De itt egy példa:
Player 10000 AA
AgressivePlayer 20000 BC
ConservativePlayer 20000 DA
TrickyPlayer 20000 FA
HumanPlayer 20000 RR
CheatingPlayer 20000 AF

184
11_monopoly_tiles.txt Normal file
View File

@ -0,0 +1,184 @@
|--------------------------------------------------------------------------|
| class Tile |
|--------------------------------------------------------------------------|
| + String get_name(); |
| + void set_name(const String &name); |
| |
| + virtual void on_player_arrived(Player *p); |
| |
| + virtual void reset(); |
| |
| + virtual void print(); |
| + virtual String get_class_name(); |
| |
| + Tile(); |
| + virtual ~Tile(); |
| |
| - String _name; |
|--------------------------------------------------------------------------|
A Mező osztály.
A rendszer majd az on_player_arrived() függvényt hívja meg, miután egy
játékos dobott, és rálép a következő mezőre.
Ez a függvény mindent releváns információt írjon a konzolra.
Itt maja a Mező fogja pl növelni a játékos pénzét, vagy börtönbe tenni,
vagy megkérdezni, hogy meg akarja-e venni meg át a mezőt.
reset() csak a OwnableTile fog itt valamit csinálni, ugyanis ebben
ki fogja nullázni a tulajdonosát. (Ez két játék közötti kinullázásra való)
A többit, ami esetleg nem triviális, lásd a player-nél.
|--------------------------------------------------------------------------|
| class TaxTile : public Tile |
|--------------------------------------------------------------------------|
| + int get_tax() const; |
| + void set_tax(const int tax); |
| |
| + void on_player_arrived(Player *p); |
| + void print(); |
| + String get_class_name(); |
| |
| + TaxTile(); |
| |
| - int _tax; |
|--------------------------------------------------------------------------|
- TaxTile - Amikor a játékos rálép ennyi adót kell fizetnie.
|--------------------------------------------------------------------------|
| class OwnableTile : public Tile |
|--------------------------------------------------------------------------|
| + int get_price() const; |
| + void set_price(const int val); |
| |
| + int get_enter_price() const; |
| + void set_enter_price(const int val); |
| |
| + Player *get_owner() const; |
| + void set_owner(Player *val); |
| |
| + void on_player_arrived(Player *p); |
| + void print(); |
| + void reset(); |
| |
| + String get_class_name(); |
| |
| + OwnableTile(); |
| |
| - int _price; |
| - int _enter_price; |
| - Player *_owner; |
|--------------------------------------------------------------------------|
- OwnableTile - Ez olyan mező, amit meg lehet venni. Van vételára,
illetve egy belépési költsége. Ha egy játékos rálép, és még senkié,
akkor az a játékos megveheti a vételárért cserébe. Ha nem veszi meg,
nem kell fizetnie semmit. Ha valaki megveszi, akkor mindenki másnak,
aki rálép meg kell fizetnie a tulajdonosnak a belépési díjat.
Ha a tulajdonos kiesik a játékból, akkor az összes tulajdona
felszabadul.
|--------------------------------------------------------------------------|
| class GainTile : public Tile |
|--------------------------------------------------------------------------|
| + int get_gain() const; |
| + void set_gain(const int val); |
| |
| + void on_player_arrived(Player *p); |
| + void print(); |
| + String get_class_name(); |
| |
| + GainTile(); |
| |
| - int _gain; |
|--------------------------------------------------------------------------|
- GainTile - Aki rálép az egy meghatározott összeget kap.
|--------------------------------------------------------------------------|
| class LuckTile : public Tile |
|--------------------------------------------------------------------------|
| + int get_chance() const; |
| + void set_chance(const int val); |
| |
| + int get_gain_min() const; |
| + void set_gain_min(const int val); |
| |
| + int get_gain_max() const; |
| + void set_gain_max(const int val); |
| |
| + void on_player_arrived(Player *p); |
| + void print(); |
| + String get_class_name(); |
| |
| + LuckTile(); |
| |
| - int _chance; |
| - int _gain_min; |
| - int _gain_max; |
|--------------------------------------------------------------------------|
- LuckTile - Aki rálép kaphat megadott %-nyi eséllyel,
két megadott érték közötti pénzt.
|--------------------------------------------------------------------------|
| class JailTile : public Tile |
|--------------------------------------------------------------------------|
| + int get_jail_time() const; |
| + void set_jail_time(const int val); |
| |
| + void on_player_arrived(Player *p); |
| + void print(); |
| + String get_class_name(); |
| |
| + JailTile(); |
| |
| - int _jail_time; |
|--------------------------------------------------------------------------|
- JailTile - Aki rálép, a megadott környi ideig börtönbe kerül, azaz
annyi körig nem léphet.
|--------------------------------------------------------------------------|
| class TileLoader |
|--------------------------------------------------------------------------|
| + static Vector<Tile *> load_tile_file(const String &file_name); |
|--------------------------------------------------------------------------|
Ugyanolyan betöltő osztály, mint a játékos estében.
Példa file szerkezet:
Tile A
TaxTile B 3433
TaxTile C 3433
OwnableTile D 222 22
OwnableTile E 222 22
OwnableTile F 222 22
GainTile G 100
TaxTile H 3433
LuckTile I 50 100 200
TaxTile J 3433
JailTile K 3
TaxTile L 3433
TaxTile M 3433
TaxTile N 3433

99
12_monopoly_board.txt Normal file
View File

@ -0,0 +1,99 @@
|--------------------------------------------------------------------------|
| class Board |
|--------------------------------------------------------------------------|
| + Player *get_current_player(); |
| + Player *get_previous_player(); |
| |
| + int get_turn() const; |
| + void set_turn(const int turn); |
| |
| + Vector<Tile *> get_tiles() const; |
| + void set_tiles(const Vector<Tile *> &tiles); |
| |
| + Vector<Player *> get_active_players() const; |
| + void set_active_players(const Vector<Player *> &players); |
| |
| + Vector<Player *> get_lost_players() const; |
| + void set_lost_players(const Vector<Player *> &players); |
| |
| + void load(const String &tile_file, const String &player_file); |
| + void load_players(const String &file); |
| + void load_tiles(const String &file); |
| |
| + void step(); |
| + void run(); |
| |
| + void on_game_finished(); |
| |
| + void clear(); |
| + void clear_players(); |
| + void reset(); |
| |
| + void print(); |
| |
| + Board(); |
| + Board(const String &tile_file, const String &player_file); |
| + virtual ~Board(); |
| |
| - Vector<Tile *> _tiles; |
| - Vector<Player *> _active_players; |
| - Vector<Player *> _lost_players; |
| - |
| - Player *_previous_player; |
| - int _current_player_index; |
| - int _turn; |
|--------------------------------------------------------------------------|
on_game_finished() a játékról kiír a konzolra mindenféle információt,
miután véget ért.
run() a fő ciklus, a step() függvényt hívogatja, amíg több mint 1
aktív játékos van. Esetleg kiléphet nagy _turn szám után is.
Ha a ciklus kilépett, hívja meg az on_game_finished()-et.
clear() Minden vektort kiürít.
clear_players() csak a 2 játékos vektort üríti ki.
ne felejtsétek ez felszabadítani a memóriát! (delete).
step():
Egy játékos körének a kezelése.
Az algoritmus:
1. Fogjuk meg az aktív játékost.
2. Ha börtönben van, vonjunk le egy kört a börtönének számából, és kész.
3. Dobassunk vele kockát.
4. Számoljuk ki (modulo), hogy melyik mezőre érkezett. (player get_tile_index())
5. Állítsuk be az új mező indexét neki (set_tile_index()).
6. kérjük ki a megfelelő mezőt a _tiles vektorból, és hívjuk meg a
on_player_arrived(p); függvényét, a játékost adjuk be paraméternek.
7. Állítsuk be a _previous_player osztályváltozót a jelenlegi játékosra.
8. Ha ajátékos vesztett (get_lost()), akkor rakjuk ár a _lost_players
veektorba, majd ellenőrizzük, hogy a _current_player_index nem indexel-e
túl a játékosok vektorán. Ha igen, akkor állítsuk a
_current_player_index-et 0-ra. (ugye eggyel csökkent a vektor mérete.)
9. Egyébként növeljük meg a _current_player_index-et 1-el, és ugyanúgy
ellenűrizzük, hogy a _current_player_index nem indexel-e
túl a játékosok vektorán, ha igen, akkor állítsuk a
_current_player_index-et 0-ra.
main.cpp + int main() :
A main függvénybe csak ennyi legyen:
Math::randomize();
Board b;
b.load("tiles.config", "players.config");
b.run();
b.print();
return 0;
Nyilvánvalóan a "tiles.config", "players.config" fájlokat hozzátok létre.

0
05_sdl_software_renderer.txt → temp/05_sdl_software_renderer.txt
View File

0
06_sdl_application.txt → temp/06_sdl_application.txt
View File

0
08_monopoly_sdl.txt → temp/08_monopoly_sdl.txt
View File

0
09_sdl_input.txt → temp/09_sdl_input.txt
View File

0
10_monopoly_input.txt → temp/10_monopoly_input.txt
View File

0
04_sdl_setup.txt → temp/10_sdl_setup.txt
View File

0
12_widget_keszlet.txt → temp/12_widget_keszlet.txt
View File