doom 0.4.0 → 0.6.0

data/lib/doom/render/status_bar.rb

@@ -8,18 +8,30 @@ module Doom
       STATUS_BAR_Y = SCREEN_HEIGHT - STATUS_BAR_HEIGHT
 
       # DOOM status bar layout (from st_stuff.c)
-      # X positions are RIGHT EDGE of each number area (numbers are right-aligned)
-      # Y positions relative to status bar top
-
-      # Right edge X positions for numbers
+      # Positions from Chocolate Doom st_stuff.c (relative to status bar top)
       AMMO_RIGHT_X = 44      # ST_AMMOX - right edge of 3-digit ammo
-      HEALTH_RIGHT_X = 90    # ST_HEALTHX - right edge of 3-digit health
-      ARMOR_RIGHT_X = 221    # ST_ARMORX - right edge of 3-digit armor
+      HEALTH_RIGHT_X = 90    # ST_HEALTHX
+      ARMOR_RIGHT_X = 221    # ST_ARMORX
+
+      ARMS_BG_X = 104        # ST_ARMSBGX
+      ARMS_BG_Y = 0          # ST_ARMSBGY (relative to status bar)
+      ARMS_X = 111            # ST_ARMSX
+      ARMS_Y = 4              # ST_ARMSY (relative to status bar)
+      ARMS_XSPACE = 12
+      ARMS_YSPACE = 10
+
+      FACE_X = 149           # Centered in face background area
+      FACE_Y = 2             # Vertically centered in status bar
 
-      FACE_X = 149           # Adjusted for proper centering in face background
       KEYS_X = 239           # ST_KEY0X
 
-      NUM_WIDTH = 14         # Width of each digit
+      # Small ammo counts (right side of status bar)
+      SMALL_AMMO_X = 288     # Current ammo X
+      SMALL_MAX_X = 314      # Max ammo X
+      SMALL_AMMO_Y = [5, 11, 23, 17]  # Bullets, Shells, Cells, Rockets (relative to bar)
+
+      NUM_WIDTH = 14          # Width of large digit
+      SMALL_NUM_WIDTH = 4     # Width of small digit
 
       def initialize(hud_graphics, player_state)
         @gfx = hud_graphics
@@ -32,25 +44,34 @@ module Doom
         # Draw status bar background
         draw_sprite(framebuffer, @gfx.status_bar, 0, STATUS_BAR_Y) if @gfx.status_bar
 
+        # Draw arms background (single-player only, replaces FRAG area)
+        draw_sprite(framebuffer, @gfx.arms_background, ARMS_BG_X, STATUS_BAR_Y + ARMS_BG_Y) if @gfx.arms_background
+
         # Y position for numbers (3 pixels from top of status bar)
         num_y = STATUS_BAR_Y + 3
 
         # Draw ammo count (right-aligned ending at AMMO_RIGHT_X)
         draw_number_right(framebuffer, @player.current_ammo, AMMO_RIGHT_X, num_y) if @player.current_ammo
 
-        # Draw health with percent (right-aligned ending at HEALTH_RIGHT_X)
+        # Draw health with percent
         draw_number_right(framebuffer, @player.health, HEALTH_RIGHT_X, num_y)
         draw_percent(framebuffer, HEALTH_RIGHT_X, num_y)
 
+        # Draw weapon selector (2-7)
+        draw_arms(framebuffer)
+
         # Draw face
         draw_face(framebuffer)
 
-        # Draw armor with percent (right-aligned ending at ARMOR_RIGHT_X)
+        # Draw armor with percent
         draw_number_right(framebuffer, @player.armor, ARMOR_RIGHT_X, num_y)
         draw_percent(framebuffer, ARMOR_RIGHT_X, num_y)
 
         # Draw keys
         draw_keys(framebuffer)
+
+        # Draw small ammo counts (right side)
+        draw_ammo_counts(framebuffer)
       end
 
       def update
@@ -113,27 +134,58 @@ module Doom
         draw_sprite(framebuffer, percent, x, y) if percent
       end
 
+      def draw_arms(framebuffer)
+        # Weapon numbers 2-7 in a 3x2 grid
+        6.times do |i|
+          weapon_num = i + 2  # weapons 2-7
+          owned = @player.has_weapons[weapon_num]
+          digit = owned ? @gfx.yellow_numbers[weapon_num] : @gfx.grey_numbers[weapon_num]
+          next unless digit
+
+          x = ARMS_X + (i % 3) * ARMS_XSPACE
+          y = STATUS_BAR_Y + ARMS_Y + (i / 3) * ARMS_YSPACE
+          draw_sprite(framebuffer, digit, x, y)
+        end
+      end
+
       def draw_face(framebuffer)
-        # In DOOM, face sprite health levels are inverted: 0 = full health, 4 = dying
-        sprite_health = 4 - @player.health_level
-        faces = @gfx.faces[sprite_health]
-        return unless faces
+        # Pain level: 0 = healthy, 4 = near death
+        health = @player.health.clamp(0, 100)
+        pain_level = ((100 - health) * 5) / 101
 
-        # Get current face sprite
         face = if @player.health <= 0
                  @gfx.faces[:dead]
-               elsif faces[:straight] && faces[:straight][@face_index]
-                 faces[:straight][@face_index]
                else
-                 faces[:straight]&.first
+                 faces = @gfx.faces[pain_level]
+                 faces[:straight][@face_index] if faces && faces[:straight]
                end
 
         return unless face
+        draw_sprite(framebuffer, face, FACE_X, STATUS_BAR_Y + FACE_Y)
+      end
+
+      def draw_ammo_counts(framebuffer)
+        ammo_current = [@player.ammo_bullets, @player.ammo_shells, @player.ammo_cells, @player.ammo_rockets]
+        ammo_max = [@player.max_bullets, @player.max_shells, @player.max_cells, @player.max_rockets]
+
+        4.times do |i|
+          y = STATUS_BAR_Y + SMALL_AMMO_Y[i]
+          draw_small_number_right(framebuffer, ammo_current[i], SMALL_AMMO_X, y)
+          draw_small_number_right(framebuffer, ammo_max[i], SMALL_MAX_X, y)
+        end
+      end
 
-        # Position face in the background area
-        face_x = FACE_X
-        face_y = STATUS_BAR_Y + 2  # Slightly below top of status bar
-        draw_sprite(framebuffer, face, face_x, face_y)
+      def draw_small_number_right(framebuffer, value, right_x, y)
+        return unless value
+        str = value.to_i.to_s
+        current_x = right_x
+        str.reverse.each_char do |char|
+          digit = @gfx.yellow_numbers[char.to_i]
+          if digit
+            current_x -= SMALL_NUM_WIDTH
+            draw_sprite(framebuffer, digit, current_x, y)
+          end
+        end
       end
 
       def draw_keys(framebuffer)

data/lib/doom/render/weapon_renderer.rb

@@ -7,6 +7,14 @@ module Doom
       # Weapon is rendered above the status bar
       WEAPON_AREA_HEIGHT = SCREEN_HEIGHT - StatusBar::STATUS_BAR_HEIGHT
 
+      # DOOM positions weapon sprites using their built-in offsets:
+      #   x = SCREENWIDTH/2 - sprite.left_offset
+      #   y = WEAPONTOP + SCREENHEIGHT - 200 - sprite.top_offset
+      # WEAPONTOP = 32 in fixed-point = 32 pixels above the default position
+      # We scale for our 240px screen vs DOOM's 200px.
+      WEAPONTOP = 32
+      SCREEN_Y_OFFSET = SCREEN_HEIGHT - 200  # 40px offset for 240px screen
+
       def initialize(hud_graphics, player_state)
         @gfx = hud_graphics
         @player = player_state
@@ -27,33 +35,21 @@ module Doom
 
         return unless sprite
 
-        # Calculate position with bob offset
-        bob_x = @player.weapon_bob_x.to_i
-        bob_y = @player.weapon_bob_y.to_i
-
-        # Center weapon horizontally (sprite width / 2 from center)
-        # Position weapon at bottom of view area
-        x = (SCREEN_WIDTH / 2) - (sprite.width / 2) + bob_x
-        # Only allow downward bob (positive values) to keep weapon bottom at status bar
-        clamped_bob_y = [bob_y, 0].max
-        y = WEAPON_AREA_HEIGHT - sprite.height + clamped_bob_y
-
-        # Add some vertical offset during attack (recoil effect)
-        if @player.attacking
-          recoil = case @player.attack_frame
-                   when 0 then -6
-                   when 1 then -3
-                   when 2 then 3
-                   else 0
-                   end
-          y += recoil
-        end
+        # Bob offset (frozen during attack to keep weapon steady)
+        bob_x = @player.attacking ? 0 : @player.weapon_bob_x.to_i
+        bob_y = @player.attacking ? 0 : @player.weapon_bob_y.to_i
+
+        # DOOM's R_DrawPSprite: x1 = centerx + (psp->sx - centerx - spriteoffset)
+        # With psp->sx = 1 (default): x = 1 - left_offset
+        # Uses sprite's built-in offsets for both weapon and flash alignment
+        x = 1 - sprite.left_offset + bob_x
+        y = 1 - sprite.top_offset + SCREEN_Y_OFFSET + bob_y
 
         draw_weapon_sprite(framebuffer, sprite, x, y)
 
-        # Draw muzzle flash for pistol
-        if @player.attacking && @player.attack_frame < 2
-          draw_muzzle_flash(framebuffer, weapon_name, x, y)
+        # Draw muzzle flash only on the first fire frame (the actual shot)
+        if @player.attacking && @player.attack_frame == 0
+          draw_muzzle_flash(framebuffer, weapon_name)
         end
       end
 
@@ -83,7 +79,7 @@ module Doom
         end
       end
 
-      def draw_muzzle_flash(framebuffer, weapon_name, weapon_x, weapon_y)
+      def draw_muzzle_flash(framebuffer, weapon_name)
         weapon_data = @gfx.weapons[weapon_name]
         return unless weapon_data && weapon_data[:flash]
 
@@ -91,9 +87,10 @@ module Doom
         flash_sprite = weapon_data[:flash][flash_frame]
         return unless flash_sprite
 
-        # Flash is drawn at weapon position (sprite handles offset)
-        flash_x = (SCREEN_WIDTH / 2) - flash_sprite.left_offset
-        flash_y = WEAPON_AREA_HEIGHT - flash_sprite.top_offset
+        # Flash uses same positioning as weapon sprite (built-in offsets)
+        # Same positioning formula as weapon sprite
+        flash_x = 1 - flash_sprite.left_offset
+        flash_y = 1 - flash_sprite.top_offset + SCREEN_Y_OFFSET
 
         draw_weapon_sprite(framebuffer, flash_sprite, flash_x, flash_y)
       end

data/lib/doom/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Doom
-  VERSION = '0.4.0'
+  VERSION = '0.6.0'
 end

data/lib/doom/wad/hud_graphics.rb

@@ -4,7 +4,7 @@ module Doom
   module Wad
     # Loads HUD graphics (status bar, weapons) from WAD
     class HudGraphics
-      attr_reader :status_bar, :numbers, :weapons, :faces, :keys
+      attr_reader :status_bar, :arms_background, :numbers, :grey_numbers, :yellow_numbers, :weapons, :faces, :keys
 
       def initialize(wad)
         @wad = wad
@@ -84,6 +84,7 @@ module Doom
 
       def load_status_bar
         @status_bar = load_graphic('STBAR')
+        @arms_background = load_graphic('STARMS')
       end
 
       def load_numbers
@@ -95,11 +96,17 @@ module Doom
         @numbers['-'] = load_graphic('STTMINUS')
         @numbers['%'] = load_graphic('STTPRCNT')
 
-        # Small grey numbers for arms
+        # Small grey numbers for arms (weapon not owned)
         @grey_numbers = {}
         (0..9).each do |n|
           @grey_numbers[n] = load_graphic("STGNUM#{n}")
         end
+
+        # Small yellow numbers for arms (weapon owned) and ammo counts
+        @yellow_numbers = {}
+        (0..9).each do |n|
+          @yellow_numbers[n] = load_graphic("STYSNUM#{n}")
+        end
       end
 
       def load_weapons
@@ -129,6 +136,67 @@ module Doom
             load_graphic('PUNGD0')
           ].compact
         }
+
+        # Shotgun (SHTG)
+        @weapons[:shotgun] = {
+          idle: load_graphic('SHTGA0'),
+          fire: [
+            load_graphic('SHTGB0'),
+            load_graphic('SHTGC0'),
+            load_graphic('SHTGD0')
+          ].compact,
+          flash: [load_graphic('SHTFA0'), load_graphic('SHTFB0')].compact
+        }
+
+        # Chaingun (CHGG)
+        @weapons[:chaingun] = {
+          idle: load_graphic('CHGGA0'),
+          fire: [
+            load_graphic('CHGGB0'),
+            load_graphic('CHGGC0')
+          ].compact,
+          flash: [load_graphic('CHGFA0'), load_graphic('CHGFB0')].compact
+        }
+
+        # Rocket launcher (MISG)
+        @weapons[:rocket] = {
+          idle: load_graphic('MISGA0'),
+          fire: [
+            load_graphic('MISGB0'),
+            load_graphic('MISGC0'),
+            load_graphic('MISGD0')
+          ].compact,
+          flash: [load_graphic('MISFA0'), load_graphic('MISFB0'), load_graphic('MISFC0')].compact
+        }
+
+        # Plasma rifle (PLSG)
+        @weapons[:plasma] = {
+          idle: load_graphic('PLSGA0'),
+          fire: [
+            load_graphic('PLSGB0')
+          ].compact,
+          flash: [load_graphic('PLSFA0'), load_graphic('PLSFB0')].compact
+        }
+
+        # BFG9000 (BFGG)
+        @weapons[:bfg] = {
+          idle: load_graphic('BFGGA0'),
+          fire: [
+            load_graphic('BFGGB0'),
+            load_graphic('BFGGC0')
+          ].compact,
+          flash: [load_graphic('BFGFA0'), load_graphic('BFGFB0')].compact
+        }
+
+        # Chainsaw (SAWG)
+        @weapons[:chainsaw] = {
+          idle: load_graphic('SAWGA0'),
+          fire: [
+            load_graphic('SAWGB0'),
+            load_graphic('SAWGC0'),
+            load_graphic('SAWGD0')
+          ].compact
+        }
       end
 
       def load_faces

data/lib/doom/wad/sprite.rb

@@ -140,6 +140,11 @@ module Doom
         @wad = wad
         @cache = {}
         @rotation_cache = {}
+
+        # Build sprite lump index: maps "PREFIXframe_rotation" -> [lump_name, mirrored?]
+        # Handles combined lumps like SPOSA2A8 (rotation 2 normal, rotation 8 mirrored)
+        @sprite_index = {}
+        build_sprite_index
       end
 
       # Get default sprite (rotation 0 or 1)
@@ -149,9 +154,8 @@ module Doom
         prefix = THING_SPRITES[thing_type]
         return nil unless prefix
 
-        # Try to find sprite with A0 (all angles) or A1 (front facing)
-        sprite = Sprite.load(@wad, "#{prefix}A0") ||
-                 Sprite.load(@wad, "#{prefix}A1")
+        sprite = load_sprite_frame(prefix, 'A', 0) ||
+                 load_sprite_frame(prefix, 'A', 1)
 
         @cache[thing_type] = sprite
         sprite
@@ -169,36 +173,106 @@ module Doom
         prefix = THING_SPRITES[thing_type]
         return nil unless prefix
 
-        # Check cache for rotation 0 (all angles) sprite
-        cache_key = "#{prefix}A0"
-        if @rotation_cache.key?(cache_key)
-          return @rotation_cache[cache_key] if @rotation_cache[cache_key]
-        else
-          sprite = Sprite.load(@wad, cache_key)
-          @rotation_cache[cache_key] = sprite
-          return sprite if sprite
-        end
+        # Check for rotation 0 (all angles) sprite first
+        sprite = load_sprite_frame(prefix, 'A', 0)
+        return sprite if sprite
 
         # Calculate rotation frame (1-8)
-        # Doom rotations: 1=front, 2=front-right, 3=right, etc. (clockwise)
-        # The angle we need is: viewer's angle to sprite - sprite's facing angle
-        angle_diff = viewer_angle - (thing_angle * Math::PI / 180.0)
-
-        # Normalize to 0-2π
+        # DOOM: rot = (R_PointToAngle(thing) - thing->angle + ANG45/2*9) >> 29
+        # Rotation 1=front (viewer faces monster's front), 5=back
+        angle_diff = viewer_angle - (thing_angle * Math::PI / 180.0) + Math::PI
         angle_diff = angle_diff % (2 * Math::PI)
         angle_diff += 2 * Math::PI if angle_diff < 0
+        rotation = ((angle_diff + Math::PI / 8) / (Math::PI / 4)).to_i % 8 + 1
+
+        load_sprite_frame(prefix, 'A', rotation) || @cache[thing_type]
+      end
+
+      # Get a specific frame (for death animations, etc.)
+      def get_frame(thing_type, frame_letter, viewer_angle, thing_angle)
+        prefix = THING_SPRITES[thing_type]
+        return nil unless prefix
+
+        # Death frames typically use rotation 0 (same from all angles)
+        sprite = load_sprite_frame(prefix, frame_letter, 0)
+        return sprite if sprite
 
-        # Convert to rotation frame (1-8)
-        # Each rotation covers 45 degrees (π/4 radians)
-        # Add π/8 to center the ranges
+        # Try with calculated rotation (same formula as get_rotated)
+        angle_diff = viewer_angle - (thing_angle * Math::PI / 180.0) + Math::PI
+        angle_diff = angle_diff % (2 * Math::PI)
+        angle_diff += 2 * Math::PI if angle_diff < 0
         rotation = ((angle_diff + Math::PI / 8) / (Math::PI / 4)).to_i % 8 + 1
 
-        cache_key = "#{prefix}A#{rotation}"
-        unless @rotation_cache.key?(cache_key)
-          @rotation_cache[cache_key] = Sprite.load(@wad, cache_key)
+        load_sprite_frame(prefix, frame_letter, rotation)
+      end
+
+      private
+
+      def build_sprite_index
+        @wad.directory.each do |entry|
+          name = entry.name
+          next if name.length < 6
+
+          prefix = name[0, 4]
+          frame1 = name[4]
+          rot1 = name[5].to_i
+
+          # Register first frame+rotation
+          key = "#{prefix}#{frame1}#{rot1}"
+          @sprite_index[key] = [name, false]
+
+          # Check for mirrored second rotation (e.g., SPOSA2A8)
+          if name.length >= 8
+            frame2 = name[6]
+            rot2 = name[7].to_i
+            key2 = "#{prefix}#{frame2}#{rot2}"
+            @sprite_index[key2] = [name, true]
+          end
+        end
+      end
+
+      def load_sprite_frame(prefix, frame, rotation)
+        key = "#{prefix}#{frame}#{rotation}"
+        return @rotation_cache[key] if @rotation_cache.key?(key)
+
+        index_entry = @sprite_index[key]
+        unless index_entry
+          @rotation_cache[key] = nil
+          return nil
+        end
+
+        lump_name, mirrored = index_entry
+        # Load the base sprite (may be shared by mirrored pair)
+        base = load_or_cache_lump(lump_name)
+        unless base
+          @rotation_cache[key] = nil
+          return nil
         end
 
-        @rotation_cache[cache_key] || @cache[thing_type]
+        sprite = mirrored ? mirror_sprite(base) : base
+        @rotation_cache[key] = sprite
+        sprite
+      end
+
+      def load_or_cache_lump(lump_name)
+        cache_key = "_lump_#{lump_name}"
+        return @rotation_cache[cache_key] if @rotation_cache.key?(cache_key)
+
+        sprite = Sprite.load(@wad, lump_name)
+        @rotation_cache[cache_key] = sprite
+        sprite
+      end
+
+      def mirror_sprite(sprite)
+        # Flip columns horizontally, adjust left_offset
+        mirrored_columns = sprite.instance_variable_get(:@columns).reverse
+        mirrored_left = sprite.width - sprite.left_offset
+        Sprite.new(
+          "#{sprite.name}_M",
+          sprite.width, sprite.height,
+          mirrored_left, sprite.top_offset,
+          mirrored_columns
+        )
       end
     end
   end

data/lib/doom/wad/texture.rb

@@ -17,6 +17,7 @@ module Doom
       def self.load_all(wad)
         pnames = load_pnames(wad)
         textures = {}
+        texture_names = []
 
         %w[TEXTURE1 TEXTURE2].each do |lump_name|
           data = wad.read_lump(lump_name)
@@ -24,10 +25,11 @@ module Doom
 
           parse_texture_lump(data).each do |tex|
             textures[tex.name] = tex
+            texture_names << tex.name
           end
         end
 
-        { textures: textures, pnames: pnames }
+        { textures: textures, pnames: pnames, texture_names: texture_names }
       end
 
       def self.load_pnames(wad)
@@ -71,13 +73,14 @@ module Doom
     end
 
     class TextureManager
-      attr_reader :textures, :pnames, :patches
+      attr_reader :textures, :pnames, :patches, :texture_names
 
       def initialize(wad)
         @wad = wad
         result = Texture.load_all(wad)
         @textures = result[:textures]
         @pnames = result[:pnames]
+        @texture_names = result[:texture_names]
         @patches = {}
         @composite_cache = {}
       end
@@ -132,21 +135,29 @@ module Doom
         @width = width
         @height = height
         @columns = columns
+        @column_cache = Array.new(width)
+        precompute_columns
       end
 
-      def column_pixels(x, height_needed = nil)
-        x = x % @width
-        posts = @columns[x]
-        height_needed ||= @height
+      def column_pixels(x, _height_needed = nil)
+        @column_cache[x & (@width - 1)]
+      end
+
+      private
 
-        pixels = Array.new(height_needed, 0)
-        posts.each do |post|
-          post.pixels.each_with_index do |color, i|
-            y = (post.top_delta + i) % @height
-            pixels[y] = color if y < height_needed
+      def precompute_columns
+        @width.times do |x|
+          posts = @columns[x]
+          pixels = Array.new(@height, 0)
+          posts.each do |post|
+            td = post.top_delta
+            post.pixels.each_with_index do |color, i|
+              y = (td + i) % @height
+              pixels[y] = color
+            end
           end
+          @column_cache[x] = pixels.freeze
         end
-        pixels
       end
     end
   end

data/lib/doom/wad_downloader.rb

@@ -66,7 +66,16 @@ module Doom
       uri = URI.parse(SHAREWARE_URL)
       downloaded = 0
 
-      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+      ssl_opts = { use_ssl: uri.scheme == 'https' }
+      # Workaround for SSL certificate issues on some systems
+      begin
+        Net::HTTP.start(uri.host, uri.port, **ssl_opts) { |h| h.head(uri) }
+      rescue OpenSSL::SSL::SSLError
+        puts "SSL certificate verification failed, retrying without verification..."
+        ssl_opts[:verify_mode] = OpenSSL::SSL::VERIFY_NONE
+      end
+
+      Net::HTTP.start(uri.host, uri.port, **ssl_opts) do |http|
         request = Net::HTTP::Get.new(uri)
 
         http.request(request) do |response|

data/lib/doom.rb

@@ -13,6 +13,11 @@ require_relative 'doom/wad/hud_graphics'
 require_relative 'doom/map/data'
 require_relative 'doom/game/player_state'
 require_relative 'doom/game/sector_actions'
+require_relative 'doom/game/animations'
+require_relative 'doom/game/item_pickup'
+require_relative 'doom/game/combat'
+require_relative 'doom/game/sector_effects'
+require_relative 'doom/game/monster_ai'
 require_relative 'doom/render/renderer'
 require_relative 'doom/render/status_bar'
 require_relative 'doom/render/weapon_renderer'
@@ -61,8 +66,12 @@ module Doom
         player_start = Map::Thing.new(0, 0, 90, 1, 0)
       end
 
+      puts 'Initializing animations...'
+      flat_names = flats.map(&:name)
+      animations = Game::Animations.new(textures.texture_names, flat_names)
+
       puts 'Creating renderer...'
-      renderer = Render::Renderer.new(wad, map, textures, palette, colormap, flats, sprites)
+      renderer = Render::Renderer.new(wad, map, textures, palette, colormap, flats, sprites, animations)
       renderer.set_player(player_start.x, player_start.y, 41, player_start.angle)
 
       puts 'Setting up player state and HUD...'
@@ -70,9 +79,13 @@ module Doom
       status_bar = Render::StatusBar.new(hud_graphics, player_state)
       weapon_renderer = Render::WeaponRenderer.new(hud_graphics, player_state)
       sector_actions = Game::SectorActions.new(map)
+      sector_effects = Game::SectorEffects.new(map)
+      item_pickup = Game::ItemPickup.new(map, player_state)
+      combat = Game::Combat.new(map, player_state, sprites)
+      monster_ai = Game::MonsterAI.new(map, combat)
 
       puts 'Starting game window...'
-      window = Platform::GosuWindow.new(renderer, palette, map, player_state, status_bar, weapon_renderer, sector_actions)
+      window = Platform::GosuWindow.new(renderer, palette, map, player_state, status_bar, weapon_renderer, sector_actions, animations, sector_effects, item_pickup, combat, monster_ai)
       window.show
     end
   end