Framework gry 2D w C ++ i SDL

Question

Po raz pierwszy tworzę prosty framework / silnik 2D na podstawie dwóch książek i zanim projekt stanie się zbyt duży, chciałbym wiedzieć, czy zamawiam rzeczy we właściwy sposób. Może są na to lepsze sposoby. Próbowałem zastosować wzory, aby jak najwięcej oddzielić i zachować abstrakcję.

Na przykład to jest Gameklasa:

#include "Game.h"

void Game::Create(int width, int height, const char * title, int window_flag, int renderer_flag){
      display.CreateWindow(800,600,"Game", SDL_WINDOW_SHOWN, SDL_RENDERER_ACCELERATED);
}

void Game::Start(){
      Uint32 first_frame_ticks; float delta_time = 0;
      SDL_Renderer * renderer = display.GetRenderer();
      while(input_handler.GetLastEvent() != SDL_QUIT){
            first_frame_ticks = SDL_GetTicks();

            bool state_manager_empty = state_manager.isEmpty();
            //update
            input_handler.Update();
            if(!state_manager_empty) state_manager.GetGameState()->onUpdate(delta_time);

            //render
            SDL_RenderClear(renderer);
            if(!state_manager_empty) state_manager.GetGameState()->onRender();
            SDL_RenderPresent(renderer);

            delta_time = (SDL_GetTicks() - first_frame_ticks) / 1000.0f;
      }

      display.Clear();
}

void Game::AddState(GameState* state){
      state->Set(display.GetRenderer(), &input_handler);
      state_manager.Add(state);
}

Lub klasa Drawer (co do której mam wątpliwości, metoda DrawEntity jest statyczna)

#include "Drawer.h"

void Drawer::DrawEntity(Entity& entity, TextureManager* texture_manager, SDL_Renderer * renderer){
      texture_manager->Draw(entity.GetSprite(), entity.GetPosition(), renderer);
}

Działa jak pośrednik między TexureManager (który rysuje tekstury) a Entity, który ma wszystkie informacje, takie jak pozycja, skala itp.

Na koniec przykładowa klasa wejściowa

#include "InputHandler.h"
#include <cstdio>

InputHandler::InputHandler(){
      keyboard_state = SDL_GetKeyboardState(NULL);
      printf("Event handler initialized\n");
}

void InputHandler::Update(){
      SDL_Event ev;
      while(SDL_PollEvent(&ev)){
            if(ev.type == SDL_KEYUP || ev.type == SDL_KEYDOWN){
                  keyboard_state = SDL_GetKeyboardState(NULL);
            }else last_event = ev.type;
      }
}

bool InputHandler::isKeyPressed(SDL_Scancode key){
      if(keyboard_state[key]) return true;
      else return false;
}

Uint32 InputHandler::GetLastEvent(){
      return last_event;
}

Zamierzam wgrać diagram zależności oraz repozytorium GitHub:

Github Repo z całym kodem

https://github.com/grazianobolla/monke-engine

Answer 1

Aktualizacja:

Cóż, jeśli ktoś chce wiedzieć, zrobiłem kilka zmian na dobre, jednym z głównych problemów było to, że nie mogłem tak naprawdę "podłączyć" GameStates do samego głównego silnika bez podania wskaźnika do silnika (który jest brudny) lub indywidualne wskazówki do InputHandler, Displayitp

Chodziło o to, że na przykład InputHandler obsługiwał zdarzenia Window i dane wejściowe z klawiatury, więc aby GameState miał do niego dostęp, musiałbym utworzyć wskaźnik do Game :: InputHandler, więc zrobiłem kilka rzeczy:

Najpierw stworzyłem KeyboardHandleklasę, która jest całkowicie niezależna od samego silnika, a jej jedyną funkcją jest uzyskiwanie danych wejściowych z klawiatury, w ten sposób mogę sprawić, że każdy stan gry będzie niezależny KeyboardHandle, również każdy stan gry ma wskaźnik do Displayklasy silnika , co oznacza że ze stanu gry można uzyskać dostęp do informacji, takich jak rozmiar okien lub SDL_Rendererbez większego problemu, dodajesz stany z Enginetak, aby Displaywskaźnik był ustawiony w tym momencie.

GameStateKlasa jest podstawą dla wszystkich gier, teraz wygląda to tak:

#pragma once
#include "KeyboardHandle.h"
#include "TextureManager.h"
#include "Display.h"

class GameState{
protected:
      KeyboardHandle keyboard;
      TextureManager texture_manager;
      Display * screen_display;
public:
      GameState(Display * display){ this->screen_display = display; }
      virtual void onStart() = 0;
      virtual void handleInput() = 0;
      virtual void onUpdate(float) = 0;
      virtual void onRender() = 0;
};

Jak widać, prawie wszystko jest niezależne od programu Engine, po prostu współdzieli wyświetlacz, abyśmy mogli renderować grafikę.

Oto przykładowy stan (rysowanie obrazu na środku ekranu):

#include "GameState.h"
#include "Entity.h"

class DefaultState : public GameState{
      Entity splash_logo;
public:
      DefaultState(Display * display) : GameState(display){ }

      void onStart(){
            texture_manager.Load("textures/splash_logo.png", "splash_logo", screen_display->GetRenderer());
            splash_logo = Entity("splash_logo", Vector2i(0, 0), Vector2i(336, 336), 1.0f);

            float center_x = (screen_display->GetWindowWidth() / 2) - splash_logo.GetCollisionBox().w / 2;
            float center_y = (screen_display->GetWindowHeight() / 2) - splash_logo.GetCollisionBox().h / 2;
            splash_logo.SetPosition({center_x, center_y});
      }

      void handleInput(){

      }

      void onUpdate(float delta_time){

      }

      void onRender(){
            texture_manager.Draw(splash_logo.GetSprite(), splash_logo.GetPosition(), screen_display->GetRenderer());
      }
};

A oto diagram zależności: