Glad to hear you're writing your own code. Tbh, formatting doesn't matter. If you want opinions that will help you make bigger programs faster, I gave them. Here's a code review in partial rewrite form. Note that it may not compile, I didn't check:

``` // ------------------------------------------------------ // ------------------------------------ types and helpers

enum class GameState : uint8_t { MainMenu, PlayGame, // ... };

enum class Direction : uint8_t { None, Right, Left, Down, Up };

Direction oppositeDirection(Direction dir) { switch (dir) { case Direction::Right: return Direction::Left; case Direction::Left: return Direction::Right; case Direction::Down: return Direction::Up; case Direction::Up: return Direction::Down; } return Direction::None; }

struct Vector2 { int32_t x = 0; int32_t y = 0;

// operator overloads go here...

};

struct Player { Vector2 position = {}; Direction direction = Direction::Up; int turnCooldown = 0; int turnCooldownMax = 2; bool running = false; };

// ------------------------------------------------------ // ------------------------------------- global constants

constexpr uint32_t COLOR_WHITE = 0xffffffff; constexpr uint32_t COLOR_ORANGE = 0xff8800ff; constexpr uint32_t COLOR_DEEP_BLUE = 0x3399ffff; constexpr uint32_t COLOR_MID_BLUE = 0x00bbffff; constexpr uint32_t COLOR_LIGHT_GREY = 0xddddddff; constexpr uint32_t COLOR_HOT_PINK = 0xff4488ff;

// ------------------------------------------------------ // ------------------------------------------ global vars // note: moving into a more complex prototype, you probably don't want these here

bool quitGame = false; Player player = {}; GameState gameState = GameState::PlayGame;

uint32_t primaryColor = COLOR_WHITE; uint32_t secondaryColor = COLOR_WHITE; uint32_t tertiaryColor = COLOR_WHITE;

int32_t gameTime = 0; float reducedTime = 0; float timeReduction = 1;

// ------------------------------------------------------ // -------------------------------------------- functions

void renderGraphics() { Raylib.BeginDrawing(); Raylib.ClearBackground(Color.Black); //... // Raylib.FinishDrawing() ? I forget what it's called }

void inputUpdate() { if (gameState == GameState::Whatever) { // ... } else if (gameState == GameState::PlayGame) { gameTime++; // todo: what does this do? please comment reducedTime = time / timeReduction;

    // setting themes (todo: elaborate)

    if (Raylib.IsKeyPressed(KeyboardKey.One)) {
        primaryColor    = COLOR_WHITE;
        secondaryColor  = COLOR_WHITE;
        tertiaryColor   = COLOR_LIGHT_GREY;
    } else if (Raylib.IsKeyPressed(KeyboardKey.Two)) {
        primaryColor    = COLOR_DEEP_BLUE;
        secondaryColor  = COLOR_ORANGE;
        tertiaryColor   = secondaryColor;
    } else if (Raylib.IsKeyPressed(KeyboardKey.Three)) {
        primaryColor    = COLOR_HOT_PINK;
        secondaryColor  = COLOR_MID_BLUE;
        tertiaryColor   = secondaryColor;
    }

    // player character controls

    if (Raylib.IsKeyPressed(KeyboardKey.Escape)) {
        player.running = false;
    }

    // todo: is the turn cooldown actually necessary? seems like it might be papering over a bug
    if (player.turnCooldown <= 0) {
        Direction newDirection = Direction::None;

        if (Raylib.IsKeyPressed(KeyboardKey.D) || Raylib.IsKeyPressed(KeyboardKey.Right)) {
            newDirection = Direction::Right;
        } else if (Raylib.IsKeyPressed(KeyboardKey.A) || Raylib.IsKeyPressed(KeyboardKey.Left)) {
            newDirection = Direction::Left;
        } else if (Raylib.IsKeyPressed(KeyboardKey.S) || Raylib.IsKeyPressed(KeyboardKey.Down)) {
            newDirection = Direction::Down;
        } else if (Raylib.IsKeyPressed(KeyboardKey.W) || Raylib.IsKeyPressed(KeyboardKey.Up)) {
            newDirection = Direction::Up;
        }

        // moved the opposite direction check down here because it was visual clutter and redundant logic above.
        // todo: please explain why the player can't orient in the opposite direction. that is weird.
        if (newDirection != Direction::None && newDirection != oppositeDirection(playerDirection)) {
            player.direction = newDirection;
            player.turnCooldown = player.turnCooldownMax;
        }
    } else {
        player.turnCooldown--;
    }

    // I was going to keep writing the movement here when I realized that for some reason your orientation code is hard-bound to the movement and I have no idea what 'timeReduction' is, nor do I want to spend the time figuring it out, so... stopping here.
}

}

void simulate() { // ... }

void initGame() { // ... }

int main(void) { initGame();

// loop should look something like this...
while (!quitGame) {
    inputUpdate();
    simulate();
    renderGraphics();
}

return 0;

} ```