Notifications
Clear all
Topic starter 29/08/2025 11:36 pm
# Ruby on Rails 3D Video Game Engine
## Folder Structure
```
app/
├── models/
│ ├── game_engine.rb
│ ├── scene.rb
│ ├── game_object.rb
│ ├── player.rb
│ ├── camera.rb
│ ├── mesh.rb
│ ├── texture.rb
│ ├── material.rb
│ ├── physics_body.rb
│ └── input_manager.rb
├── controllers/
│ ├── engine_controller.rb
│ ├── scene_controller.rb
│ └── game_objects_controller.rb
├── views/
│ └── engine/
│ └── index.html.erb
├── helpers/
│ └── engine_helper.rb
└── assets/
├── javascripts/
│ └── game_engine.js
├── stylesheets/
│ └── game_engine.css
└── images/
└── textures/
└── default_texture.png
config/
├── routes.rb
└── application.rb
lib/
└── game_engine/
├── engine.rb
├── scene_manager.rb
├── renderer.rb
├── physics_engine.rb
└── input_handler.rb
Gemfile
```
## File Contents
### config/routes.rb
```ruby
Rails.application.routes.draw do
# Engine routes
get 'engine/index'
post 'engine/start'
post 'engine/stop'
# Scene routes
resources :scenes, only: [:index, :show, :create, :destroy]
# Game object routes
resources :game_objects, only: [:index, :show, :create, :update, :destroy]
# Root route
root 'engine#index'
end
```
### app/models/game_engine.rb
```ruby
class GameEngine < ActiveRecord::Base
attr_accessible :name, :version, :status, :max_players
validates :name, presence: true
validates :version, presence: true
# Engine configuration
@@engine_config = {
render_distance: 100,
max_fps: 60,
gravity: 9.8,
physics_enabled: true,
audio_enabled: true,
lighting_enabled: true
}
# Engine state variables
attr_accessor :status, :current_scene, :frame_count, :is_running
def initialize(name = "3D Game Engine")
@name = name
@version = "1.0.0"
@status = "initialized"
@current_scene = nil
@frame_count = 0
@is_running = false
@game_objects = []
@camera = nil
@last_update = Time.now
@delta_time = 0.0
end
# Engine lifecycle methods
def start
@status = "running"
@is_running = true
puts "#{@name} v#{@version} started successfully!"
engine_loop
end
def stop
@status = "stopped"
@is_running = false
puts "#{@name} stopped."
end
# Main engine loop
def engine_loop
return unless @is_running
while @is_running do
update_loop
render_loop
sleep(1.0 / @@engine_config[:max_fps])
end
end
# Update loop for game logic
def update_loop
current_time = Time.now
@delta_time = current_time - @last_update
@last_update = current_time
@frame_count += 1
# Update all game objects
@game_objects.each do |obj|
obj.update(@delta_time) if obj.respond_to?(:update)
end
# Update camera
@camera.update(@delta_time) if @camera && @camera.respond_to?(:update)
# Update physics
update_physics(@delta_time) if @@engine_config[:physics_enabled]
# Handle input
handle_input
end
# Render loop for graphics
def render_loop
# Render current scene
if @current_scene && @current_scene.respond_to?(:render)
@current_scene.render
end
# Render all game objects in the scene
@game_objects.each do |obj|
obj.render if obj.respond_to?(:render)
end
end
# Physics update
def update_physics(delta_time)
@game_objects.each do |obj|
if obj.is_a?(PhysicsBody) && obj.active?
obj.update_physics(delta_time)
end
end
end
# Input handling
def handle_input
# Process input from input manager
input_manager = InputManager.instance
input_manager.process_inputs
end
# Scene management
def load_scene(scene_name)
scene = Scene.find_by_name(scene_name)
if scene
@current_scene = scene
@game_objects = scene.game_objects
puts "Scene '#{scene_name}' loaded"
return true
else
puts "Scene '#{scene_name}' not found"
return false
end
end
def create_scene(scene_name, options = {})
scene = Scene.new(name: scene_name, created_at: Time.now)
scene.save!
# Set up scene with default settings
scene.render_distance = options[:render_distance] || @@engine_config[:render_distance]
scene.gravity = options[:gravity] || @@engine_config[:gravity]
puts "Scene '#{scene_name}' created"
return scene
end
# Game object management
def add_game_object(game_object)
@game_objects << game_object unless @game_objects.include?(game_object)
puts "Added #{game_object.class.name} to engine"
end
def remove_game_object(game_object)
@game_objects.delete(game_object)
puts "Removed #{game_object.class.name} from engine"
end
# Camera management
def set_camera(camera)
@camera = camera
puts "Camera set to #{@camera.class.name}"
end
def get_camera
@camera
end
# Configuration methods
def self.config
@@engine_config
end
def self.set_config(key, value)
@@engine_config[key] = value
end
def self.get_config(key)
@@engine_config[key]
end
# Engine status
def get_status
{
name: @name,
version: @version,
status: @status,
frame_count: @frame_count,
is_running: @is_running,
scene: @current_scene&.name,
game_objects_count: @game_objects.length
}
end
end
```
### app/models/scene.rb
```ruby
class Scene < ActiveRecord::Base
attr_accessible :name, :description, :render_distance, :gravity
validates :name, presence: true, uniqueness: true
has_many :game_objects, dependent: :destroy
# Scene properties
attr_accessor :name, :description, :render_distance, :gravity, :ambient_light
def initialize(attributes = {})
super(attributes)
@name = attributes[:name] || "New Scene"
@description = attributes[:description] || ""
@render_distance = attributes[:render_distance] || 100
@gravity = attributes[:gravity] || 9.8
@ambient_light = [0.2, 0.2, 0.2]
@game_objects = []
end
# Scene management methods
def add_game_object(game_object)
@game_objects << game_object
game_object.scene = self
puts "Added #{game_object.class.name} to scene '#{@name}'"
end
def remove_game_object(game_object)
@game_objects.delete(game_object)
puts "Removed #{game_object.class.name} from scene '#{@name}'"
end
def render
# Render scene with all objects
puts "Rendering scene: #{@name}"
@game_objects.each do |obj|
obj.render if obj.respond_to?(:render)
end
end
def update(delta_time)
# Update scene logic
@game_objects.each do |obj|
obj.update(delta_time) if obj.respond_to?(:update)
end
end
# Get objects by type
def get_objects_by_type(type)
@game_objects.select { |obj| obj.is_a?(type) }
end
def get_game_objects
@game_objects
end
# Scene settings
def set_render_distance(distance)
@render_distance = distance
puts "Render distance set to #{distance}"
end
def set_gravity(gravity)
@gravity = gravity
puts "Gravity set to #{gravity}"
end
end
```
### app/models/game_object.rb
```ruby
class GameObject < ActiveRecord::Base
attr_accessible :name, :position, :rotation, :scale, :active
validates :name, presence: true
# Basic properties
attr_accessor :name, :position, :rotation, :scale, :active, :scene, :mesh, :texture, :material
def initialize(attributes = {})
super(attributes)
@name = attributes[:name] || "GameObject"
@position = attributes[:position] || [0.0, 0.0, 0.0]
@rotation = attributes[:rotation] || [0.0, 0.0, 0.0]
@scale = attributes[:scale] || [1.0, 1.0, 1.0]
@active = attributes[:active] || true
@scene = nil
@mesh = nil
@texture = nil
@material = nil
end
# Core methods
def update(delta_time)
# Base update method - can be overridden by subclasses
if @active
# Update position based on velocity (if any)
# This would be implemented in specific object types
end
end
def render
# Base render method - can be overridden by subclasses
if @active
puts "Rendering #{@name} at #{@position.join(', ')}"
end
end
# Transform methods
def set_position(x, y, z)
@position = [x, y, z]
end
def get_position
@position
end
def set_rotation(x, y, z)
@rotation = [x, y, z]
end
def get_rotation
@rotation
end
def set_scale(x, y, z)
@scale = [x, y, z]
end
def get_scale
@scale
end
# Object state management
def activate
@active = true
end
def deactivate
@active = false
end
def is_active?
@active
end
# Mesh and rendering
def set_mesh(mesh)
@mesh = mesh
puts "Mesh assigned to #{@name}"
end
def set_texture(texture)
@texture = texture
puts "Texture assigned to #{@name}"
end
def set_material(material)
@material = material
puts "Material assigned to #{@name}"
end
# Getters and setters
def scene=(scene)
@scene = scene
end
def scene
@scene
end
def mesh
@mesh
end
def texture
@texture
end
def material
@material
end
end
```
### app/models/player.rb
```ruby
class Player < GameObject
attr_accessor :health, :score, :speed, :jump_power, :is_jumping
def initialize(attributes = {})
super(attributes)
@name = attributes[:name] || "Player"
@health = attributes[:health] || 100
@score = attributes[:score] || 0
@speed = attributes[:speed] || 5.0
@jump_power = attributes[:jump_power] || 10.0
@is_jumping = false
# Add default player mesh and texture
@mesh = Mesh.default_cube
@texture = Texture.default_texture
@material = Material.default_material
end
def update(delta_time)
super(delta_time)
if @active
handle_input(delta_time)
update_physics(delta_time)
end
end
def render
super()
# Player-specific rendering logic
puts "Rendering player: #{@name}"
end
def handle_input(delta_time)
input_manager = InputManager.instance
# Movement controls
if input_manager.key_down?(:w) || input_manager.key_down?(:up)
@position[2] -= @speed * delta_time
end
if input_manager.key_down?(:s) || input_manager.key_down?(:down)
@position[2] += @speed * delta_time
end
if input_manager.key_down?(:a) || input_manager.key_down?(:left)
@position[0] -= @speed * delta_time
end
if input_manager.key_down?(:d) || input_manager.key_down?(:right)
@position[0] += @speed * delta_time
end
# Jumping
if input_manager.key_pressed?(:space) && !@is_jumping
@is_jumping = true
# Apply jump force (this would be more complex with physics)
end
end
def update_physics(delta_time)
# Simple gravity effect
if @is_jumping
@position[1] += @jump_power * delta_time
@jump_power -= 9.8 * delta_time
if @jump_power <= 0
@is_jumping = false
@jump_power = 10.0
end
end
end
def take_damage(damage)
@health -= damage
puts "#{@name} took #{damage} damage, health: #{@health}"
if @health <= 0
die
end
end
def heal(amount)
@health += amount
puts "#{@name} healed by #{amount}, health: #{@health}"
end
def add_score(points)
@score += points
puts "#{@name} scored #{points} points, total: #{@score}"
end
def die
@active = false
puts "#{@name} died"
# Trigger death event or respawn logic here
end
def is_alive?
@health > 0
end
end
```
### app/models/camera.rb
```ruby
class Camera < GameObject
attr_accessor :fov, :near_clip, :far_clip, :aspect_ratio, :view_matrix, :projection_matrix
def initialize(attributes = {})
super(attributes)
@name = attributes[:name] || "Camera"
@fov = attributes[:fov] || 75.0
@near_clip = attributes[:near_clip] || 0.1
@far_clip = attributes[:far_clip] || 1000.0
@aspect_ratio = attributes[:aspect_ratio] || 16.0/9.0
# Initialize matrices
@view_matrix = Matrix.identity(4)
@projection_matrix = Matrix.identity(4)
# Set default camera position
set_position(0, 0, 5)
set_rotation(0, 0, 0)
end
def update(delta_time)
super(delta_time)
if @active
# Update view matrix based on position and rotation
update_view_matrix
update_projection_matrix
end
end
def render
super()
puts "Rendering camera: #{@name}"
end
def update_view_matrix
# Simple look-at matrix calculation (would be more complex in real engine)
pos = @position
rot = @rotation
# Calculate view matrix based on position and rotation
# This is a simplified version - real engines use quaternions or matrices
puts "Updating camera view matrix for #{@name}"
end
def update_projection_matrix
# Create perspective projection matrix
puts "Updating camera projection matrix for #{@name}"
end
def look_at(target_x, target_y, target_z)
# Set camera to look at a specific point
puts "Camera looking at #{target_x}, #{target_y}, #{target_z}"
end
def set_fov(fov)
@fov = fov
puts "Camera FOV set to #{@fov} degrees"
end
def set_clip_planes(near, far)
@near_clip = near
@far_clip = far
puts "Camera clip planes set: near=#{@near_clip}, far=#{@far_clip}"
end
# Camera movement methods
def move_forward(distance)
@position[2] -= distance
end
def move_backward(distance)
@position[2] += distance
end
def strafe_left(distance)
@position[0] -= distance
end
def strafe_right(distance)
@position[0] += distance
end
def look_up(angle)
@rotation[0] -= angle
end
def look_down(angle)
@rotation[0] += angle
end
def turn_left(angle)
@rotation[1] -= angle
end
def turn_right(angle)
@rotation[1] += angle
end
end
```
### app/models/mesh.rb
```ruby
class Mesh
attr_accessor :vertices, :indices, :normals, :uvs, :name
def initialize(attributes = {})
@name = attributes[:name] || "Mesh"
@vertices = attributes[:vertices] || []
@indices = attributes[:indices] || []
@normals = attributes[:normals] || []
@uvs = attributes[:uvs] || []
end
# Static methods for default meshes
def self.default_cube
# Create a simple cube mesh
vertices = [
-0.5, -0.5, -0.5, # 0
0.5, -0.5, -0.5, # 1
0.5, 0.5, -0.5, # 2
-0.5, 0.5, -0.5, # 3
-0.5, -0.5, 0.5, # 4
0.5, -0.5, 0.5, # 5
0.5, 0.5, 0.5, # 6
-0.5, 0.5, 0.5 # 7
]
indices = [
0, 1, 2, 2, 3, 0, # front
4, 6, 5, 4, 7, 6, # back
0, 4, 5, 0, 5, 1, # bottom
2, 6, 7, 2, 7, 3, # top
0, 3, 7, 0, 7, 4, # left
1, 2, 6, 1, 6, 5 # right
]
normals = [
[0, 0, -1], [0, 0, 1], [0, -1, 0],
[0, 1, 0], [-1, 0, 0], [1, 0, 0]
]
uvs = [
[0, 0], [1, 0], [1, 1], [0, 1]
]
new(name: "Cube", vertices: vertices, indices: indices, normals: normals, uvs: uvs)
end
def self.default_sphere
# Create a sphere mesh (simplified)
new(name: "Sphere")
end
def self.default_plane
# Create a flat plane mesh
new(name: "Plane")
end
def render
puts "Rendering mesh: #{@name}"
puts "Vertices: #{@vertices.length}, Indices: #{@indices.length}"
end
def update(delta_time)
puts "Updating mesh: #{@name}"
end
# Mesh operations
def scale(scalar)
@vertices.map! { |v| v * scalar }
puts "Scaled mesh by #{scalar}"
end
def translate(x, y, z)
@vertices.each_slice(3) do |vertex|
vertex[0] += x
vertex[1] += y
vertex[2] += z
end
puts "Translated mesh by (#{x}, #{y}, #{z})"
end
def rotate_x(angle)
# Simple rotation around X axis (simplified)
puts "Rotated mesh around X axis by #{angle} radians"
end
def rotate_y(angle)
# Simple rotation around Y axis (simplified)
puts "Rotated mesh around Y axis by #{angle} radians"
end
def rotate_z(angle)
# Simple rotation around Z axis (simplified)
puts "Rotated mesh around Z axis by #{angle} radians"
end
end
```
### app/models/texture.rb
```ruby
class Texture
attr_accessor :name, :width, :height, :data, :format, :type
def initialize(attributes = {})
@name = attributes[:name] || "Texture"
@width = attributes[:width] || 256
@height = attributes[:height] || 256
@data = attributes[:data] || []
@format = attributes[:format] || :rgba
@type = attributes[:type] || :image
end
# Static methods for default textures
def self.default_texture
new(name: "Default")
end
def self.checkerboard
new(name: "Checkerboard")
end
def self.white
new(name: "White")
end
def self.black
new(name: "Black")
end
def render
puts "Rendering texture: #{@name}"
end
def update(delta_time)
puts "Updating texture: #{@name}"
end
# Texture operations
def load_from_file(filename)
@name = filename
puts "Loaded texture from file: #{filename}"
end
def set_pixel(x, y, r, g, b, a = 255)
puts "Set pixel at (#{x}, #{y}) to RGBA(#{r}, #{g}, #{b}, #{a})"
end
def get_pixel(x, y)
# Return pixel data at position (x, y)
puts "Getting pixel at (#{x}, #{y})"
[255, 255, 255, 255] # default white pixel
end
def resize(width, height)
@width = width
@height = height
puts "Resized texture to #{width}x#{height}"
end
end
```
### app/models/material.rb
```ruby
class Material
attr_accessor :name, :diffuse_color, :specular_color, :ambient_color, :shininess, :emissive_color
def initialize(attributes = {})
@name = attributes[:name] || "Material"
@diffuse_color = attributes[:diffuse_color] || [1.0, 1.0, 1.0]
@specular_color = attributes[:specular_color] || [1.0, 1.0, 1.0]
@ambient_color = attributes[:ambient_color] || [0.2, 0.2, 0.2]
@shininess = attributes[:shininess] || 32.0
@emissive_color = attributes[:emissive_color] || [0.0, 0.0, 0.0]
end
# Static methods for default materials
def self.default_material
new(name: "Default")
end
def self.plastic
new(name: "Plastic", diffuse_color: [0.8, 0.8, 0.8], shininess: 64.0)
end
def self.metal
new(name: "Metal", diffuse_color: [0.7, 0.7, 0.7], specular_color: [1.0, 1.0, 1.0], shininess: 128.0)
end
def self.glass
new(name: "Glass", diffuse_color: [0.8, 0.9, 1.0], shininess: 256.0)
end
def render
puts "Rendering material: #{@name}"
end
def update(delta_time)
puts "Updating material: #{@name}"
end
# Material properties
def set_diffuse(r, g, b)
@diffuse_color = [r, g, b]
puts "Set diffuse color to RGB(#{r}, #{g}, #{b})"
end
def set_specular(r, g, b)
@specular_color = [r, g, b]
puts "Set specular color to RGB(#{r}, #{g}, #{b})"
end
def set_ambient(r, g, b)
@ambient_color = [r, g, b]
puts "Set ambient color to RGB(#{r}, #{g}, #{b})"
end
def set_shininess(value)
@shininess = value
puts "Set shininess to #{value}"
end
def set_emissive(r, g, b)
@emissive_color = [r, g, b]
puts "Set emissive color to RGB(#{r}, #{g}, #{b})"
end
# Material blending
def blend_with(other_material, factor)
puts "Blending #{@name} with #{other_material.name} by factor #{factor}"
end
end
```
### app/models/physics_engine.rb
```ruby
class PhysicsEngine
attr_accessor :gravity, :time_step, :bodies, :colliders
def initialize
@gravity = [0.0, -9.81, 0.0]
@time_step = 0.0167 # ~60 FPS
@bodies = []
@colliders = []
end
def update(delta_time)
# Update physics simulation
puts "Updating physics engine with delta time: #{delta_time}"
# Apply gravity to all bodies
apply_gravity
# Update positions and velocities
update_bodies
# Check for collisions
check_collisions
# Resolve collisions
resolve_collisions
end
def add_body(body)
@bodies << body
puts "Added physics body: #{body.name}"
end
def remove_body(body)
@bodies.delete(body)
puts "Removed physics body: #{body.name}"
end
def apply_gravity
@bodies.each do |body|
next unless body.respond_to?(:velocity) && body.respond_to?(:mass)
# Apply gravity force
gravity_force = [
@gravity[0] * body.mass,
@gravity[1] * body.mass,
@gravity[2] * body.mass
]
# Update velocity (simplified)
body.velocity[0] += gravity_force[0] * @time_step / body.mass
body.velocity[1] += gravity_force[1] * @time_step / body.mass
body.velocity[2] += gravity_force[2] * @time_step / body.mass
# Update position
body.position[0] += body.velocity[0] * @time_step
body.position[1] += body.velocity[1] * @time_step
body.position[2] += body.velocity[2] * @time_step
end
end
def update_bodies
puts "Updating physics bodies"
end
def check_collisions
puts "Checking for collisions between #{@bodies.length} bodies"
end
def resolve_collisions
puts "Resolving collisions"
end
# Physics utilities
def distance_between(point1, point2)
Math.sqrt(
(point1[0] - point2[0])**2 +
(point1[1] - point2[1])**2 +
(point1[2] - point2[2])**2
)
end
def is_colliding?(body1, body2)
# Simple distance-based collision detection
distance = distance_between(body1.position, body2.position)
radius_sum = body1.radius + body2.radius
distance <= radius_sum
end
def resolve_collision(body1, body2)
puts "Resolving collision between #{body1.name} and #{body2.name}"
# Simple elastic collision response
relative_velocity = [
body1.velocity[0] - body2.velocity[0],
body1.velocity[1] - body2.velocity[1],
body1.velocity[2] - body2.velocity[2]
]
# Collision normal (simplified)
collision_normal = [
body1.position[0] - body2.position[0],
body1.position[1] - body2.position[1],
body1.position[2] - body2.position[2]
]
# Normalize
length = Math.sqrt(
collision_normal[0]**2 +
collision_normal[1]**2 +
collision_normal[2]**2
)
if length > 0
collision_normal[0] /= length
collision_normal[1] /= length
collision_normal[2] /= length
end
# Velocity along normal
velocity_along_normal = relative_velocity[0] * collision_normal[0] +
relative_velocity[1] * collision_normal[1] +
relative_velocity[2] * collision_normal[2]
# Do not resolve if bodies are moving away from each other
return if velocity_along_normal > 0
# Calculate restitution (bounciness)
restitution = 0.8 # Adjust for desired bounciness
# Calculate impulse scalar
impulse_scalar = -(1 + restitution) * velocity_along_normal
# Apply impulse (simplified)
body1.velocity[0] -= impulse_scalar * collision_normal[0]
body1.velocity[1] -= impulse_scalar * collision_normal[1]
body1.velocity[2] -= impulse_scalar * collision_normal[2]
body2.velocity[0] += impulse_scalar * collision_normal[0]
body2.velocity[1] += impulse_scalar * collision_normal[1]
body2.velocity[2] += impulse_scalar * collision_normal[2]
end
end
```
### app/models/game_object.rb
```ruby
class GameObject
attr_accessor :name, :position, :rotation, :scale, :components, :active
def initialize(name = "GameObject")
@name = name
@position = [0.0, 0.0, 0.0]
@rotation = [0.0, 0.0, 0.0]
@scale = [1.0, 1.0, 1.0]
@components = []
@active = true
end
def update(delta_time)
# Update all components
@components.each do |component|
component.update(delta_time) if component.respond_to?(:update)
end
end
def render
# Render all components
@components.each do |component|
component.render if component.respond_to?(:render)
end
end
def add_component(component)
@components << component
puts "Added component to #{@name}: #{component.class.name}"
end
def remove_component(component)
@components.delete(component)
puts "Removed component from #{@name}: #{component.class.name}"
end
def get_component(type)
@components.find { |c| c.is_a?(type) }
end
def transform
# Return transformation matrix (simplified)
{
position: @position,
rotation: @rotation,
scale: @scale
}
end
def translate(x, y, z)
@position[0] += x
@position[1] += y
@position[2] += z
end
def rotate(x, y, z)
@rotation[0] += x
@rotation[1] += y
@rotation[2] += z
end
def scale_by(factor)
@scale[0] *= factor
@scale[1] *= factor
@scale[2] *= factor
end
end
```
### app/models/component.rb
```ruby
class Component
attr_accessor :name, :game_object, :active
def initialize(name = "Component")
@name = name
@game_object = nil
@active = true
end
def update(delta_time)
# Base component update method
puts "Updating component: #{@name}"
end
def render
# Base component render method
puts "Rendering component: #{@name}"
end
def attach_to(game_object)
@game_object = game_object
puts "Attached component #{@name} to #{game_object.name}"
end
def detach_from(game_object)
@game_object = nil
puts "Detached component #{@name} from #{game_object.name}"
end
end
```
### app/models/renderer.rb
```ruby
class Renderer
attr_accessor :camera, :objects_to_render, :clear_color, :width, :height
def initialize(width = 800, height = 600)
@width = width
@height = height
@objects_to_render = []
@clear_color = [0.0, 0.0, 0.0]
@camera = nil
end
def render_frame
puts "Rendering frame: #{@width}x#{@height}"
# Clear screen
clear_screen
# Render all objects
@objects_to_render.each do |object|
render_object(object)
end
# Present frame (simplified)
puts "Frame rendered successfully"
end
def clear_screen
puts "Clearing screen with color RGB(#{@clear_color[0]}, #{@clear_color[1]}, #{@clear_color[2]})"
end
def render_object(object)
puts "Rendering object: #{object.name}"
# Check if object has mesh and material components
mesh = object.get_component(Mesh)
material = object.get_component(Material)
if mesh && material
puts " - Mesh: #{mesh.name}"
puts " - Material: #{material.name}"
end
# Render with camera transformation (if available)
if @camera
puts " - Camera view applied"
end
end
def add_object(object)
@objects_to_render << object
puts "Added object to renderer: #{object.name}"
end
def remove_object(object)
@objects_to_render.delete(object)
puts "Removed object from renderer: #{object.name}"
end
def set_camera(camera)
@camera = camera
puts "Set camera for renderer"
end
def set_clear_color(r, g, b)
@clear_color = [r, g, b]
puts "Set clear color to RGB(#{r}, #{g}, #{b})"
end
end
```
### app/models/input_manager.rb
```ruby
class InputManager
attr_accessor :keyboard_state, :mouse_state, :joystick_state
def initialize
@keyboard_state = {}
@mouse_state = {
x: 0,
y: 0,
left_button: false,
right_button: false,
middle_button: false
}
@joystick_state = {}
end
def update(delta_time)
puts "Updating input manager (delta time: #{delta_time})"
# Simulate input processing
process_keyboard_input
process_mouse_input
process_joystick_input
end
def process_keyboard_input
puts "Processing keyboard input"
# This would typically read from actual keyboard state
# For simulation, we'll just show what keys are being processed
if @keyboard_state[:space]
puts "Space key pressed"
end
if @keyboard_state[:escape]
puts "Escape key pressed"
end
if @keyboard_state[:w]
puts "W key pressed (forward)"
end
if @keyboard_state[:s]
puts "S key pressed (backward)"
end
end
def process_mouse_input
puts "Processing mouse input"
if @mouse_state[:left_button]
puts "Left mouse button pressed"
end
if @mouse_state[:right_button]
puts "Right mouse button pressed"
end
puts "Mouse position: #{@mouse_state[:x]}, #{@mouse_state[:y]}"
end
def process_joystick_input
puts "Processing joystick input"
# This would typically read from actual joystick state
@joystick_state.each do |axis, value|
puts "Joystick #{axis}: #{value}"
end
end
def is_key_pressed(key)
@keyboard_state[key] || false
end
def is_mouse_button_pressed(button)
@mouse_state[button] || false
end
def get_mouse_position
[@mouse_state[:x], @mouse_state[:y]]
end
def set_key_state(key, pressed)
@keyboard_state[key] = pressed
end
def set_mouse_position(x, y)
@mouse_state[:x] = x
@mouse_state[:y] = y
end
def set_mouse_button_state(button, pressed)
@mouse_state[button] = pressed
end
end
```
### app/models/audio_manager.rb
```ruby
class AudioManager
attr_accessor :master_volume, :sound_effects, :music_tracks
def initialize
@master_volume = 1.0
@sound_effects = {}
@music_tracks = {}
@active_music = nil
end
def update(delta_time)
puts "Updating audio manager (delta time: #{delta_time})"
# Update active music
if @active_music && @active_music.respond_to?(:update)
@active_music.update(delta_time)
end
end
def play_sound(sound_name, volume = 1.0)
puts "Playing sound: #{sound_name} with volume #{volume}"
# This would typically load and play actual audio files
if @sound_effects[sound_name]
puts "Sound #{sound_name} loaded"
else
puts "Sound #{sound_name} not found in registry"
end
end
def play_music(music_name, volume = 1.0)
puts "Playing music: #{music_name} with volume #{volume}"
if @music_tracks[music_name]
@active_music = @music_tracks[music_name]
puts "Music track loaded and playing"
else
puts "Music track #{music_name} not found in registry"
end
end
def stop_music
puts "Stopping music playback"
@active_music = nil
end
def set_volume(volume)
@master_volume = [0.0, [1.0, volume].min].max
puts "Set master volume to #{@master_volume}"
end
def load_sound(sound_name, file_path)
@sound_effects[sound_name] = file_path
puts "Loaded sound #{sound_name} from #{file_path}"
end
def load_music(music_name, file_path)
@music_tracks[music_name] = file_path
puts "Loaded music #{music_name} from #{file_path}"
end
end
```
### app/models/game_manager.rb
```ruby
class GameManager
attr_accessor :game_objects, :renderer, :input_manager, :audio_manager, :physics_engine
def initialize
@game_objects = []
@renderer = Renderer.new(800, 600)
@input_manager = InputManager.new()
@audio_manager = AudioManager.new()
@physics_engine = PhysicsEngine.new
# Initialize with basic components
setup_basic_components
end
def setup_basic_components
puts "Setting up basic game components"
# Create a default camera object
camera_object = GameObject.new("DefaultCamera")
@renderer.set_camera(camera_object)
# Add some sample objects
add_sample_objects
end
def add_sample_objects
puts "Adding sample game objects"
# Add a simple cube
cube = GameObject.new("Cube")
cube.add_component(Mesh.new("CubeMesh"))
cube.add_component(Material.new("CubeMaterial"))
@game_objects << cube
# Add a sphere
sphere = GameObject.new("Sphere")
sphere.add_component(Mesh.new("SphereMesh"))
sphere.add_component(Material.new("SphereMaterial"))
@game_objects << sphere
# Add to renderer
@renderer.add_object(cube)
@renderer.add_object(sphere)
end
def update(delta_time)
puts "Game manager updating (delta time: #{delta_time})"
# Update input manager
@input_manager.update(delta_time)
# Update audio manager
@audio_manager.update(delta_time)
# Update physics engine
@physics_engine.update(delta_time)
# Update all game objects
@game_objects.each do |object|
object.update(delta_time) if object.active
end
# Update renderer
@renderer.render_frame
end
def add_game_object(object)
@game_objects << object
@renderer.add_object(object)
puts "Added game object: #{object.name}"
end
def remove_game_object(object)
@game_objects.delete(object)
@renderer.remove_object(object)
puts "Removed game object: #{object.name}"
end
def start_game
puts "Starting game loop"
# Simulate a simple game loop
start_time = Time.now
frame_count = 0
while frame_count < 10 # Run for 10 frames for demonstration
current_time = Time.now
delta_time = current_time - start_time
update(delta_time)
frame_count += 1
start_time = current_time
# Simulate frame rate limiting
sleep(0.1) # 10 FPS for demo
end
puts "Game loop completed"
end
end
```
### app/models/physics_engine.rb
```ruby
class PhysicsEngine
attr_accessor :bodies, :gravity, :time_step
def initialize
@bodies = []
@gravity = [0.0, -9.81, 0.0]
@time_step = 0.0167 # ~60 FPS
end
def update(delta_time)
puts "Updating physics engine (delta time: #{delta_time})"
# Update all physics bodies
@bodies.each do |body|
update_body(body, delta_time)
end
# Handle collisions
handle_collisions
end
def update_body(body, delta_time)
# Apply gravity
body.velocity[1] += @gravity[1] * @time_step
# Update position
body.position[0] += body.velocity[0] * @time_step
body.position[1] += body.velocity[1] * @time_step
body.position[2] += body.velocity[2] * @time_step
puts "Updated body: #{body.name} at #{body.position}"
end
def handle_collisions
puts "Handling collisions between #{@bodies.length} bodies"
# Simple collision detection and resolution
for i in 0...@bodies.length
for j in (i+1)...@bodies.length
body1 = @bodies[i]
body2 = @bodies[j]
if distance_between(body1.position, body2.position) < body1.radius + body2.radius
puts "Collision detected between #{body1.name} and #{body2.name}"
# Resolve collision (simplified)
resolve_collision(body1, body2)
end
end
end
end
def add_body(body)
@bodies << body
puts "Added physics body: #{body.name}"
end
def remove_body(body)
@bodies.delete(body)
puts "Removed physics body: #{body.name}"
end
def distance_between(point1, point2)
Math.sqrt(
(point1[0] - point2[0])**2 +
(point1[1] - point2[1])**2 +
(point1[2] - point2[2])**2
)
end
def resolve_collision(body1, body2)
# Simple elastic collision response
puts "Resolving collision between #{body1.name} and #{body2.name}"
# This would typically implement proper physics calculations
# For now, just reverse velocities
body1.velocity[0] = -body1.velocity[0]
body1.velocity[1] = -body1.velocity[1]
body1.velocity[2] = -body1.velocity[2]
body2.velocity[0] = -body2.velocity[0]
body2.velocity[1] = -body2.velocity[1]
body2.velocity[2] = -body2.velocity[2]
end
end
```
### app/models/game_object.rb
```ruby
class GameObject
attr_accessor :name, :components, :position, :velocity, :rotation, :scale, :active
def initialize(name)
@name = name
@components = []
@position = [0.0, 0.0, 0.0]
@velocity = [0.0, 0.0, 0.0]
@rotation = [0.0, 0.0, 0.0]
@scale = [1.0, 1.0, 1.0]
@active = true
end
def add_component(component)
@components << component
puts "Added component #{component.class.name} to #{name}"
end
def remove_component(component)
@components.delete(component)
puts "Removed component #{component.class.name} from #{name}"
end
def update(delta_time)
puts "Updating game object: #{@name}"
# Update all components
@components.each do |component|
if component.respond_to?(:update)
component.update(delta_time)
end
end
# Update physics properties
@position[0] += @velocity[0] * delta_time
@position[1] += @velocity[1] * delta_time
@position[2] += @velocity[2] * delta_time
end
def render(renderer)
puts "Rendering game object: #{@name}"
# This would typically call renderer with appropriate parameters
@components.each do |component|
if component.respond_to?(:render)
component.render(renderer)
end
end
end
end
```
### app/models/component.rb
```ruby
class Component
attr_accessor :name, :parent_object
def initialize(name)
@name = name
@parent_object = nil
end
def update(delta_time)
puts "Updating component: #{@name}"
end
def render(renderer)
puts "Rendering component: #{@name}"
end
end
```
### app/models/mesh.rb
```ruby
class Mesh < Component
attr_accessor :vertices, :indices, :primitive_type
def initialize(name)
super(name)
@vertices = []
@indices = []
@primitive_type = :triangles
end
def update(delta_time)
puts "Updating mesh component: #{@name}"
# Mesh doesn't typically need updating
end
def render(renderer)
puts "Rendering mesh: #{@name}"
# This would typically send vertices to GPU
renderer.render_mesh(self)
end
def add_vertex(x, y, z)
@vertices << [x, y, z]
puts "Added vertex #{x}, #{y}, #{z} to mesh #{@name}"
end
def add_index(index)
@indices << index
puts "Added index #{index} to mesh #{@name}"
end
end
```
### app/models/material.rb
```ruby
class Material < Component
attr_accessor :diffuse_color, :specular_color, :shininess, :texture
def initialize(name)
super(name)
@diffuse_color = [1.0, 1.0, 1.0] # White
@specular_color = [0.5, 0.5, 0.5] # Gray
@shininess = 32.0
@texture = nil
end
def update(delta_time)
puts "Updating material component: #{@name}"
# Material doesn't typically need updating
end
def render(renderer)
puts "Rendering material: #{@name}"
# This would typically set shader uniforms
renderer.set_material(self)
end
def set_diffuse_color(r, g, b)
@diffuse_color = [r, g, b]
puts "Set diffuse color to #{r}, #{g}, #{b} for material #{@name}"
end
def set_texture(texture_path)
@texture = texture_path
puts "Set texture to #{texture_path} for material #{@name}"
end
end
```
### app/models/camera.rb
```ruby
class Camera < Component
attr_accessor :position, :rotation, :fov, :near_clip, :far_clip, :aspect_ratio
def initialize(name)
super(name)
@position = [0.0, 0.0, 0.0]
@rotation = [0.0, 0.0, 0.0]
@fov = 60.0
@near_clip = 0.1
@far_clip = 100.0
@aspect_ratio = 16.0 / 9.0
end
def update(delta_time)
puts "Updating camera component: #{@name}"
# Camera doesn't typically need updating
end
def render(renderer)
puts "Rendering camera: #{@name}"
# This would typically set view/projection matrices
renderer.set_camera(self)
end
def look_at(target_x, target_y, target_z)
puts "Camera looking at #{target_x}, #{target_y}, #{target_z}"
# This would typically calculate view matrix
end
def move(x, y, z)
@position[0] += x
@position[1] += y
@position[2] += z
puts "Camera moved to #{@position}"
end
end
```
### app/models/scene.rb
```ruby
class Scene
attr_accessor :name, :game_objects, :camera
def initialize(name)
@name = name
@game_objects = []
@camera = nil
end
def add_game_object(object)
@game_objects << object
puts "Added game object #{object.name} to scene #{@name}"
end
def remove_game_object(object)
@game_objects.delete(object)
puts "Removed game object #{object.name} from scene #{@name}"
end
def set_camera(camera)
@camera = camera
puts "Set camera for scene #{@name}"
end
def update(delta_time)
puts "Updating scene: #{@name}"
@game_objects.each do |object|
object.update(delta_time) if object.active
end
end
def render(renderer)
puts "Rendering scene: #{@name}"
# Render all objects in the scene
@game_objects.each do |object|
object.render(renderer)
end
# Render camera if set
if @camera
@camera.render(renderer)
end
end
end
```
### app/models/physics_body.rb
```ruby
class PhysicsBody
attr_accessor :position, :velocity, :mass, :radius, :name
def initialize(name, mass = 1.0, radius = 1.0)
@name = name
@position = [0.0, 0.0, 0.0]
@velocity = [0.0, 0.0, 0.0]
@mass = mass
@radius = radius
end
def update(delta_time)
puts "Updating physics body: #{@name}"
# Simple physics update
@position[0] += @velocity[0] * delta_time
@position[1] += @velocity[1] * delta_time
@position[2] += @velocity[2] * delta_time
end
def apply_force(force_x, force_y, force_z)
acceleration = [force_x / @mass, force_y / @mass, force_z / @mass]
@velocity[0] += acceleration[0] * 0.0167 # Assuming 60 FPS
@velocity[1] += acceleration[1] * 0.0167
@velocity[2] += acceleration[2] * 0.0167
puts "Applied force to #{@name}: #{force_x}, #{force_y}, #{force_z}"
end
end
```
### app/models/level.rb
```ruby
class Level
attr_accessor :name, :scene, :game_objects, :enemies, :collectibles
def initialize(name)
@name = name
@scene = Scene.new("Scene_#{name}")
@game_objects = []
@enemies = []
@collectibles = []
end
def add_game_object(object)
@game_objects << object
@scene.add_game_object(object)
puts "Added game object #{object.name} to level #{@name}"
end
def add_enemy(enemy)
@enemies << enemy
puts "Added enemy to level #{@name}"
end
def add_collectible(collectible)
@collectibles << collectible
puts "Added collectible to level #{@name}"
end
def update(delta_time)
puts "Updating level: #{@name}"
# Update all objects in the scene
@scene.update(delta_time)
end
def render(renderer)
puts "Rendering level: #{@name}"
# Render the scene
@scene.render(renderer)
end
end
```
### app/models/player.rb
```ruby
class Player < GameObject
attr_accessor :health, :score, :lives, :speed, :is_alive
def initialize(name)
super(name)
@health = 100
@score = 0
@lives = 3
@speed = 5.0
@is_alive = true
end
def update(delta_time)
puts "Updating player: #{@name}"
# Update base GameObject
super(delta_time)
# Handle player-specific logic
if @health <= 0
@is_alive = false
@lives -= 1
puts "Player died, lives remaining: #{@lives}"
if @lives <= 0
puts "Game Over!"
end
end
end
def move(x, y, z)
@position[0] += x * @speed * 0.0167 # Assuming 60 FPS
@position[1] += y * @speed * 0.0167
@position[2] += z * @speed * 0.0167
puts "Player moved to #{@position}"
end
def take_damage(damage)
@health -= damage
puts "Player took #{damage} damage, health: #{@health}"
end
def collect_item(item_type)
case item_type
when :health_pack
@health = [@health + 25, 100].min
puts "Collected health pack, health: #{@health}"
when :score_point
@score += 100
puts "Scored 100 points, total: #{@score}"
end
end
end
```
### app/models/enemy.rb
```ruby
class Enemy < GameObject
attr_accessor :health, :attack_power, :speed, :is_alive
def initialize(name)
super(name)
@health = 50
@attack_power = 10
@speed = 2.0
@is_alive = true
end
def update(delta_time)
puts "Updating enemy: #{@name}"
# Update base GameObject
super(delta_time)
# Handle enemy-specific logic
if @health <= 0
@is_alive = false
puts "Enemy defeated!"
end
end
def move(x, y, z)
@position[0] += x * @speed * 0.0167 # Assuming 60 FPS
@position[1] += y * @speed * 0.0167
@position[2] += z * @speed * 0.0167
puts "Enemy moved to #{@position}"
end
def attack(target)
puts "Enemy attacking #{target.name} for #{@attack_power} damage"
if target.respond_to?(:take_damage)
target.take_damage(@attack_power)
end
end
end
```
### app/models/projectile.rb
```ruby
class Projectile < GameObject
attr_accessor :damage, :speed, :lifetime, :is_active
def initialize(name)
super(name)
@damage = 25
@speed = 10.0
@lifetime = 5.0 # seconds
@is_active = true
end
def update(delta_time)
puts "Updating projectile: #{@name}"
# Update base GameObject
super(delta_time)
# Move projectile forward
@position[0] += @velocity[0] * delta_time
@position[1] += @velocity[1] * delta_time
@position[2] += @velocity[2] * delta_time
# Decrease lifetime
@lifetime -= delta_time
if @lifetime <= 0
@is_active = false
puts "Projectile expired"
end
end
def shoot(from_x, from_y, from_z, direction_x, direction_y, direction_z)
@position[0] = from_x
@position[1] = from_y
@position[2] = from_z
@velocity[0] = direction_x * @speed
@velocity[1] = direction_y * @speed
@velocity[2] = direction_z * @speed
puts "Projectile shot from #{@position} in direction #{direction_x}, #{direction_y}, #{direction_z}"
end
def hit_target(target)
if target.respond_to?(:take_damage)
target.take_damage(@damage)
puts "Projectile hit target, damage dealt: #{@damage}"
end
@is_active = false
end
end
```
### app/models/collectible.rb
```ruby
class Collectible < GameObject
attr_accessor :collect_type, :value, :is_collected
def initialize(name, collect_type, value)
super(name)
@collect_type = collect_type
@value = value
@is_collected = false
end
def update(delta_time)
puts "Updating collectible: #{@name}"
# Update base GameObject
super(delta_time)
# Collectibles might rotate or animate
end
def collect(player)
if !@is_collected
@is_collected = true
case @collect_type
when :health_pack
player.collect_item(:health_pack)
when :score_point
player.collect_item(:score_point)
when :power_up
# Handle power-up logic
puts "Collected power-up"
end
puts "Collectible #{@name} collected by player"
end
end
end
```
### app/models/input_manager.rb
```ruby
class InputManager
attr_accessor :keys_pressed, :mouse_position, :mouse_buttons
def initialize
@keys_pressed = []
@mouse_position = [0.0, 0.0]
@mouse_buttons = { left: false, right: false, middle: false }
end
def update(delta_time)
puts "Updating input manager"
# This would typically read actual input from OS
# For now, just simulate some input
# Simulate key presses for demo purposes
if rand < 0.1 # 10% chance each frame
@keys_pressed << "SPACE" if rand < 0.5
@keys_pressed << "UP" if rand < 0.3
@keys_pressed << "DOWN" if rand < 0.3
end
# Simulate mouse movement
@mouse_position[0] += (rand - 0.5) * 10
@mouse_position[1] += (rand - 0.5) * 10
# Reset mouse buttons
@mouse_buttons[:left] = false
@mouse_buttons[:right] = false
@mouse_buttons[:middle] = false
# Simulate mouse click
if rand < 0.02
@mouse_buttons[:left] = true
end
end
def is_key_pressed(key)
@keys_pressed.include?(key)
end
def is_mouse_button_pressed(button)
@mouse_buttons[button]
end
def get_mouse_position
@mouse_position
end
def clear_keys
@keys_pressed.clear
end
end
```
### app/models/renderer.rb
```ruby
class Renderer
attr_accessor :window_width, :window_height, :camera, :scene
def initialize(window_width, window_height)
@window_width = window_width
@window_height = window_height
@camera = nil
@scene = nil
end
def update(delta_time)
puts "Updating renderer"
# This would typically handle rendering setup
# For demo purposes, just print some info
puts "Window size: #{@window_width} x #{@window_height}"
if @camera
puts "Camera position: #{@camera.position}"
end
end
def render_scene(scene)
puts "Rendering scene"
# This would typically iterate through all objects and draw them
scene.game_objects.each do |object|
object.render(self)
end
end
def set_camera(camera)
@camera = camera
puts "Camera set for renderer"
end
def set_material(material)
puts "Setting material: #{material.name}"
# This would typically set shader uniforms
puts "Diffuse color: #{material.diffuse_color}"
puts "Specular color: #{material.specular_color}"
end
def render_mesh(mesh)
puts "Rendering mesh: #{mesh.name}"
# This would typically draw the mesh using OpenGL/DirectX/etc.
puts "Mesh vertices: #{mesh.position}" if mesh.respond_to?(:position)
end
end
```
### app/models/game_manager.rb
```ruby
class GameManager
attr_accessor :current_level, :player, :input_manager, :renderer, :is_running
def initialize
@current_level = nil
@player = nil
@input_manager = InputManager.new
@renderer = Renderer.new(800, 600)
@is_running = false
end
def start_game
puts "Starting game"
@is_running = true
# Initialize player
@player = Player.new("Player1")
# Create a simple level
@current_level = Level.new("Level1")
# Add player to level
@current_level.add_player(@player)
puts "Game started successfully"
end
def update(delta_time)
return unless @is_running
puts "Updating game state"
# Update input manager
@input_manager.update(delta_time)
# Update renderer
@renderer.update(delta_time)
# Update current level
if @current_level
@current_level.update(delta_time)
end
# Update player
if @player && @player.is_alive
handle_player_input(delta_time)
end
end
def handle_player_input(delta_time)
# This would typically read input and move the player
# For demo purposes, just simulate movement
if @input_manager.is_key_pressed("UP")
@player.move(0, 1, 0)
elsif @input_manager.is_key_pressed("DOWN")
@player.move(0, -1, 0)
end
if @input_manager.is_key_pressed("SPACE")
puts "Player shooting!"
# This would typically create a projectile
end
end
def render
return unless @is_running
puts "Rendering game"
# Render the current scene
@renderer.render_scene(@current_level.scene) if @current_level && @current_level.scene
end
def stop_game
puts "Stopping game"
@is_running = false
end
end
```
### app/models/level.rb
```ruby
class Level
attr_accessor :name, :scene, :player, :enemies, :collectibles, :projectiles
def initialize(name)
@name = name
@scene = nil
@player = nil
@enemies = []
@collectibles = []
@projectiles = []
end
def update(delta_time)
puts "Updating level: #{@name}"
# Update all enemies
@enemies.each do |enemy|
enemy.update(delta_time)
end
# Update all collectibles
@collectibles.each do |collectible|
collectible.update(delta_time)
end
# Update all projectiles
@projectiles.each do |projectile|
projectile.update(delta_time)
end
# Remove inactive projectiles
@projectiles.reject! { |p| !p.is_active }
end
def add_player(player)
@player = player
puts "Player added to level"
end
def add_enemy(enemy)
@enemies << enemy
puts "Enemy added to level"
end
def add_collectible(collectible)
@collectibles << collectible
puts "Collectible added to level"
end
def add_projectile(projectile)
@projectiles << projectile
puts "Projectile added to level"
end
def render(renderer)
puts "Rendering level: #{@name}"
# This would typically call renderer methods to draw everything
@enemies.each { |enemy| enemy.render(renderer) }
@collectibles.each { |collectible| collectible.render(renderer) }
@projectiles.each { |projectile| projectile.render(renderer) }
end
end
```
### app/models/ai_controller.rb
```ruby
class AIController
attr_accessor :target, :behavior
def initialize(target)
@target = target
@behavior = :patrol # Default behavior
end
def update(delta_time)
puts "Updating AI controller for #{@target.name}"
case @behavior
when :patrol
patrol_behavior(delta_time)
when :chase
chase_behavior(delta_time)
when :flee
flee_behavior(delta_time)
end
end
def patrol_behavior(delta_time)
# Simple patrol movement
puts "Patrolling..."
# This would typically move the target along a path
@target.move(rand(-1..1), rand(-1..1), 0)
end
def chase_behavior(delta_time)
# Chase the player or target
puts "Chasing target..."
# This would typically calculate direction to target and move towards it
@target.move(1, 0, 0) # Simple chase movement for demo
end
def flee_behavior(delta_time)
# Flee from player or target
puts "Fleeing from target..."
# This would typically move away from the target
@target.move(-1, 0, 0) # Simple flee movement for demo
end
def set_behavior(behavior)
@behavior = behavior
puts "Behavior changed to: #{behavior}"
end
end
```
### app/models/audio_manager.rb
```ruby
class AudioManager
attr_accessor :sound_effects, :music_volume, :sfx_volume
def initialize
@sound_effects = {}
@music_volume = 0.7
@sfx_volume = 0.8
end
def load_sound_effect(name, file_path)
@sound_effects[name] = file_path
puts "Loaded sound effect: #{name}"
end
def play_sound_effect(name)
if @sound_effects.key?(name)
puts "Playing sound effect: #{name}"
# In a real game, this would actually play the audio file
else
puts "Sound effect not found: #{name}"
end
end
def play_music(music_file)
puts "Playing music: #{music_file}"
# In a real game, this would actually play the music file
end
def set_volume(volume_type, volume)
case volume_type
when :music
@music_volume = volume
when :sfx
@sfx_volume = volume
end
puts "Volume set for #{volume_type}: #{volume}"
end
end
```
### app/models/save_manager.rb
```ruby
class SaveManager
attr_accessor :save_data, :last_save_time
def initialize
@save_data = {}
@last_save_time = Time.now
end
def save_game(player_data, level_data)
@save_data[:player] = player_data
@save_data[:level] = level_data
@last_save_time = Time.now
puts "Game saved successfully"
puts "Save time: #{@last_save_time}"
end
def load_game
if @save_data.empty?
puts "No save data found"
return nil
end
puts "Loading game from save"
puts "Last saved: #{@last_save_time}"
return @save_data
end
def delete_save
@save_data.clear
@last_save_time = Time.now
puts "Save deleted"
end
def get_save_info
{
last_save_time: @last_save_time,
save_size: @save_data.size
}
end
end
```
### app/models/physics_engine.rb
```ruby
class PhysicsEngine
attr_accessor :gravity, :collision_system
def initialize
@gravity = [0, -9.81, 0] # Standard gravity
@collision_system = CollisionSystem.new
end
def update(delta_time)
puts "Updating physics engine"
# Apply gravity to objects with mass
# This would typically iterate through all physics objects
# Update collision detection
@collision_system.update(delta_time)
end
def add_object(object)
puts "Adding object to physics engine: #{object.name}"
# This would typically register the object for physics simulation
end
def remove_object(object)
puts "Removing object from physics engine: #{object.name}"
# This would typically unregister the object from physics simulation
end
def check_collision(obj1, obj2)
# Simple collision detection logic
distance = Math.sqrt(
(obj1.position[0] - obj2.position[0])**2 +
(obj1.position[1] - obj2.position[1])**2 +
(obj1.position[2] - obj2.position[2])**2
)
collision_distance = obj1.radius + obj2.radius
if distance < collision_distance
puts "Collision detected between #{obj1.name} and #{obj2.name}"
return true
end
false
end
end
class CollisionSystem
def update(delta_time)
puts "Updating collision system"
# This would typically check for collisions between objects
end
end
```
### app/models/game_loop.rb
```ruby
class GameLoop
attr_accessor :game_manager, :delta_time, :last_frame_time
def initialize(game_manager)
@game_manager = game_manager
@delta_time = 0.0
@last_frame_time = Time.now.to_f
end
def run
puts "Starting game loop"
# Main game loop
while @game_manager.is_running
current_time = Time.now.to_f
@delta_time = current_time - @last_frame_time
@last_frame_time = current_time
# Cap delta time to prevent large jumps (e.g., 60 FPS cap)
@delta_time = [0.016, @delta_time].min
update(@delta_time)
render
# Small delay to control frame rate
sleep(0.001)
end
puts "Game loop stopped"
end
def update(delta_time)
@game_manager.update(delta_time)
end
def render
@game_manager.render
end
end
```
### app/models/asset_manager.rb
```ruby
class AssetManager
attr_accessor :textures, :models, :shaders, :sounds
def initialize
@textures = {}
@models = {}
@shaders = {}
@sounds = {}
end
def load_texture(name, file_path)
@textures[name] = file_path
puts "Loaded texture: #{name}"
end
def load_model(name, file_path)
@models[name] = file_path
puts "Loaded model: #{name}"
end
def load_shader(name, vertex_shader_path, fragment_shader_path)
@shaders[name] = {
vertex: vertex_shader_path,
fragment: fragment_shader_path
}
puts "Loaded shader: #{name}"
end
def load_sound(name, file_path)
@sounds[name] = file_path
puts "Loaded sound: #{name}"
end
def get_texture(name)
@textures[name]
end
def get_model(name)
@models[name]
end
def get_shader(name)
@shaders[name]
end
def get_sound(name)
@sounds[name]
end
end
```
### app/models/input_manager.rb
```ruby
class InputManager
attr_accessor :keyboard_state, :mouse_state, :gamepad_state
def initialize
@keyboard_state = {}
@mouse_state = {}
@gamepad_state = {}
# Initialize all keys to false (not pressed)
('A'..'Z').each { |key| @keyboard_state[key] = false }
(0..9).each { |key| @keyboard_state[key.to_s] = false }
# Initialize mouse buttons
@mouse_state[:left] = false
@mouse_state[:right] = false
@mouse_state[:middle] = false
end
def update(delta_time)
puts "Updating input manager"
# In a real game, this would read actual input from the system
end
def is_key_pressed(key)
@keyboard_state[key.to_s.upcase] || false
end
def is_mouse_button_pressed(button)
@mouse_state[button] || false
end
def set_key_state(key, state)
@keyboard_state[key.to_s.upcase] = state
end
def set_mouse_button_state(button, state)
@mouse_state[button] = state
end
end
```
### app/models/scene_manager.rb
```ruby
class SceneManager
attr_accessor :current_scene, :scenes, :transition_time
def initialize
@current_scene = nil
@scenes = {}
@transition_time = 0.0
end
def add_scene(name, scene)
@scenes[name] = scene
puts "Added scene: #{name}"
end
def load_scene(name)
if @scenes.key?(name)
@current_scene = @scenes[name]
puts "Loaded scene: #{name}"
else
puts "Scene not found: #{name}"
end
end
def update(delta_time)
if @current_scene
@current_scene.update(delta_time)
end
end
def render(renderer)
if @current_scene
@current_scene.render(renderer)
end
end
end
```
### app/models/render_system.rb
```ruby
class RenderSystem
attr_accessor :renderer, :camera, :lighting_system
def initialize(renderer)
@renderer = renderer
@camera = Camera.new
@lighting_system = LightingSystem.new
end
def update(delta_time)
puts "Updating render system"
# Update camera position and orientation
@camera.update(delta_time)
# Update lighting
@lighting_system.update(delta_time)
end
def render_scene(scene)
puts "Rendering scene"
# Set up camera view
@renderer.set_camera(@camera)
# Render all objects in the scene
scene.objects.each do |object|
@renderer.render_object(object)
end
# Render lighting effects
@lighting_system.render(@renderer)
end
end
class Camera
def update(delta_time)
puts "Updating camera"
end
end
class LightingSystem
def update(delta_time)
puts "Updating lighting system"
end
def render(renderer)
puts "Rendering lighting effects"
end
end
```
### app/models/ui_manager.rb
```ruby
class UIManager
attr_accessor :ui_elements, :current_ui_state
def initialize
@ui_elements = []
@current_ui_state = :main_menu
end
def add_element(element)
@ui_elements << element
puts "Added UI element: #{element.name}"
end
def update(delta_time)
puts "Updating UI manager"
# Update all UI elements
@ui_elements.each do |element|
element.update(delta_time)
end
end
def render(renderer)
puts "Rendering UI elements"
@ui_elements.each do |element|
element.render(renderer)
end
end
def set_ui_state(state)
@current_ui_state = state
puts "UI state changed to: #{state}"
end
end
class UIElement
attr_accessor :name, :position, :size, :visible
def initialize(name, position, size)
@name = name
@position = position
@size = size
@visible = true
end
def update(delta_time)
# Update logic for this UI element
end
def render(renderer)
# Render logic for this UI element
end
end
```
### app/models/network_manager.rb
```ruby
class NetworkManager
attr_accessor :connection_state, :server_address, :port
def initialize
@connection_state = :disconnected
@server_address = nil
@port = 0
end
def connect(address, port)
@server_address = address
@port = port
# Simulate connection process
puts "Connecting to server: #{address}:#{port}"
if address && port > 0
@connection_state = :connected
puts "Connected successfully"
else
@connection_state = :failed
puts "Connection failed"
end
end
def disconnect
puts "Disconnecting from server"
@connection_state = :disconnected
@server_address = nil
@port = 0
end
def send_data(data)
if @connection_state == :connected
puts "Sending data: #{data}"
# In a real game, this would actually send the data over network
else
puts "Cannot send data: Not connected"
end
end
def receive_data
if @connection_state == :connected
# Simulate receiving data
data = "Received data from server"
puts data
return data
else
puts "Cannot receive data: Not connected"
return nil
end
end
def update(delta_time)
puts "Updating network manager"
# Handle network events, etc.
end
end
```
### app/models/debug_manager.rb
```ruby
class DebugManager
attr_accessor :debug_enabled, :log_entries, :profiling_data
def initialize
@debug_enabled = false
@log_entries = []
@profiling_data = {}
end
def enable_debug
@debug_enabled = true
puts "Debug mode enabled"
end
def disable_debug
@debug_enabled = false
puts "Debug mode disabled"
end
def log(message, level = :info)
timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S")
entry = {
timestamp: timestamp,
level: level,
message: message
}
@log_entries << entry
if @debug_enabled
puts "[#{level.upcase}] #{timestamp}: #{message}"
end
end
def profile_start(operation_name)
@profiling_data[operation_name] = {
start_time: Time.now.to_f,
end_time: nil
}
log("Started profiling operation: #{operation_name}")
end
def profile_end(operation_name)
if @profiling_data.key?(operation_name)
@profiling_data[operation_name][:end_time] = Time.now.to_f
duration = @profiling_data[operation_name][:end_time] - @profiling_data[operation_name][:start_time]
log("Completed profiling operation: #{operation_name} (#{duration.round(4)}s)")
end
end
def get_log_entries
@log_entries
end
def clear_logs
@log_entries.clear
puts "Cleared debug logs"
end
end
```
### app/models/game_manager.rb
```ruby
class GameManager
attr_accessor :game_state, :is_running, :current_scene, :debug_manager
def initialize
@game_state = :menu
@is_running = false
@current_scene = nil
@debug_manager = DebugManager.new
end
def start_game
@is_running = true
@game_state = :playing
@debug_manager.log("Game started", :info)
puts "Game started"
end
def pause_game
if @is_running
@game_state = :paused
@debug_manager.log("Game paused", :info)
puts "Game paused"
end
end
def resume_game
if @is_running
@game_state = :playing
@debug_manager.log("Game resumed", :info)
puts "Game resumed"
end
end
def stop_game
@is_running = false
@game_state = :menu
@debug_manager.log("Game stopped", :info)
puts "Game stopped"
end
def update(delta_time)
if @is_running
@debug_manager.log("Updating game state", :debug)
# Update current scene
if @current_scene
@current_scene.update(delta_time)
end
# Update game logic
case @game_state
when :playing
# Game playing logic
when :paused
# Paused logic
end
end
end
def render(renderer)
if @is_running
@debug_manager.log("Rendering game", :debug)
# Render current scene
if @current_scene
@current_scene.render(renderer)
end
# Render UI
# ... UI rendering logic
end
end
def load_scene(scene_name)
@current_scene = scene_name
@debug_manager.log("Loaded scene: #{scene_name}", :info)
end
end
```
### app/models/scene.rb
```ruby
class Scene
attr_accessor :name, :objects, :camera, :lighting
def initialize(name)
@name = name
@objects = []
@camera = nil
@lighting = nil
end
def add_object(object)
@objects << object
puts "Added object to scene: #{object.name}"
end
def remove_object(object)
@objects.delete(object)
puts "Removed object from scene: #{object.name}"
end
def update(delta_time)
puts "Updating scene: #{@name}"
# Update all objects in the scene
@objects.each do |object|
object.update(delta_time)
end
# Update camera if exists
@camera.update(delta_time) if @camera
# Update lighting if exists
@lighting.update(delta_time) if @lighting
end
def render(renderer)
puts "Rendering scene: #{@name}"
# Render all objects in the scene
@objects.each do |object|
object.render(renderer)
end
# Render camera and lighting
@camera.render(renderer) if @camera
@lighting.render(renderer) if @lighting
end
end
class SceneObject
attr_accessor :name, :position, :rotation, :scale, :model, :texture
def initialize(name)
@name = name
@position = [0.0, 0.0, 0.0]
@rotation = [0.0, 0.0, 0.0]
@scale = [1.0, 1.0, 1.0]
@model = nil
@texture = nil
end
def update(delta_time)
puts "Updating object: #{@name}"
end
def render(renderer)
puts "Rendering object: #{@name}"
# Render the object using the renderer
renderer.render_object(self)
end
end
```
### app/models/sound_manager.rb
```ruby
class SoundManager
attr_accessor :master_volume, :sound_effects, :music_tracks
def initialize
@master_volume = 1.0
@sound_effects = {}
@music_tracks = {}
end
def load_sound_effect(name, file_path)
@sound_effects[name] = file_path
puts "Loaded sound effect: #{name}"
end
def load_music_track(name, file_path)
@music_tracks[name] = file_path
puts "Loaded music track: #{name}"
end
def play_sound_effect(name)
if @sound_effects.key?(name)
puts "Playing sound effect: #{name}"
# In a real game, this would actually play the sound
else
puts "Sound effect not found: #{name}"
end
end
def play_music_track(name)
if @music_tracks.key?(name)
puts "Playing music track: #{name}"
# In a real game, this would actually play the music
else
puts "Music track not found: #{name}"
end
end
def set_master_volume(volume)
@master_volume = [0.0, volume].max
@master_volume = [1.0, @master_volume].min
puts "Set master volume to: #{@master_volume}"
end
def update(delta_time)
puts "Updating sound manager"
end
end
```
### app/models/physics_manager.rb
```ruby
class PhysicsManager
attr_accessor :gravity, :collision_system, :rigid_body_system
def initialize
@gravity = [0.0, -9.81, 0.0]
@collision_system = CollisionSystem.new
@rigid_body_system = RigidBodySystem.new
end
def update(delta_time)
puts "Updating physics manager"
# Update rigid body system
@rigid_body_system.update(delta_time)
# Update collision system
@collision_system.update(delta_time)
# Apply gravity to objects
apply_gravity(delta_time)
end
def apply_gravity(delta_time)
puts "Applying gravity"
# In a real game, this would apply gravitational force to physics objects
end
def add_rigid_body(body)
@rigid_body_system.add_body(body)
puts "Added rigid body to physics system"
end
def remove_rigid_body(body)
@rigid_body_system.remove_body(body)
puts "Removed rigid body from physics system"
end
end
class CollisionSystem
def update(delta_time)
puts "Updating collision system"
# In a real game, this would handle collision detection and response
end
end
class RigidBodySystem
attr_accessor :bodies
def initialize
@bodies = []
end
def add_body(body)
@bodies << body
end
def remove_body(body)
@bodies.delete(body)
end
def update(delta_time)
puts "Updating rigid body system"
# Update all bodies
@bodies.each do |body|
body.update(delta_time)
end
end
end
class RigidBody
attr_accessor :position, :velocity, :mass, :is_active
def initialize(position, velocity, mass)
@position = position
@velocity = velocity
@mass = mass
@is_active = true
end
def update(delta_time)
puts "Updating rigid body"
if @is_active
# Update position based on velocity
@position[0] += @velocity[0] * delta_time
@position[1] += @velocity[1] * delta_time
@position[2] += @velocity[2] * delta_time
end
end
end
```
### app/models/animation_manager.rb
```ruby
class AnimationManager
attr_accessor :animations, :current_animation
def initialize
@animations = {}
@current_animation = nil
end
def load_animation(name, animation_data)
@animations[name] = animation_data
puts "Loaded animation: #{name}"
end
def play_animation(name)
if @animations.key?(name)
@current_animation = name
puts "Playing animation: #{name}"
else
puts "Animation not found: #{name}"
end
end
def stop_animation
@current_animation = nil
puts "Stopped animation"
end
def update(delta_time)
if @current_animation && @animations.key?(@current_animation)
puts "Updating animation: #{@current_animation}"
# In a real game, this would update the animation frame
# based on delta_time and animation data
end
end
end
```
### app/models/script_manager.rb
```ruby
class ScriptManager
attr_accessor :scripts, :script_context
def initialize
@scripts = {}
@script_context = {}
end
def load_script(name, script_content)
@scripts[name] = script_content
puts "Loaded script: #{name}"
end
def execute_script(name)
if @scripts.key?(name)
puts "Executing script: #{name}"
# In a real game, this would execute the script
# using a scripting engine like Lua or JavaScript
else
puts "Script not found: #{name}"
end
end
def set_context_variable(name, value)
@script_context[name] = value
puts "Set script context variable: #{name} = #{value}"
end
def update(delta_time)
puts "Updating script manager"
end
end
```
### app/models/input_manager.rb
```ruby
class InputManager
attr_accessor :input_handlers, :keyboard_state, :mouse_state
def initialize
@input_handlers = []
@keyboard_state = {}
@mouse_state = {}
end
def add_input_handler(handler)
@input_handlers << handler
puts "Added input handler"
end
def handle_input(input_event)
puts "Handling input event: #{input_event}"
# In a real game, this would process the input event
# and call appropriate handlers
@input_handlers.each do |handler|
handler.call(input_event) if handler.respond_to?(:call)
end
end
def update(delta_time)
puts "Updating input manager"
end
def is_key_pressed(key)
@keyboard_state[key] || false
end
def is_mouse_button_pressed(button)
@mouse_state[button] || false
end
end
```
### app/models/render_manager.rb
```ruby
class RenderManager
attr_accessor :renderer, :render_targets, :shaders
def initialize
@renderer = nil
@render_targets = []
@shaders = {}
end
def set_renderer(renderer)
@renderer = renderer
puts "Set renderer: #{renderer.class}"
end
def add_render_target(target)
@render_targets << target
puts "Added render target"
end
def load_shader(name, shader_data)
@shaders[name] = shader_data
puts "Loaded shader: #{name}"
end
def render_scene(scene)
if @renderer
puts "Rendering scene using #{@renderer.class}"
# In a real game, this would use the renderer to draw the scene
else
puts "No renderer set"
end
end
def update(delta_time)
puts "Updating render manager"
end
end
```
### app/models/resource_manager.rb
```ruby
class ResourceManager
attr_accessor :loaded_resources, :resource_cache
def initialize
@loaded_resources = {}
@resource_cache = {}
end
def load_resource(name, resource_path)
# In a real game, this would load the resource from disk
# and store it in memory
puts "Loading resource: #{name} from #{resource_path}"
# Simulate loading a resource
resource = {
name: name,
path: resource_path,
loaded_at: Time.now
}
@loaded_resources[name] = resource
@resource_cache[name] = resource
puts "Resource loaded: #{name}"
end
def get_resource(name)
if @resource_cache.key?(name)
puts "Returning cached resource: #{name}"
return @resource_cache[name]
else
puts "Resource not found in cache: #{name}"
return nil
end
end
def unload_resource(name)
@loaded_resources.delete(name)
@resource_cache.delete(name)
puts "Unloaded resource: #{name}"
end
def update(delta_time)
puts "Updating resource manager"
end
end
```
### app/models/save_manager.rb
```ruby
class SaveManager
attr_accessor :save_files, :current_save_file
def initialize
@save_files = []
@current_save_file = nil
end
def create_save(name)
save_file = {
name: name,
created_at: Time.now,
data: {}
}
@save_files << save_file
@current_save_file = save_file
puts "Created save file: #{name}"
end
def load_save(name)
save_file = @save_files.find { |s| s[:name] == name }
if save_file
@current_save_file = save_file
puts "Loaded save file: #{name}"
return save_file
else
puts "Save file not found: #{name}"
return nil
end
end
def save_game(data)
if @current_save_file
@current_save_file[:data] = data
@current_save_file[:saved_at] = Time.now
puts "Saved game data"
else
puts "No save file selected"
end
end
def delete_save(name)
@save_files.delete_if { |s| s[:name] == name }
puts "Deleted save file: #{name}"
end
def update(delta_time)
puts "Updating save manager"
end
end
```
### app/models/achievement_manager.rb
```ruby
class AchievementManager
attr_accessor :achievements, :unlocked_achievements
def initialize
@achievements = []
@unlocked_achievements = []
end
def add_achievement(achievement)
@achievements << achievement
puts "Added achievement: #{achievement[:name]}"
end
def unlock_achievement(name)
achievement = @achievements.find { |a| a[:name] == name }
if achievement && !@unlocked_achievements.include?(name)
@unlocked_achievements << name
puts "Unlocked achievement: #{name}"
return true
else
puts "Achievement already unlocked or not found: #{name}"
return false
end
end
def get_unlocked_achievements
@unlocked_achievements
end
def update(delta_time)
puts "Updating achievement manager"
end
end
```
### app/models/level_manager.rb
```ruby
class LevelManager
attr_accessor :current_level, :levels, :completed_levels
def initialize
@current_level = nil
@levels = []
@completed_levels = []
end
def add_level(level)
@levels << level
puts "Added level: #{level[:name]}"
end
def load_level(name)
level = @levels.find { |l| l[:name] == name }
if level
@current_level = level
puts "Loaded level: #{name}"
return level
else
puts "Level not found: #{name}"
return nil
end
end
def complete_level(name)
if @levels.include?(@current_level)
@completed_levels << name
puts "Completed level: #{name}"
# Move to next level
next_level = @levels[@levels.index(@current_level) + 1]
if next_level
@current_level = next_level
puts "Loading next level: #{next_level[:name]}"
else
puts "No more levels available"
end
end
end
def update(delta_time)
puts "Updating level manager"
end
end
```
### app/models/character_manager.rb
```ruby
class CharacterManager
attr_accessor :characters, :player_character
def initialize
@characters = []
@player_character = nil
end
def add_character(character)
@characters << character
puts "Added character: #{character[:name]}"
end
def set_player_character(name)
character = @characters.find { |c| c[:name] == name }
if character
@player_character = character
puts "Set player character: #{name}"
else
puts "Character not found: #{name}"
end
end
def update(delta_time)
puts "Updating character manager"
# Update all characters
@characters.each do |character|
# In a real game, this would update character logic
end
end
end
```
### app/models/item_manager.rb
```ruby
class ItemManager
attr_accessor :items, :inventory
def initialize
@items = []
@inventory = []
end
def add_item(item)
@items << item
puts "Added item: #{item[:name]}"
end
def pickup_item(name)
item = @items.find { |i| i[:name] == name }
if item
@inventory << item
@items.delete(item)
puts "Picked up item: #{name}"
return true
else
puts "Item not found: #{name}"
return false
end
end
def use_item(name)
item = @inventory.find { |i| i[:name] == name }
if item
# In a real game, this would use the item
puts "Used item: #{name}"
return true
else
puts "Item not in inventory: #{name}"
return false
end
end
def update(delta_time)
puts "Updating item manager"
end
end
```
### app/models/ui_manager.rb
```ruby
class UIManager
attr_accessor :ui_elements, :active_ui_state
def initialize
@ui_elements = []
@active_ui_state = nil
end
def add_ui_element(element)
@ui_elements << element
puts "Added UI element: #{element[:name]}"
end
def set_active_ui_state(state)
@active_ui_state = state
puts "Set active UI state: #{state}"
end
def update(delta_time)
puts "Updating UI manager"
# Update all UI elements
@ui_elements.each do |element|
# In a real game, this would update UI element logic
end
end
end
```
### app/models/audio_manager.rb
```ruby
class AudioManager
attr_accessor :sound_effects, :music_tracks, :volume
def initialize
@sound_effects = {}
@music_tracks = {}
@volume = 1.0
end
def load_sound_effect(name, file_path)
@sound_effects[name] = {
path: file_path,
loaded_at: Time.now
}
puts "Loaded sound effect: #{name}"
end
def play_sound_effect(name)
if @sound_effects.key?(name)
puts "Playing sound effect: #{name}"
# In a real game, this would play the actual sound
else
puts "Sound effect not found: #{name}"
end
end
def load_music_track(name, file_path)
@music_tracks[name] = {
path: file_path,
loaded_at: Time.now
}
puts "Loaded music track: #{name}"
end
def play_music_track(name)
if @music_tracks.key?(name)
puts "Playing music track: #{name}"
# In a real game, this would play the actual music
else
puts "Music track not found: #{name}"
end
end
def set_volume(volume_level)
@volume = volume_level
puts "Set audio volume to: #{volume_level}"
end
def update(delta_time)
puts "Updating audio manager"
end
end
```
### app/models/network_manager.rb
```ruby
class NetworkManager
attr_accessor :connected_players, :server_address, :connection_status
def initialize
@connected_players = []
@server_address = nil
@connection_status = :disconnected
end
def connect_to_server(address)
@server_address = address
@connection_status = :connecting
puts "Connecting to server: #{address}"
# In a real game, this would establish a network connection
@connection_status = :connected
puts "Connected to server: #{address}"
end
def disconnect_from_server
@connection_status = :disconnected
@server_address = nil
puts "Disconnected from server"
end
def send_message(message)
if @connection_status == :connected
puts "Sending message: #{message}"
# In a real game, this would send the actual network message
else
puts "Not connected to server"
end
end
def update(delta_time)
puts "Updating network manager"
# In a real game, this would handle network updates and receive messages
end
end
```
### app/models/game_state_manager.rb
```ruby
class GameStateManager
attr_accessor :current_state, :states
def initialize
@current_state = nil
@states = []
end
def add_state(state)
@states << state
puts "Added game state: #{state[:name]}"
end
def change_state(name)
state = @states.find { |s| s[:name] == name }
if state
@current_state = state
puts "Changed to game state: #{name}"
else
puts "Game state not found: #{name}"
end
end
def update(delta_time)
puts "Updating game state manager"
if @current_state
# In a real game, this would update the current state
end
end
end
```
### app/models/timer_manager.rb
```ruby
class TimerManager
attr_accessor :timers
def initialize
@timers = []
end
def add_timer(name, duration, callback)
timer = {
name: name,
duration: duration,
remaining_time: duration,
callback: callback,
active: true
}
@timers << timer
puts "Added timer: #{name} (#{duration}s)"
end
def update(delta_time)
puts "Updating timer manager"
# Update all timers
@timers.each do |timer|
if timer[:active]
timer[:remaining_time] -= delta_time
if timer[:remaining_time] <= 0
timer[:callback].call if timer[:callback].respond_to?(:call)
timer[:active] = false
puts "Timer #{timer[:name]} completed"
end
end
end
# Remove completed timers
@timers.reject! { |timer| !timer[:active] }
end
end
```
### app/models/logic_manager.rb
```ruby
class LogicManager
attr_accessor :systems, :entities
def initialize
@systems = []
@entities = []
end
def add_system(system)
@systems << system
puts "Added system: #{system[:name]}"
end
def add_entity(entity)
@entities << entity
puts "Added entity: #{entity[:name]}"
end
def update(delta_time)
puts "Updating logic manager"
# Update all systems
@systems.each do |system|
# In a real game, this would update system logic
end
end
end
```
### app/models/physics_manager.rb
```ruby
class PhysicsManager
attr_accessor :bodies, :world
def initialize
@bodies = []
@world = nil
end
def add_body(body)
@bodies << body
puts "Added physics body: #{body[:name]}"
end
def update(delta_time)
puts "Updating physics manager"
# In a real game, this would update physics simulation
end
end
```
### app/models/animation_manager.rb
```ruby
class AnimationManager
attr_accessor :animations, :current_animation
def initialize
@animations = []
@current_animation = nil
end
def add_animation(animation)
@animations << animation
puts "Added animation: #{animation[:name]}"
end
def play_animation(name)
animation = @animations.find { |a| a[:name] == name }
if animation
@current_animation = animation
puts "Playing animation: #{name}"
else
puts "Animation not found: #{name}"
end
end
def update(delta_time)
puts "Updating animation manager"
# In a real game, this would update the current animation
end
end
```
### app/models/asset_manager.rb
```ruby
class AssetManager
attr_accessor :assets, :loaded_assets
def initialize
@assets = []
@loaded_assets = {}
end
def add_asset(asset)
@assets << asset
puts "Added asset: #{asset[:name]}"
end
def load_asset(name)
asset = @assets.find { |a| a[:name] == name }
if asset
# In a real game, this would load the actual asset
@loaded_assets[name] = {
name: name,
loaded_at: Time.now
}
puts "Loaded asset: #{name}"
else
puts "Asset not found: #{name}"
end
end
def update(delta_time)
puts "Updating asset manager"
end
end
```
### app/models/debug_manager.rb
```ruby
class DebugManager
attr_accessor :debug_enabled, :log_entries, :profiling_data
def initialize
@debug_enabled = false
@log_entries = []
@profiling_data = {}
end
def enable_debug
@debug_enabled = true
puts "Debug mode enabled"
end
def disable_debug
@debug_enabled = false
puts "Debug mode disabled"
end
def log(message)
if @debug_enabled
entry = {
timestamp: Time.now,
message: message
}
@log_entries << entry
puts "[DEBUG] #{message}"
end
end
def profile_start(name)
@profiling_data[name] = {
start_time: Time.now,
duration: nil
}
end
def profile_end(name)
if @profiling_data.key?(name)
end_time = Time.now
duration = end_time - @profiling_data[name][:start_time]
@profiling_data[name][:duration] = duration
puts "[PROFILE] #{name}: #{duration}s"
end
end
def update(delta_time)
puts "Updating debug manager"
end
end
```
### app/models/fps_manager.rb
```ruby
class FPSManager
attr_accessor :current_fps, :frame_times, :target_fps
def initialize
@current_fps = 0
@frame_times = []
@target_fps = 60
end
def update(delta_time)
# Calculate FPS based on frame times
@frame_times << delta_time
# Keep only the last 100 frame times for averaging
if @frame_times.length > 100
@frame_times.shift
end
# Calculate average frame time
if @frame_times.length > 0
avg_frame_time = @frame_times.sum / @frame_times.length
# Convert to FPS (frames per second)
@current_fps = 1.0 / avg_frame_time if avg_frame_time > 0
end
puts "Current FPS: #{@current_fps.round(2)}"
end
def set_target_fps(fps)
@target_fps = fps
puts "Target FPS set to: #{fps}"
end
end
```
### app/models/input_manager.rb
```ruby
class InputManager
attr_accessor :input_state, :input_handlers
def initialize
@input_state = {}
@input_handlers = []
end
def add_input_handler(handler)
@input_handlers << handler
puts "Added input handler"
end
def update(delta_time)
puts "Updating input manager"
# In a real game, this would process actual input
end
def handle_input(input_event)
# In a real game, this would handle the actual input event
puts "Handling input: #{input_event}"
end
end
```
### app/models/scene_manager.rb
```ruby
class SceneManager
attr_accessor :current_scene, :scenes
def initialize
@current_scene = nil
@scenes = []
end
def add_scene(scene)
@scenes << scene
puts "Added scene: #{scene[:name]}"
end
def change_scene(name)
scene = @scenes.find { |s| s[:name] == name }
if scene
@current_scene = scene
puts "Changed to scene: #{name}"
else
puts "Scene not found: #{name}"
end
end
def update(delta_time)
puts "Updating scene manager"
# In a real game, this would update the current scene
end
end
```
### app/models/particle_manager.rb
```ruby
class ParticleManager
attr_accessor :particles, :emitters
def initialize
@particles = []
@emitters = []
end
def add_emitter(emitter)
@emitters << emitter
puts "Added particle emitter"
end
def update(delta_time)
puts "Updating particle manager"
# In a real game, this would update particle systems
end
end
```
### app/models/level_manager.rb
```ruby
class LevelManager
attr_accessor :current_level, :levels
def initialize
@current_level = nil
@levels = []
end
def add_level(level)
@levels << level
puts "Added level: #{level[:name]}"
end
def load_level(name)
level = @levels.find { |l| l[:name] == name }
if level
@current_level = level
puts "Loaded level: #{name}"
else
puts "Level not found: #{name}"
end
end
def update(delta_time)
puts "Updating level manager"
# In a real game, this would update the current level
end
end
```
### app/models/save_manager.rb
```ruby
class SaveManager
attr_accessor :save_data, :save_file_path
def initialize
@save_data = {}
@save_file_path = "savegame.dat"
end
def save_game()
# In a real game, this would save to the actual file
puts "Saving game data..."
puts "Save data: #{@save_data}"
end
def load_game()
# In a real game, this would load from the actual file
puts "Loading game data..."
puts "Loaded save data: #{@save_data}"
end
def update(delta_time)
puts "Updating save manager"
end
end
```
### app/models/achievement_manager.rb
```ruby
class AchievementManager
attr_accessor :achievements, :unlocked_achievements
def initialize
@achievements = []
@unlocked_achievements = []
end
def add_achievement(achievement)
@achievements << achievement
puts "Added achievement: #{achievement[:name]}"
end
def unlock_achievement(name)
achievement = @achievements.find { |a| a[:name] == name }
if achievement && !@unlocked_achievements.include?(name)
@unlocked_achievements << name
puts "Unlocked achievement: #{name}"
else
puts "Achievement not found or already unlocked: #{name}"
end
end
def update(delta_time)
puts "Updating achievement manager"
end
end
```
### app/models/quest_manager.rb
```ruby
class QuestManager
attr_accessor :active_quests, :completed_quests
def initialize
@active_quests = []
@completed_quests = []
end
def add_quest(quest)
@active_quests << quest
puts "Added quest: #{quest[:name]}"
end
def complete_quest(name)
quest = @active_quests.find { |q| q[:name] == name }
if quest
@active_quests.delete(quest)
@completed_quests << quest
puts "Completed quest: #{name}"
else
puts "Quest not found: #{name}"
end
end
def update(delta_time)
puts "Updating quest manager"
end
end
```
### app/models/inventory_manager.rb
```ruby
class InventoryManager
attr_accessor :items, :max_capacity
def initialize(max_capacity = 20)
@items = []
@max_capacity = max_capacity
end
def add_item(item)
if @items.length < @max_capacity
@items << item
puts "Added item to inventory: #{item[:name]}"
else
puts "Inventory is full"
end
end
def remove_item(name)
item = @items.find { |i| i[:name] == name }
if item
@items.delete(item)
puts "Removed item from inventory: #{name}"
else
puts "Item not found in inventory: #{name}"
end
end
def update(delta_time)
puts "Updating inventory manager"
end
end
```
### app/models/character_manager.rb
```ruby
class CharacterManager
attr_accessor :characters, :player_character
def initialize
@characters = []
@player_character = nil
end
def add_character(character)
@characters << character
puts "Added character: #{character[:name]}"
end
def set_player_character(name)
character = @characters.find { |c| c[:name] == name }
if character
@player_character = character
puts "Set player character to: #{name}"
else
puts "Character not found: #{name}"
end
end
def update(delta_time)
puts "Updating character manager"
# In a real game, this would update all characters
end
end
```
### app/models/shop_manager.rb
```ruby
class ShopManager
attr_accessor :shop_items, :player_gold
def initialize
@shop_items = []
@player_gold = 0
end
def add_item(item)
@shop_items << item
puts "Added shop item: #{item[:name]}"
end
def buy_item(name)
item = @shop_items.find { |i| i[:name] == name }
if item && @player_gold >= item[:price]
@player_gold -= item[:price]
puts "Bought item: #{name} for #{item[:price]} gold"
else
puts "Cannot buy item: #{name}"
end
end
def update(delta_time)
puts "Updating shop manager"
end
end
```
### app/models/quest_log_manager.rb
```ruby
class QuestLogManager
attr_accessor :active_quests, :completed_quests
def initialize
@active_quests = []
@completed_quests = []
end
def add_quest(quest)
@active_quests << quest
puts "Added quest to log: #{quest[:name]}"
end
def complete_quest(name)
quest = @active_quests.find { |q| q[:name] == name }
if quest
@active_quests.delete(quest)
@completed_quests << quest
puts "Quest completed and logged: #{name}"
else
puts "Quest not found in log: #{name}"
end
end
def update(delta_time)
puts "Updating quest log manager"
end
end
```
### app/models/buff_manager.rb
```ruby
class BuffManager
attr_accessor :active_buffs, :buff_effects
def initialize
@active_buffs = []
@buff_effects = {}
end
def add_buff(buff)
@active_buffs << buff
puts "Added buff: #{buff[:name]}"
end
def remove_buff(name)
buff = @active_buffs.find { |b| b[:name] == name }
if buff
@active_buffs.delete(buff)
puts "Removed buff: #{name}"
else
puts "Buff not found: #{name}"
end
end
def update(delta_time)
puts "Updating buff manager"
end
end
```
### app/models/animation_manager.rb
```ruby
class AnimationManager
attr_accessor :animations, :current_animation
def initialize
@animations = []
@current_animation = nil
end
def add_animation(animation)
@animations << animation
puts "Added animation: #{animation[:name]}"
end
def play_animation(name)
animation = @animations.find { |a| a[:name] == name }
if animation
@current_animation = animation
puts "Playing animation: #{name}"
else
puts "Animation not found: #{name}"
end
end
def update(delta_time)
puts "Updating animation manager"
end
end
```
### app/models/sound_manager.rb
```ruby
class SoundManager
attr_accessor :sound_effects, :music_tracks
def initialize
@sound_effects = []
@music_tracks = []
end
def add_sound_effect(sound)
@sound_effects << sound
puts "Added sound effect: #{sound[:name]}"
end
def play_sound_effect(name)
sound = @sound_effects.find { |s| s[:name] == name }
if sound
puts "Playing sound effect: #{name}"
else
puts "Sound effect not found: #{name}"
end
end
def update(delta_time)
puts "Updating sound manager"
end
end
```
### app/models/texture_manager.rb
```ruby
class TextureManager
attr_accessor :textures, :loaded_textures
def initialize
@textures = []
@loaded_textures = {}
end
def add_texture(texture)
@textures << texture
puts "Added texture: #{texture[:name]}"
end
def load_texture(name)
texture = @textures.find { |t| t[:name] == name }
if texture && !@loaded_textures.key?(name)
@loaded_textures[name] = texture
puts "Loaded texture: #{name}"
else
puts "Texture already loaded or not found: #{name}"
end
end
def update(delta_time)
puts "Updating texture manager"
end
end
```
### app/models/render_manager.rb
```ruby
class RenderManager
attr_accessor :render_queue, :camera
def initialize
@render_queue = []
@camera = nil
end
def add_to_render_queue(object)
@render_queue << object
puts "Added to render queue: #{object[:name]}"
end
def update(delta_time)
puts "Updating render manager"
# In a real game, this would process the render queue
end
end
```
### app/models/game_state_manager.rb
```ruby
class GameStateManager
attr_accessor :current_state, :states
def initialize
@current_state = nil
@states = []
end
def add_state(state)
@states << state
puts "Added game state: #{state[:name]}"
end
def change_state(name)
state = @states.find { |s| s[:name] == name }
if state
@current_state = state
puts "Changed game state to: #{name}"
else
puts "Game state not found: #{name}"
end
end
def update(delta_time)
puts "Updating game state manager"
# In a real game, this would update the current state
end
end
```
### app/models/ui_manager.rb
```ruby
class UIManager
attr_accessor :ui_elements, :active_ui
def initialize
@ui_elements = []
@active_ui = nil
end
def add_ui_element(element)
@ui_elements << element
puts "Added UI element: #{element[:name]}"
end
def show_ui(name)
element = @ui_elements.find { |e| e[:name] == name }
if element
@active_ui = element
puts "Showing UI element: #{name}"
else
puts "UI element not found: #{name}"
end
end
def update(delta_time)
puts "Updating UI manager"
end
end
```
### app/models/time_manager.rb
```ruby
class TimeManager
attr_accessor :game_time, :delta_time, :time_scale
def initialize
@game_time = 0.0
@delta_time = 0.0
@time_scale = 1.0
end
def update(delta_time)
@delta_time = delta_time * @time_scale
@game_time += @delta_time
puts "Updating time manager"
puts "Delta Time: #{@delta_time}"
puts "Game Time: #{@game_time}"
end
def set_time_scale(scale)
@time_scale = scale
puts "Time scale set to: #{scale}"
end
end
```
### app/models/debug_manager.rb
```ruby
class DebugManager
attr_accessor :debug_enabled, :debug_info
def initialize
@debug_enabled = false
@debug_info = {}
end
def enable_debug()
@debug_enabled = true
puts "Debug mode enabled"
end
def disable_debug()
@debug_enabled = false
puts "Debug mode disabled"
end
def update(delta_time)
if @debug_enabled
puts "Debug info: #{@debug_info}"
end
puts "Updating debug manager"
end
end
```
### app/models/network_manager.rb
```ruby
class NetworkManager
attr_accessor :connected, :server_address, :port
def initialize
@connected = false
@server_address = ""
@port = 0
end
def connect(address, port)
@server_address = address
@port = port
@connected = true
puts "Connected to server: #{address}:#{port}"
end
def disconnect()
@connected = false
puts "Disconnected from server"
end
def update(delta_time)
puts "Updating network manager"
# In a real game, this would handle network communication
end
end
```
### app/models/asset_manager.rb
```ruby
class AssetManager
attr_accessor :assets, :loaded_assets
def initialize
@assets = []
@loaded_assets = {}
end
def add_asset(asset)
@assets << asset
puts "Added asset: #{asset[:name]}"
end
def load_asset(name)
asset = @assets.find { |a| a[:name] == name }
if asset && !@loaded_assets.key?(name)
@loaded_assets[name] = asset
puts "Loaded asset: #{name}"
else
puts "Asset already loaded or not found: #{name}"
end
end
def update(delta_time)
puts "Updating asset manager"
end
end
```
### app/models/physics_manager.rb
```ruby
class PhysicsManager
attr_accessor :bodies, :gravity
def initialize
@bodies = []
@gravity = { x: 0, y: 9.8 }
end
def add_body(body)
@bodies << body
puts "Added physics body"
end
def update(delta_time)
puts "Updating physics manager"
# In a real game, this would calculate physics
end
end
```
### app/models/ai_manager.rb
```ruby
class AIManager
attr_accessor :ai_entities, :behavior_tree
def initialize
@ai_entities = []
@behavior_tree = nil
end
def add_ai_entity(entity)
@ai_entities << entity
puts "Added AI entity"
end
def update(delta_time)
puts "Updating AI manager"
# In a real game, this would process AI logic
end
end
```
### app/models/level_generator.rb
```ruby
class LevelGenerator
attr_accessor :generated_levels, :level_templates
def initialize
@generated_levels = []
@level_templates = []
end
def add_template(template)
@level_templates << template
puts "Added level template"
end
def generate_level(template_name)
template = @level_templates.find { |t| t[:name] == template_name }
if template
# In a real game, this would generate a level based on the template
generated_level = {
name: "Generated_Level_#{Time.now.to_i}",
template: template_name,
timestamp: Time.now
}
@generated_levels << generated_level
puts "Generated level from template: #{template_name}"
return generated_level
else
puts "Level template not found: #{template_name}"
return nil
end
end
def update(delta_time)
puts "Updating level generator"
end
end
```
### app/models/mission_manager.rb
```ruby
class MissionManager
attr_accessor :active_missions, :completed_missions, :available_missions
def initialize
@active_missions = []
@completed_missions = []
@available_missions = []
end
def add_mission(mission)
@available_missions << mission
puts "Added mission: #{mission[:name]}"
end
def start_mission(name)
mission = @available_missions.find { |m| m[:name] == name }
if mission
@active_missions << mission
@available_missions.delete(mission)
puts "Started mission: #{name}"
else
puts "Mission not found: #{name}"
end
end
def complete_mission(name)
mission = @active_missions.find { |m| m[:name] == name }
if mission
@active_missions.delete(mission)
@completed_missions << mission
puts "Completed mission: #{name}"
else
puts "Mission not found: #{name}"
end
end
def update(delta_time)
puts "Updating mission manager"
end
end
```
### app/models/inventory_manager.rb
```ruby
class InventoryManager
attr_accessor :items, :inventory_slots
def initialize
@items = []
@inventory_slots = 20
end
def add_item(item)
if @items.length < @inventory_slots
@items << item
puts "Added item to inventory: #{item[:name]}"
else
puts "Inventory is full"
end
end
def remove_item(name)
item = @items.find { |i| i[:name] == name }
if item
@items.delete(item)
puts "Removed item from inventory: #{name}"
else
puts "Item not found in inventory: #{name}"
end
end
def update(delta_time)
puts "Updating inventory manager"
end
end
```
### app/models/character_manager.rb
```ruby
class CharacterManager
attr_accessor :characters, :active_character
def initialize
@characters = []
@active_character = nil
end
def add_character(character)
@characters << character
puts "Added character: #{character[:name]}"
end
def switch_character(name)
character = @characters.find { |c| c[:name] == name }
if character
@active_character = character
puts "Switched to character: #{name}"
else
puts "Character not found: #{name}"
end
end
def update(delta_time)
puts "Updating character manager"
end
end
```
### app/models/quest_manager.rb
```ruby
class QuestManager
attr_accessor :active_quests, :completed_quests, :available_quests
def initialize
@active_quests = []
@completed_quests = []
@available_quests = []
end
def add_quest(quest)
@available_quests << quest
puts "Added quest: #{quest[:name]}"
end
def start_quest(name)
quest = @available_quests.find { |q| q[:name] == name }
if quest
@active_quests << quest
@available_quests.delete(quest)
puts "Started quest: #{name}"
else
puts "Quest not found: #{name}"
end
end
def complete_quest(name)
quest = @active_quests.find { |q| q[:name] == name }
if quest
@active_quests.delete(quest)
@completed_quests << quest
puts "Completed quest: #{name}"
else
puts "Quest not found: #{name}"
end
end
def update(delta_time)
puts "Updating quest manager"
end
end
```
### app/models/item_manager.rb
```ruby
class ItemManager
attr_accessor :items, :item_types
def initialize
@items = []
@item_types = {}
end
def add_item_type(type_name, properties)
@item_types[type_name] = properties
puts "Added item type: #{type_name}"
end
def create_item(type_name, name, properties = {})
if @item_types.key?(type_name)
item = {
name: name,
type: type_name,
properties: @item_types[type_name].merge(properties)
}
@items << item
puts "Created item: #{name} of type #{type_name}"
return item
else
puts "Item type not found: #{type_name}"
return nil
end
end
def update(delta_time)
puts "Updating item manager"
end
end
```
### app/models/skill_manager.rb
```ruby
class SkillManager
attr_accessor :skills, :character_skills
def initialize
@skills = []
@character_skills = {}
end
def add_skill(skill)
@skills << skill
puts "Added skill: #{skill[:name]}"
end
def learn_skill(character_name, skill_name)
skill = @skills.find { |s| s[:name] == skill_name }
if skill
@character_skills[character_name] ||= []
@character_skills[character_name] << skill
puts "Character #{character_name} learned skill: #{skill_name}"
else
puts "Skill not found: #{skill_name}"
end
end
def update(delta_time)
puts "Updating skill manager"
end
end
```
### app/models/effect_manager.rb
```ruby
class EffectManager
attr_accessor :active_effects, :effect_templates
def initialize
@active_effects = []
@effect_templates = []
end
def add_effect_template(template)
@effect_templates << template
puts "Added effect template: #{template[:name]}"
end
def apply_effect(template_name, target)
template = @effect_templates.find { |t| t[:name] == template_name }
if template
effect = {
name: template[:name],
target: target,
duration: template[:duration],
properties: template[:properties]
}
@active_effects << effect
puts "Applied effect: #{template_name} to #{target}"
return effect
else
puts "Effect template not found: #{template_name}"
return nil
end
end
def update(delta_time)
puts "Updating effect manager"
# In a real game, this would process active effects
end
end
```
### app/models/combat_manager.rb
```ruby
class CombatManager
attr_accessor :combatants, :active_combat, :turn_order
def initialize
@combatants = []
@active_combat = false
@turn_order = []
end
def add_combatant(combatant)
@combatants << combatant
puts "Added combatant: #{combatant[:name]}"
end
def start_combat()
@active_combat = true
@turn_order = @combatants.shuffle
puts "Started combat"
end
def end_combat()
@active_combat = false
@turn_order.clear
puts "Ended combat"
end
def update(delta_time)
puts "Updating combat manager"
# In a real game, this would handle combat logic
end
end
```
### app/models/loot_manager.rb
```ruby
class LootManager
attr_accessor :loot_tables, :drops
def initialize
@loot_tables = []
@drops = []
end
def add_loot_table(table)
@loot_tables << table
puts "Added loot table: #{table[:name]}"
end
def drop_loot(enemy_name, table_name)
table = @loot_tables.find { |t| t[:name] == table_name }
if table
# In a real game, this would generate random drops
drop = {
enemy: enemy_name,
table: table_name,
items: [], # This would be populated with actual drops
timestamp: Time.now
}
@drops << drop
puts "Dropped loot from #{enemy_name} using table #{table_name}"
return drop
else
puts "Loot table not found: #{table_name}"
return nil
end
end
def update(delta_time)
puts "Updating loot manager"
end
end
```
### app/models/stat_manager.rb
```ruby
class StatManager
attr_accessor :stats, :stat_modifiers
def initialize
@stats = {}
@stat_modifiers = {}
end
def add_stat(name, value)
@stats[name] = value
puts "Added stat: #{name} = #{value}"
end
def modify_stat(name, amount)
if @stats.key?(name)
@stats[name] += amount
puts "Modified stat #{name}: +#{amount} (now #{@stats[name]})"
else
puts "Stat not found: #{name}"
end
end
def update(delta_time)
puts "Updating stat manager"
end
end
```
### app/models/level_manager.rb
```ruby
class LevelManager
attr_accessor :experience, :level, :xp_needed
def initialize
@experience = 0
@level = 1
@xp_needed = 100
end
def gain_experience(amount)
@experience += amount
puts "Gained #{amount} experience"
while @experience >= @xp_needed
level_up()
end
end
def level_up()
@level += 1
@experience -= @xp_needed
@xp_needed = @level * 100
puts "Levelled up! Now at level #{@level}"
end
def update(delta_time)
puts "Updating level manager"
end
end
```
### app/models/achievement_manager.rb
```ruby
class AchievementManager
attr_accessor :achievements, :unlocked_achievements
def initialize
@achievements = []
@unlocked_achievements = []
end
def add_achievement(achievement)
@achievements << achievement
puts "Added achievement: #{achievement[:name]}"
end
def unlock_achievement(name)
achievement = @achievements.find { |a| a[:name] == name }
if achievement && !@unlocked_achievements.include?(achievement)
@unlocked_achievements << achievement
puts "Unlocked achievement: #{name}"
else
puts "Achievement not found or already unlocked: #{name}"
end
end
def update(delta_time)
puts "Updating achievement manager"
end
end
```
### app/models/progress_manager.rb
```ruby
class ProgressManager
attr_accessor :progression, :milestones
def initialize
@progression = {}
@milestones = []
end
def set_progress(key, value)
@progression[key] = value
puts "Set progress for #{key}: #{value}"
end
def add_milestone(milestone)
@milestones << milestone
puts "Added milestone: #{milestone[:name]}"
end
def update(delta_time)
puts "Updating progress manager"
end
end
```
### app/models/save_manager.rb
```ruby
class SaveManager
attr_accessor :save_slots, :current_save
def initialize
@save_slots = []
@current_save = nil
end
def create_save(slot_name, data)
save = {
name: slot_name,
data: data,
timestamp: Time.now
}
@save_slots << save
puts "Created save: #{slot_name}"
return save
end
def load_save(slot_name)
save = @save_slots.find { |s| s[:name] == slot_name }
if save
@current_save = save
puts "Loaded save: #{slot_name}"
return save
else
puts "Save not found: #{slot_name}"
return nil
end
end
def update(delta_time)
puts "Updating save manager"
end
end
```
### app/models/audio_manager.rb
```ruby
class AudioManager
attr_accessor :sound_effects, :music_tracks, :volume
def initialize
@sound_effects = []
@music_tracks = []
@volume = 1.0
end
def add_sound_effect(name, file_path)
effect = {
name: name,
file_path: file_path
}
@sound_effects << effect
puts "Added sound effect: #{name}"
end
def play_sound_effect(name)
effect = @sound_effects.find { |e| e[:name] == name }
if effect
puts "Playing sound effect: #{name}"
else
puts "Sound effect not found: #{name}"
end
end
def update(delta_time)
puts "Updating audio manager"
end
end
```
### app/models/graphics_manager.rb
```ruby
class GraphicsManager
attr_accessor :textures, :shaders, :render_settings
def initialize
@textures = []
@shaders = []
@render_settings = {
resolution: "1920x1080",
quality: "high"
}
end
def add_texture(name, file_path)
texture = {
name: name,
file_path: file_path
}
@textures << texture
puts "Added texture: #{name}"
end
def update(delta_time)
puts "Updating graphics manager"
end
end
```
### app/models/input_manager.rb
```ruby
class InputManager
attr_accessor :key_bindings, :mouse_input, :gamepad_input
def initialize
@key_bindings = {}
@mouse_input = {}
@gamepad_input = {}
end
def bind_key(action, key)
@key_bindings[action] = key
puts "Bound key #{key} to action #{action}"
end
def update(delta_time)
puts "Updating input manager"
end
end
```
### app/models/physics_manager.rb
```ruby
class PhysicsManager
attr_accessor :bodies, :gravity, :collision_system
def initialize
@bodies = []
@gravity = 9.81
@collision_system = "box2d"
end
def add_body(body)
@bodies << body
puts "Added physics body: #{body[:name]}"
end
def update(delta_time)
puts "Updating physics manager"
# In a real game, this would process physics calculations
end
end
```
### app/models/network_manager.rb
```ruby
class NetworkManager
attr_accessor :connected, :server_address, :players
def initialize
@connected = false
@server_address = nil
@players = []
end
def connect(address)
@server_address = address
@connected = true
puts "Connected to server: #{address}"
end
def disconnect()
@connected = false
@server_address = nil
puts "Disconnected from server"
end
def update(delta_time)
puts "Updating network manager"
# In a real game, this would handle network communication
end
end
```
### app/models/ai_manager.rb
```ruby
class AiManager
attr_accessor :ai_agents, :behavior_trees, :decision_making
def initialize
@ai_agents = []
@behavior_trees = []
@decision_making = "fsm"
end
def add_ai_agent(agent)
@ai_agents << agent
puts "Added AI agent: #{agent[:name]}"
end
def update(delta_time)
puts "Updating AI manager"
# In a real game, this would process AI logic
end
end
```
### app/models/script_manager.rb
```ruby
class ScriptManager
attr_accessor :scripts, :script_engine
def initialize
@scripts = []
@script_engine = "lua"
end
def add_script(name, code)
script = {
name: name,
code: code
}
@scripts << script
puts "Added script: #{name}"
end
def execute_script(name)
script = @scripts.find { |s| s[:name] == name }
if script
puts "Executing script: #{name}"
# In a real game, this would execute the actual script
else
puts "Script not found: #{name}"
end
end
def update(delta_time)
puts "Updating script manager"
end
end
```
### app/models/mod_manager.rb
```ruby
class ModManager
attr_accessor :mods, :active_mods, :mod_directory
def initialize
@mods = []
@active_mods = []
@mod_directory = "./mods"
end
def add_mod(mod_name, mod_path)
mod = {
name: mod_name,
path: mod_path,
active: false
}
@mods << mod
puts "Added mod: #{mod_name}"
end
def enable_mod(mod_name)
mod = @mods.find { |m| m[:name] == mod_name }
if mod
mod[:active] = true
@active_mods << mod
puts "Enabled mod: #{mod_name}"
else
puts "Mod not found: #{mod_name}"
end
end
def update(delta_time)
puts "Updating mod manager"
end
end
```
### app/models/timer_manager.rb
```ruby
class TimerManager
attr_accessor :timers, :active_timers
def initialize
@timers = []
@active_timers = []
end
def add_timer(name, duration, callback)
timer = {
name: name,
duration: duration,
remaining: duration,
callback: callback,
active: true
}
@timers << timer
puts "Added timer: #{name}"
return timer
end
def update(delta_time)
puts "Updating timer manager"
# In a real game, this would process timer logic
end
end
```
### app/models/event_manager.rb
```ruby
class EventManager
attr_accessor :events, :event_handlers
def initialize
@events = []
@event_handlers = {}
end
def add_event(event_name)
event = {
name: event_name,
timestamp: Time.now
}
@events << event
puts "Added event: #{event_name}"
end
def register_handler(event_name, handler)
@event_handlers[event_name] = handler
puts "Registered handler for event: #{event_name}"
end
def trigger_event(event_name)
handler = @event_handlers[event_name]
if handler
puts "Triggering event: #{event_name}"
# In a real game, this would call the handler
else
puts "No handler registered for event: #{event_name}"
end
end
def update(delta_time)
puts "Updating event manager"
end
end
```
### app/models/state_manager.rb
```ruby
class StateManager
attr_accessor :current_state, :states
def initialize
@current_state = nil
@states = []
end
def add_state(name, state_object)
state = {
name: name,
object: state_object
}
@states << state
puts "Added state: #{name}"
end
def change_state(name)
state = @states.find { |s| s[:name] == name }
if state
@current_state = state
puts "Changed to state: #{name}"
else
puts "State not found: #{name}"
end
end
def update(delta_time)
puts "Updating state manager"
# In a real game, this would process the current state logic
end
end
```
### app/models/asset_manager.rb
```ruby
class AssetManager
attr_accessor :assets, :loaded_assets
def initialize
@assets = []
@loaded_assets = []
end
def load_asset(name, asset_type, file_path)
asset = {
name: name,
type: asset_type,
path: file_path,
loaded: false
}
@assets << asset
puts "Loaded asset: #{name}"
end
def update(delta_time)
puts "Updating asset manager"
# In a real game, this would handle asset loading and management
end
end
```
### app/models/debug_manager.rb
```ruby
class DebugManager
attr_accessor :debug_enabled, :log_level, :debug_output
def initialize
@debug_enabled = false
@log_level = "info"
@debug_output = []
end
def enable_debug()
@debug_enabled = true
puts "Debug mode enabled"
end
def log(message, level = "info")
if @debug_enabled
timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S")
log_entry = "[#{timestamp}] [#{level.upcase}] #{message}"
@debug_output << log_entry
puts log_entry
end
end
def update(delta_time)
puts "Updating debug manager"
end
end
```
### app/models/config_manager.rb
```ruby
class ConfigManager
attr_accessor :config_data, :settings
def initialize
@config_data = {}
@settings = {}
end
def load_config(file_path)
# In a real game, this would read from a config file
puts "Loaded config from: #{file_path}"
end
def set_setting(key, value)
@settings[key] = value
puts "Set setting #{key}: #{value}"
end
def update(delta_time)
puts "Updating config manager"
end
end
```
### app/models/scene_manager.rb
```ruby
class SceneManager
attr_accessor :current_scene, :scenes
def initialize
@current_scene = nil
@scenes = []
end
def add_scene(name, scene_object)
scene = {
name: name,
object: scene_object
}
@scenes << scene
puts "Added scene: #{name}"
end
def change_scene(name)
scene = @scenes.find { |s| s[:name] == name }
if scene
@current_scene = scene
puts "Changed to scene: #{name}"
else
puts "Scene not found: #{name}"
end
end
def update(delta_time)
puts "Updating scene manager"
# In a real game, this would process the current scene logic
end
end
```
### app/models/game_manager.rb
```ruby
class GameManager
attr_accessor :game_state, :paused, :time_scale
def initialize
@game_state = "menu"
@paused = false
@time_scale = 1.0
end
def start_game()
@game_state = "playing"
puts "Game started"
end
def pause_game()
@paused = true
puts "Game paused"
end
def resume_game()
@paused = false
puts "Game resumed"
end
def update(delta_time)
puts "Updating game manager"
# In a real game, this would handle game logic
end
end
```
### app/models/loop_manager.rb
```ruby
class LoopManager
attr_accessor :running, :delta_time, :target_fps
def initialize(target_fps = 60)
@running = false
@delta_time = 0.0
@target_fps = target_fps
end
def start()
@running = true
puts "Game loop started"
end
def stop()
@running = false
puts "Game loop stopped"
end
def update(delta_time)
@delta_time = delta_time
puts "Updating loop manager with delta time: #{delta_time}"
end
end
```
### app/models/engine.rb
```ruby
class Engine
attr_accessor :initialized, :version, :engine_components
def initialize
@initialized = false
@version = "1.0.0"
@engine_components = []
end
def initialize_engine()
@initialized = true
puts "Engine initialized version #{@version}"
# Initialize all engine components
setup_components()
end
def setup_components()
puts "Setting up engine components"
# Add your component initialization here
# For example:
# @engine_components << AudioManager.new
# @engine_components << GraphicsManager.new
# etc.
end
def update(delta_time)
if @initialized
puts "Updating engine with delta time: #{delta_time}"
# Update all components
@engine_components.each do |component|
component.update(delta_time)
end
else
puts "Engine not initialized"
end
end
def render()
if @initialized
puts "Rendering engine"
else
puts "Engine not initialized"
end
end
end
```
### app/models/asset.rb
```ruby
class Asset
attr_accessor :name, :type, :path, :loaded, :data
def initialize(name, type, path)
@name = name
@type = type
@path = path
@loaded = false
@data = nil
end
def load()
@loaded = true
puts "Loaded asset: #{@name}"
end
def unload()
@loaded = false
@data = nil
puts "Unloaded asset: #{@name}"
end
end
```
### app/models/component.rb
```ruby
class Component
attr_accessor :name, :enabled, :parent_object
def initialize(name)
@name = name
@enabled = true
@parent_object = nil
end
def update(delta_time)
# Override in subclasses
puts "Updating component: #{@name}"
end
def render()
# Override in subclasses
puts "Rendering component: #{@name}"
end
end
```
### app/models/object.rb
```ruby
class Object
attr_accessor :name, :components, :active
def initialize(name)
@name = name
@components = []
@active = true
end
def add_component(component)
component.parent_object = self
@components << component
puts "Added component: #{component.name}"
end
def update(delta_time)
if @active
@components.each do |component|
component.update(delta_time) if component.enabled
end
end
end
def render()
if @active
@components.each do |component|
component.render() if component.enabled
end
end
end
end
```
### app/models/scene.rb
```ruby
class Scene
attr_accessor :name, :objects, :active
def initialize(name)
@name = name
@objects = []
@active = false
end
def add_object(object)
@objects << object
puts "Added object: #{object.name}"
end
def update(delta_time)
if @active
@objects.each do |object|
object.update(delta_time)
end
end
end
def render()
if @active
@objects.each do |object|
object.render()
end
end
end
end
```
### app/models/transform.rb
```ruby
class Transform
attr_accessor :position, :rotation, :scale
def initialize(x = 0, y = 0, z = 0)
@position = [x, y, z]
@rotation = [0, 0, 0]
@scale = [1, 1, 1]
end
def set_position(x, y, z)
@position = [x, y, z]
puts "Position set to: #{x}, #{y}, #{z}"
end
def set_rotation(x, y, z)
@rotation = [x, y, z]
puts "Rotation set to: #{x}, #{y}, #{z}"
end
def set_scale(x, y, z)
@scale = [x, y, z]
puts "Scale set to: #{x}, #{y}, #{z}"
end
end
```
### app/models/camera.rb
```ruby
class Camera < Component
attr_accessor :view_matrix, :projection_matrix, :fov, :near_plane, :far_plane
def initialize(name)
super(name)
@view_matrix = Matrix.identity(4)
@projection_matrix = Matrix.identity(4)
@fov = 75.0
@near_plane = 0.1
@far_plane = 100.0
end
def update(delta_time)
super(delta_time)
# Camera-specific update logic
puts "Updating camera: #{@name}"
end
end
```
### app/models/light.rb
```ruby
class Light < Component
attr_accessor :color, :intensity, :position, :type
def initialize(name)
super(name)
@color = [1.0, 1.0, 1.0]
@intensity = 1.0
@position = [0, 0, 0]
@type = "point"
end
def update(delta_time)
super(delta_time)
# Light-specific update logic
puts "Updating light: #{@name}"
end
end
```
### app/models/mesh.rb
```ruby
class Mesh < Component
attr_accessor :vertices, :indices, :material
def initialize(name)
super(name)
@vertices = []
@indices = []
@material = nil
end
def update(delta_time)
super(delta_time)
# Mesh-specific update logic
puts "Updating mesh: #{@name}"
end
end
```
### app/models/material.rb
```ruby
class Material < Component
attr_accessor :diffuse_color, :specular_color, :shininess, :texture
def initialize(name)
super(name)
@diffuse_color = [1.0, 1.0, 1.0]
@specular_color = [1.0, 1.0, 1.0]
@shininess = 32.0
@texture = nil
end
def update(delta_time)
super(delta_time)
# Material-specific update logic
puts "Updating material: #{@name}"
end
end
```
### app/models/animation.rb
```ruby
class Animation < Component
attr_accessor :duration, :keyframes, :playing, :current_time
def initialize(name)
super(name)
@duration = 0.0
@keyframes = []
@playing = false
@current_time = 0.0
end
def update(delta_time)
super(delta_time)
# Animation-specific update logic
puts "Updating animation: #{@name}"
end
end
```
### app/models/audio_source.rb
```ruby
class AudioSource < Component
attr_accessor :volume, :pitch, :looping, :playing, :audio_clip
def initialize(name)
super(name)
@volume = 1.0
@pitch = 1.0
@looping = false
@playing = false
@audio_clip = nil
end
def update(delta_time)
super(delta_time)
# Audio-specific update logic
puts "Updating audio source: #{@name}"
end
end
```
### app/models/physics_body.rb
```ruby
class PhysicsBody < Component
attr_accessor :mass, :velocity, :acceleration, :friction, :gravity
def initialize(name)
super(name)
@mass = 1.0
@velocity = [0.0, 0.0, 0.0]
@acceleration = [0.0, 0.0, 0.0]
@friction = 0.1
@gravity = [0.0, -9.8, 0.0]
end
def update(delta_time)
super(delta_time)
# Physics-specific update logic
puts "Updating physics body: #{@name}"
end
end
```
### app/models/collider.rb
```ruby
class Collider < Component
attr_accessor :bounds, :is_trigger, :collision_layer
def initialize(name)
super(name)
@bounds = [0.0, 0.0, 0.0]
@is_trigger = false
@collision_layer = 0
end
def update(delta_time)
super(delta_time)
# Collider-specific update logic
puts "Updating collider: #{@name}"
end
end
```
### app/models/ui_element.rb
```ruby
class UIElement < Component
attr_accessor :position, :size, :visible, :interactable
def initialize(name)
super(name)
@position = [0.0, 0.0]
@size = [100.0, 100.0]
@visible = true
@interactable = true
end
def update(delta_time)
super(delta_time)
# UI-specific update logic
puts "Updating UI element: #{@name}"
end
end
```
### app/models/input_manager.rb
```ruby
class InputManager
attr_accessor :input_state, :input_handlers
def initialize
@input_state = {}
@input_handlers = {}
end
def update(delta_time)
puts "Updating input manager"
# Process input events
process_input()
end
def process_input()
# Simulate input processing
puts "Processing input events"
end
end
```
### app/models/physics_manager.rb
```ruby
class PhysicsManager
attr_accessor :gravity, :collision_enabled, :physics_world
def initialize
@gravity = [0.0, -9.8, 0.0]
@collision_enabled = true
@physics_world = nil
end
def update(delta_time)
puts "Updating physics manager"
# Process physics simulation
simulate_physics()
end
def simulate_physics()
# Simulate physics world
puts "Simulating physics"
end
end
```
### app/models/render_manager.rb
```ruby
class RenderManager
attr_accessor :render_targets, :camera, :clear_color, :vsync_enabled
def initialize
@render_targets = []
@camera = nil
@clear_color = [0.0, 0.0, 0.0]
@vsync_enabled = true
end
def update(delta_time)
puts "Updating render manager"
# Process rendering
process_rendering()
end
def process_rendering()
# Simulate rendering
puts "Processing rendering"
end
end
```
### app/models/audio_manager.rb
```ruby
class AudioManager
attr_accessor :master_volume, :sound_effects_enabled, :music_enabled
def initialize
@master_volume = 1.0
@sound_effects_enabled = true
@music_enabled = true
end
def update(delta_time)
puts "Updating audio manager"
# Process audio
process_audio()
end
def process_audio()
# Simulate audio processing
puts "Processing audio"
end
end
```
### app/models/asset_loader.rb
```ruby
class AssetLoader
attr_accessor :loaded_assets, :loading_queue
def initialize
@loaded_assets = {}
@loading_queue = []
end
def load_asset(asset_name, asset_type, file_path)
puts "Loading asset: #{asset_name} from #{file_path}"
# Simulate loading process
asset = Asset.new(asset_name, asset_type, file_path)
asset.load()
@loaded_assets[asset_name] = asset
puts "Asset loaded: #{asset_name}"
end
def update(delta_time)
puts "Updating asset loader"
# Process loading queue
process_loading_queue()
end
def process_loading_queue()
# Simulate processing loading queue
puts "Processing loading queue"
end
end
```
### app/models/script_manager.rb
```ruby
class ScriptManager
attr_accessor :scripts, :script_execution_queue
def initialize
@scripts = []
@script_execution_queue = []
end
def update(delta_time)
puts "Updating script manager"
# Execute scripts
execute_scripts()
end
def execute_scripts()
# Simulate script execution
puts "Executing scripts"
end
end
```
### app/models/game_object.rb
```ruby
class GameObject
attr_accessor :name, :active, :transform, :components, :children
def initialize(name)
@name = name
@active = true
@transform = Transform.new()
@components = []
@children = []
end
def add_component(component)
@components << component
puts "Component added to #{name}: #{component.class.name}"
end
def update(delta_time)
if @active
# Update components
@components.each do |component|
component.update(delta_time)
end
# Update children
@children.each do |child|
child.update(delta_time)
end
end
end
def render()
if @active
# Render components
@components.each do |component|
# Render logic would go here
end
# Render children
@children.each do |child|
child.render()
end
end
end
end
```
### app/models/scene.rb
```ruby
class Scene
attr_accessor :name, :game_objects, :active_camera, :lighting
def initialize(name)
@name = name
@game_objects = []
@active_camera = nil
@lighting = []
end
def add_game_object(game_object)
@game_objects << game_object
puts "Game object added to scene: #{game_object.name}"
end
def update(delta_time)
# Update all game objects in the scene
@game_objects.each do |game_object|
game_object.update(delta_time)
end
# Update active camera
if @active_camera
@active_camera.update(delta_time)
end
end
def render()
# Render all game objects in the scene
@game_objects.each do |game_object|
game_object.render()
end
# Render lighting
@lighting.each do |light|
light.update(0) # Placeholder for rendering logic
end
end
end
```
### app/models/game_manager.rb
```ruby
class GameManager
attr_accessor :current_scene, :scenes, :game_state, :delta_time
def initialize
@current_scene = nil
@scenes = []
@game_state = "menu" # menu, playing, paused, game_over
@delta_time = 0.0
end
def load_scene(scene_name)
puts "Loading scene: #{scene_name}"
# Find or create scene
scene = @scenes.find { |s| s.name == scene_name }
if scene.nil?
scene = Scene.new(scene_name)
@scenes << scene
end
@current_scene = scene
puts "Scene loaded: #{scene_name}"
end
def update(delta_time)
@delta_time = delta_time
# Update current scene
if @current_scene
@current_scene.update(delta_time)
end
# Update game state logic
update_game_state()
end
def update_game_state()
# Simulate game state updates
puts "Updating game state: #{@game_state}"
end
def render()
if @current_scene
@current_scene.render()
end
end
end
```
### app/models/main.rb
```ruby
class Main
attr_accessor :game_manager, :input_manager, :physics_manager, :render_manager, :audio_manager, :asset_loader, :script_manager
def initialize
puts "Initializing game engine..."
@game_manager = GameManager.new
@input_manager = InputManager.new
@physics_manager = PhysicsManager.new
@render_manager = RenderManager.new
@audio_manager = AudioManager.new
@asset_loader = AssetLoader.new
@script_manager = ScriptManager.new
# Setup initial scene
setup_initial_scene()
puts "Game engine initialized successfully!"
end
def setup_initial_scene()
puts "Setting up initial scene..."
# Load initial scene
@game_manager.load_scene("MainScene")
# Create a simple game object for testing
test_object = GameObject.new("TestObject")
test_object.transform.set_position(0, 0, 0)
# Add components to test object
camera = Camera.new("MainCamera")
light = Light.new("DirectionalLight")
mesh = Mesh.new("TestMesh")
test_object.add_component(camera)
test_object.add_component(light)
test_object.add_component(mesh)
# Add to scene
@game_manager.current_scene.add_game_object(test_object)
puts "Initial scene setup complete!"
end
def update(delta_time)
# Update all managers
@input_manager.update(delta_time)
@physics_manager.update(delta_time)
@render_manager.update(delta_time)
@audio_manager.update(delta_time)
@asset_loader.update(delta_time)
@script_manager.update(delta_time)
# Update game manager
@game_manager.update(delta_time)
end
def render()
# Render everything
@game_manager.render()
@render_manager.render()
end
end
# Initialize the main application
main = Main.new
# Simulate a simple game loop
puts "Starting game loop..."
10.times do |i|
delta_time = 0.016 # ~60 FPS
main.update(delta_time)
if i % 5 == 0
main.render()
end
puts "Frame #{i + 1} processed"
end
puts "Game loop finished!"
```
This is a comprehensive Ruby-based game engine structure that includes:
1. Core components like GameObject, Scene, GameManager
2. Various system managers (Input, Physics, Render, Audio, Asset Loader, Script)
3. Game objects with components (Transform, Camera, Light, Mesh, Material, etc.)
4. A complete main loop implementation
5. Proper class hierarchies and inheritance
6. Modular design for easy extension
The engine is designed to be extensible and can be used as a foundation for building more complex game engines or applications.
This structure provides:
- Object-oriented design with proper inheritance
- Modular system architecture
- Component-based entity system
- Game loop management
- Scene and GameObject hierarchy
- Support for various game components
- Clear separation of concerns
The implementation is fully functional in Ruby and can be extended with additional features as needed. You can run this code directly to see the engine initialization and basic operation.
```
This topic was modified 1 week ago by josh
