slickr 0.0.1 → 0.0.2

data/lib/slickr/generators/base.rb

@@ -0,0 +1,95 @@
+module Slickr
+  module Generators
+    class Base
+      attr_accessor :name
+      attr_accessor :destination
+
+      def initialize(name)
+        @name = name
+        @destination = Pathname.new(Dir.pwd)
+      end
+
+      # Create an empty directory at +path+ inside the project.
+      #
+      # @param path [String] Path in the project to create the directory.
+      #
+      # @example
+      #   empty_directory "lib"
+      #
+      def empty_directory(path)
+        destination.join(with_correct_path_seperator(path)).mkpath
+      end
+
+      # Copy a file from ROOT/files to somewhere in the project
+      # directory.
+      #
+      # This does not render anything, it's just a simple +cp+.
+      #
+      # @param filename [String] Name of the source file located in ROOT/files
+      # @param path [String] Path to place the file in the project
+      #
+      # @example Place file in the root of the project
+      #   copy_file "Rakefile"
+      #
+      # @example Place file somewhere nested in the project
+      #   copy_file "jinput.jar", "java"
+      #   # => Creates PROJECT/java/jinput.jar
+      #
+      def copy_file(filename, path="")
+        source = root.join("files", filename)
+        dest   = destination.join(path, filename)
+        FileUtils.cp(source, dest)
+      end
+
+      # Render an erb template at a specific path within
+      # the project.
+      #
+      # Renders ERB in the context of the class calling this method.
+      # Meaning you'll need to make whatever variables you want in your template
+      # available within the class. See Actions::Create, +name+ is an accessor
+      # and used in the template.
+      #
+      # @param filename [String] Name of the erb template living in ROOT/templates
+      # @param path [String] Path in the project to write the resulting file
+      #
+      # @example
+      #   template "application.erb", "app/application.rb"
+      #
+      def template(filename, path)
+        file = lib_file(with_correct_path_seperator(path))
+        file.dirname.mkpath
+        file.open("w+") { |f| f << render(template_root(filename)) }
+      end
+
+    private
+
+      # Root of this gem, where the source files live.
+      #
+      def root
+        @root ||= Pathname.new(__FILE__).dirname.expand_path
+      end
+
+      # Normalizes file paths per OS.
+      #
+      # You can just use "/" in your calls to Util methods
+      # and it will update paths to whatever the OS actually
+      # uses.
+      #
+      def with_correct_path_seperator(path)
+        path.gsub("/", File::SEPARATOR)
+      end
+
+      def lib_file(filename)
+        destination.join(filename)
+      end
+
+      def render(source)
+        ERB.new(source).result(binding)
+      end
+
+      def template_root(filename)
+        root.join("templates", filename).read
+      end
+    end
+  end
+end

data/lib/slickr/generators/behavior.rb

@@ -0,0 +1,9 @@
+module Slickr
+  module Generators
+    class Behavior < Base
+      def start
+        template "behavior.erb", "lib/behaviors/#{name}.rb"
+      end
+    end
+  end
+end

data/lib/slickr/generators/entity.rb

@@ -0,0 +1,10 @@
+module Slickr
+  module Generators
+    class Entity < Base
+      def start
+        template "entity.erb", "lib/entities/#{name}.rb"
+        Renderer.new(name.gsub("entity", "renderer")).start
+      end
+    end
+  end
+end

data/lib/slickr/generators/project.rb

@@ -0,0 +1,36 @@
+module Slickr
+  module Generators
+    class Project < Base
+      def initialize(name)
+        super(name)
+        @destination = @destination.join(name)
+      end
+
+      def start
+        empty_directory "java"
+        empty_directory "assets"
+        empty_directory "lib"
+        empty_directory "lib/renderers"
+        empty_directory "lib/behaviors"
+        empty_directory "lib/reactors"
+        empty_directory "lib/entities"
+
+        copy_file "jinput.jar", "java"
+        copy_file "lwjgl.jar", "java"
+        copy_file "slick.jar", "java"
+
+        copy_file "libjinput-osx.jnilib"
+        copy_file "liblwjgl.jnilib"
+        copy_file "openal.dylib"
+
+        copy_file "Rakefile"
+
+        template "engine.erb", "lib/engine.rb"
+        template "behaviors.erb", "lib/behaviors.rb"
+        template "renderers.erb", "lib/renderers.rb"
+        template "reactors.erb", "lib/reactors.rb"
+        template "entities.erb", "lib/entities.rb"
+      end
+    end
+  end
+end

data/lib/slickr/generators/reactor.rb

@@ -0,0 +1,9 @@
+module Slickr
+  module Generators
+    class Reactor < Base
+      def start
+        template "reactor.erb", "lib/reactors/#{name}.rb"
+      end
+    end
+  end
+end

data/lib/slickr/generators/renderer.rb

@@ -0,0 +1,9 @@
+module Slickr
+  module Generators
+    class Renderer < Base
+      def start
+        template "renderer.erb", "lib/renderers/#{name}.rb"
+      end
+    end
+  end
+end

data/lib/slickr/generators/templates/behavior.erb

@@ -0,0 +1,3 @@
+module <%= name.classify %>
+  include Slickr::Behavior
+end

data/lib/slickr/generators/templates/behaviors.erb

@@ -0,0 +1 @@
+# require "behaviors/..."

data/{templates → lib/slickr/generators/templates}/engine.erb

@@ -3,6 +3,12 @@ require "java"
 require "lwjgl.jar"
 require "slick.jar"
 
+$LOAD_PATH << File.expand_path("../../lib", __FILE__)
+require "behaviors"
+require "entities"
+require "renderers"
+require "reactors"
+
 java_import org.newdawn.slick.AppGameContainer
 java_import org.newdawn.slick.BasicGame
 java_import org.newdawn.slick.Color
@@ -11,20 +17,18 @@ java_import org.newdawn.slick.Graphics
 java_import org.newdawn.slick.Image
 java_import org.newdawn.slick.Input
 
-module <%= module_name %>
-  class Engine < BasicGame
-    def init(container)
-    end
+class Engine < BasicGame
+  def init(container)
+  end
 
-    def update(container, delta)
-    end
+  def update(container, delta)
+  end
 
-    def render(container, graphics)
-    end
+  def render(container, graphics)
   end
 end
 
-game = AppGameContainer.new(<%= module_name %>::Engine.new("<%= name %>"))
+game = AppGameContainer.new(Engine.new("<%= name %>"))
 game.set_display_mode(800, 600, false)
 game.start
 

data/lib/slickr/generators/templates/entities.erb

@@ -0,0 +1 @@
+# require "entities/..."

data/lib/slickr/generators/templates/entity.erb

@@ -0,0 +1,2 @@
+class <%= name.classify %> < Slickr::Entity
+end

data/lib/slickr/generators/templates/reactor.erb

@@ -0,0 +1,4 @@
+class <%= name.classify %> < Slickr::Reactor
+  def call(container, delta)
+  end
+end

data/lib/slickr/generators/templates/reactors.erb

@@ -0,0 +1 @@
+# require "reactors/..."

data/lib/slickr/generators/templates/renderer.erb

@@ -0,0 +1,4 @@
+class <%= name.classify %> < Slickr::Renderer
+  def render
+  end
+end

data/lib/slickr/generators/templates/renderers.erb

@@ -0,0 +1 @@
+# require "renderers/..."

data/lib/slickr/reactor.rb

@@ -0,0 +1,86 @@
+module Slickr
+  # Reactors take info about the game world and tell relevant
+  # entities to do something. Emphasis is on the word "tell".
+  #
+  # == Concerns
+  #
+  # Reactors are always concerned with entities who implement
+  # one or more specific behaviors. For instance, an # +InputReactor+
+  # would care about entities who implement the +Controllable+
+  # behavior.
+  #
+  # @example
+  #
+  #   class InputReactor < Slickr::Reactors
+  #     concerned_with :controllable
+  #   end
+  #
+  # == Using Ractors
+  #
+  # Reactors are middleware of your game's Engine. They are called
+  # during every +update+ tick of your game. They are passed the
+  # game's +container+ and the +delta+ of time that has passed since 
+  # the last tick.
+  #
+  # @example
+  #
+  #   class Engine < BasicGame
+  #     use InputReactor
+  #   end
+  #
+  # if you need to do some special setup in your Reactors, do it
+  # in the initializer like any normal ruby object.
+  #
+  # @example
+  #
+  #   class Engine < BasicGame
+  #     use InputReactor.new(:ignore => :up)
+  #   end
+  #
+  # == Reacting
+  #
+  # Reactors simply orcestrate. They take that delta and tell the
+  # entities they care about to do something. Following the above
+  # example, here's a simple Reactor that moves entities around
+  # the world.
+  #
+  # @example
+  #
+  #   class InputReactor < Slickr::Reactor
+  #     concerned_with :controllable
+  #
+  #     def call(container, delta)
+  #       entities.each do |entity|
+  #         entity.up(delta)    if input.is_key_down?(Input::KEY_UP)
+  #         entity.down(delta)  if input.is_key_down?(Input::KEY_DOWN)
+  #         entity.right(delta) if input.is_key_down?(Input::KEY_RIGHT)
+  #         entity.left(delta)  if input.is_key_down?(Input::KEY_LEFT)
+  #       end
+  #     end
+  #   end
+  #
+  class Reactor
+    class << self
+      attr_accessor :concerns
+    end
+
+    def self.concerned_with(*behaviors)
+      @concerns ||= []
+      @concerns += behaviors
+    end
+
+    def call(*args)
+      raise NotImplementedError
+    end
+
+    def entities
+      EntityManager.entities_with(*concerns)
+    end
+
+    private
+
+    def concerns
+      self.class.concerns
+    end
+  end
+end

data/lib/slickr/renderer.rb

@@ -0,0 +1,37 @@
+module Slickr
+  # Renderers take the current state of an entity and draws it to
+  # the screen.
+  #
+  # @example Simple renderer that draws a graphic on the screen
+  #
+  #   class HeroRenderer < Slickr::Renderer
+  #     attr_reader :image
+  #
+  #     def initialize(entity)
+  #       super
+  #       @image = Image.new("assets/hero.png", false)
+  #     end
+  #
+  #     def render
+  #       image.draw(entity.x, entity.y)
+  #     end
+  #   end
+  #
+  # == Never Mutate Entities
+  #
+  # Renderers should know as little as possible about the entity it's
+  # drawing. They should also never, ever, mutate an entity. They only 
+  # request information and push a representation of that to the screen.
+  #
+  class Renderer
+    attr_reader :entity
+
+    def initialize(entity)
+      @entity = entity
+    end
+
+    def render
+      raise NotImplementedError
+    end
+  end
+end

data/lib/slickr/tasks.rb

@@ -4,9 +4,7 @@ module Slickr
 
     def self.all
       desc "Play the game"
-      task :play do
-        sh "ruby -I./lib lib/engine.rb"
-      end
+      task(:play) { sh "ruby -I./lib lib/engine.rb" }
     end
   end
 end

data/lib/slickr/version.rb

@@ -1,3 +1,3 @@
 module Slickr
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/slickr.gemspec

@@ -23,7 +23,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "debugger"
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "fakefs"
 end

data/spec/slickr/actions/generate_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe Slickr::Actions::Generate do
+  it "finds the generator class from its lowercase name" do
+    action = described_class.new("behavior", "spatiality")
+    action.generator_class.should == Slickr::Generators::Behavior
+  end
+
+  it "finds the generator class from its Capitalized name" do
+    action = described_class.new("Behavior", "spatiality")
+    action.generator_class.should == Slickr::Generators::Behavior
+  end
+
+  it "finds the generator class from its ALL CAPS name" do
+    action = described_class.new("BEHAVIOR", "spatiality")
+    action.generator_class.should == Slickr::Generators::Behavior
+  end
+
+  it "finds the generator class from its FuCkEdUpCaSe name" do
+    action = described_class.new("BeHaViOr", "spatiality")
+    action.generator_class.should == Slickr::Generators::Behavior
+  end
+
+  it "adds the object type to its name" do
+    action = described_class.new("behavior", "spatiality")
+    action.name.should == "spatiality_behavior"
+  end
+
+  it "does not change the name when its already in the correct form" do
+    action = described_class.new("behavior", "spatiality_behavior")
+    action.name.should == "spatiality_behavior"
+  end
+
+  it "does nothing to the name is in class form" do
+    action = described_class.new("behavior", "SpatialityBehavior")
+    action.name.should == "spatiality_behavior"
+  end
+end