Initial

HF/Forráskód/modules/menu/menuDraw.c

@@ -0,0 +1,236 @@
+#include "menuDraw.h"
+
+
+///A menüben lévő havazást kezeli, sokkal olcsóbb, mintha egy mapDrawt hívnánk.
+static void drawMenuParticles(int deltaTime) {
+    int columns = getColumns();
+    int i;
+    for(i = 0; i < columns; i++)
+        drawParticles(i, 0, columns, deltaTime);
+}
+
+///A főmenüt rajzolja.
+void drawMainMenu(int deltaTime) {
+    Uint16 menuOptions[][50] = {
+        L"Indítás",
+        L"Betöltés",
+        L"Beállítások",
+        L"Ranglista",
+        L"Leírás",
+        L"Kilépés",
+        L""
+    };
+
+    unicodePrintCentered(L"Platform játék", 50, 20, large);
+
+    int i;
+    for(i = 0; menuOptions[i][0] != '\0'; i++)
+        unicodePrintCentered(menuOptions[i], 50, menuStart + i * menuTav, isMouseOverRect(50, menuStart + menuTav*i, 15, menuTav / 2) ? smallBold : small);
+
+    drawMenuParticles(deltaTime);
+}
+
+///A "vissza" gombot rajzolja
+static inline void printBack() {
+    unicodePrintCentered(L"Visszalépés", 50, menuStart + 5 * menuTav, isMouseOverRect(50, menuStart + menuTav*5, 15, menuTav / 2) ? smallBold : small);
+}
+
+///A beállítások menüpont rajzolása, a beállításokat a betöltött mentések is befolyásolják. Figyelni kell, hogy a belépés kattintását ne érzékelje csúszka kattintásnak.
+void drawOptionsMenu(int deltaTime, int currentOptions[], bool click) {
+    Uint16 optionsMenuOptions[][50] = {
+        L"Világ szélessége",
+        L"Világ magassága",
+        L"Részecskék száma",
+        L"Gravitáció",
+        L"Ellenségek közti idő",
+        L""
+    };
+
+    int minOptions[] = {  10,   20,  0,   150,  2000};
+    int maxOptions[] = {3000, 3000, 50,   800, 20000};
+
+    int i = 0;
+    while(optionsMenuOptions[i][0] != '\0') {
+
+        unicodePrintCentered(optionsMenuOptions[i], 50, optionsStart + (i - 0.3) * optionsTav, tiny);
+        lineColor(
+            screen,
+            0.3 * screen -> w, (float) screen -> h / 100 * (optionsStart + i * optionsTav),
+            0.7 * screen -> w, (float) screen -> h / 100 * (optionsStart + i * optionsTav), 0xFFFFFFFF
+        );
+
+        filledCircleColor(screen, (float) screen -> w / 100 * (30 + 0.4 * 100 * (float)(currentOptions[i] - minOptions[i]) / (maxOptions[i] - minOptions[i])),
+            (float) screen -> h / 100 * (optionsStart + i * optionsTav), 20, 0xFFFFFFFF
+        );
+        aacircleColor(screen, (float) screen -> w / 100 * (30 + 0.4 * 100 * (float)(currentOptions[i] - minOptions[i]) / (maxOptions[i] - minOptions[i])),
+           (float) screen -> h / 100 * (optionsStart + i * optionsTav), 20, 0xFFFFFFFF
+        );
+
+        i++;
+    }
+
+    if(click)
+        for(i = 0; i < 5; i++)
+            if(isMouseOverRect(50, optionsStart + optionsTav * i, 50, optionsTav / 2)) {
+            //Ezek nem magic számok, csak egy kicsit.
+            currentOptions[i] = minOptions[i] + (int)((maxOptions[i] - minOptions[i]) * (getMousePosition().x - screen -> w * 0.3) / (screen -> w * 0.4) );
+            putInsideInterval(minOptions[i], &currentOptions[i], maxOptions[i]);
+        }
+
+        printBack();
+        drawMenuParticles(deltaTime);
+}
+
+///A játék leírását rajzolja meg.
+void drawInfoMenu(int deltaTime) {
+
+    Uint16 info[][150] = {
+        L"Ebben a játékban pontokat szerezni és költeni",
+        L"is tudsz. Minden megtalált kék kockáért jár egy pont.",
+        L"Mozogni a WAD billentyűk, szóköz, vagy a nyilak",
+        L"segítségével tudsz. A bal egérgombbal egy pontért",
+        L"cserébe lőhetsz. A jobb egérgombbal lelassíthatod",
+        L"az időt, természetesen ez sincs ingyen. A repülő piros",
+        L"kockák az ellenségek, ha hozzád érnek a játéknak vége.",
+        L"A játékot az ESC megnyomásával szüneteltetheted.",
+        L""
+    };
+
+    int i = 0;
+    while(info[i][0] != '\0') {
+        unicodePrintCentered(info[i], 50, infoStart + i * infoTav, tiny);
+        i++;
+    }
+
+    printBack();
+    drawMenuParticles(deltaTime);
+}
+
+Uint16 names[topListItemsMax][100];
+int points[topListItemsMax];
+int namesIndex;
+
+///Ha megtelt a toplista, rendezi, és az utolsó elemét lecseréli. A ranglista fájlt se kéne nagyon piszkálni a felhasználónak.
+static void sortTopList() {
+
+    int i, j;
+    int tmpInt;
+    Uint16 tmpStr[100];
+
+    for(i = 0; i < namesIndex; i++) {
+        int maxIndex = i;
+        for(j = i + 1; j <= namesIndex; j++)
+            if(points[maxIndex] < points[j])
+                maxIndex = j;
+
+        tmpInt = points[i];
+        points[i] = points[maxIndex];
+        points[maxIndex] = tmpInt;
+
+        wcscpy(tmpStr, names[i]);
+        wcscpy(names[i], names[maxIndex]);
+        wcscpy(names[maxIndex], tmpStr);
+    }
+}
+
+///A toplista menü előtt meg kell hívni, hogy rendezett létező toplistát lássunk.
+void loadTopList() {
+    FILE* topList = fopen("rang.lst", "r");
+
+    int i;
+
+    if(topList != NULL) {
+        namesIndex = 0;
+        while(true) {
+            i = 0;
+            do {
+                if(fwscanf(topList, L"%lc", &names[namesIndex][i]) == 0) goto end;
+            }
+            while(names[namesIndex][i++] != L',');
+            names[namesIndex][i] = 0;
+
+            fwscanf(topList, L"%d", &points[namesIndex]);
+            fwscanf(topList, L"\n");
+            if(namesIndex < topListItemsMax - 1) namesIndex++;
+            else sortTopList();
+        }
+        end:
+            sortTopList();
+            fclose(topList);
+    }
+}
+
+///Maga a toplista razoló függvény, az első pár helyet nagyobb betűvel rajzolja.
+void drawTopList(int deltaTime) {
+    int i;
+    for(i = 0; i < namesIndex; i++) {
+        Uint16 nameWScore[600];
+        swprintf(nameWScore, L"%ls %d", names[i], points[i]);
+        unicodePrintCentered(nameWScore, 50, 20 + ((i == 0) ?  0 : (i + 1)*infoTav), (i == 0) ? large : (i == 1) ? small : tiny);
+    }
+
+    printBack();
+    drawMenuParticles(deltaTime);
+}
+
+///Ha a játékos szüneteltei a játékot(ESC) ezt fogja látni. Elég drága az átlátszó box, szóval csak óvatosan a méretével.
+void drawPauseMenu(bool saved) {
+    Uint16 pauseOptions[][100] = {
+        L"Játék folytatása",
+        L"Pálya elmentése",
+        L"Mentés betöltése",
+        L"Kilépés a főmenübe",
+        L"",
+        L"Elmentve"
+    };
+
+    boxRGBA(screen, screen -> w * 0.3, screen -> h * 0.3, screen -> w * 0.7, screen -> h * 0.7, 0, 0, 0, 200);
+
+    int i;
+    for(i = 0; pauseOptions[i][0] != '\0'; i++) {
+        if(i == 1 && saved) unicodePrintCentered(pauseOptions[5], 50, menuStart - 5 + i * menuTav, isMouseOverRect(50, (menuStart - 5) + menuTav*i, 15, menuTav/2) ? smallBold : small);
+        else unicodePrintCentered(pauseOptions[i], 50, menuStart - 5 + i * menuTav, isMouseOverRect(50, (menuStart - 5) + menuTav*i, 15, menuTav/2) ? smallBold : small);
+    }
+}
+
+///Itt lehet mentett játékot betölteni, ha belépünk ebbe a menübe, a jelenlegi játékmenetünk elveszik.
+void drawLoadMenu(int deltaTime) {
+    time_t ages[maxNOSaves];
+    int points[maxNOSaves];
+    getExistingSaveFiles(ages, points);
+
+
+    int i;
+    Uint16 timeStrings[][50] = {
+        L"másodperccel",
+        L"perccel",
+        L"órával",
+        L"nappal",
+        L"héttel",
+        L"hónappal",
+        L"évvel"
+    };
+    int timeConversion[] = {
+        1, 60, 60*60, 60*60*24, 60*60*24*7, 60*60*24*30, 60*60*24*365
+    };
+    int timeStringsIndex;
+    int k =0;
+    for(i = 0; i < maxNOSaves; i++) {
+        if(existingSaves[i]) {
+            int deltaRealTime = time(NULL) - ages[i];
+
+            for(timeStringsIndex = 0; timeStringsIndex < 6; timeStringsIndex++)
+                if(deltaRealTime < timeConversion[timeStringsIndex+1])
+                    break;
+
+            int elapsedSaveTime = deltaRealTime / timeConversion[timeStringsIndex];
+            Uint16 save[200];
+            swprintf(save, L"%d %ls ezelőtti mentés, %d ponttal", elapsedSaveTime, timeStrings[timeStringsIndex], points[i]);
+            unicodePrintCentered(save, 50, loadStart + k * loadTav, isMouseOverRect(50, loadStart + loadTav*k, 25, 3) ? smallBold : small);
+            unicodePrintCentered(L"Törlés", 50, loadStart + k * loadTav + 5, isMouseOverRect(50, loadStart + loadTav*k + 5, 25, 2) ? smallBold : small);
+        k++;
+        }
+    }
+    printBack();
+    drawMenuParticles(deltaTime);
+}

HF/Forráskód/modules/menu/menuDraw.h

@@ -0,0 +1,45 @@
+#ifndef MENU_H_INCLUDED
+#define MENU_H_INCLUDED
+
+    #include <stdio.h>
+    #include <wchar.h>
+    #include "../global.h"
+    #include "../particles.h"
+    #include "../saves.h"
+    #include "../auxiliary/unicodePrint.h"
+    #include "../auxiliary/auxSDL.h"
+
+    #define topListItemsMax 8
+    #define menuStart (int) 42
+    #define menuTav (int) 9
+    #define optionsStart (int) 25
+    #define optionsTav (int) 13
+    #define infoStart (int) 20
+    #define infoTav (int) 7
+    #define loadStart (int) 10
+    #define loadTav (int) 15
+
+    typedef enum states {
+        mainMenu,
+        optionsMenu,
+        infoMenu,
+        pauseMenu,
+        game,
+        nameInput,
+        fading,
+        topListMenu,
+        loadMenu,
+        quit,
+        initGame,
+        initLoadedGame
+    } states;
+
+    void drawMainMenu(int deltaTime);
+    void drawOptionsMenu(int deltaTime, int currentOptions[], bool click);
+    void drawInfoMenu(int deltaTime);
+    void loadTopList();
+    void drawTopList(int deltaTime);
+    void drawPauseMenu(bool saved);
+    void drawLoadMenu(int deltaTime);
+
+#endif // MENU_H_INCLUDED

HF/Forráskód/modules/menu/menuFSM.c

@@ -0,0 +1,245 @@
+#include "menuFSM.h"
+
+
+int currentOptions[] = {2000, 2000, 3, 450, 6000};
+int currentSpawnRate, fadeStartTime, elapsedTime = 0, nameIndex = 0, cursorBlinking = 0;
+
+bool prematureClick, isDollying, saved = false;
+Uint16 name[100] = {0};
+FILE* topList;
+
+states gameState = mainMenu;        /**< Kezdőállapot. */
+
+///Visszaadja a jelenlegi állapotot, a quit-hez kell a mainnek.
+states getGameState() {
+    return gameState;
+}
+
+///Minden állapothoz tartozó kattintós eventet kezel, a beállítások menü miatt kell a prematureClick, hogy a belépést ne érzékelje beállításmódosításnak.
+void handleClicks(bool* prematureClick) {
+    switch(gameState) {
+        case game:
+            if(isAlive()) shoot(getMousePosition());
+            break;
+
+        case mainMenu:
+            if(isMouseOverRect(50, menuStart, 15, menuTav / 2)) {
+                gameState = initGame;
+            }
+            else if(isMouseOverRect(50, menuStart + menuTav, 15, menuTav / 2)) {
+                gameState = loadMenu;
+            }
+            else if(isMouseOverRect(50, menuStart + menuTav*2, 15, menuTav / 2)) {
+                gameState = optionsMenu;
+                *prematureClick = true;
+            }
+            else if(isMouseOverRect(50, menuStart + menuTav*3, 15, menuTav / 2)) {
+                loadTopList();
+                gameState = topListMenu;
+            }
+            else if(isMouseOverRect(50, menuStart + menuTav*4, 15, menuTav / 2))
+                gameState = infoMenu;
+            else if(isMouseOverRect(50, menuStart + menuTav*5, 15, menuTav / 2)) {
+                gameState = quit;
+            }
+            break;
+        case pauseMenu:
+            if(isMouseOverRect(50, menuStart - 5, 15, menuTav/2)) {
+                gameState = game;
+                updateText(getPoints());
+            }
+            if(isMouseOverRect(50, menuStart - 5 + menuTav, 15, menuTav/2)) {
+                saveGame(currentOptions);
+                saved = true;
+            }
+            if(isMouseOverRect(50, menuStart - 5 + menuTav*2, 15, menuTav/2)) {
+                createMenuWorld();
+                gameState = loadMenu;
+            }
+            if(isMouseOverRect(50, menuStart - 5 + menuTav*3, 15, menuTav/2)) {
+                createMenuWorld();
+                gameState = mainMenu;
+            }
+            break;
+
+        case loadMenu:
+            if(isMouseOverRect(50, menuStart + menuTav * 5, 15, menuTav/2)) {
+                gameState = mainMenu;
+                break;
+            }
+
+            int i, j = 0;
+            for(i = 0; i < maxNOSaves; i++) {
+                if(existingSaves[i]) {
+                    if(isMouseOverRect(50, loadStart + loadTav*j, 25, 3)) {
+                        loadGame(currentOptions, i);
+                        gameState = initLoadedGame;
+                    }
+                    else if(isMouseOverRect(50, loadStart + loadTav*j + 5, 25, 2)) {
+                        deleteSave(i);
+                    }
+                    j++;
+                }
+            }
+
+            break;
+        case topListMenu:
+        case optionsMenu:
+        case infoMenu:
+            if(isMouseOverRect(50, menuStart + menuTav*5, 15, menuTav/2))
+                gameState = mainMenu;
+            break;
+    }
+}
+
+/** \brief Ez igenis egy kifejező függyvény név. Az állapothoz megfelelő műveletek elvéűgzése, és a kimenet létrehozása. Tehát ha a játék magától csinál valamit, azt itt csinálja.
+ * Ez az egész egy nagy állapotgép. Igazából a mainben is lehetne, de szerintem így szebben néz ki.
+ * \param egérgomb bal
+ * \param egérgomb jobb
+ * \param prematureClick a beállítás menünek
+ * A deltaTime a menüben kisebb, mint máshol, így egyszerűbben meg leeht oldani a hóesés lassítását. Amúgy az egész játék deltaTimera épült, ha
+ * c-ben megbízhatóan lehetne miliseces pontossággal lehetne időt mérni, akkor az FPS sokkal dinamikusabb lehetne (a jelenlegi fix 50-hez képest).
+ * Ilyet viszont nem lehet, de azért benne hagytam, egyrészről a menü miatt, másrészről az időlassítás miatt, meg esetleg azért is, mert később, más
+ * környezetben még lehet jól jön ez a megoldás.
+ */
+void doStuff(bool isLMBDown, bool isRMBDown, bool prematureClick) {
+    bool isInSlowMo = false;
+    int deltaTime = 20;
+    switch(gameState) {
+        case mainMenu:
+            drawMainMenu(deltaTime);
+            break;
+
+        case optionsMenu:
+            drawOptionsMenu(deltaTime, currentOptions, isLMBDown && !prematureClick);
+            break;
+
+        case infoMenu:
+            drawInfoMenu(deltaTime);
+            break;
+
+        case topListMenu:
+            drawTopList(deltaTime);
+            break;
+
+        case pauseMenu:
+            deltaTime = 0;
+            drawMap(deltaTime);
+            drawPauseMenu(saved);
+            break;
+
+        case loadMenu:
+            drawLoadMenu(deltaTime);
+            break;
+
+        case initGame:
+            createWorld(currentOptions);
+        case initLoadedGame:
+            currentSpawnRate = currentOptions[4];
+            isDollying = true;
+            elapsedTime = 0;
+            cameraDollyZ(0, true);
+            gameState = game;
+            break;
+
+        case game:
+            isInSlowMo = slowTime(isRMBDown);
+            deltaTime = (int)(1000.0 / FPS) * (isInSlowMo ? slowMoMult : 1);
+            elapsedTime += deltaTime;
+            if(isDollying) isDollying = cameraDollyZ(deltaTime, false);
+
+            drawMap(deltaTime);
+
+            if(isAlive()) {
+                movePlayer(keys, deltaTime);
+                moveFloaters(deltaTime);
+                drawPointsText();
+
+                if(elapsedTime > currentSpawnRate) {
+                    createEnemy();
+                    elapsedTime = 0;
+                    if(currentSpawnRate > 1500) currentSpawnRate -= 10;
+                }
+            }
+            else {
+                fadeStartTime = elapsedTime;
+                name[0] = 0;
+                nameIndex = 0;
+                gameState = fading;
+            }
+            break;
+        case fading:
+            drawMap(0);
+
+            elapsedTime += deltaTime;
+            if((elapsedTime - fadeStartTime) / fadeTime >= 1)
+                gameState = nameInput;
+            boxRGBA(screen, 0, 0, screen -> w, screen -> h, 0, 0, 0, smaller(255, (int)(255 * (elapsedTime - fadeStartTime) / fadeTime)));
+            break;
+
+        case nameInput:
+            boxRGBA(screen, 0, 0, screen -> w, screen -> h, 0, 0, 0, 255);
+            cursorBlinking += deltaTime;
+            if(cursorBlinking > 1000) cursorBlinking = 0;
+            Uint16 loseText[300];
+            swprintf(loseText, L"%ls vesztett, a pontszáma %d.", cursorBlinking > 500 ? L"|" : L"", getPoints());
+            Uint16* endText = concatUnicode(name, loseText);
+            unicodePrintCentered(endText, 50, 50, small);
+            free(endText);
+            break;
+    }
+    if(isAlive()) drawMouse(isInSlowMo);
+}
+
+///A nameInputból returnnel és ESC-vel is ki lehet lépni, ezért kell ez a függvény rá, amit mindkét esetben meg lehet hívni.
+static void escapeFromNameInput() {
+    if(gameState == nameInput) {
+        gameState = mainMenu;
+        setDie(false);
+        createMenuWorld();
+        topList = fopen("rang.lst", "a");
+        if(topList != NULL) {
+            fwprintf(topList, L"%ls,%d\n", name[0] == 0 ? L"Névtelen" : name, getPoints());
+            fclose(topList);
+        }
+    }
+}
+
+///Az ESC billenytű lenyomását kezeli.
+void whatToDoOnEscape() {
+    switch(gameState) {
+        case pauseMenu:
+            gameState = game;
+            updateText(getPoints());
+            break;
+        case game:
+            if(isAlive()) {
+                gameState = pauseMenu;
+                saved = false;
+            }
+            break;
+        case mainMenu:
+            gameState = quit;
+            break;
+        case fading:
+            gameState = nameInput;
+            break;
+        case nameInput:
+            escapeFromNameInput();
+            gameState = mainMenu;
+            break;
+        default:
+            gameState = mainMenu;
+    }
+}
+
+///A szöveges bemenetet továbbítja egy Uint16-os stringbe.
+void processTyping(SDL_Event event) {
+    if(gameState  == nameInput) {
+        Uint16 chr = event.key.keysym.unicode;
+        if(strcmp(SDL_GetKeyName(chr), "backspace") == 0) name[--nameIndex] = 0;
+        else if(strcmp(SDL_GetKeyName(chr), "return") == 0) escapeFromNameInput();
+        else if(isValidChar(chr)) name[nameIndex++] = chr;
+        name[nameIndex] = 0;
+    }
+}

HF/Forráskód/modules/menu/menuFSM.h

@@ -0,0 +1,21 @@
+#ifndef MENUFSM_H_INCLUDED
+#define MENUFSM_H_INCLUDED
+
+    #include "../global.h"
+    #include "menuDraw.h"
+    #include "../world.h"
+    #include "../saves.h"
+    #include "../auxiliary/auxSDL.h"
+    #include "../auxiliary/unicodePrint.h"
+
+    #define fadeTime 1750   /**< Halál esetén meddig tartson a sötétítés? */
+    #define slowMoMult 0.3  /**< A slowMo (jobb egérgomb), mennyiszeresére lassítsa az időt? */
+
+    states getGameState();
+
+    void handleClicks(bool* prematureClick);
+    void doStuff(bool isLMBDown, bool isRMBDown, bool prematureClick);
+    void whatToDoOnEscape();
+    void processTyping(SDL_Event event);
+
+#endif // MENUFSM_H_INCLUDED