diff --git a/source/rendering/opengl/opengl_shader.cpp b/source/rendering/opengl/opengl_shader.cpp
index dc9bd89..c8131f8 100644
--- a/source/rendering/opengl/opengl_shader.cpp
+++ b/source/rendering/opengl/opengl_shader.cpp
@@ -76,8 +76,8 @@ auto OpenGLShader::compileShader(const std::string& source, GLenum shader_type)
         return 0;
     }
 
-    const char* sources[1] = {source.c_str()};
-    glShaderSource(shader_id, 1, sources, nullptr);
+    std::array<const char*, 1> sources = {source.c_str()};
+    glShaderSource(shader_id, 1, sources.data(), nullptr);
     checkGLError("glShaderSource");
 
     glCompileShader(shader_id);
@@ -149,7 +149,7 @@ auto OpenGLShader::linkProgram(GLuint vertex_shader, GLuint fragment_shader) ->
 void OpenGLShader::createQuadGeometry() {
     // Datos del quad: posición (x, y) + coordenadas de textura (u, v)
     // Formato: x, y, u, v
-    float vertices[] = {
+    std::array<float, 16> vertices = {
         // Posición      // TexCoords
         -1.0F,
         -1.0F,
@@ -170,7 +170,7 @@ void OpenGLShader::createQuadGeometry() {
     };
 
     // Índices para dibujar el quad con dos triángulos
-    unsigned int indices[] = {
+    std::array<unsigned int, 6> indices = {
         0,
         1,
         2,  // Primer triángulo
@@ -187,22 +187,22 @@ void OpenGLShader::createQuadGeometry() {
     // Generar y configurar VBO
     glGenBuffers(1, &vbo_);
     glBindBuffer(GL_ARRAY_BUFFER, vbo_);
-    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices.data(), GL_STATIC_DRAW);
     checkGLError("glBufferData(VBO)");
 
     // Generar y configurar EBO
     glGenBuffers(1, &ebo_);
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo_);
-    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices.data(), GL_STATIC_DRAW);
     checkGLError("glBufferData(EBO)");
 
     // Atributo 0: Posición (2 floats)
-    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void*)0);
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), nullptr);
     glEnableVertexAttribArray(0);
     checkGLError("glVertexAttribPointer(position)");
 
     // Atributo 1: Coordenadas de textura (2 floats)
-    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void*)(2 * sizeof(float)));
+    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), reinterpret_cast<void*>(2 * sizeof(float)));
     glEnableVertexAttribArray(1);
     checkGLError("glVertexAttribPointer(texcoord)");
 
@@ -212,7 +212,9 @@ void OpenGLShader::createQuadGeometry() {
 }
 
 auto OpenGLShader::getTextureID(SDL_Texture* texture) -> GLuint {
-    if (!texture) return 1;
+    if (texture == nullptr) {
+        return 1;
+    }
 
     SDL_PropertiesID props = SDL_GetTextureProperties(texture);
     GLuint texture_id = 0;
@@ -245,7 +247,7 @@ auto OpenGLShader::init(SDL_Window* window,
     back_buffer_ = texture;
     renderer_ = SDL_GetRenderer(window);
 
-    if (!renderer_) {
+    if (renderer_ == nullptr) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
             "Error: No se pudo obtener el renderer");
         return false;
@@ -276,10 +278,10 @@ auto OpenGLShader::init(SDL_Window* window,
 
     // Verificar que es OpenGL
     const char* renderer_name = SDL_GetRendererName(renderer_);
-    if (!renderer_name || strncmp(renderer_name, "opengl", 6) != 0) {
+    if ((renderer_name == nullptr) || strncmp(renderer_name, "opengl", 6) != 0) {
         SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
             "Renderer no es OpenGL: %s",
-            renderer_name ? renderer_name : "unknown");
+            (renderer_name != nullptr) ? renderer_name : "unknown");
         return false;
     }
 
@@ -305,8 +307,12 @@ auto OpenGLShader::init(SDL_Window* window,
     if (vertex_shader == 0 || fragment_shader == 0) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
             "Error al compilar shaders");
-        if (vertex_shader != 0) glDeleteShader(vertex_shader);
-        if (fragment_shader != 0) glDeleteShader(fragment_shader);
+        if (vertex_shader != 0) {
+            glDeleteShader(vertex_shader);
+        }
+        if (fragment_shader != 0) {
+            glDeleteShader(fragment_shader);
+        }
         return false;
     }
 
@@ -370,15 +376,16 @@ void OpenGLShader::render() {
     }
 
     // Obtener tamaño actual de ventana (puede haber cambiado)
-    int current_width, current_height;
+    int current_width;
+    int current_height;
     SDL_GetWindowSize(window_, &current_width, &current_height);
 
     // Guardar estados OpenGL
     GLint old_program;
     glGetIntegerv(GL_CURRENT_PROGRAM, &old_program);
 
-    GLint old_viewport[4];
-    glGetIntegerv(GL_VIEWPORT, old_viewport);
+    std::array<GLint, 4> old_viewport{};
+    glGetIntegerv(GL_VIEWPORT, old_viewport.data());
 
     GLboolean was_texture_enabled = glIsEnabled(GL_TEXTURE_2D);
     GLint old_texture;
@@ -403,7 +410,8 @@ void OpenGLShader::render() {
     checkGLError("glUseProgram");
 
     // Configurar viewport (obtener tamaño lógico de SDL)
-    int logical_w, logical_h;
+    int logical_w;
+    int logical_h;
     SDL_RendererLogicalPresentation mode;
     SDL_GetRenderLogicalPresentation(renderer_, &logical_w, &logical_h, &mode);
 
@@ -413,14 +421,16 @@ void OpenGLShader::render() {
     }
 
     // Calcular viewport considerando aspect ratio
-    int viewport_x = 0, viewport_y = 0;
-    int viewport_w = current_width, viewport_h = current_height;
+    int viewport_x = 0;
+    int viewport_y = 0;
+    int viewport_w = current_width;
+    int viewport_h = current_height;
 
     if (mode == SDL_LOGICAL_PRESENTATION_INTEGER_SCALE) {
         int scale_x = current_width / logical_w;
         int scale_y = current_height / logical_h;
         int scale = (scale_x < scale_y) ? scale_x : scale_y;
-        if (scale < 1) scale = 1;
+        scale = std::max(scale, 1);
 
         viewport_w = logical_w * scale;
         viewport_h = logical_h * scale;
@@ -444,7 +454,7 @@ void OpenGLShader::render() {
 
     // Dibujar quad usando VAO
     glBindVertexArray(vao_);
-    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
+    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr);
     checkGLError("glDrawElements");
 
     // Presentar
@@ -453,7 +463,7 @@ void OpenGLShader::render() {
     // Restaurar estados OpenGL
     glUseProgram(old_program);
     glBindTexture(GL_TEXTURE_2D, old_texture);
-    if (!was_texture_enabled) {
+    if (was_texture_enabled == 0u) {
         glDisable(GL_TEXTURE_2D);
     }
     glBindVertexArray(old_vao);
diff --git a/source/rendering/opengl/opengl_shader.hpp b/source/rendering/opengl/opengl_shader.hpp
index 3617db7..00bc538 100644
--- a/source/rendering/opengl/opengl_shader.hpp
+++ b/source/rendering/opengl/opengl_shader.hpp
@@ -39,8 +39,8 @@ class OpenGLShader : public ShaderBackend {
         auto compileShader(const std::string& source, GLenum shader_type) -> GLuint;
         auto linkProgram(GLuint vertex_shader, GLuint fragment_shader) -> GLuint;
         void createQuadGeometry();
-        auto getTextureID(SDL_Texture* texture) -> GLuint;
-        void checkGLError(const char* operation);
+        static auto getTextureID(SDL_Texture* texture) -> GLuint;
+        static void checkGLError(const char* operation);
 
         // Estado SDL
         SDL_Window* window_ = nullptr;
diff --git a/source/sections/game.hpp b/source/sections/game.hpp
index 5034d14..61fc367 100644
--- a/source/sections/game.hpp
+++ b/source/sections/game.hpp
@@ -337,7 +337,7 @@ class Game {
 
         // --- Gestion y dibujado de jugadores en z-order ---
         static void buildPlayerDrawList(const Players& elements, Players& draw_list);   // Construye el draw_list a partir del vector principal
-        void updatePlayerDrawList(const Players& elements, Players& draw_list);         // Actualiza draw_list tras cambios en los z_order
+        static void updatePlayerDrawList(const Players& elements, Players& draw_list);  // Actualiza draw_list tras cambios en los z_order
         static void renderPlayerDrawList(const Players& draw_list);                     // Dibuja en el orden definido
         static auto findPlayerIndex(const Players& elems, const std::shared_ptr<Player>& who) -> size_t;
         void sendPlayerToBack(Players& elements, const std::shared_ptr<Player>& who, Players& draw_list);    // Envia al jugador al fondo de la pantalla