slickr 0.0.1 → 0.0.2

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ODRmY2E3NWEwZjg0YTc1Y2QwZDlkYTExZGNmMWZlMmQxMDEyMjJkNg==
-  data.tar.gz: !binary |-
-    ZjVmZWI5MTU5ZWNhOGRmZTNmM2NlYjNlNWE4MjViNjkyMDNiZTZhYQ==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    ZGRkMzg4NGE3MTE1OTkyNzk1MDkxMDk5MjViNTdiYzU5ODliMDUyYTZhMDk4
-    YTVmMWNkNTgxZjlhOWQ3NDAyYzIwYWJkMjJmYWI0ODlmMzM2ZmU4NmJiYTI5
-    YjZjYjQ5NWNjM2RmZWM4ZTZiMjY0ZjY1MTllNGFiZTI1MjRlNTI=
-  data.tar.gz: !binary |-
-    YzQ4MWI3YTE3YzZkZmJjMzMwOTY4NzFkMzUyMzk5Zjg4NmVkNDQ1MDRlNzg2
-    OTc2OWE4NWVjODg1MWZkOTJmMmE2MDg0NmFhMzRhMWYwZTkzZDdkNzM2MWNk
-    NWFmMGY0YzFiYmY5Y2ZhYjU4M2UxZmViY2YzMDY4OTIzZTUyODM=
+SHA1:
+  metadata.gz: 7593e388d74d18775d44ce56aac159b23a9e93ad
+  data.tar.gz: 05a5b28e4c555ec670421a490e6dda4c54413eb5
+SHA512:
+  metadata.gz: 870175e5c09cea5de268086d2cc3e643f64193b947c26dd2d5c378e7660ecd20ffc42dc4fb0ea7493ca60c4a211ad88a4cf3b81cce853288502ce903e342ff1a
+  data.tar.gz: e0e2781159242322ad0be3ce13a439f8e32df97a6739a5aa7ee7d4f5a655a92386603013a5b933cf4e16782b261365a024a8b9c33a11c757d024eafffb51a472

data/.rspec

@@ -1,3 +1,2 @@
 --color
 --format progress
--d

data/.travis.yml

@@ -0,0 +1,4 @@
+rvm:
+  - "1.9.2"
+  - "1.9.3"
+  - jruby-19mode

data/Gemfile

@@ -1,4 +1,2 @@
 source 'https://rubygems.org'
-
-# Specify your gem's dependencies in slickj.gemspec
 gemspec

data/README.md

@@ -1,18 +1,49 @@
-# slickr
+# Welcome to Slickr
+[![Build Status](https://travis-ci.org/mnoble/slickr.png?branch=master)](https://travis-ci.org/mnoble/slickr)
+[![Code Climate](https://codeclimate.com/github/mnoble/slickr.png)](https://codeclimate.com/github/mnoble/slickr)
 
-JRuby Slick2D project generators.
+Slickr is a JRuby, Slick2D, project framework.
 
-## Overview
+Slickr tries to merge concepts from Entity-Component and good old
+fashion Object Oriented Design. Ruby gives you a lot of power to
+write great code and Slickr tries to help you do that, while developing
+games.
 
-The project Slickr sets up is an attempt to merge concepts from
-Entity-Component and just plain old OOP best practices. Ruby gives you 
-a lot of power to write great code and Slickr tries to set you up to do 
-that well.
+"Slick2D is an easy to use set of tools and utilities wrapped around
+LWJGL OpenGL bindings to make 2D Java game development easier." —
+[http://www.slick2d.org/wiki/index.php/Main_Page](http://www.slick2d.org/wiki/index.php/Main_Page)
 
-Keep things simple. Components should have no knowledge of the Entities
-that will implement them; Systems should not care about what type of
-Entity they're acting on. Basically, watch or read anything Sandi Metz
-says and follow it.
+## Getting Started
+
+1\. Install Slickr
+
+```
+$ gem install slickr
+```
+
+2\. Create a new Slickr game
+
+```
+$ slickr new my_game
+```
+
+where "my_game" is the name of the game.
+
+3\. Change directory to `my_game` and play it
+
+```
+$ cd my_game
+$ rake play
+```
+
+You should see a Window with nothing but a white background and some FPS
+information.
+
+## Generating New Code
+
+```
+$ slickr generate [component|entity|renderer|system] NAME
+```
 
 ## Project Structure
 
@@ -22,62 +53,37 @@ says and follow it.
     │   ├── jinput.jar
     │   ├── lwjgl.jar
     │   └── slick.jar
-    ├── lib
-    │   ├── components
-    │   ├── components.rb
+    ├── lib/
+    │   ├── behaviors/
+    │   ├── behaviors.rb
     │   ├── engine.rb
-    │   ├── entities
+    │   ├── entities/
     │   ├── entities.rb
-    │   ├── renderers
+    │   ├── renderers/
     │   ├── renderers.rb
-    │   ├── systems
-    │   └── systems.rb
+    │   ├── reactors/
+    │   └── reactors.rb
     ├── libjinput-osx.jnilib
     ├── liblwjgl.jnilib
     └── openal.dylib
 
-### assets
-
+**assets/**<br/>
 Images, sounds, videos, etc.
 
-### java
-
+**java/**<br/>
 Slick2D framework jars.
 
-### lib
-
-Your game code.
-
-### lib/components
-
-Behaviors that entities will include. These are modules that implement
-whatever behavior the entity should have. A common example will be a
-`Spatial` component that implements `x` and `y` position and movement.
-
-### lib/entities
-
-The actual objects that live your game's world. Entities will implement
-Components and Systems conduct Entities. These will be your Heros,
-Enemies, Bosses, etc.
+**lib/behaviors/**<br/>
+Behaviors that entities will include.
 
-### lib/renderers
+**lib/entities/**<br/>
+The actual objects that live your game's world.
 
+**lib/renderers/**<br/>
 Draws the current state of entities to the screen.
 
-### lib/systems
-
-Systems react to changes in the world and update entitites accordingly.
-View these as controllers of sorts. A good example of this is an `Input`
-system. It would react to keyboard events and tell the appropriate
-entities where to move.
-
-## Installation
-
-    $ gem install slickr
-
-## Usage
-
-    $ slickr new PROJECT_NAME
+**lib/reactors/**<br/>
+Reactors take changes in the world and updates entitites accordingly.
 
 ## Contributing
 

data/Rakefile

@@ -1 +1,5 @@
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/lib/slickr.rb

@@ -2,6 +2,23 @@ require "fileutils"
 require "pathname"
 require "thor"
 require "active_support/all"
+
 require "slickr/version"
+require "slickr/actions/generate"
+require "slickr/generators/base"
+require "slickr/generators/project"
+require "slickr/generators/behavior"
+require "slickr/generators/entity"
+require "slickr/generators/renderer"
+require "slickr/generators/reactor"
+require "slickr/entity_manager"
+require "slickr/entity"
+require "slickr/behavior"
+require "slickr/reactor"
+require "slickr/renderer"
 require "slickr/cli"
-require "slickr/actions/create"
+
+module Slickr
+  class SlickrError < StandardError; end
+  class NotImplementedError < SlickrError; end
+end

data/lib/slickr/actions/generate.rb

@@ -0,0 +1,51 @@
+module Slickr
+  module Actions
+    # Adapter for calling the different types of Generators.
+    #
+    # This class takes the name of the generator, in any form, and
+    # the name the user wants to give to the new piece of code. It
+    # will normalize both to follow Slickr conventions.
+    #
+    # == Naming Conventions
+    #
+    # Slickr follows the same sort of conventions as Rails. Classes
+    # are appended with their type. Eg. a "spatiality" behavior will
+    # become +SpatialityBehavior+, a "hero" renderer will become
+    # +HeroRenderer+, etc.
+    #
+    # @example Generating a new behavior
+    #   Slickr::Actions::Generate.new("behavior", "spatiality").start
+    #   # => lib/behaviors/spatiality_behavior.rb
+    #
+    # @example Generating a new behavior by specifying the full name
+    #   Slickr::Actions::Generate.new("behavior", "spatiality_behavior").start
+    #   # => lib/behaviors/spatiality_behavior.rb
+    #
+    # @example Generating a new behavior by specifying the name in class form
+    #   Slickr::Actions::Generate.new("behavior", "SpatialityBehavior").start
+    #   # => lib/behaviors/spatiality_behavior.rb
+    #
+    class Generate
+      def initialize(type, name)
+        @type = type
+        @name = name
+      end
+
+      def start
+        generator_class.new(name).start
+      end
+
+      def generator_class
+        Slickr::Generators.const_get(:"#{@type.capitalize}")
+      end
+
+      def name
+        "#{basename}_#{@type}".squeeze("_")
+      end
+
+      def basename
+        @name.gsub(/#{@type}/i, "").downcase
+      end
+    end
+  end
+end

data/lib/slickr/behavior.rb

@@ -0,0 +1,68 @@
+module Slickr
+  # Behaviors give entities the ability to do things. They should
+  # implement the logic to move around the world, detect collision,
+  # etc.
+  #
+  # A behavior should not care about what entities use it. It should
+  # specify all the attribute and methods relevant to what it does.
+  #
+  #    module Spatiality
+  #      include Slickr::Behavior
+  #
+  #      attr_access :x, :y, :speed
+  #
+  #      def prepare(options={})
+  #        @x = options.fetch(:x, 0)
+  #        @y = options.fetch(:y, 0)
+  #        @speed = options.fetch(:speed, 0)
+  #      end
+  #
+  #      def up(delta)
+  #        self.y -= speed * delta
+  #      end
+  #
+  #      def down(delta)
+  #        self.y += speed * delta
+  #      end
+  #
+  #      def left(delta)
+  #        self.x -= speed * delta
+  #      end
+  #
+  #      def right(delta)
+  #        self.x += speed * delta
+  #      end
+  #    end
+  #
+  # == Preparing
+  #
+  # since behaviors are modules that get mixed into entities, we can't
+  # use the normal +initialize+ to set defaults. Instead, Slickr uses
+  # a convention of the +prepare+ method.
+  #
+  # When you specify an entity should implement some behavior, it's 
+  # pushed into the entity's behavior stack. When that entity is
+  # instantiated, it will run through all of its behaviors and
+  # +prepare+ each one with the options specified in the entity.
+  #
+  #   class Hero < Slickr::Entity
+  #     use Spatiality, x: 10, y: 10, speed: 0.2
+  #   end
+  #
+  #   hero = Hero.new
+  #   hero.x #=> 10
+  #   hero.y #=> 10
+  #   hero.speed #=> 0.2
+  #
+  # == Don't Clobber Behavior Attributes
+  #
+  # Use good OO common-sense here. Don't create multiple behaviors that
+  # all depend on attributes of the same name. Behaviors should be 
+  # independent of one another.
+  #
+  module Behavior
+    def prepare(*args)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/slickr/cli.rb

@@ -1,9 +1,18 @@
 module Slickr
   class CLI < Thor
-    desc "new NAME", "Create a new jruby slick2d project"
-    method_options :name => :string
+    desc "generate GENERATOR NAME", "Generate new code"
+    def generate(generator, name)
+      Actions::Generate.new(generator, name).start
+    end
+
+    desc "g GENERATOR NAME", "Shortcut for generate", hide: true
+    def g(*args)
+      generate(*args)
+    end
+
+    desc "new NAME [options]", "Create a new jruby slick2d project"
     def new(name)
-      Actions::Create.new(name).start
+      Generators::Project.new(name).start
     end
   end
 end

data/lib/slickr/entity.rb

@@ -0,0 +1,64 @@
+module Slickr
+  class Entity
+    class << self
+      attr_writer :behaviors
+    end
+
+    # Specify that an Entity should behave a certain way.
+    #
+    # @param behavior [Slickr::Behavior] The behavior to use.
+    # @param options  [Hash] Default behavior values.
+    #
+    # @example A Hero can move about the world.
+    #
+    #   class Hero < Slickr::Entity
+    #     use Spatiality
+    #   end
+    #
+    # Different Behaviors will allow you to specify different
+    # default values. For example, a Spatiality behavior that
+    # allows an Entity to move about the world, may take a
+    # default +x+ and +y+ value. The Entity will be placed at
+    # that location when the scene is first loaded.
+    #
+    # @example A Hero starting at a specific location.
+    #
+    #   class Hero < Slickr::Entity
+    #     use Spatiality, x: 100, y: 100
+    #   end
+    #
+    def self.use(behavior, options={})
+      behaviors << [behavior, options]
+    end
+
+    def self.behaviors
+      @behaviors ||= []
+    end
+
+    def self.reset
+      @behaviors = []
+    end
+
+    def initialize
+      behaviors.each { |behavior, options| behave_like(behavior, options) }
+    end
+
+    def behaviors
+      self.class.behaviors
+    end
+
+    private
+
+    # Mixin a behavior and configure it with the appropriate options.
+    #
+    # Each behavior must implement a +prepare+ method that initializes
+    # the Entity with any default values. The +prepare+ method will
+    # always be that of the last Behavior mixed in.
+    #
+    def behave_like(behavior, options={})
+      extend behavior
+      prepare(options)
+      EntityManager.register(self, behavior)
+    end
+  end
+end

data/lib/slickr/entity_manager.rb

@@ -0,0 +1,105 @@
+module Slickr
+  # Provides a central repository for storing and querying for Entities
+  # that exhibit some behavior.
+  #
+  # Each scene of your game will probably have many entities. When you 
+  # instantiate one of those Entities, it's automatically registered
+  # to the +EntityManager+, with the behaviors it implements.
+  #
+  # @example
+  #
+  #     class Boss < Slickr::Entity
+  #       use Spatial, x: 0, y: 0
+  #     end
+  #
+  #     boss = Boss.new
+  #     # => #<Boss components=[:spatial]>
+  #
+  #     EntityManager.entities
+  #     # => [#<Boss components=[:spatial]>]
+  #
+  # Systems and Renderers are the two things that will likely need to
+  # alter or manipulate entities. Systems change the data associated
+  # with an entity and Renderers draw that to the screen. These objects
+  # can ask the +EntityManager+ for any entities that care about the
+  # behaviors they affect.
+  #
+  # @example
+  #
+  #     class Systems::Input
+  #       def call(delta)
+  #         entities.each { |e| e.up(delta) } if up_key?
+  #       end
+  #
+  #       def entities
+  #         EntityManager.entities_with(:controllable, :spatial)
+  #       end
+  #     end
+  #
+  # The +Input+ system cares about entities that can be moved by keyboard
+  # or mouse input and have spatial awareness; that is, things that can
+  # move. The above +System+ tells an entity to move up if the up key is
+  # pressed. What "moving up" means is determined by the component. The
+  # System doesn't care; it just reacts to events in the world and tells
+  # entities to do stuff based on that.
+  #
+  # It's important to view +:controllable+ and +:spatial+ as behaviors.
+  # Systems and Renderers expect these objects to conform to some standard
+  # API. We don't care where the object came from, what type it is or
+  # what it does outside of what we expect. We're going for good object
+  # oriented design through duck typing here.
+  #
+  module EntityManager
+    extend self
+
+    # @!attribute entities
+    #   Hash of entities and their registered components
+    #
+    def entities
+      @entities ||= reset!
+    end
+
+    # Register an +Entity+ as conforming to a specific +Component+
+    # behavior.
+    #
+    # @param entity [Entity] The +Entity+ that includes the behavior
+    # @param type [Module] A +Component+ module.
+    #
+    def register(entity, type)
+      entities[entity] << symbolize(type)
+    end
+
+    # Retrieve all registered entities that include all of the 
+    # components passed.
+    #
+    # @param components [Array<Component>] List of components
+    #
+    # @example
+    #   EntityManager.entities
+    #   => { #<Entity components=[:spatial, :size]>, #<Entity components=[:spatial]> }
+    #
+    #   EntityManager.entities_with(:spatial, :size)
+    #   => #<Entity components=[:spatial, :size]>
+    #
+    def entities_with(*components)
+      entities.select { |entity, types| includes_all?(types, Set[*components]) }.keys
+    end
+
+    # Remove all entities.
+    #
+    def reset!
+      @entities = Hash.new { |h,k| h[k] = Set.new }
+    end
+
+    private
+
+    def includes_all?(types, items)
+      items.subset?(types)
+    end
+
+    def symbolize(type)
+      type.name.demodulize.underscore.gsub("_behavior", "").to_sym
+    end
+  end
+end
+