From 480f91b56e74f0a628842807eddea3ac98808577 Mon Sep 17 00:00:00 2001 From: Relintai Date: Mon, 5 Apr 2021 15:39:08 +0200 Subject: [PATCH] Split the txts. Now one txt only has one exercise. --- 01_alapok.txt | 305 ---------- 01_vector2.txt | 43 ++ 02_vector3.txt | 45 ++ 03_monopoly.txt | 533 ------------------ 03_rect2.txt | 67 +++ 04_int_vector.txt | 35 ++ 05_vector.txt | 82 +++ 06_string.txt | 25 + 07_consts.txt | 6 + 02_math_osztaly.txt => 08_math.txt | 0 09_monopoly.txt | 77 +++ 10_monopoly_players.txt | 170 ++++++ 11_monopoly_tiles.txt | 184 ++++++ 12_monopoly_board.txt | 99 ++++ .../05_sdl_software_renderer.txt | 0 .../06_sdl_application.txt | 0 .../08_monopoly_sdl.txt | 0 09_sdl_input.txt => temp/09_sdl_input.txt | 0 .../10_monopoly_input.txt | 0 04_sdl_setup.txt => temp/10_sdl_setup.txt | 0 .../12_widget_keszlet.txt | 0 21 files changed, 833 insertions(+), 838 deletions(-) delete mode 100755 01_alapok.txt create mode 100755 01_vector2.txt create mode 100755 02_vector3.txt delete mode 100644 03_monopoly.txt create mode 100755 03_rect2.txt create mode 100755 04_int_vector.txt create mode 100755 05_vector.txt create mode 100755 06_string.txt create mode 100755 07_consts.txt rename 02_math_osztaly.txt => 08_math.txt (100%) create mode 100644 09_monopoly.txt create mode 100644 10_monopoly_players.txt create mode 100644 11_monopoly_tiles.txt create mode 100644 12_monopoly_board.txt rename 05_sdl_software_renderer.txt => temp/05_sdl_software_renderer.txt (100%) rename 06_sdl_application.txt => temp/06_sdl_application.txt (100%) rename 08_monopoly_sdl.txt => temp/08_monopoly_sdl.txt (100%) rename 09_sdl_input.txt => temp/09_sdl_input.txt (100%) rename 10_monopoly_input.txt => temp/10_monopoly_input.txt (100%) rename 04_sdl_setup.txt => temp/10_sdl_setup.txt (100%) rename 12_widget_keszlet.txt => temp/12_widget_keszlet.txt (100%) diff --git a/01_alapok.txt b/01_alapok.txt deleted file mode 100755 index 0978085..0000000 --- a/01_alapok.txt +++ /dev/null @@ -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 Vector { - - T get(int index); - set(int index, T val); - - //etc... - - Vector(); - -private: - T *_data; -}; - -int main() { - Vector 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 b; - Vector c; - - //... - - return 0; -} - -7. Valamelyik vektor osztályból készíts egy saját String osztályt. (Vector -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!) - - - diff --git a/01_vector2.txt b/01_vector2.txt new file mode 100755 index 0000000..9c77a0e --- /dev/null +++ b/01_vector2.txt @@ -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) | +------------------------------------------------| diff --git a/02_vector3.txt b/02_vector3.txt new file mode 100755 index 0000000..b644afb --- /dev/null +++ b/02_vector3.txt @@ -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) | +------------------------------------------------| + diff --git a/03_monopoly.txt b/03_monopoly.txt deleted file mode 100644 index 246bb9d..0000000 --- a/03_monopoly.txt +++ /dev/null @@ -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 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 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 get_tiles() const; | -| + void set_tiles(const Vector &tiles); | -| | -| + Vector get_active_players() const; | -| + void set_active_players(const Vector &players); | -| | -| + Vector get_lost_players() const; | -| + void set_lost_players(const Vector &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 _tiles; | -| - Vector _active_players; | -| - Vector _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. - - diff --git a/03_rect2.txt b/03_rect2.txt new file mode 100755 index 0000000..45cc502 --- /dev/null +++ b/03_rect2.txt @@ -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)); + diff --git a/04_int_vector.txt b/04_int_vector.txt new file mode 100755 index 0000000..4344b7f --- /dev/null +++ b/04_int_vector.txt @@ -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 +------------------------------------------------------| diff --git a/05_vector.txt b/05_vector.txt new file mode 100755 index 0000000..d76502a --- /dev/null +++ b/05_vector.txt @@ -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 Vector { + + T get(int index); + set(int index, T val); + + //etc... + + Vector(); + +private: + T *_data; +}; + +int main() { + Vector 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 b; + Vector c; + + //... + + return 0; +} diff --git a/06_string.txt b/06_string.txt new file mode 100755 index 0000000..c6fc554 --- /dev/null +++ b/06_string.txt @@ -0,0 +1,25 @@ + +Valamelyik vektor osztályból készíts egy saját String osztályt. (Vector -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; + } +} diff --git a/07_consts.txt b/07_consts.txt new file mode 100755 index 0000000..e758e4c --- /dev/null +++ b/07_consts.txt @@ -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!) + diff --git a/02_math_osztaly.txt b/08_math.txt similarity index 100% rename from 02_math_osztaly.txt rename to 08_math.txt diff --git a/09_monopoly.txt b/09_monopoly.txt new file mode 100644 index 0000000..9f239c9 --- /dev/null +++ b/09_monopoly.txt @@ -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. diff --git a/10_monopoly_players.txt b/10_monopoly_players.txt new file mode 100644 index 0000000..87ac737 --- /dev/null +++ b/10_monopoly_players.txt @@ -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 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 + diff --git a/11_monopoly_tiles.txt b/11_monopoly_tiles.txt new file mode 100644 index 0000000..800c750 --- /dev/null +++ b/11_monopoly_tiles.txt @@ -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 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 + + diff --git a/12_monopoly_board.txt b/12_monopoly_board.txt new file mode 100644 index 0000000..d54aa7d --- /dev/null +++ b/12_monopoly_board.txt @@ -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 get_tiles() const; | +| + void set_tiles(const Vector &tiles); | +| | +| + Vector get_active_players() const; | +| + void set_active_players(const Vector &players); | +| | +| + Vector get_lost_players() const; | +| + void set_lost_players(const Vector &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 _tiles; | +| - Vector _active_players; | +| - Vector _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. + + diff --git a/05_sdl_software_renderer.txt b/temp/05_sdl_software_renderer.txt similarity index 100% rename from 05_sdl_software_renderer.txt rename to temp/05_sdl_software_renderer.txt diff --git a/06_sdl_application.txt b/temp/06_sdl_application.txt similarity index 100% rename from 06_sdl_application.txt rename to temp/06_sdl_application.txt diff --git a/08_monopoly_sdl.txt b/temp/08_monopoly_sdl.txt similarity index 100% rename from 08_monopoly_sdl.txt rename to temp/08_monopoly_sdl.txt diff --git a/09_sdl_input.txt b/temp/09_sdl_input.txt similarity index 100% rename from 09_sdl_input.txt rename to temp/09_sdl_input.txt diff --git a/10_monopoly_input.txt b/temp/10_monopoly_input.txt similarity index 100% rename from 10_monopoly_input.txt rename to temp/10_monopoly_input.txt diff --git a/04_sdl_setup.txt b/temp/10_sdl_setup.txt similarity index 100% rename from 04_sdl_setup.txt rename to temp/10_sdl_setup.txt diff --git a/12_widget_keszlet.txt b/temp/12_widget_keszlet.txt similarity index 100% rename from 12_widget_keszlet.txt rename to temp/12_widget_keszlet.txt