demigod_game 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MGY1ZWFlYWE0Mjk4MjU2MTg5OWYwYzMwZDY0YTM4ZjcyMWQwZDZhMA==
+  data.tar.gz: !binary |-
+    MDc5MGM0MjU3MzNhOGFjNDgyOWVlM2JlY2Q2YjY4MzlkNmU4MjcyZQ==
+SHA512:
+  metadata.gz: !binary |-
+    ZmRjYmIzNWU1OTFlYzJlYzc2OWYwMDE4ZGVkMjdhMzU0YjI2OWIxZmY5MTNm
+    ZDdlY2NjOWVhMzZkYzFmOGQ4MDJlMGEwMGE4MWI4YzI5MTZiN2YxYmE1NTVj
+    NzEzOWVjNGFhZmYwOTYyZWRhYTBkNGQwMTYzNzA3NzYyZWM0YmU=
+  data.tar.gz: !binary |-
+    ZmVmODM1NGFlNWNhNWFlZDUzOWUzYmNjZTBlNzQ2YWUwNDMyYWQ3OTNkNjhl
+    YTY0YzZhOGI0MmI1ODA0NjY2YmY2MzE3ZWY1MGNkYWIxODU3MDI1NTFhYWM5
+    OTQwZTNhN2ExODJkMzRhYTIwODhlYTdlNDgyZDI0NTM5MjBjOTI=

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Yuval
+
+MIT License
+
+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,29 @@
+# DemigodGame
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'demigodGame'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install demigodGame
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/demigod

@@ -0,0 +1,5 @@
+#!/usr/bin/ruby
+require_relative '../lib/demigodGame'
+
+DemigodGame.new
+DemigodGame.run

data/demigodGame.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'demigodGame/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "demigod_game"
+  spec.version       = DemigodGame::VERSION
+  spec.authors       = ["Yuval"]
+  spec.email         = ["yvw.bor@gmail.com"]
+  spec.description   = %q{A learning project game, build your own island and unleash the dragons from the dragon shrine!}
+  spec.summary       = %q{Build your own island and unleash the dragons!}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/demigodGame.rb

@@ -0,0 +1,25 @@
+require_relative 'demigodGame/version'
+require_relative 'demigodGame/Demigod'
+require_relative 'demigodGame/World'
+
+module DemigodGame
+  @demigod
+  def self.new
+    puts UiHandler::NEW_GAME
+    until (size = gets.chomp).match(/^\d+$/) && size.to_i >= 3
+      puts "Invalid world size"
+    end
+
+    @demigod = Demigod.new(World.new(size.to_i))
+  end
+
+  def self.run
+    while true
+      @demigod.turn
+    end
+  end
+
+end
+
+DemigodGame.new
+DemigodGame.run

data/lib/demigodGame/Demigod.rb

@@ -0,0 +1,109 @@
+# This file will handle the Demigod class, which is the heart of the game
+# = as it's the player controlled class
+#
+# Turn order:
+#-  First resources are calculater for the turn and printed on the screen
+#-  The player then needs to answer in event, not all of them are interactive
+#-  The player can either choose a tile to build on or skip by returning an empty line
+#-  If the player chose a tile he now needs to input his action for the tile
+# =============================================================================
+
+require_relative 'UiHandler'
+require_relative 'GameData'
+require_relative 'World'
+
+class Demigod
+  attr_reader :resources
+  @world
+
+  # Starts a new game - each demigod has one world to rule
+  # accepts different starting resources as a parameter
+  def initialize (world, resources = GameData::STARTING_RESOURCES)
+    @world = world
+    @resources = resources
+    system "clear" or system "cls"
+  end
+
+  # Handles a turn, main function of the game
+  def turn
+
+    # calculates new amount of resources using the production function
+    # world.production accepts a resources hash and returns a newly
+    # calculated resource hash based on production
+    @resources = @world.production(@resources)
+    p @resources
+
+    #do_event # ========= TODO ========= #
+
+    # part 2 of every turn
+    UiHandler.print_world(@world)
+    UiHandler.print_turn_message
+
+    # Asks the user for a tile to do his action on
+    decision = gets.chomp
+
+    until (@world.exists?(decision) || decision == '')
+      UiHandler.print_error(UiHandler::NO_TILE)
+      UiHandler.print_turn_message
+      decision = gets.chomp
+    end
+
+    unless decision == ''
+      tile = @world.get_tile decision # returns the tile at decision
+      tile.print_options
+
+      # asks for action on tile
+      decision = gets.chomp
+
+      # tile.accepts? uses number of resources to decide if a move is valid
+      until tile.accepts?(decision, @resources)
+        break if decision == ''
+        UiHandler.print_error(UiHandler::INVALID)
+        tile.print_options
+        decision = gets.chomp
+      end
+
+      if decision != ''
+        price = GameData.get_price(decision)
+        @resources = reduce(price)
+        @world.advance(tile, decision)
+      end
+    end
+
+    # Clears the screen
+    system "clear" or system "cls"
+  end
+
+private
+
+  # calls and handles a new event         # === TODO === #
+  def do_event
+=begin
+
+     event = Events.new(@resources[:luck])
+    # starts an event
+    event.start
+    decision = gets.chomp
+
+    until event.accepts? decision # Requires valid input
+      UiHandler.print_error(event.valid_range)
+      decision = gets.chomp
+    end
+
+    # event.dispatch accepts player decision and affects the world
+    # returning new number of resources
+    @resources = event.dispatch(decision)
+
+=end
+  end
+
+  # Reduces resources
+  def reduce(amount)
+    amount.each do |name, value|
+      @resources[name] -= value
+    end
+    @resources
+  end
+
+end
+

data/lib/demigodGame/GameData.rb

@@ -0,0 +1,59 @@
+# GameData module Holds all important and CONSTANT game GameData
+# Includes methods to return specific prices
+# ==============================================================
+
+module GameData
+  STARTING_RESOURCES = {:wood => 2,
+                        :food => 2,
+                        :population => 1,
+                        :iron => 0,
+                        :favor => 20,
+                        :luck => 0
+                        }
+
+  RAISE_PLAINS_PRICE = {:favor => 5}
+  RAISE_FOREST_PRICE = {:favor => 5}
+  RAISE_RIDGE_PRICE = {:favor => 10}
+
+=begin
+  RAISE_PRICES = {:p => RAISE_PLAINS_PRICE,
+                  :f => RAISE_FOREST_PRICE,
+                  :r => RAISE_RIDGE_PRICE
+                  }
+  RAISE_PRICES.default = nil
+=end
+
+  BUILD_WOODCUTTER_PRICE = {:food => 3}
+  BUILD_SHEEP_PRICE = {:food => 0} # Sheeps are free, yay!
+  BUILD_DRAGONSHRINE_PRICE = {:food => 10, :iron => 10, :wood => 10, :favor => 100}
+  BUILD_MINE_PRICE = {:wood => 5}
+  BUILD_CHAPEL_PRICE = {:wood => 2, :food => 3}
+  BUILD_HOUSE_PRICE = {:wood => 2}
+
+=begin
+  BUILD_PRICES = {:w => BUILD_WOODCUTTER_PRICE,
+                  :s => BUILD_SHEEP_PRICE,
+                  :d => BUILD_DRAGONSHRINE_PRICE,
+                  :m => BUILD_MINE_PRICE,
+                  :c => BUILD_CHAPEL_PRICE,
+                  :h => BUILD_HOUSE_PRICE
+                  }
+  BUILD_PRICES.default = nil
+=end
+
+  PRICES = {:w => BUILD_WOODCUTTER_PRICE,
+            :s => BUILD_SHEEP_PRICE,
+            :d => BUILD_DRAGONSHRINE_PRICE,
+            :m => BUILD_MINE_PRICE,
+            :c => BUILD_CHAPEL_PRICE,
+            :h => BUILD_HOUSE_PRICE,
+            :p => RAISE_PLAINS_PRICE,
+            :f => RAISE_FOREST_PRICE,
+            :r => RAISE_RIDGE_PRICE
+          }
+
+  def self.get_price(sym)
+    return PRICES[sym.to_sym]
+  end
+
+end

data/lib/demigodGame/Tile.rb

@@ -0,0 +1,129 @@
+# Includes the base Tile class and all subsequent Tile types
+# Handles the work with tiles, checks which values are valid for current tile
+#
+# Subclasses are: Sea, Mountain, Plain and Forest
+# ================================================================
+require_relative 'GameData'
+class Tile
+
+  attr_reader :raisable, :buildable, :built_on, :x, :y
+  def initialize(x, y)
+    @x = x
+    @y = y
+    @raisable = []
+    @buildable = []
+    @type = '.'
+  end
+
+  # The base tile class is abstract and therfore accepts no value
+  # Should probably be overriden in subclasses
+  def accepts?(order, resources)
+    false
+  end
+
+  def print_options
+
+    if @raisable != [] # raising options
+      print "You can raise with:"
+      @raisable.each do |name|
+        print " #{name.to_s} | "
+      end
+      puts
+    end
+
+    if @buildable != [] # building options
+      print "You can build with:"
+      @buildable.each do |name|
+        print " #{name.to_s} | "
+      end
+      puts
+    end
+
+    puts UiHandler::RAISE_WARNING if @built_on
+    puts UiHandler::BACK
+
+
+    print UiHandler::PROMPT
+  end
+
+  def to_s
+    "#{@type}#{@built_on}"
+  end
+
+  # Adds building to tile, doesn't check if valid building
+  def build(building)
+    @built_on = building
+    @buildable = []
+  end
+
+  # Checks if an order is valid
+  def accepts?(order, resources)
+    return false if !order.match( /\A\w\Z/ ) # vaild command
+
+    (@raisable + @buildable).each do |check| # checks which order was given
+      if (check.to_s == order)
+        cost = GameData.get_price(check)
+        puts "This costs #{cost}"
+        if !check_cost(cost, resources)
+          puts "Not enough resources!"
+          return false
+        end
+        return true
+      end
+    end
+    false
+  end
+
+private
+
+  def check_cost(cost, resources)
+
+    # checks each resource for the correct amount
+    cost.each do |resource, amount|
+      return false if amount > resources[resource]
+    end
+    return true
+  end
+end
+
+# Sea class, can raise plains, can't be built on
+class Sea < Tile
+
+  def initialize(x, y)
+    super(x, y)
+    @raisable = [:p]
+    @type = '-'
+  end
+end
+
+# Ridge class, can't be raised, can build mine, chapel and dragon shrine
+class Ridge < Tile
+
+  def initialize(x, y)
+    super(x, y)
+    @buildable = [:m, :c, :d]
+    @type = 'R'
+  end
+end
+
+# Plains class, can be raised to ridge or forest, can build house, chapel and sheeps
+class Plains < Tile
+
+  def initialize(x, y)
+    super(x, y)
+    @raisable = [:r, :f]
+    @buildable = [:h, :c, :s]
+    @type = 'P'
+  end
+end
+
+# Forst class, can be raised to ridge, can build woodcutter, chapel, house
+class Forest < Tile
+
+  def initialize(x, y)
+    super(x, y)
+    @buildable = [:w, :c, :h]
+    @raisable = [:r]
+    @type = 'F'
+  end
+end

data/lib/demigodGame/UiHandler.rb

@@ -0,0 +1,61 @@
+# Module to handle most of the output to the screen
+# =================================================
+
+module UiHandler
+
+  NEW_GAME = "Welcome to Demigod! What size would you want your world to be?"
+  PROMPT = '>'
+  NO_TILE = "There is no such tile"
+  NOT_ENOUGH_FOOD = "Your people lack food! Some have died of starvation!"
+  RAISE_WARNING = "Warning: Raising the ground here will destroy the existing building!"
+  BACK = "Press enter on an empty line to go back"
+  INVALID = "That's an invalid move!"
+  LOST = "You ran out of resources, I guess you lose..."
+  WIN = "The dragon shrine is built and so the dragons grant you all the powers of immortality" 
+
+  def self.print_world(world)
+    puts
+    print ' -'
+    (world.size).times { |i| print "-#{i+1}--"}
+    puts
+
+    row_number = 1
+    world.tiles.each do |row|
+      print "#{row_number}"
+      row.each do |tile|
+        print "| #{tile.to_s}"
+        print " " if tile.to_s.length == 1
+      end
+      puts '|'
+      row_number += 1
+    end
+
+    print ' -'
+    (world.size).times { |i| print "----"}
+
+    puts ''
+  end
+
+  def self.print_status(resources, buildings)
+    print_hash resources
+    print_hash buildings
+    puts
+  end
+
+  def self.print_hash(hash)
+    hash. each do |name, amount|
+      print "#{name}: #{amount} | " if name != :luck
+    end
+    puts
+  end
+
+  def self.print_turn_message
+      puts "Choose a tile to work on. Enter 2 numbers with a space in between i.e. \"1 1\""
+      print PROMPT
+  end
+
+  def self.print_error(error_str)
+    puts "Oops! #{error_str}"
+    puts
+  end
+end

data/lib/demigodGame/World.rb

@@ -0,0 +1,155 @@
+# This file will handle the World class, which holds the world map and all relevant functions
+# =============================================================================
+require_relative 'Tile'
+require_relative 'UiHandler'
+require_relative 'GameData'
+
+class World
+  BUILDABLE = {:wood_cutter => 'w', :sheep => 's', :mines => 'm', :chapel => 'c', :house => 'h', :dragon => 'd'}
+  DECISIONS = {:build => {:w => 'wood_cutter', :s => 'sheep', :m => 'mines', :c => 'chapel', :h => 'house', :d => 'dragon'},
+               :raise => {:r => 'ridge', :f => 'forest', :p => 'plains'}}
+  DECISIONS.default = nil
+
+  attr_reader :tiles, :buildings, :size
+
+  def initialize(size = 5)
+    @buildings = {:wood_cutter => 0, :sheep => 0, :mines => 0, :chapel => 0, :house => 0, :dragon => 0}
+    @size = size
+
+    generate_tiles(size)
+  end
+
+  # returns a specific tile from an str with a space
+  def get_tile(str)
+    str.strip!
+    str = str.split(" ")
+    x = str[0].to_i - 1
+    y = str[1].to_i - 1
+    @tiles[x][y]
+  end
+
+  # Advances the world map based on given 1-letter instruction
+  # Assumes all given decisions were checked by tile.accept
+  def advance(tile, order)
+    if order.match(/\A[rfp]\Z/) # for raise of Ridge, Forest or Plain
+      raise_tile(tile.x, tile.y, DECISIONS[:raise][order.to_sym])
+
+    elsif order.match(/\A[wsmchd]\Z/) # for build of any building
+      build_on_tile(tile, DECISIONS[:build][order.to_sym])
+    else
+      puts "Error occured, continuing but turn skipped."
+    end
+  end
+
+  # Adds to resources by number of buildings. Also checks the only lose condition in the game
+  def production(resources)
+    resources[:wood] += @buildings[:wood_cutter]
+    resources[:food] += @buildings[:sheep] -resources[:population]
+    resources[:iron] += @buildings[:mines]
+    resources[:favor] += @buildings[:chapel] * (resources[:population] / 10 + 1)
+    resources[:favor] = (resources[:favor] * 0.9).to_i
+
+    if resources[:population] < resources[:food]
+      resources[:population] += @buildings[:house]
+    else
+      puts UiHandler::NOT_ENOUGH_FOOD
+      resources[:population] -= resources[:population] - resources[:food]
+    end
+    UiHandler.print_status(resources, @buildings)
+
+    resources.each do |name, value| # lose condition
+      if value < 0
+        system "clear" or system "cls"
+        puts "#{name} is negative!"
+        puts UiHandler::LOST
+        exit
+      end
+    end
+    resources
+  end
+
+  def exists? (str)
+    str.strip!
+    return false if !str.match(/\A\d+\s\d+\Z/)
+    true
+  end
+
+private
+
+  # generates a starting grid based on size
+  def generate_tiles(size)
+
+    @tiles = []     # starts from fresh
+
+    size.times do |x|
+      @tiles << []     # Creates a multi dimensional array
+      size.times do |y|
+        tiles[x] << Sea.new(x, y)     # Adds the sea
+      end
+    end
+
+    middle = size / 2
+
+    # raises an initial cross of plains
+    (-1..1).step(1) do |i|
+      raise_tile(middle + i, middle, :plains)
+      raise_tile(middle, middle + i, :plains)
+    end
+
+    # puts initial buildings
+      build_on_tile(@tiles[middle][middle], :house)
+      random1, random2 = (rand(0..1) * 2 - 1), (rand(0..1) * 2 - 1)
+      build_on_tile(@tiles[middle + random1][middle], :chapel)
+      build_on_tile(@tiles[middle][middle + random2], :sheep)
+
+    # initial forest
+      raise_tile(middle - random1, middle - random2, :forest)
+  end
+
+  # creates a new tile, placing it in given location
+  # does not check for compatibility
+  def raise_tile(x, y, tile_type)
+    case tile_type.to_sym
+    when :ridge
+      new_tile = Ridge.new(x, y)
+    when :plains
+      new_tile = Plains.new(x, y)
+    when :sea
+      new_tile = Sea.new(x, y)
+    when :forest
+      new_tile = Forest.new(x, y)
+    end
+    @tiles[x][y] = new_tile
+  end
+
+  # builds given building on given location, and updates building count
+  # does not check tile compatability
+  # does check for empty tile
+  def build_on_tile(tile , building)
+    if !tile.built_on
+
+      tile.build(BUILDABLE[building.to_sym])
+      @buildings[building.to_sym] += 1
+      if building.to_sym == :dragon
+        puts UiHandler::WIN
+        exit
+      end
+    else # This shouldn't happen normally
+      puts "There's already a building here"
+    end
+
+  end
+
+  # debugging purpose print world function
+  def temp_print_world
+    puts "======================================="
+    @tiles.each do |row|
+      row.each do |tile|
+        print "#{tile.to_s}\t"
+      end
+      puts
+    end
+    puts "======================================="
+  end
+end
+

data/lib/demigodGame/version.rb

@@ -0,0 +1,3 @@
+module DemigodGame
+  VERSION = "1.0.0"
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: demigod_game
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Yuval
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A learning project game, build your own island and unleash the dragons
+  from the dragon shrine!
+email:
+- yvw.bor@gmail.com
+executables:
+- demigod
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/demigod
+- demigodGame.gemspec
+- lib/demigodGame.rb
+- lib/demigodGame/Demigod.rb
+- lib/demigodGame/GameData.rb
+- lib/demigodGame/Tile.rb
+- lib/demigodGame/UiHandler.rb
+- lib/demigodGame/World.rb
+- lib/demigodGame/version.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Build your own island and unleash the dragons!
+test_files: []