Kihagyás

Kötelező programok

A félév során minden hallgatónak (csapatban vagy egyénileg) választania kell egy kötelező programot, melyet a CooSpace felületén kiírt Projektmunka nevű feladathoz kell leadni az ott meghatározott határidőig.

Általános elvárások

Egy projektet több személy vállalhat, az egyes projekttagokra jutó feladatrészek a feladatleírásokban egyértelműen definiálva lesznek. A megvalósítás és értékelés további keretei a következők:

  • Make rendszer: A projektmunkának make-kel fordíthatónak kell lennie. Ez megvalósítható közvetlenül makefile vagy Cmake segítségével is.
  • Modularitás: A lib-ek általános lib-ekként készüljenek el (szabványos header interfész és c megvalósítás), ne legyenek összevissza "bedrótozva" a főprogramba/egymásba.
  • Makróhasználat: Ha valamit makróval könnyebb / egyszerűbb / észszerűbb megvalósítani, akkor az makróval legyen megvalósítva.
  • Tesztek: A lib elemekhez egységteszteket is írni kell egységteszt keretrendszer segítségével. A főprogramhoz is legyenek rendszertesztek (valamilyen formában). A make rendszerben legyen egy-egy külön target a lib-ek egységtesztjeinek illetve a főprogram tesztjeinek futtatásához.
  • Dinamikus viselkedés: A programok ellenőrzése során dinamikus elemzéseket is futtatunk majd, ezek nem mutathatnak ki hibát.
  • Biztonsági szempontok: Az értékelés során külön figyelmet fordítunk a biztonságos kódolási elvek betartásának ellenőrzésére.
  • Egyéb hasznos/helyénvaló technikai megoldások: Bármely egyéb megvalósítás-technikai elemet (mint pl. Debug módú kiíratások -DDEBUG kapcsoló esetén, statikus helyett dinamikus lib, programon belülről kezelt .so, stb.) pozitívan értékelünk, ha az racionálsan indokolható.
  • Egyéni munka: A forráskódban pontosan jelezni kell, hogy ki melyik részt írta. Nyilván lesznek közös részek is, ott pedig arányt kell jelezni, hogy ki mennyire vett benne részt. A "mindent közösen csináltunk" nem egy jó taktika (tapasztalat alapján ilyenkor nagyrészt egyvalaki dolgozott, a többiek hozzájárulása pedig minimális). Ha a többszemélyes feladatot valaki egyedül csinálja, az nem kifogás arra, hogy miért nem készült el (vagyis lib-eket, biztonságot, make rendszert, stb. ugyanúgy elvárunk), ugyanakkor nyilvánvalóan más mennyiségi elvárásaink lesznek az 1 illetve 3 fő által megírt projektekkel szemben.

Választható feladatok

Pénztárgép

Pénztárgép (3 fő részére)

A feladat egy egyszerű pénztárgép szimulálása. Három fő része van:

  • Beolvasó rész
  • Nyomtató rész
  • Fő logika

A három fő rész közül a nyomtató rész és a beolvasó rész legyen library-ként megvalósítva. Így a pénztárgépben egyszerűen kicserélhetővé válik a nyomtató logika (pl. html helyett xml-be nyomtatás) illetve a billentyűzet/bevitel módja is könnyen cserélhető. A pénztárgép a beolvasó résszel indul. A beolvasó rész egy billentyűzetből és egy kijelzőből áll, mely a terminálban meg is jelenik a felhasználó számára. Például egy lehetséges megvalósítás:

1
2
3
4
5
K:
_______________________________________
|1(space)  |2(a/b/c)  |3(d/e/f)  | Ok |
|4(g/h/i)  |5(j/k/l)  |6(m/n/o)  |  X |
|7(p/q/r/s)|8(t/u/v)  |9(w/x/y/z)| Ny |

A megvásárolandó tétel felvitele nézhet így ki:

  • Betűk bevitele (tétel neve). Ezt úgy mint a régi telefonoknál, két db 2-esből lesz egy b betű. A tétel neve tetszőleges hosszú lehessen. A tételek neve ezzel a logikával nem tartalmazhat számot, de például ha a három funkciógomb mellé kerül egy negyedik pl. Shift, akkor megoldható.
  • X lenyomása (árbeviteli módba lépés)
  • Számok bevitele (a tétel ára)
  • X lenyomása (darabszám beviteli módba lépés)
  • Számok bevitele (a tétel darabszáma)
  • Ok lenyomása (tétel felvétel befejezve)

A felvitel művelet közben a kijelzőn jelenjenek meg a bevitt karakterek pl. csirkefarhat X 2 200Ft. A beolvasó rész továbbítja a fő logikának a felvitt tételt. A fő logika minden nyugtának 1-től növekvő sorszámot ad és hozzáadogatja a nyugtához a tételeket. Egy nyugtán tetszőleges számú tétel lehessen. Amikor a felhasználó a beviteli részen lenyomja az Ny gombot, akkor a nyugta lezáródik (amennyiben az éppen felvitt tétel Ok-al le lett már zárva). Az Ny hatására a nyomtató rész készítsen egy szövegfájlt a nyugtáról. Ez egy HTML dokumentum legyen, amit böngészőben tudunk nézegetni. Egy példa kinézet:

1
2
3
4
5
6
        Nyugta 12
csirkefarhat   1 db 100Ft
WC papir     200 db 500Ft

Osszesen            600Ft
2021. 04. 17.

A kinyomtatott nyugtáknak egyetlen paraméterük van, ezt a pénztárgép induláskor megkapja: hány karakter széles a papírszalag. Ennek megfelelően ha túl hosszú a tétel neve tördelésre lehet szükség. Nyomtatás után új tétel felvitelével lehessen egy új nyugtát nyitni. A szimulált pénztárgép való életből vett elemekkel bővíthető még.

Sakk

Sakk (2 fő részére)

A feladat egy projekt elkészítése, amelyik egy sakkprogram megvalósítását támogató lib-ből, és egy főprogramból áll. A lib fő funkcionalitásai:

  • Kezdeti állás: a lib inicializálja a táblát a sakk kezdő állására és eltárolja, mint belső állapot
  • Lépés: az adott belső állapotban eltárolt állást módosítja az adott lépésnek megfelelően
    • Nem kell figyelni, hogy a lépések szabályosak-e vagy sem
    • Viszont támogatni kell az ütést, a sáncolást és az átváltozást
      • Enélkül nem lenne értelme, és nem is lehetne használni a programot
  • Lépés visszavonása: a lépéseket lehessen visszavonni, egészen a kezdeti állásig
  • Sakkparti elmentése (1 személy esetén nem szükséges)
  • Sakkparti betöltése (1 személy esetén nem szükséges)
    • Betöltött sakkparti lejátszásának támogatása

A program a lib segítségével valósítson meg egy sakkprogramot, ahol néhány alapvető funkcionalitás a következő lehet:

  • Játékosok nevének bekérése
  • Lépések bekérése
    • ,,Szabálytalan’’ lépések esetén hibajelzés
      • Nem jó figurával lép (világos jön de sötét figurával akar lépni)
      • Nincs ott figura
  • Parti feladása vagy döntetlen elfogadása
  • Parti elmentése
    • Fájlnév bekérése
  • Parti betöltése és lejátszása

Segítség a sakkbábuk kirajzolásához:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
#include <stdio.h>
#include <wchar.h>
#include <locale.h>

int main() {
    setlocale(LC_CTYPE, "");
    for (wchar_t p = 0x2654; p <= 0x265F; p++) {
        wprintf(L"%lc\n", p);
    }
}

Slide-a-lama

Slide-a-lama (2 fő részére)

A játékhoz itt egy rövid videó.

A Slide-a-lama egy kétszemélyes játék, és a játék célja, hogy az ellenfél lámáit elnyerjük. Egy láma elnyeréséhez legalább 50 ponttal kell vezetnünk a másik játékossal szemben, 2 lámához legalább 100-zal, így az 5 lámához 250 ponttal kell felülmúlni az ellenfelet.

A játék egy 5x5-ös táblán játszódik, amire a két játékos felváltva teszi le az éppen soron következő figurát.

  • A kockát oldalról vagy felülről lehet lerakni, és ha a sor/oszlop tele volt, akkor a kocka a másik végéről kiesik.
  • A cél, hogy legalább 3 egyforma összejöjjön függőlegesen vagy vízszintesen, mert ezekért lehet pontokat kapni. A pontozás a videóban látszik.
    • Ha 4 egyforma összejön, akkor a pontszám kétszeresét kapja meg (azaz banánért nem 20, hanem 40 pont jár), és 5 esetében meg háromszoros a szorzó.
  • Ha 3 (vagy több) egyforma összejön, akkor azok kiesnek, és a többi kocka lefelé csúszik. Ha ekkor újabb 3 (vagy több) összejön, akkor ezek is kiesnek, és a játékos további pontokat kap.
  • Mindkét játékos ugyanabból az inputból dolgozik, azaz aki éppen rak, az látja az aktuális kockát, látja, hogy az ellenfele mit fog majd rakni, és azt is, hogy utána neki milyen kocka fog jönni.
  • A lehetséges figurák a kockákon és a pontozás a videóból leolvasható.
  • Nem kell, hogy időre lépjenek a játékosok.

A játék felépítése:

  • Legyen egy lib, amely magát a játékot megvalósítja
    • Kirajzolja a táblát
    • Tárolja az állást
    • Megadott lépések szerint frissíti a táblát
    • Számolja a pontokat
    • Észreveszi, ha vége a játéknak
  • A fő program feladata
    • Bekéri a játékosok neveit
    • Beolvassa az inputot
    • Használja a lib-et a játék során
    • Kiírja, ha valamelyik játékos nyert
      • Megkérdezi, hogy akarnak-e visszavágót

A játékban használt ikonok helyett lehet mást is használni, de célszerű színeket is alkalmazni, mert az sokat segít az áttekintésben. Néhány unicode karakter, amely hasznos lehet.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
#include <stdio.h>
#include <wchar.h>
#include <locale.h>

int main() {
    setlocale(LC_CTYPE, "");
    wprintf(L"\e[1;33m\e[1;42m");
    for (wchar_t p = 127815; p <= 127827; p++) {
        wprintf(L"%lc ", p);
    }
    wprintf(L"\n\e[1;31m\e[1;44m");
    for (wchar_t p = 128000; p <= 128060; p++) {
        wprintf(L"%lc ", p);
    }
    wprintf(L"\n\e[0m");
}
Kő, papír, olló

Kő, papír, olló (2 fő részére)

A játékról itt találtok egy videót.

A feladat a videón látható kő, papír, olló játék megvalósítása, ahol egy játékos a gép ellen tud játszani. (Ha valami nem világos, akkor kérdezzetek.)

A játék felépítése:

  • Legyen egy lib, amely magát a játékot megvalósítja
    • Kirajzolja a táblát
    • Tárolja az állást
      • A kezdeti állásnál meg lehet adni a csapda és a zászló helyét
    • Megadott lépések szerint frissíti a táblát
    • Harc esetén, ha döntetlen alakul ki, akkor jelzi
      • Ekkor újabb inputot "vár"
    • Észreveszi, ha vége a játéknak
  • A fő program feladata
    • Bekéri a játékos nevét
    • Beolvassa az inputot
    • Használja a lib-et a játék során
    • Kiírja, hogy a játékos nyert vagy vesztett
      • Megkérdezi, hogy akar-e visszavágót

A játék megjelenítését le lehet egyszerűsíteni úgy, hogy vannak az ismeretlen bábuk (piros és kék), illetve van a már megismert, ám ekkor már nem a bábut rajzolja ki a program, hanem csak azt, hogy kő, papír vagy olló az adott figura. És hasonlóan a csapda és a zászló esetében is.

Amőba

Amőba (3 fő részére)

A feladat az amőba játék megvalósítása, több részre bontva. Magát a játékot két játékos játszhatja egy adott méretű (10x10-es) táblán. Felváltva raknak a tábla tetszőleges még üres mezőjére, és akinek hamarabb kigyűlik 5 jele sorban egymás mellett (vízszintesen, függőlegesen vagy átlósan), az nyer.

A megvalósítás több modulból álljon. Legyen egy, ami a táblát/játékot kezeli (paraméterezhető táblamérettel, lépés és győzelem vizsgálattal). Legyen egy/kettő, ami a lépéseket valósítja meg: a felhasználótól kéri be, vagy valamilyen algoritmus szerint magától lép. Legyen egy, ami a tábla kirajzolásáért felelős, és legyen a főprogram, ami mindezeket kezeli, és amely tud kétjátékos, játékos-gép, gép-gép-elleni üzemmódokat, és "tornákat", vagyis N győzelemig folyó párharcokat.

Potyogós amőba

Potyogós amőba (3 fő részére)

A feladat a potyogós amőba játék megvalósítása, több részre bontva. Magát a játékot két játékos játszhatja egy adott méretű (8x8-as) táblán. Felváltva raknak a tábla tetszőleges még meg nem telt oszlopába, amelyben az adott játékos jele "lepogyog" a legalsó még üres mezőre (vagyis felülről lehet egymásra potyogtatni a jeleket). Az győz, akinek hamarabb kigyűlik 4 jele sorban egymás mellett (vízszintesen, függőlegesen vagy átlósan).

A megvalósítás több modulból álljon. Legyen egy, ami a táblát/játékot kezeli (paraméterezhető táblamérettel, lépés és győzelem vizsgálattal). Legyen egy/kettő, ami a lépéseket valósítja meg: a felhasználótól kéri be, vagy valamilyen algoritmus szerint magától lép. Legyen egy, ami a tábla kirajzolásáért felelős, és legyen a főprogram, ami mindezeket kezeli, és amely tud kétjátékos, játékos-gép, gép-gép-ellen üzemmódokat, és "tornákat", vagyis N győzelemig folyó párharcokat.


Utolsó frissítés: 2022-03-16 08:33:42