konpeito 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 453b0bb32e4ef66b8b6020d262200e070caf01fb483cff4a0ebd6ceba46495b3
-  data.tar.gz: 7b38fb2807e1649150a0febae5defcb8f964967a715770db1de857d6409f88b3
+  metadata.gz: c6e49cc678968c9afbf41e3483ce19ac9d0f506bf18b31def5de3468fdef18b3
+  data.tar.gz: f6f85c8b6d646c56ace6b35338ea66adeabc53eec3a21b50b0953346145b0d59
 SHA512:
-  metadata.gz: afa5fd10db773c8e1bb3c399a39cf140b1c7577271420750368551ee80cab864683d9455860ddba185b0d53cc221df42b5beb3a7334fbc67b56747e4a7bd6e0f
-  data.tar.gz: 7fbe956b09d489f9af313c0fa6600f81960cb02cb72d95f912a4d50d9f658b4b7bff35528d43b73c223d011d0aa5c35f6c63bf09ce5f1873c14605cd7274395e
+  metadata.gz: cc766128892195b93c5acf173b7a84c3ee86415932b9d477a952a824cb9167b15c7e63b74ab894dcd7e8213e731b5c6b2dfd1f2ef829c2e380583d7e85f1536b
+  data.tar.gz: 692f32eee6feb583b24b7f468fbd659c784f01c41ecde853272966c13bdda0032c47e8d55d0d0f0d084dd9493f0df50d9f0f483245f7d9f1a8ef98f43bbb6c70

data/CHANGELOG.md

@@ -7,6 +7,29 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.6.0] - 2026-03-11
+
+### Added
+- **Raylib stdlib expansion**: 119 new cfunc bindings (87 → 206 total) for 2D RPG/SLG game development
+  - Texture/Sprite management (10): load, unload, draw, draw_rec, draw_pro, draw_scaled, dimensions, validity check
+  - Audio — Sound (10): load, unload, play, stop, pause, resume, playing?, volume, pitch
+  - Audio — Music (13): load, unload, play, stop, pause, resume, update, playing?, volume, pitch, time_length, time_played, seek
+  - Audio — Device (4): init, close, ready?, master volume
+  - Camera2D (4): begin/end mode, world-to-screen coordinate conversion (x/y)
+  - File I/O (4): save/load text files, file/directory existence checks
+  - Font management (6): load, load_ex, unload, draw_text_ex, measure_text_ex (x/y)
+  - Gamepad input (7 + 21 constants): button pressed/down/released/up, axis movement/count, D-pad/face/trigger/middle button and axis constants
+  - Extended shapes (5): draw_rectangle_pro, draw_rectangle_rounded, gradient v/h, circle sector
+  - Collision detection (5): recs, circles, circle-rec, point-rec, point-circle
+  - ID table pattern for resource management: textures (256), sounds (128), music (32), fonts (32)
+- **RPG tilemap demo**: `examples/mruby_rpg_demo/rpg_demo.rb` — 40×40 tilemap, smooth camera scrolling, 4-direction player movement with animation, sign interaction, HUD with step counter
+- macOS audio framework linker flags (CoreAudio, AudioToolbox, CoreFoundation)
+
+### Fixed
+- **Inliner CFuncCall bug**: `clone_and_rename()` now handles `CFuncCall`, `ExternConstructorCall`, and `ExternMethodCall` — parameters are correctly remapped when user functions calling `@cfunc` are inlined (previously fell through to default case, returning instructions with unmapped parameters)
+- **CI lint**: use anonymous block forwarding (`&`) in `rbs_loader.rb`
+- **CI test isolation**: use unique symbol names in `module_native_array_test` to avoid ELF symbol interposition on Linux
+
 ## [0.5.0] - 2026-03-10
 
 ### Added

data/lib/konpeito/codegen/inliner.rb

@@ -542,6 +542,40 @@ module Konpeito
             result_var: new_result
           )
 
+        when HIR::CFuncCall
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          new_args = inst.args.map { |a| transform_value(a, prefix, param_map) }
+          HIR::CFuncCall.new(
+            c_func_name: inst.c_func_name,
+            args: new_args,
+            cfunc_type: inst.cfunc_type,
+            result_var: new_result
+          )
+
+        when HIR::ExternConstructorCall
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          new_args = inst.args.map { |a| transform_value(a, prefix, param_map) }
+          HIR::ExternConstructorCall.new(
+            extern_type: inst.extern_type,
+            c_func_name: inst.c_func_name,
+            args: new_args,
+            method_sig: inst.method_sig,
+            result_var: new_result
+          )
+
+        when HIR::ExternMethodCall
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          new_receiver = transform_value(inst.receiver, prefix, param_map)
+          new_args = inst.args.map { |a| transform_value(a, prefix, param_map) }
+          HIR::ExternMethodCall.new(
+            receiver: new_receiver,
+            c_func_name: inst.c_func_name,
+            args: new_args,
+            extern_type: inst.extern_type,
+            method_sig: inst.method_sig,
+            result_var: new_result
+          )
+
         else
           # For other instructions, just return as-is with renamed result
           inst

data/lib/konpeito/codegen/mruby_backend.rb

@@ -1171,7 +1171,9 @@ module Konpeito
         # Known framework dependencies for popular libraries
         case lib_name
         when "raylib"
-          ["-framework", "IOKit", "-framework", "Cocoa", "-framework", "OpenGL"]
+          ["-framework", "IOKit", "-framework", "Cocoa", "-framework", "OpenGL",
+           "-framework", "CoreAudio", "-framework", "AudioToolbox",
+           "-framework", "CoreFoundation"]
         when "SDL2", "sdl2"
           ["-framework", "IOKit", "-framework", "Cocoa", "-framework", "Carbon",
            "-framework", "CoreAudio", "-framework", "AudioToolbox",

data/lib/konpeito/stdlib/raylib/raylib.rb

@@ -144,4 +144,116 @@ module Raylib
   def self.flag_window_resizable() end
   def self.flag_window_highdpi() end
   def self.flag_msaa_4x_hint() end
+
+  # Texture Management
+  def self.load_texture(path) end
+  def self.unload_texture(id) end
+  def self.draw_texture(id, x, y, tint) end
+  def self.draw_texture_rec(id, sx, sy, sw, sh, dx, dy, tint) end
+  def self.draw_texture_pro(id, sx, sy, sw, sh, dx, dy, dw, dh, ox, oy, rotation, tint) end
+  def self.get_texture_width(id) end
+  def self.get_texture_height(id) end
+  def self.texture_valid?(id) end
+  def self.draw_texture_scaled(id, x, y, scale, tint) end
+
+  # Audio — Device
+  def self.init_audio_device() end
+  def self.close_audio_device() end
+  def self.audio_device_ready?() end
+  def self.set_master_volume(vol) end
+  def self.get_master_volume() end
+
+  # Audio — Sound
+  def self.load_sound(path) end
+  def self.unload_sound(id) end
+  def self.play_sound(id) end
+  def self.stop_sound(id) end
+  def self.pause_sound(id) end
+  def self.resume_sound(id) end
+  def self.sound_playing?(id) end
+  def self.set_sound_volume(id, vol) end
+  def self.set_sound_pitch(id, pitch) end
+
+  # Audio — Music
+  def self.load_music(path) end
+  def self.unload_music(id) end
+  def self.play_music(id) end
+  def self.stop_music(id) end
+  def self.pause_music(id) end
+  def self.resume_music(id) end
+  def self.update_music(id) end
+  def self.music_playing?(id) end
+  def self.set_music_volume(id, vol) end
+  def self.set_music_pitch(id, pitch) end
+  def self.get_music_time_length(id) end
+  def self.get_music_time_played(id) end
+  def self.seek_music(id, position) end
+
+  # Camera2D
+  def self.begin_mode_2d(offset_x, offset_y, target_x, target_y, rotation, zoom) end
+  def self.end_mode_2d() end
+  def self.get_world_to_screen_2d_x(world_x, world_y, offset_x, offset_y, target_x, target_y, rotation, zoom) end
+  def self.get_world_to_screen_2d_y(world_x, world_y, offset_x, offset_y, target_x, target_y, rotation, zoom) end
+
+  # File I/O
+  def self.save_file_text(path, text) end
+  def self.load_file_text(path) end
+  def self.file_exists?(path) end
+  def self.directory_exists?(path) end
+
+  # Font Management
+  def self.load_font(path) end
+  def self.load_font_ex(path, size) end
+  def self.unload_font(id) end
+  def self.draw_text_ex(font_id, text, x, y, size, spacing, tint) end
+  def self.measure_text_ex_x(font_id, text, size, spacing) end
+  def self.measure_text_ex_y(font_id, text, size, spacing) end
+
+  # Gamepad Input
+  def self.gamepad_available?(gamepad) end
+  def self.gamepad_button_pressed?(gamepad, button) end
+  def self.gamepad_button_down?(gamepad, button) end
+  def self.gamepad_button_released?(gamepad, button) end
+  def self.gamepad_button_up?(gamepad, button) end
+  def self.get_gamepad_axis_movement(gamepad, axis) end
+  def self.get_gamepad_axis_count(gamepad) end
+
+  # Gamepad Button Constants
+  def self.gamepad_button_left_face_up() end
+  def self.gamepad_button_left_face_right() end
+  def self.gamepad_button_left_face_down() end
+  def self.gamepad_button_left_face_left() end
+  def self.gamepad_button_right_face_up() end
+  def self.gamepad_button_right_face_right() end
+  def self.gamepad_button_right_face_down() end
+  def self.gamepad_button_right_face_left() end
+  def self.gamepad_button_left_trigger_1() end
+  def self.gamepad_button_left_trigger_2() end
+  def self.gamepad_button_right_trigger_1() end
+  def self.gamepad_button_right_trigger_2() end
+  def self.gamepad_button_middle_left() end
+  def self.gamepad_button_middle() end
+  def self.gamepad_button_middle_right() end
+
+  # Gamepad Axis Constants
+  def self.gamepad_axis_left_x() end
+  def self.gamepad_axis_left_y() end
+  def self.gamepad_axis_right_x() end
+  def self.gamepad_axis_right_y() end
+  def self.gamepad_axis_left_trigger() end
+  def self.gamepad_axis_right_trigger() end
+
+  # Drawing — Extended Shapes
+  def self.draw_rectangle_pro(x, y, w, h, ox, oy, rotation, color) end
+  def self.draw_rectangle_rounded(x, y, w, h, roundness, segments, color) end
+  def self.draw_rectangle_gradient_v(x, y, w, h, color1, color2) end
+  def self.draw_rectangle_gradient_h(x, y, w, h, color1, color2) end
+  def self.draw_circle_sector(cx, cy, radius, start_angle, end_angle, segments, color) end
+
+  # Collision Detection
+  def self.check_collision_recs(x1, y1, w1, h1, x2, y2, w2, h2) end
+  def self.check_collision_circles(cx1, cy1, r1, cx2, cy2, r2) end
+  def self.check_collision_circle_rec(cx, cy, radius, rx, ry, rw, rh) end
+  def self.check_collision_point_rec(px, py, rx, ry, rw, rh) end
+  def self.check_collision_point_circle(px, py, cx, cy, radius) end
 end

data/lib/konpeito/stdlib/raylib/raylib.rbs

@@ -386,4 +386,292 @@ module Raylib
 
   %a{cfunc: "konpeito_flag_msaa_4x_hint"}
   def self.flag_msaa_4x_hint: () -> Integer
+
+  # ── Texture Management ──
+
+  %a{cfunc: "konpeito_load_texture"}
+  def self.load_texture: (String path) -> Integer
+
+  %a{cfunc: "konpeito_unload_texture"}
+  def self.unload_texture: (Integer id) -> void
+
+  %a{cfunc: "konpeito_draw_texture"}
+  def self.draw_texture: (Integer id, Integer x, Integer y, Integer tint) -> void
+
+  %a{cfunc: "konpeito_draw_texture_rec"}
+  def self.draw_texture_rec: (Integer id, Float sx, Float sy, Float sw, Float sh, Integer dx, Integer dy, Integer tint) -> void
+
+  %a{cfunc: "konpeito_draw_texture_pro"}
+  def self.draw_texture_pro: (Integer id, Float sx, Float sy, Float sw, Float sh, Float dx, Float dy, Float dw, Float dh, Float ox, Float oy, Float rotation, Integer tint) -> void
+
+  %a{cfunc: "konpeito_get_texture_width"}
+  def self.get_texture_width: (Integer id) -> Integer
+
+  %a{cfunc: "konpeito_get_texture_height"}
+  def self.get_texture_height: (Integer id) -> Integer
+
+  %a{cfunc: "konpeito_is_texture_valid"}
+  def self.texture_valid?: (Integer id) -> Integer
+
+  %a{cfunc: "konpeito_draw_texture_scaled"}
+  def self.draw_texture_scaled: (Integer id, Integer x, Integer y, Float scale, Integer tint) -> void
+
+  # ── Audio — Device ──
+
+  %a{cfunc: "konpeito_init_audio_device"}
+  def self.init_audio_device: () -> void
+
+  %a{cfunc: "konpeito_close_audio_device"}
+  def self.close_audio_device: () -> void
+
+  %a{cfunc: "konpeito_is_audio_device_ready"}
+  def self.audio_device_ready?: () -> Integer
+
+  %a{cfunc: "konpeito_set_master_volume"}
+  def self.set_master_volume: (Float vol) -> void
+
+  %a{cfunc: "konpeito_get_master_volume"}
+  def self.get_master_volume: () -> Float
+
+  # ── Audio — Sound ──
+
+  %a{cfunc: "konpeito_load_sound"}
+  def self.load_sound: (String path) -> Integer
+
+  %a{cfunc: "konpeito_unload_sound"}
+  def self.unload_sound: (Integer id) -> void
+
+  %a{cfunc: "konpeito_play_sound"}
+  def self.play_sound: (Integer id) -> void
+
+  %a{cfunc: "konpeito_stop_sound"}
+  def self.stop_sound: (Integer id) -> void
+
+  %a{cfunc: "konpeito_pause_sound"}
+  def self.pause_sound: (Integer id) -> void
+
+  %a{cfunc: "konpeito_resume_sound"}
+  def self.resume_sound: (Integer id) -> void
+
+  %a{cfunc: "konpeito_is_sound_playing"}
+  def self.sound_playing?: (Integer id) -> Integer
+
+  %a{cfunc: "konpeito_set_sound_volume"}
+  def self.set_sound_volume: (Integer id, Float vol) -> void
+
+  %a{cfunc: "konpeito_set_sound_pitch"}
+  def self.set_sound_pitch: (Integer id, Float pitch) -> void
+
+  # ── Audio — Music ──
+
+  %a{cfunc: "konpeito_load_music"}
+  def self.load_music: (String path) -> Integer
+
+  %a{cfunc: "konpeito_unload_music"}
+  def self.unload_music: (Integer id) -> void
+
+  %a{cfunc: "konpeito_play_music"}
+  def self.play_music: (Integer id) -> void
+
+  %a{cfunc: "konpeito_stop_music"}
+  def self.stop_music: (Integer id) -> void
+
+  %a{cfunc: "konpeito_pause_music"}
+  def self.pause_music: (Integer id) -> void
+
+  %a{cfunc: "konpeito_resume_music"}
+  def self.resume_music: (Integer id) -> void
+
+  %a{cfunc: "konpeito_update_music"}
+  def self.update_music: (Integer id) -> void
+
+  %a{cfunc: "konpeito_is_music_playing"}
+  def self.music_playing?: (Integer id) -> Integer
+
+  %a{cfunc: "konpeito_set_music_volume"}
+  def self.set_music_volume: (Integer id, Float vol) -> void
+
+  %a{cfunc: "konpeito_set_music_pitch"}
+  def self.set_music_pitch: (Integer id, Float pitch) -> void
+
+  %a{cfunc: "konpeito_get_music_time_length"}
+  def self.get_music_time_length: (Integer id) -> Float
+
+  %a{cfunc: "konpeito_get_music_time_played"}
+  def self.get_music_time_played: (Integer id) -> Float
+
+  %a{cfunc: "konpeito_seek_music"}
+  def self.seek_music: (Integer id, Float position) -> void
+
+  # ── Camera2D ──
+
+  %a{cfunc: "konpeito_begin_mode_2d"}
+  def self.begin_mode_2d: (Float offset_x, Float offset_y, Float target_x, Float target_y, Float rotation, Float zoom) -> void
+
+  %a{cfunc: "konpeito_end_mode_2d"}
+  def self.end_mode_2d: () -> void
+
+  %a{cfunc: "konpeito_get_world_to_screen_2d_x"}
+  def self.get_world_to_screen_2d_x: (Float world_x, Float world_y, Float offset_x, Float offset_y, Float target_x, Float target_y, Float rotation, Float zoom) -> Integer
+
+  %a{cfunc: "konpeito_get_world_to_screen_2d_y"}
+  def self.get_world_to_screen_2d_y: (Float world_x, Float world_y, Float offset_x, Float offset_y, Float target_x, Float target_y, Float rotation, Float zoom) -> Integer
+
+  # ── File I/O ──
+
+  %a{cfunc: "konpeito_save_file_text"}
+  def self.save_file_text: (String path, String text) -> Integer
+
+  %a{cfunc: "konpeito_load_file_text"}
+  def self.load_file_text: (String path) -> String
+
+  %a{cfunc: "konpeito_file_exists"}
+  def self.file_exists?: (String path) -> Integer
+
+  %a{cfunc: "konpeito_directory_exists"}
+  def self.directory_exists?: (String path) -> Integer
+
+  # ── Font Management ──
+
+  %a{cfunc: "konpeito_load_font"}
+  def self.load_font: (String path) -> Integer
+
+  %a{cfunc: "konpeito_load_font_ex"}
+  def self.load_font_ex: (String path, Integer size) -> Integer
+
+  %a{cfunc: "konpeito_unload_font"}
+  def self.unload_font: (Integer id) -> void
+
+  %a{cfunc: "konpeito_draw_text_ex"}
+  def self.draw_text_ex: (Integer font_id, String text, Float x, Float y, Float size, Float spacing, Integer tint) -> void
+
+  %a{cfunc: "konpeito_measure_text_ex_x"}
+  def self.measure_text_ex_x: (Integer font_id, String text, Float size, Float spacing) -> Integer
+
+  %a{cfunc: "konpeito_measure_text_ex_y"}
+  def self.measure_text_ex_y: (Integer font_id, String text, Float size, Float spacing) -> Integer
+
+  # ── Gamepad Input ──
+
+  %a{cfunc: "konpeito_is_gamepad_available"}
+  def self.gamepad_available?: (Integer gamepad) -> Integer
+
+  %a{cfunc: "konpeito_is_gamepad_button_pressed"}
+  def self.gamepad_button_pressed?: (Integer gamepad, Integer button) -> Integer
+
+  %a{cfunc: "konpeito_is_gamepad_button_down"}
+  def self.gamepad_button_down?: (Integer gamepad, Integer button) -> Integer
+
+  %a{cfunc: "konpeito_is_gamepad_button_released"}
+  def self.gamepad_button_released?: (Integer gamepad, Integer button) -> Integer
+
+  %a{cfunc: "konpeito_is_gamepad_button_up"}
+  def self.gamepad_button_up?: (Integer gamepad, Integer button) -> Integer
+
+  %a{cfunc: "konpeito_get_gamepad_axis_movement"}
+  def self.get_gamepad_axis_movement: (Integer gamepad, Integer axis) -> Float
+
+  %a{cfunc: "konpeito_get_gamepad_axis_count"}
+  def self.get_gamepad_axis_count: (Integer gamepad) -> Integer
+
+  # ── Gamepad Button Constants ──
+
+  %a{cfunc: "konpeito_gamepad_button_left_face_up"}
+  def self.gamepad_button_left_face_up: () -> Integer
+
+  %a{cfunc: "konpeito_gamepad_button_left_face_right"}
+  def self.gamepad_button_left_face_right: () -> Integer
+
+  %a{cfunc: "konpeito_gamepad_button_left_face_down"}
+  def self.gamepad_button_left_face_down: () -> Integer
+
+  %a{cfunc: "konpeito_gamepad_button_left_face_left"}
+  def self.gamepad_button_left_face_left: () -> Integer
+
+  %a{cfunc: "konpeito_gamepad_button_right_face_up"}
+  def self.gamepad_button_right_face_up: () -> Integer
+
+  %a{cfunc: "konpeito_gamepad_button_right_face_right"}
+  def self.gamepad_button_right_face_right: () -> Integer
+
+  %a{cfunc: "konpeito_gamepad_button_right_face_down"}
+  def self.gamepad_button_right_face_down: () -> Integer
+
+  %a{cfunc: "konpeito_gamepad_button_right_face_left"}
+  def self.gamepad_button_right_face_left: () -> Integer
+
+  %a{cfunc: "konpeito_gamepad_button_left_trigger_1"}
+  def self.gamepad_button_left_trigger_1: () -> Integer
+
+  %a{cfunc: "konpeito_gamepad_button_left_trigger_2"}
+  def self.gamepad_button_left_trigger_2: () -> Integer
+
+  %a{cfunc: "konpeito_gamepad_button_right_trigger_1"}
+  def self.gamepad_button_right_trigger_1: () -> Integer
+
+  %a{cfunc: "konpeito_gamepad_button_right_trigger_2"}
+  def self.gamepad_button_right_trigger_2: () -> Integer
+
+  %a{cfunc: "konpeito_gamepad_button_middle_left"}
+  def self.gamepad_button_middle_left: () -> Integer
+
+  %a{cfunc: "konpeito_gamepad_button_middle"}
+  def self.gamepad_button_middle: () -> Integer
+
+  %a{cfunc: "konpeito_gamepad_button_middle_right"}
+  def self.gamepad_button_middle_right: () -> Integer
+
+  # ── Gamepad Axis Constants ──
+
+  %a{cfunc: "konpeito_gamepad_axis_left_x"}
+  def self.gamepad_axis_left_x: () -> Integer
+
+  %a{cfunc: "konpeito_gamepad_axis_left_y"}
+  def self.gamepad_axis_left_y: () -> Integer
+
+  %a{cfunc: "konpeito_gamepad_axis_right_x"}
+  def self.gamepad_axis_right_x: () -> Integer
+
+  %a{cfunc: "konpeito_gamepad_axis_right_y"}
+  def self.gamepad_axis_right_y: () -> Integer
+
+  %a{cfunc: "konpeito_gamepad_axis_left_trigger"}
+  def self.gamepad_axis_left_trigger: () -> Integer
+
+  %a{cfunc: "konpeito_gamepad_axis_right_trigger"}
+  def self.gamepad_axis_right_trigger: () -> Integer
+
+  # ── Drawing — Extended Shapes ──
+
+  %a{cfunc: "konpeito_draw_rectangle_pro"}
+  def self.draw_rectangle_pro: (Float x, Float y, Float w, Float h, Float ox, Float oy, Float rotation, Integer color) -> void
+
+  %a{cfunc: "konpeito_draw_rectangle_rounded"}
+  def self.draw_rectangle_rounded: (Float x, Float y, Float w, Float h, Float roundness, Integer segments, Integer color) -> void
+
+  %a{cfunc: "konpeito_draw_rectangle_gradient_v"}
+  def self.draw_rectangle_gradient_v: (Integer x, Integer y, Integer w, Integer h, Integer color1, Integer color2) -> void
+
+  %a{cfunc: "konpeito_draw_rectangle_gradient_h"}
+  def self.draw_rectangle_gradient_h: (Integer x, Integer y, Integer w, Integer h, Integer color1, Integer color2) -> void
+
+  %a{cfunc: "konpeito_draw_circle_sector"}
+  def self.draw_circle_sector: (Integer cx, Integer cy, Float radius, Float start_angle, Float end_angle, Integer segments, Integer color) -> void
+
+  # ── Collision Detection ──
+
+  %a{cfunc: "konpeito_check_collision_recs"}
+  def self.check_collision_recs: (Float x1, Float y1, Float w1, Float h1, Float x2, Float y2, Float w2, Float h2) -> Integer
+
+  %a{cfunc: "konpeito_check_collision_circles"}
+  def self.check_collision_circles: (Float cx1, Float cy1, Float r1, Float cx2, Float cy2, Float r2) -> Integer
+
+  %a{cfunc: "konpeito_check_collision_circle_rec"}
+  def self.check_collision_circle_rec: (Float cx, Float cy, Float radius, Float rx, Float ry, Float rw, Float rh) -> Integer
+
+  %a{cfunc: "konpeito_check_collision_point_rec"}
+  def self.check_collision_point_rec: (Float px, Float py, Float rx, Float ry, Float rw, Float rh) -> Integer
+
+  %a{cfunc: "konpeito_check_collision_point_circle"}
+  def self.check_collision_point_circle: (Float px, Float py, Float cx, Float cy, Float radius) -> Integer
 end

data/lib/konpeito/stdlib/raylib/raylib_native.c

@@ -12,6 +12,7 @@
 #include <raylib.h>
 #include <string.h>
 #include <math.h>
+#include <stdlib.h>
 
 /* ── macOS app activation ── */
 #ifdef __APPLE__
@@ -258,3 +259,512 @@ int konpeito_get_random_value(int min, int max) {
 int konpeito_flag_window_resizable(void) { return FLAG_WINDOW_RESIZABLE; }
 int konpeito_flag_window_highdpi(void)   { return FLAG_WINDOW_HIGHDPI; }
 int konpeito_flag_msaa_4x_hint(void)     { return FLAG_MSAA_4X_HINT; }
+
+/* ═══════════════════════════════════════════
+ *  Texture Management (ID-based table)
+ * ═══════════════════════════════════════════ */
+
+#define MAX_TEXTURES 256
+
+static Texture2D g_textures[MAX_TEXTURES];
+static int       g_texture_used[MAX_TEXTURES];
+static int       g_textures_initialized = 0;
+
+static void ensure_textures_init(void) {
+    if (g_textures_initialized) return;
+    memset(g_texture_used, 0, sizeof(g_texture_used));
+    g_textures_initialized = 1;
+}
+
+static int alloc_texture_slot(void) {
+    ensure_textures_init();
+    for (int i = 0; i < MAX_TEXTURES; i++) {
+        if (!g_texture_used[i]) {
+            g_texture_used[i] = 1;
+            return i;
+        }
+    }
+    return -1;
+}
+
+int konpeito_load_texture(const char *path) {
+    int slot = alloc_texture_slot();
+    if (slot < 0) return -1;
+    g_textures[slot] = LoadTexture(path);
+    if (g_textures[slot].id == 0) {
+        g_texture_used[slot] = 0;
+        return -1;
+    }
+    return slot;
+}
+
+void konpeito_unload_texture(int id) {
+    if (id < 0 || id >= MAX_TEXTURES || !g_texture_used[id]) return;
+    UnloadTexture(g_textures[id]);
+    g_texture_used[id] = 0;
+}
+
+void konpeito_draw_texture(int id, int x, int y, int tint) {
+    if (id < 0 || id >= MAX_TEXTURES || !g_texture_used[id]) return;
+    DrawTexture(g_textures[id], x, y, int_to_color(tint));
+}
+
+void konpeito_draw_texture_rec(int id, double sx, double sy, double sw, double sh,
+                                int dx, int dy, int tint) {
+    if (id < 0 || id >= MAX_TEXTURES || !g_texture_used[id]) return;
+    Rectangle source = { (float)sx, (float)sy, (float)sw, (float)sh };
+    Vector2 pos = { (float)dx, (float)dy };
+    DrawTextureRec(g_textures[id], source, pos, int_to_color(tint));
+}
+
+void konpeito_draw_texture_pro(int id,
+                                double sx, double sy, double sw, double sh,
+                                double dx, double dy, double dw, double dh,
+                                double ox, double oy, double rotation, int tint) {
+    if (id < 0 || id >= MAX_TEXTURES || !g_texture_used[id]) return;
+    Rectangle source = { (float)sx, (float)sy, (float)sw, (float)sh };
+    Rectangle dest   = { (float)dx, (float)dy, (float)dw, (float)dh };
+    Vector2 origin   = { (float)ox, (float)oy };
+    DrawTexturePro(g_textures[id], source, dest, origin, (float)rotation, int_to_color(tint));
+}
+
+int konpeito_get_texture_width(int id) {
+    if (id < 0 || id >= MAX_TEXTURES || !g_texture_used[id]) return 0;
+    return g_textures[id].width;
+}
+
+int konpeito_get_texture_height(int id) {
+    if (id < 0 || id >= MAX_TEXTURES || !g_texture_used[id]) return 0;
+    return g_textures[id].height;
+}
+
+int konpeito_is_texture_valid(int id) {
+    if (id < 0 || id >= MAX_TEXTURES || !g_texture_used[id]) return 0;
+    return (int)IsTextureValid(g_textures[id]);
+}
+
+void konpeito_draw_texture_scaled(int id, int x, int y, double scale, int tint) {
+    if (id < 0 || id >= MAX_TEXTURES || !g_texture_used[id]) return;
+    DrawTextureEx(g_textures[id], (Vector2){(float)x, (float)y},
+                  0.0f, (float)scale, int_to_color(tint));
+}
+
+/* ═══════════════════════════════════════════
+ *  Audio Management (ID-based tables)
+ * ═══════════════════════════════════════════ */
+
+#define MAX_SOUNDS 128
+#define MAX_MUSIC  32
+
+static Sound  g_sounds[MAX_SOUNDS];
+static int    g_sound_used[MAX_SOUNDS];
+static int    g_sounds_initialized = 0;
+
+static Music  g_music[MAX_MUSIC];
+static int    g_music_used[MAX_MUSIC];
+static int    g_music_initialized = 0;
+
+static void ensure_sounds_init(void) {
+    if (g_sounds_initialized) return;
+    memset(g_sound_used, 0, sizeof(g_sound_used));
+    g_sounds_initialized = 1;
+}
+
+static void ensure_music_init(void) {
+    if (g_music_initialized) return;
+    memset(g_music_used, 0, sizeof(g_music_used));
+    g_music_initialized = 1;
+}
+
+/* Audio device */
+void konpeito_init_audio_device(void)  { InitAudioDevice(); }
+void konpeito_close_audio_device(void) { CloseAudioDevice(); }
+int  konpeito_is_audio_device_ready(void) { return (int)IsAudioDeviceReady(); }
+void konpeito_set_master_volume(double vol) { SetMasterVolume((float)vol); }
+double konpeito_get_master_volume(void) { return (double)GetMasterVolume(); }
+
+/* Sound */
+int konpeito_load_sound(const char *path) {
+    ensure_sounds_init();
+    for (int i = 0; i < MAX_SOUNDS; i++) {
+        if (!g_sound_used[i]) {
+            g_sounds[i] = LoadSound(path);
+            if (g_sounds[i].frameCount == 0) return -1;
+            g_sound_used[i] = 1;
+            return i;
+        }
+    }
+    return -1;
+}
+
+void konpeito_unload_sound(int id) {
+    if (id < 0 || id >= MAX_SOUNDS || !g_sound_used[id]) return;
+    UnloadSound(g_sounds[id]);
+    g_sound_used[id] = 0;
+}
+
+void konpeito_play_sound(int id) {
+    if (id < 0 || id >= MAX_SOUNDS || !g_sound_used[id]) return;
+    PlaySound(g_sounds[id]);
+}
+
+void konpeito_stop_sound(int id) {
+    if (id < 0 || id >= MAX_SOUNDS || !g_sound_used[id]) return;
+    StopSound(g_sounds[id]);
+}
+
+void konpeito_pause_sound(int id) {
+    if (id < 0 || id >= MAX_SOUNDS || !g_sound_used[id]) return;
+    PauseSound(g_sounds[id]);
+}
+
+void konpeito_resume_sound(int id) {
+    if (id < 0 || id >= MAX_SOUNDS || !g_sound_used[id]) return;
+    ResumeSound(g_sounds[id]);
+}
+
+int konpeito_is_sound_playing(int id) {
+    if (id < 0 || id >= MAX_SOUNDS || !g_sound_used[id]) return 0;
+    return (int)IsSoundPlaying(g_sounds[id]);
+}
+
+void konpeito_set_sound_volume(int id, double vol) {
+    if (id < 0 || id >= MAX_SOUNDS || !g_sound_used[id]) return;
+    SetSoundVolume(g_sounds[id], (float)vol);
+}
+
+void konpeito_set_sound_pitch(int id, double pitch) {
+    if (id < 0 || id >= MAX_SOUNDS || !g_sound_used[id]) return;
+    SetSoundPitch(g_sounds[id], (float)pitch);
+}
+
+/* Music stream */
+int konpeito_load_music(const char *path) {
+    ensure_music_init();
+    for (int i = 0; i < MAX_MUSIC; i++) {
+        if (!g_music_used[i]) {
+            g_music[i] = LoadMusicStream(path);
+            if (g_music[i].frameCount == 0) return -1;
+            g_music_used[i] = 1;
+            return i;
+        }
+    }
+    return -1;
+}
+
+void konpeito_unload_music(int id) {
+    if (id < 0 || id >= MAX_MUSIC || !g_music_used[id]) return;
+    UnloadMusicStream(g_music[id]);
+    g_music_used[id] = 0;
+}
+
+void konpeito_play_music(int id) {
+    if (id < 0 || id >= MAX_MUSIC || !g_music_used[id]) return;
+    PlayMusicStream(g_music[id]);
+}
+
+void konpeito_stop_music(int id) {
+    if (id < 0 || id >= MAX_MUSIC || !g_music_used[id]) return;
+    StopMusicStream(g_music[id]);
+}
+
+void konpeito_pause_music(int id) {
+    if (id < 0 || id >= MAX_MUSIC || !g_music_used[id]) return;
+    PauseMusicStream(g_music[id]);
+}
+
+void konpeito_resume_music(int id) {
+    if (id < 0 || id >= MAX_MUSIC || !g_music_used[id]) return;
+    ResumeMusicStream(g_music[id]);
+}
+
+void konpeito_update_music(int id) {
+    if (id < 0 || id >= MAX_MUSIC || !g_music_used[id]) return;
+    UpdateMusicStream(g_music[id]);
+}
+
+int konpeito_is_music_playing(int id) {
+    if (id < 0 || id >= MAX_MUSIC || !g_music_used[id]) return 0;
+    return (int)IsMusicStreamPlaying(g_music[id]);
+}
+
+void konpeito_set_music_volume(int id, double vol) {
+    if (id < 0 || id >= MAX_MUSIC || !g_music_used[id]) return;
+    SetMusicVolume(g_music[id], (float)vol);
+}
+
+void konpeito_set_music_pitch(int id, double pitch) {
+    if (id < 0 || id >= MAX_MUSIC || !g_music_used[id]) return;
+    SetMusicPitch(g_music[id], (float)pitch);
+}
+
+double konpeito_get_music_time_length(int id) {
+    if (id < 0 || id >= MAX_MUSIC || !g_music_used[id]) return 0.0;
+    return (double)GetMusicTimeLength(g_music[id]);
+}
+
+double konpeito_get_music_time_played(int id) {
+    if (id < 0 || id >= MAX_MUSIC || !g_music_used[id]) return 0.0;
+    return (double)GetMusicTimePlayed(g_music[id]);
+}
+
+void konpeito_seek_music(int id, double position) {
+    if (id < 0 || id >= MAX_MUSIC || !g_music_used[id]) return;
+    SeekMusicStream(g_music[id], (float)position);
+}
+
+/* ═══════════════════════════════════════════
+ *  Camera2D
+ * ═══════════════════════════════════════════ */
+
+void konpeito_begin_mode_2d(double offset_x, double offset_y,
+                             double target_x, double target_y,
+                             double rotation, double zoom) {
+    Camera2D cam = {0};
+    cam.offset   = (Vector2){ (float)offset_x, (float)offset_y };
+    cam.target   = (Vector2){ (float)target_x, (float)target_y };
+    cam.rotation = (float)rotation;
+    cam.zoom     = (float)zoom;
+    BeginMode2D(cam);
+}
+
+void konpeito_end_mode_2d(void) {
+    EndMode2D();
+}
+
+/* World ↔ screen coordinate conversion */
+int konpeito_get_world_to_screen_2d_x(double world_x, double world_y,
+                                       double offset_x, double offset_y,
+                                       double target_x, double target_y,
+                                       double rotation, double zoom) {
+    Camera2D cam = {0};
+    cam.offset   = (Vector2){ (float)offset_x, (float)offset_y };
+    cam.target   = (Vector2){ (float)target_x, (float)target_y };
+    cam.rotation = (float)rotation;
+    cam.zoom     = (float)zoom;
+    Vector2 result = GetWorldToScreen2D((Vector2){(float)world_x, (float)world_y}, cam);
+    return (int)result.x;
+}
+
+int konpeito_get_world_to_screen_2d_y(double world_x, double world_y,
+                                       double offset_x, double offset_y,
+                                       double target_x, double target_y,
+                                       double rotation, double zoom) {
+    Camera2D cam = {0};
+    cam.offset   = (Vector2){ (float)offset_x, (float)offset_y };
+    cam.target   = (Vector2){ (float)target_x, (float)target_y };
+    cam.rotation = (float)rotation;
+    cam.zoom     = (float)zoom;
+    Vector2 result = GetWorldToScreen2D((Vector2){(float)world_x, (float)world_y}, cam);
+    return (int)result.y;
+}
+
+/* ═══════════════════════════════════════════
+ *  File I/O (Save / Load)
+ * ═══════════════════════════════════════════ */
+
+int konpeito_save_file_text(const char *path, const char *text) {
+    return (int)SaveFileText(path, (char *)text);
+}
+
+const char *konpeito_load_file_text(const char *path) {
+    return LoadFileText(path);
+}
+
+int konpeito_file_exists(const char *path) {
+    return (int)FileExists(path);
+}
+
+int konpeito_directory_exists(const char *path) {
+    return (int)DirectoryExists(path);
+}
+
+/* ═══════════════════════════════════════════
+ *  Font Management (ID-based table)
+ * ═══════════════════════════════════════════ */
+
+#define MAX_FONTS 32
+
+static Font g_raylib_fonts[MAX_FONTS];
+static int  g_raylib_font_used[MAX_FONTS];
+static int  g_raylib_fonts_initialized = 0;
+
+static void ensure_fonts_init(void) {
+    if (g_raylib_fonts_initialized) return;
+    memset(g_raylib_font_used, 0, sizeof(g_raylib_font_used));
+    g_raylib_fonts_initialized = 1;
+}
+
+int konpeito_load_font(const char *path) {
+    ensure_fonts_init();
+    for (int i = 0; i < MAX_FONTS; i++) {
+        if (!g_raylib_font_used[i]) {
+            g_raylib_fonts[i] = LoadFont(path);
+            if (g_raylib_fonts[i].baseSize == 0) return -1;
+            g_raylib_font_used[i] = 1;
+            return i;
+        }
+    }
+    return -1;
+}
+
+int konpeito_load_font_ex(const char *path, int size) {
+    ensure_fonts_init();
+    for (int i = 0; i < MAX_FONTS; i++) {
+        if (!g_raylib_font_used[i]) {
+            g_raylib_fonts[i] = LoadFontEx(path, size, NULL, 0);
+            if (g_raylib_fonts[i].baseSize == 0) return -1;
+            g_raylib_font_used[i] = 1;
+            return i;
+        }
+    }
+    return -1;
+}
+
+void konpeito_unload_font(int id) {
+    if (id < 0 || id >= MAX_FONTS || !g_raylib_font_used[id]) return;
+    UnloadFont(g_raylib_fonts[id]);
+    g_raylib_font_used[id] = 0;
+}
+
+void konpeito_draw_text_ex(int font_id, const char *text,
+                            double x, double y, double size,
+                            double spacing, int tint) {
+    Font font;
+    if (font_id < 0 || font_id >= MAX_FONTS || !g_raylib_font_used[font_id]) {
+        font = GetFontDefault();
+    } else {
+        font = g_raylib_fonts[font_id];
+    }
+    DrawTextEx(font, text, (Vector2){(float)x, (float)y},
+               (float)size, (float)spacing, int_to_color(tint));
+}
+
+int konpeito_measure_text_ex_x(int font_id, const char *text,
+                                double size, double spacing) {
+    Font font;
+    if (font_id < 0 || font_id >= MAX_FONTS || !g_raylib_font_used[font_id]) {
+        font = GetFontDefault();
+    } else {
+        font = g_raylib_fonts[font_id];
+    }
+    Vector2 v = MeasureTextEx(font, text, (float)size, (float)spacing);
+    return (int)v.x;
+}
+
+int konpeito_measure_text_ex_y(int font_id, const char *text,
+                                double size, double spacing) {
+    Font font;
+    if (font_id < 0 || font_id >= MAX_FONTS || !g_raylib_font_used[font_id]) {
+        font = GetFontDefault();
+    } else {
+        font = g_raylib_fonts[font_id];
+    }
+    Vector2 v = MeasureTextEx(font, text, (float)size, (float)spacing);
+    return (int)v.y;
+}
+
+/* ═══════════════════════════════════════════
+ *  Gamepad Input
+ * ═══════════════════════════════════════════ */
+
+int konpeito_is_gamepad_available(int gamepad)          { return (int)IsGamepadAvailable(gamepad); }
+int konpeito_is_gamepad_button_pressed(int gp, int btn) { return (int)IsGamepadButtonPressed(gp, btn); }
+int konpeito_is_gamepad_button_down(int gp, int btn)    { return (int)IsGamepadButtonDown(gp, btn); }
+int konpeito_is_gamepad_button_released(int gp, int btn){ return (int)IsGamepadButtonReleased(gp, btn); }
+int konpeito_is_gamepad_button_up(int gp, int btn)      { return (int)IsGamepadButtonUp(gp, btn); }
+double konpeito_get_gamepad_axis_movement(int gp, int axis) {
+    return (double)GetGamepadAxisMovement(gp, axis);
+}
+int konpeito_get_gamepad_axis_count(int gp) { return GetGamepadAxisCount(gp); }
+
+/* Gamepad button constants */
+int konpeito_gamepad_button_left_face_up(void)    { return GAMEPAD_BUTTON_LEFT_FACE_UP; }
+int konpeito_gamepad_button_left_face_right(void) { return GAMEPAD_BUTTON_LEFT_FACE_RIGHT; }
+int konpeito_gamepad_button_left_face_down(void)  { return GAMEPAD_BUTTON_LEFT_FACE_DOWN; }
+int konpeito_gamepad_button_left_face_left(void)  { return GAMEPAD_BUTTON_LEFT_FACE_LEFT; }
+int konpeito_gamepad_button_right_face_up(void)   { return GAMEPAD_BUTTON_RIGHT_FACE_UP; }
+int konpeito_gamepad_button_right_face_right(void){ return GAMEPAD_BUTTON_RIGHT_FACE_RIGHT; }
+int konpeito_gamepad_button_right_face_down(void) { return GAMEPAD_BUTTON_RIGHT_FACE_DOWN; }
+int konpeito_gamepad_button_right_face_left(void) { return GAMEPAD_BUTTON_RIGHT_FACE_LEFT; }
+int konpeito_gamepad_button_left_trigger_1(void)  { return GAMEPAD_BUTTON_LEFT_TRIGGER_1; }
+int konpeito_gamepad_button_left_trigger_2(void)  { return GAMEPAD_BUTTON_LEFT_TRIGGER_2; }
+int konpeito_gamepad_button_right_trigger_1(void) { return GAMEPAD_BUTTON_RIGHT_TRIGGER_1; }
+int konpeito_gamepad_button_right_trigger_2(void) { return GAMEPAD_BUTTON_RIGHT_TRIGGER_2; }
+int konpeito_gamepad_button_middle_left(void)     { return GAMEPAD_BUTTON_MIDDLE_LEFT; }
+int konpeito_gamepad_button_middle(void)          { return GAMEPAD_BUTTON_MIDDLE; }
+int konpeito_gamepad_button_middle_right(void)    { return GAMEPAD_BUTTON_MIDDLE_RIGHT; }
+
+/* Gamepad axis constants */
+int konpeito_gamepad_axis_left_x(void)       { return GAMEPAD_AXIS_LEFT_X; }
+int konpeito_gamepad_axis_left_y(void)       { return GAMEPAD_AXIS_LEFT_Y; }
+int konpeito_gamepad_axis_right_x(void)      { return GAMEPAD_AXIS_RIGHT_X; }
+int konpeito_gamepad_axis_right_y(void)      { return GAMEPAD_AXIS_RIGHT_Y; }
+int konpeito_gamepad_axis_left_trigger(void) { return GAMEPAD_AXIS_LEFT_TRIGGER; }
+int konpeito_gamepad_axis_right_trigger(void){ return GAMEPAD_AXIS_RIGHT_TRIGGER; }
+
+/* ═══════════════════════════════════════════
+ *  Drawing — Extended Shapes
+ * ═══════════════════════════════════════════ */
+
+void konpeito_draw_rectangle_pro(double x, double y, double w, double h,
+                                  double ox, double oy, double rotation, int color) {
+    DrawRectanglePro((Rectangle){(float)x, (float)y, (float)w, (float)h},
+                     (Vector2){(float)ox, (float)oy}, (float)rotation, int_to_color(color));
+}
+
+void konpeito_draw_rectangle_rounded(double x, double y, double w, double h,
+                                      double roundness, int segments, int color) {
+    DrawRectangleRounded((Rectangle){(float)x, (float)y, (float)w, (float)h},
+                         (float)roundness, segments, int_to_color(color));
+}
+
+void konpeito_draw_rectangle_gradient_v(int x, int y, int w, int h, int color1, int color2) {
+    DrawRectangleGradientV(x, y, w, h, int_to_color(color1), int_to_color(color2));
+}
+
+void konpeito_draw_rectangle_gradient_h(int x, int y, int w, int h, int color1, int color2) {
+    DrawRectangleGradientH(x, y, w, h, int_to_color(color1), int_to_color(color2));
+}
+
+void konpeito_draw_circle_sector(int cx, int cy, double radius,
+                                  double start_angle, double end_angle,
+                                  int segments, int color) {
+    DrawCircleSector((Vector2){(float)cx, (float)cy}, (float)radius,
+                     (float)start_angle, (float)end_angle, segments, int_to_color(color));
+}
+
+/* ═══════════════════════════════════════════
+ *  Collision Detection Helpers
+ * ═══════════════════════════════════════════ */
+
+int konpeito_check_collision_recs(double x1, double y1, double w1, double h1,
+                                   double x2, double y2, double w2, double h2) {
+    Rectangle r1 = { (float)x1, (float)y1, (float)w1, (float)h1 };
+    Rectangle r2 = { (float)x2, (float)y2, (float)w2, (float)h2 };
+    return (int)CheckCollisionRecs(r1, r2);
+}
+
+int konpeito_check_collision_circles(double cx1, double cy1, double r1,
+                                      double cx2, double cy2, double r2) {
+    return (int)CheckCollisionCircles((Vector2){(float)cx1, (float)cy1}, (float)r1,
+                                      (Vector2){(float)cx2, (float)cy2}, (float)r2);
+}
+
+int konpeito_check_collision_circle_rec(double cx, double cy, double radius,
+                                         double rx, double ry, double rw, double rh) {
+    return (int)CheckCollisionCircleRec((Vector2){(float)cx, (float)cy}, (float)radius,
+                                        (Rectangle){(float)rx, (float)ry, (float)rw, (float)rh});
+}
+
+int konpeito_check_collision_point_rec(double px, double py,
+                                        double rx, double ry, double rw, double rh) {
+    return (int)CheckCollisionPointRec((Vector2){(float)px, (float)py},
+                                       (Rectangle){(float)rx, (float)ry, (float)rw, (float)rh});
+}
+
+int konpeito_check_collision_point_circle(double px, double py,
+                                           double cx, double cy, double radius) {
+    return (int)CheckCollisionPointCircle((Vector2){(float)px, (float)py},
+                                          (Vector2){(float)cx, (float)cy}, (float)radius);
+}

data/lib/konpeito/type_checker/rbs_loader.rb

@@ -140,8 +140,8 @@ module Konpeito
       end
 
       # Iterate over all native modules
-      def each_native_module(&block)
-        @native_modules.each(&block)
+      def each_native_module(&)
+        @native_modules.each(&)
       end
 
       # Check if a class is explicitly boxed (VALUE-based, for CRuby interop)

data/lib/konpeito/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Konpeito
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: konpeito
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Yasushi Itoh