yeah 0.2.2 → 0.3.3

data/lib/yeah/basic_physics.rb

@@ -1,11 +0,0 @@
-module Yeah::BasicPhysics
-  attr_writer :velocity
-
-  def velocity
-    @velocity ||= V[0, 0, 0]
-  end
-
-  def move
-    self.position += @velocity
-  end
-end

data/lib/yeah/desktop.rb

@@ -1,72 +0,0 @@
-require 'rubygame'
-
-# Bindings to the native desktop powered by Rubygame.
-class Yeah::Desktop
-  # @!attribute [r] screen
-  #   @return [Rubygame::Screen]
-  # @!attribute resolution
-  #   @return [Vector] size of game window
-  # @!attribute tickrate
-  #   @return [Integer] target ticks per second
-  attr_reader :screen, :resolution, :tickrate
-
-  def initialize(resolution=V[320, 180])
-    self.resolution = resolution
-
-    @clock = Rubygame::Clock.new
-    self.tickrate = 30
-
-    @pressables = {}
-    pressables_keys = [(:a..:z).to_a, (:A..:Z).to_a, (0..9).to_a,
-                       :up, :down, :left, :right].flatten
-    pressables_keys.each { |pk| @pressables[pk] = false }
-  end
-
-  def resolution=(value)
-    @screen = Rubygame::Screen.new(value.components[0..1])
-    @resolution = value
-  end
-
-  def tickrate=(value)
-    @clock.target_framerate = value
-    @tickrate = value
-  end
-
-  # Project a surface onto screen.
-  # @param [Surface]
-  def render(surface)
-    masks = [0x0000ff,  0x00ff00,  0xff0000, 0]
-    rg_surface = Rubygame::Surface.new(surface.size.to_a[0..1], masks: masks)
-    rg_surface.pixels = surface.data
-    rg_surface.blit(screen, [0, 0])
-    screen.update
-  end
-
-  # Execute passed block on each tick.
-  # @yield
-  def each_tick
-    loop do
-      yield
-      @clock.tick
-    end
-  end
-
-  # Press a key or button.
-  # @param [Symbol|Integer] key or button
-  def press(pressable)
-    @pressables[pressable] = true
-  end
-
-  # Release a key or button.
-  # @param [Symbol|Integer] key or button
-  def release(pressable)
-    @pressables[pressable] = false
-  end
-
-  # Is a key or button being pressed?
-  # @param [Symbol|Integer] key or button
-  def pressing?(*pressables)
-    raise ArgumentError if pressables.empty?
-    pressables.any? { |p| @pressables[p] }
-  end
-end

data/lib/yeah/entity.rb

@@ -1,137 +0,0 @@
-# Game object.
-class Yeah::Entity
-  # @!attribute position
-  #   @return [Vector] position within a game
-  # @!attribute size
-  #   @return [NilClass|Vector] visual size
-  # @!attribute state
-  #   @return [Symbol] state in game
-  # @!attribute visual
-  #   @return [Visual] visual representation within a game
-  # @!attribute game
-  #   @return [Game] game to which this belongs to
-  attr_accessor :position, :state, :visual
-  attr_reader :game
-  attr_writer :size
-
-  def initialize(position=V[])
-    @position = position
-  end
-
-  class << self
-    def define_position_helpers
-      %w(x y z).each_with_index do |coord, i|
-        define_method(coord) { @position[i] }
-        define_method("#{coord}=") { |val| @position[i] = val }
-      end
-    end
-  end
-
-  def size
-    @size || visual && visual.size || V[]
-  end
-
-  def game=(value)
-    @game = value
-    @game.entities << self unless @game.entities.include? self
-  end
-
-  # @!attribute x
-  #   @return [Vector] position.x
-  # @!attribute y
-  #   @return [Vector] position.y
-  # @!attribute z
-  #   @return [Vector] position.z
-  define_position_helpers
-
-  # Update entity.
-  def update
-  end
-
-  # Get visual representation from visual.
-  #   @return [Surface] visual representation
-  def draw
-    visual.draw if visual
-  end
-
-  def pressing?(pressable)
-    game.pressing? pressable
-  end
-
-  def control(attrName, input, value)
-    if input.class == Array
-      polarity = 0
-      polarity += 1 if game.platform.pressing?(input.first)
-      polarity -= 1 if game.platform.pressing?(input.last)
-    else
-      polarity = game.platform.pressing?(input) ? 1 : -1
-    end
-
-    self.instance_eval("#{attrName} += #{value} * #{polarity}")
-  end
-
-  # X of right edge.
-  #   @return [Integer]
-  def right
-    position.x + size.x
-  end
-
-  # X of left edge.
-  #   @return [Integer]
-  def left
-    position.x
-  end
-
-  # Y of top edge.
-  #   @return [Integer]
-  def top
-    position.y + size.y
-  end
-
-  # Y of bottom edge.
-  #   @return [Integer]
-  def bottom
-    position.y
-  end
-
-  # Z of front edge.
-  #   @return [Integer]
-  def front
-    position.z + size.z
-  end
-
-  # Z of back edge.
-  #   @return [Integer]
-  def back
-    position.z
-  end
-
-  # Coordinate of center.
-  #   @return [Vector]
-  def center
-    position + size / 2
-  end
-
-  # Is intersected with other entity or entity of subclass?
-  #   @return [Boolean]
-  def touching?(other)
-    return false if other == self
-
-    if other.is_a?(Class)
-      if game
-        return game.entities.select { |e| e.is_a? other }
-                            .any? { |e| touching? e }
-      else
-        return false
-      end
-    end
-
-    return false if size == V[] || other.size == V[]
-
-    not_touching_x = left > other.right || right < other.left
-    not_touching_y = bottom > other.top || top < other.bottom
-    not_touching_z = back > other.front || front < other.back
-
-    !(not_touching_x && not_touching_y && not_touching_z)
-  end
-end

data/lib/yeah/map.rb

@@ -1,40 +0,0 @@
-# A map of entities for a Game.
-class Yeah::Map
-  # @!attribute background
-  #   @return [Color] background color
-  # @!attribute key
-  #   @return [Hash] tile key
-  # @!attribute tile_size
-  #   @return [Vector] size of each character in #tiles
-  # @!attribute tiles
-  #   @return [Array<String>] entities at relative positions
-  attr_accessor :background, :key, :tile_size, :tiles
-
-  def self.background(background)
-    @@background = background
-  end
-
-  def self.key(key)
-    @@key = key
-  end
-
-  def self.tile_size(tile_size)
-    @@tile_size = tile_size
-  end
-
-  def self.tiles(tiles)
-    @@tiles = tiles
-  end
-
-  def initialize
-    @background = @@background || Color[]
-    @key = @@key ||= {}
-    @tile_size = @@tile_size ||= nil
-    @tiles = @@tiles ||= []
-  end
-
-  def key=(key)
-    @key = key
-    self.tile_size = @key.first.last.new.size if @key.first && tile_size.nil?
-  end
-end

data/lib/yeah/rectangle.rb

@@ -1,21 +0,0 @@
-# Colored rectangle Visual.
-class Yeah::Rectangle
-  # @!attribute size
-  #   @return [Vector]
-  # @!attribute color
-  #   @return [Color]
-  attr_accessor :size, :color
-
-  def initialize(size=V[], color=Color[*[255]*4])
-    @size = size
-    @color = color
-  end
-
-  # Surface representation.
-  # @return [Surface]
-  def draw
-    surface = Surface.new(size)
-    surface.fill(color)
-    surface
-  end
-end

data/lib/yeah/surface.rb

@@ -1,66 +0,0 @@
-# Rectangular pixel data.
-class Yeah::Surface
-  # @!attribute size
-  #   @return [Vector]
-  # @!attribute data
-  #   @param [Symbol] color byte order (:rgba or :bgra)
-  #   @return [String] pixel data as string of bytes
-  attr_reader :size
-  attr_accessor :data
-
-  def initialize(size=V[])
-    self.size = size
-  end
-
-  def size=(value)
-    @size = value
-    @data = "\x00" * 4 * size.x * size.y
-  end
-
-  # Color of pixel at a position.
-  # @param [Vector] position of pixel
-  # @return [Color]
-  def color_at(position)
-    data_lines = data.scan(/.{#{size.x*4}}/)
-    line = data_lines[position.y]
-    color_string = line[position.x*4..position.x*4+3]
-    color_bytes = color_string.unpack('H*')[0].
-      scan(/.{2}/).map { |b| b.to_i(16) }
-    Color[*color_bytes]
-  end
-
-  # Fill a rectangular area with a color.
-  # @param [Color] fill color
-  # @param [Vector] position of first corner
-  # @param [Vector] position of other corner
-  def fill(color, position1=V[0, 0], position2=size-1)
-    color_byte_string = color.rgba_bytes.pack('C*')
-    data_lines = data.scan(/.{#{size.x*4}}/)
-
-    rect_width = (position2.x - position1.x).abs + 1
-    (position1.y..position2.y).each do |i|
-      line = data_lines[i]
-      color_bytes_row = color_byte_string * rect_width
-      line[position1.x*4...(position2.x+1)*4] = color_bytes_row
-    end
-
-    @data = data_lines.join
-  end
-
-  # Draw onto other surface.
-  # @param [Surface] surface to draw on
-  # @param [Vector] position to draw on other surface
-  def draw(surface, position=V[0, 0])
-    data_lines = data.scan(/.{#{size.x*4}}/)
-    surface_data_lines = surface.data.scan(/.{#{surface.size.x*4}}/)
-
-    (position.y...position.y+surface.size.height).each_with_index do |y, i|
-      line = data_lines[y]
-      surface_line = surface_data_lines[i]
-
-      line[position.x*4...(position.x+surface.size.width)*4] = surface_line
-    end
-
-    @data = data_lines.join
-  end
-end