tardvig 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 724c04628100a4d2d3fe3c4f246af597a26807c3
+  data.tar.gz: db371a8e466d8b3de396119bbeca10581b335f1b
+SHA512:
+  metadata.gz: d9139f6e0c19bad867a5310718aecc2139f20e1009b8a75494eb3232eeca23fe9b2248ac9e2e04443c04308d3ba0cbde4f5b294a40cb8d08b607e46759713d46
+  data.tar.gz: 982a8884b2c6dfe3bf10172d4d2ada79634b3824a0f8ee60adbc61fe720550b1b12c49d9ed0e1f1cf02ed18b63cb472f768bab22ca7299290081c0a46471e817

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2016 Vadim Saprykin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,62 @@
+# Tardvig [![Gem Version](https://badge.fury.io/rb/tardvig.svg)](https://badge.fury.io/rb/tardvig)
+
+[RubyGem](https://rubygems.org/gems/tardvig) |
+[RubyDoc](http://www.rubydoc.info/gems/tardvig) |
+
+**Warning!** I do **not** recommend to use it.
+This gem is in the alpha stage of development now and it is very badly written
+and it does almost nothing.
+
+My English is very bad. Please, do not be mad at me. You can correct my errors
+if you want.
+
+## Description
+Lightweight structure for Ruby-based game engines.
+
+In fact, this is just a bundle of several simple helpful classes and modules
+which can be integrated and extended to make a game engine.
+
+### What is it for?
+It was developed for my single-player browser game which is divided into levels,
+but probably this gem can be used for any other types of games with any IO, I
+tried to make it as flexible as possible.
+For example, I used a similar structure for my text-based game with console IO
+earlier.
+
+*Important!* I recommend to familiarize with this gem before using it because
+it may be not applicable to your game.
+
+## Getting Started
+Tardvig consists of some modules and classes (i will call them "parts"). In this
+guide I am not going to describe them, because you already have docs as their
+description and specs as their examples. I'll tell you what you should pay
+attention to.
+I recommend you to read the description of parts immediately
+after you noticed their names so you can understand further guide (however, the
+guide is short).
+
+`Events` mixin and `Command` class are base parts which are not related directly
+to the game structure, but are very useful for parts which are related to it.
+
+The main part of a Tardvig-based game is `Act` class. Game is a sequence of
+acts. Acts can have different types.
+Example: Tardvig-based 3D FPS would be a sequence of acts of types `shooting`
+(user can run and shoot; each location is an act) and `cutscene` (user watches
+video), finished with a `credits` act (user watches authors' names).
+
+Important fact is that acts have attribute `subject`.
+
+Acts have attribute `io` which should contain an instance of any class which
+gives you ability to communicate with something that will dislay your game.
+I recommend you to communicate via `GameIO`.
+
+Well, now you know the basic parts. Final thing you should to do before you can
+use this gem is reading the example. It takes place in the
+`spec/integration_spec.rb` file.
+
+## You can also see...
+`Rakefile` - Rake tasks for contribution
+
+`tardvig.gemspec` - here you can see my name and email and this gem's depencies
+
+`LICENSE` - this gem's license

data/lib/tardvig/act.rb

@@ -0,0 +1,69 @@
+module Tardvig
+  # @abstract Represents the abstract part of your game.
+  #   It may be anything, depends on your realization: level, location,
+  #   cut-scene, credits, etc.
+  class Act < Command
+    class << self
+      # @overload act_type(type)
+      #   @param type [String, Symbol] set your custom act type. This is needed
+      #     for your display to differ acts and correspondingly intepret them.
+      # @overload act_type
+      #   @return type of your act
+      def act_type(type = nil)
+        if type
+          @type = type
+        elsif @type
+          @type
+        elsif superclass.respond_to? :act_type
+          superclass.act_type
+        end
+      end
+
+      # @overload subject(value)
+      #   If there was MVC, I would
+      #   say act is a model, subject is its data and other part of act is
+      #   business logic.
+      #   But there is no MVC, so *subject is the content of
+      #   your act and the methods of the act should process it*.
+      #
+      #   For example, if your act is a location of FPS, subject is the location
+      #   file and methods of your act should control player's enemies. If act
+      #   is a cut-scene, subject is the video file (probably name of the file).
+      #   @param value [Object] subject of your act.
+      # @overload subject
+      #   @return [Object] subject of your act
+      def subject(value = nil)
+        if value
+          @subject = value
+        else
+          @subject
+        end
+      end
+    end
+
+    private
+
+    def process
+    end
+
+    def execute
+      notify_display
+      process
+    end
+
+    # This method notifies your display via GameIO when the act is executed.
+    # You can redefine it if you want to send another message or do not want to
+    # send anything.
+    # @!visibility public
+    def notify_display
+      io.happen :act_start, type: self.class.act_type, subject: display_format
+    end
+
+    # This method should return the object which will be sent to the display.
+    # By default it returns the subject. But you can redefine it.
+    # @!visibility public
+    def display_format
+      self.class.subject
+    end
+  end
+end

data/lib/tardvig/command.rb

@@ -0,0 +1,58 @@
+module Tardvig
+  # @abstract The class represents abstract algorithm.
+  #   It is something like Proc, but your code is stored in the class instead of
+  #   object so you can use instance variables and divide your code into
+  #   methods.
+  #
+  #   See the `spec` directory for example.
+  class Command
+    # @param params [Hash] these key => value pairs will be instance variables
+    #  with reader methods
+    def initialize(params = {})
+      handle_params(params)
+    end
+
+    # Executes your process (you should redefine the `process` method)
+    # @param (see #initialize)
+    # @return [Command] self
+    def call(params = {})
+      handle_params(params)
+      execute
+      self
+    end
+
+    # Creates a new instance and executes it.
+    # @param (see #call)
+    # @return self
+    def self.call(params = {})
+      new.call(params)
+    end
+
+    private
+
+    # The method is used for be redefined in the situation when you need to
+    # change the execution order. By default it executes `process` only.
+    # See the specs for example.
+    # @!visibility public
+    def execute
+      process
+    end
+
+    # @abstract Redefine this method and it will do whatever you want whilst
+    #   execution
+    # @!visibility public
+    def process
+      raise NoMethodError, 'You should define #process for your Command'
+    end
+
+    def handle_params(params)
+      params.each_pair do |name, value|
+        var_name = :"@#{name}"
+        instance_variable_set var_name, value
+        define_singleton_method name do
+          instance_variable_get var_name
+        end
+      end
+    end
+  end
+end

data/lib/tardvig/events.rb

@@ -0,0 +1,52 @@
+module Tardvig
+  # The mixin gives ability to have events
+  # @see https://en.wikipedia.org/wiki/Event_%28computing%29
+  module Events
+    # Binds given listener (handler/callback) to given event name
+    # @param event [Object] any custom identificator. Your listener will be
+    #   executed only when you trigger event with this identificator.
+    # @param listener [#call] this object will be executed (through the #call
+    #   method) when you trigger the given event.
+    def on(event, &listener)
+      listeners(event) << listener
+    end
+
+    # Does the same as {#on}, but the listener will be executed only once, then
+    # it will be deleted.
+    # @param (see #on)
+    def on_first(event, &listener)
+      throwaway_callback = proc do |*args|
+        remove_listener event, throwaway_callback
+        listener.call(*args)
+      end
+      listeners(event) << throwaway_callback
+    end
+
+    # Unbinds given listener from the given event name
+    def remove_listener(event, listener = nil)
+      if listener.nil?
+        listeners(event).clear
+      else
+        listeners(event).delete listener
+      end
+    end
+
+    # Executes all the listeners which are bound to the given event name
+    # @param data [Object] the object will be passed as an argument to the
+    #   listeners
+    def happen(event, data = nil)
+      listeners(event).clone.each do |listener|
+        listener.call(data)
+      end
+    end
+
+    alias trigger happen
+
+    # @return [Array] array with all the listeners which are bound to the given
+    #   event name
+    def listeners(event)
+      @listeners ||= {}
+      @listeners[event] ||= []
+    end
+  end
+end

data/lib/tardvig/gameio.rb

@@ -0,0 +1,12 @@
+module Tardvig
+  # Interface which represents a connection to something that will display your
+  # game (I will call something that will display your game "display").
+  # Every display has its GameIO so if your game has a server and many people
+  # connected then you will have many GameIO instances.
+  #
+  # Communication should be realized via events.
+  # @abstract
+  class GameIO
+    include Events
+  end
+end

data/lib/tardvig/saved_hash.rb

@@ -0,0 +1,51 @@
+module Tardvig
+  # This is a hash which can be saved to a file (via YAML). It also has some
+  # events.
+  #
+  # It is useful for progress saving, configuration and settings files,
+  # localization files and many other things.
+  #
+  # Events:
+  # * `save` happen before saving data to a file. Arguments: the hash itself
+  # * `load` happen after loading data from a file. Arguments: the hash itself
+  class SavedHash < Hash
+    include Events
+
+    def initialize(io = nil)
+      load io unless io.nil?
+    end
+
+    # Save the hash to the file through YAML
+    # @param io [IO, String] the IO instance or the name of the file.
+    #   The data will be saved here.
+    def save(io)
+      open_file io, 'w' do |f|
+        trigger :save, self
+        f.write YAML.dump(self)
+      end
+    end
+
+    # Loads the data from the YAML file to itself. If there are old data in the
+    # hash, it overrides them.
+    # @param io [IO, String] the IO instance or the name of the file.
+    #   The data will be loaded from here.
+    def load(io)
+      open_file io, 'r' do |f|
+        merge! YAML.load(f.read)
+        trigger :load, self
+      end
+    end
+
+    private
+
+    def open_file(io, mode)
+      if io.respond_to?(:read) && io.respond_to?(:write)
+        yield io
+      elsif io.is_a? String
+        File.open(io, mode) { |f| yield f }
+      else
+        raise ArgumentError
+      end
+    end
+  end
+end

data/lib/tardvig/toolkit.rb

@@ -0,0 +1,53 @@
+module Tardvig
+  # Container which initializes and gives you access to its tools (objects).
+  # Useful when you need to do a DSL
+  class Toolkit
+    class << self
+      # @return [Hash] your tools
+      def tools
+        @tools ||= {}
+      end
+
+      # Adds a new tool (object).
+      #
+      # If the given object has either `call` or `new` methods then result of
+      # the method execution will be used as a tool instead. When the `call`
+      # method of your tool is executed, the toolkit will be given as the first
+      # argument and the `params` (see {#initialize}) as the second.
+      # @param name [Symbol] you can access your tool via this method name
+      # @param tool_itself [#call, #new, Object] your tool.
+      def tool(name, tool_itself = nil)
+        tools[name] = tool_itself || Proc.new
+      end
+    end
+
+    # Creates a new toolbox instance and initializes its tools.
+    # @param params [Hash] it will be available as the second argument passed to
+    #   the `call` methods of your tools.
+    def initialize(params = {})
+      @params = params
+      create_tools_readers
+    end
+
+    private
+
+    def tool_initialize(tool)
+      if tool.respond_to? :call
+        tool.call self, @params
+      elsif tool.respond_to? :new
+        tool.new
+      else
+        tool
+      end
+    end
+
+    def create_tools_readers
+      self.class.tools.each do |name, tool|
+        instance_variable_set "@#{name}", tool_initialize(tool)
+        define_singleton_method name do
+          instance_variable_get "@#{name}"
+        end
+      end
+    end
+  end
+end

data/lib/tardvig/version.rb

@@ -0,0 +1,3 @@
+module Tardvig
+  VERSION = '0.2.0'.freeze
+end

data/lib/tardvig.rb

@@ -0,0 +1,13 @@
+require 'yaml'
+
+require_relative 'tardvig/version.rb'
+require_relative 'tardvig/events.rb'
+require_relative 'tardvig/command.rb'
+require_relative 'tardvig/saved_hash.rb'
+require_relative 'tardvig/toolkit.rb'
+require_relative 'tardvig/gameio.rb'
+require_relative 'tardvig/act.rb'
+
+# The main namespace for the gem
+module Tardvig
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: tardvig
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Vadim Saprykin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+description: 'Tardvig is a bundle of classes and modules which can be integrated and
+  extended to make a game engine.
+
+'
+email: sprkweb@ya.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/tardvig.rb
+- lib/tardvig/act.rb
+- lib/tardvig/command.rb
+- lib/tardvig/events.rb
+- lib/tardvig/gameio.rb
+- lib/tardvig/saved_hash.rb
+- lib/tardvig/toolkit.rb
+- lib/tardvig/version.rb
+homepage: https://github.com/sprkweb/tardvig
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Lightweight structure for Ruby-based games
+test_files: []