shirokuro 0.0.1

data/lib/shirokuro/ecs/game_object_manager.rb

@@ -0,0 +1,51 @@
+module SK
+	class GameObjectManager
+
+		attr_accessor :physics
+
+		def initialize
+			@id_generator = IdGenerator.new
+			@game_objects = []			
+			@started = false
+
+			@physics = Physics.new
+		end
+
+		def create name
+			id = @id_generator.next()
+			game_object = GameObject.new(name, id)
+			game_object.instance_variable_set(:@manager, self)
+			@game_objects << game_object
+			if @started
+				game_object.start
+			end
+			game_object
+		end
+
+		def remove game_object
+			@game_objects.delete game_object
+		end
+
+		def start
+			@game_objects.each{ |x| x.start }
+			@started = true
+		end
+
+		def update dt
+			@physics.update dt
+			@game_objects.each{ |x| x.update dt}
+		end
+
+		def draw context
+			components = @game_objects.collect{|obj| obj.components }
+				.flatten.collect{|c| c }
+				.sort_by{ |c|
+					[c.layer, c.order_in_layer]
+				}
+
+			components.each do |component|
+				component.draw context
+			end
+		end
+	end
+end

data/lib/shirokuro/ecs/id_generator.rb

@@ -0,0 +1,10 @@
+class IdGenerator
+
+	def initialize
+		@current = 0
+	end
+
+	def next
+		@current += 1
+	end
+end

data/lib/shirokuro/math/matrix.rb

@@ -0,0 +1,72 @@
+module SK
+	class Matrix
+
+		attr_accessor :values
+
+		def initialize values = []
+			@values = values
+		end
+
+		def self.identity
+			Matrix.new([
+				1.0, 0, 0, 0,
+				0, 1.0, 0, 0,
+				0, 0, 0, 0,
+				0, 0, 0, 0
+			])
+		end
+
+		def self.create_rotation angle
+			c = Math::cos(angle)
+			s = Math::sin(angle)
+
+			result = Matrix.new([
+				+c, +s, 0.0, 0.0,
+		        -s, +c, 0.0, 0.0,
+		        0.0,  0.0,  1.0, 0.0,
+		        0.0,  0.0,  0.0, 1.0
+			])
+		end
+
+		def self.create_translation(x, y)
+			Matrix.new([
+				1, 0, 0, 0,
+		        0, 1, 0, 0,
+		        0, 0, 1, 0,
+		        x, y, 0, 1
+		    ])
+		end
+
+		def self.create_scale x, y
+			Matrix.new([
+		        x, 0, 0, 0,
+		        0, y, 0, 0,
+		        0, 0, 1, 0,
+		        0, 0, 0, 1
+			])
+		end
+
+		def decompose
+			position = Vec2.new(@values[12], @values[13])
+			# tan^-1(2/3) = tan^-1(-1/0)
+			rotation = Math::tan(-1.0 * (@values[0] / @values[1]))
+			scale = Vec2.new(@values[0], @values[5])
+			transform = Transform.new
+			transform.position.x = position.x
+			transform.position.y = position.y
+			transform.rotation = rotation
+			transform
+		end
+
+		def * (right)
+			result = []
+			16.times do |i|
+				result[i] = 0;
+				4.times do |j|
+		        	result[i] += @values[i / 4 * 4 + j] * right.values[i % 4 + j * 4]
+		        end
+			end
+		    return Matrix.new(result)
+		end
+	end
+end

data/lib/shirokuro/math/transform.rb

@@ -0,0 +1,16 @@
+module SK
+	class Transform
+
+		attr_accessor :position, :rotation, :scale
+
+		def initialize
+			@position = Vec2.new
+			@scale = Vec2.new(1.0, 1.0)
+			@rotation = 0.0		
+		end
+
+#		def matrix
+#			Matrix.new(4, 4)
+#		end
+	end
+end

data/lib/shirokuro/math/vec2.rb

@@ -0,0 +1,38 @@
+module SK
+	class Vec2
+		attr_accessor :x, :y
+
+		def initialize x = 0.0, y = 0.0
+			@x = x
+			@y = y
+		end
+
+		def + other
+			if other.is_a?(Numeric)
+				return Vec2.new(@x + other, @y + other)
+			end
+			Vec2.new(@x + other.x, @y + other.y)
+		end
+
+		def - other
+			if other.is_a?(Numeric)
+				return Vec2.new(@x - other, @y - other)
+			end
+			Vec2.new(@x - other.x, @y - other.y)
+		end
+
+		def * other
+			if other.is_a?(Numeric)
+				return Vec2.new(@x * other, @y * other)
+			end
+			Vec2.new(@x * other.x, @y * other.y)
+		end
+
+		def / other
+			if other.is_a?(Numeric)
+				return Vec2.new(@x / other, @y / other)
+			end
+			Vec2.new(@x / other.x, @y / other.y)
+		end
+	end
+end

data/lib/shirokuro/physics/physics.rb

@@ -0,0 +1,22 @@
+module SK
+	class Physics
+
+		attr_reader :space
+
+		def initialize
+			@space = CP::Space.new
+			@space.gravity.y = 100.0
+			@simulation_substeps = 6
+		end
+
+		def update dt
+			@simulation_substeps.times do 
+				@space.step((1.0 / 30.0) / @simulation_substeps.to_f)
+			end
+
+			@space.instance_variable_get(:@bodies).each do |body|
+				body.reset_forces
+			end
+		end
+	end
+end

data/lib/shirokuro/standard_components/animations/animation.rb

@@ -0,0 +1,30 @@
+module SK
+	class Animation
+		def initialize frames, interval
+			@frames = frames
+			@interval = interval
+			@current = 0.0
+			@current_frame = 0
+		end
+
+		def frame
+			@frames[@current_frame]
+		end
+
+		def reset
+			@current = 0.0
+			@current_frame = 0
+		end
+		
+		def update dt
+			@current += dt
+			if @current > @interval
+				@current = 0.0
+				@current_frame += 1
+				if @current_frame > @frames.size - 1
+					reset
+				end
+			end
+		end
+	end
+end

data/lib/shirokuro/standard_components/animations/animation_component.rb

@@ -0,0 +1,28 @@
+module SK
+	class AnimationComponent < Component
+		
+		attr_accessor :animations, :current
+
+		def initialize animations
+			@animations = animations
+			@current = animations.keys.first
+		end
+
+		def set name
+			if name == @current
+				return
+			end
+			@current = name
+			@animations[@current].reset
+		end
+
+		def frame
+			@animations[@current].frame
+		end
+		
+		def update dt
+			@animations[@current].update dt
+		end
+		
+	end
+end

data/lib/shirokuro/standard_components/cameras/camera.rb

@@ -0,0 +1,59 @@
+module SK
+	class Camera < Component
+
+		attr_accessor :speed
+
+		def initialize screen_size
+			@screen_size = screen_size / 2.0
+			@target = Vec2.new
+			@speed = 0.05
+		end
+
+		def x
+			-transform.position.x + (@screen_size.x / 2.0)
+		end
+
+		def y
+			-transform.position.y + (@screen_size.y / 2.0)
+		end
+		
+		def move x, y
+			@target.x = x
+			@target.y = y
+		end
+
+		def move_by x, y
+			@target.x += x
+			@target.y += y
+		end
+
+		def zoom_by factor
+			transform.scale += factor
+		end
+
+		def set_zoom zoom
+			transform.scale.x = zoom
+			transform.scale.y = zoom
+		end
+
+		def lerp x, y, w
+			x + (y - x) * w
+		end
+
+		def update dt
+			# TODO: apply delta to smooth movement
+			transform.position.x = lerp(transform.position.x, @target.x, @speed)
+			transform.position.y = lerp(transform.position.y, @target.y, @speed)
+		end
+
+		def view window, &block
+			window.translate(@screen_size.x, @screen_size.y) do
+				window.scale(transform.scale.x, transform.scale.y) do		
+					window.translate(-transform.position.x, -transform.position.y) do
+						block.call()
+					end
+				end
+			end
+		end
+	end
+end

data/lib/shirokuro/standard_components/maps/map_component.rb

@@ -0,0 +1,10 @@
+module SK
+	class MapComponent < Component
+		
+		attr_accessor :map
+
+		def initialize map
+			@map = map
+		end
+	end
+end

data/lib/shirokuro/standard_components/physics/box_collider.rb

@@ -0,0 +1,40 @@
+module SK
+	class BoxCollider < Component
+
+		attr_accessor :width, :height, :friction, :restitution, :shape
+
+		def initialize width, height
+			@width = width
+			@height = height
+			@friction = 0.4
+			@restitution = 0.1
+		end
+		
+		def start
+			rigid_body = get_component(RigidBody)
+			
+			if rigid_body == nil
+				raise "RigidBody required for BoxCollider"
+			end
+
+			half_width = @width / 2.0
+			half_height = @height / 2.0
+			
+			vertices = [
+				CP::Vec2.new(-half_width, -half_height),
+				CP::Vec2.new(-half_width, half_height),
+				CP::Vec2.new(half_width, half_height),
+				CP::Vec2.new(half_width, -half_height)
+			]
+
+			@shape = CP::Shape::Poly.new(rigid_body.body, vertices, CP::Vec2.new(0, 0))
+			@shape.u = @friction
+			@shape.e = @restitution
+
+			# recalculate inertia
+			rigid_body.body.i = CP.moment_for_box(rigid_body.body.m, @width, @height)
+
+			physics.space.add_shape(@shape)
+		end
+	end
+end

data/lib/shirokuro/standard_components/physics/circle_collider.rb

@@ -0,0 +1,29 @@
+module SK
+	class CircleCollider < Component
+
+		attr_accessor :radius, :friction, :restitution, :shape
+
+		def initialize radius
+			@radius = radius
+			@friction = 0.4
+			@restitution = 0.1
+		end
+		
+		def start
+			rigid_body = get_component(RigidBody)
+			
+			if rigid_body == nil
+				raise "RigidBody required for BoxCollider"
+			end
+
+			@shape = CP::Shape::Circle.new(rigid_body.body, @radius, CP::Vec2.new(0, 0))
+			@shape.u = @friction
+			@shape.e = @restitution
+
+			# recalculate inertia
+			rigid_body.body.i = CP.moment_for_circle(rigid_body.body.m, @radius, @radius, CP::Vec2.new(0, 0))
+
+			physics.space.add_shape(@shape)
+		end
+	end
+end

data/lib/shirokuro/standard_components/physics/polygon_collider.rb

@@ -0,0 +1,35 @@
+module SK
+	class PolygonCollider < Component
+
+		attr_accessor :vertices, :friction, :restitution, :shape
+
+		def initialize vertices
+			@vertices = vertices
+			@friction = 0.4
+			@restitution = 0.1
+		end
+		
+		def start
+			rigid_body = get_component(RigidBody)
+			
+			if rigid_body == nil
+				raise "RigidBody required for BoxCollider"
+			end
+
+			unless CP::Shape::Poly.valid?(@vertices)
+				raise "Vertices does not form a valid polygon"
+			end
+
+			centroid = CP::centroid_for_poly(@vertices)
+
+			@shape = CP::Shape::Poly.new(rigid_body.body, vertices, centroid)
+			@shape.u = @friction
+			@shape.e = @restitution
+
+			# recalculate inertia
+			rigid_body.body.i = CP.moment_for_poly(rigid_body.body.m, @vertices, centroid)
+
+			physics.space.add_shape(@shape)
+		end
+	end
+end