bloodchalice 1.0.0

data/assets/world/map1

@@ -0,0 +1,15 @@
+#####################################################################################
+# C 1   2  #                         P                                              #
+#          #               #####                                    P               #
+#   3   4                                         P            #######              #
+############                                                   #  P P#              #
+#                                  ####                        #     #        P     #
+#                      #####       ######                      ##   ##              #
+#                 ###########              ###                                      #
+#      ##                                   ###                                     #
+#      ##                  Z                      ##############               P    #
+#      ##          #####                 K        #      #  P  #       P            #
+#   P  ##              #####                                   #                    #
+#            P            P                                    #                    #
+#                 #                 #####         #      #     #              P     #
+#####################################################################################

data/bin/bloodchalice

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative '../lib/bloodchalice'
+
+BloodChalice::Application.run

data/lib/bloodchalice.rb

@@ -0,0 +1,16 @@
+require 'io/console'
+require 'pathname'
+require 'highline/import'
+
+require_relative 'bloodchalice/event_deck'
+require_relative 'bloodchalice/tile'
+require_relative 'bloodchalice/movable'
+require_relative 'bloodchalice/ai'
+require_relative 'bloodchalice/map'
+require_relative 'bloodchalice/bloodchalice'
+require_relative 'bloodchalice/game'
+require_relative 'bloodchalice/player'
+require_relative 'bloodchalice/zombie'
+require_relative 'bloodchalice/peasant'
+require_relative 'bloodchalice/knight'
+require_relative 'bloodchalice/chalice'

data/lib/bloodchalice/ai.rb

@@ -0,0 +1,39 @@
+########
+# This is a very basic IA just for testing.
+########
+
+class BloodChalice
+  module ArtificialIntelligence
+    def think()
+      self.speed.times { move(Movable::DIRECTIONS.keys.sample) }
+    end                                   
+    
+    def reacts_to(tile)
+      if tile.wall?
+        return :stop
+      elsif tile.empty?
+        return :move
+      end
+    end
+    
+    def die()
+      @game.remove_npc(self)
+      @map.set_tile @position, Tile.new(@position, ' ')
+    end
+
+    def bited()
+      @blood -= 1
+      if @blood <= 0
+        die()
+      end
+    end
+
+    def hit(damage)
+      @life -= damage
+      if @life <= 0
+        die()
+      end
+    end
+    
+  end   
+end

data/lib/bloodchalice/bloodchalice.rb

@@ -0,0 +1,16 @@
+class BloodChalice                                                
+  
+  ASSETS_FOLDER = Pathname.new(__FILE__).dirname + '../../' + 'assets'
+      
+  class Application
+    def self.run
+      say('Welcome to Blood Chalice')
+      number_of_players = ask("How many players are going to play?").to_i
+      
+      game = Game.new(number_of_players: number_of_players)
+      while not game.end_of_game?
+        game.next_turn
+      end
+    end
+  end  
+end

data/lib/bloodchalice/chalice.rb

@@ -0,0 +1,21 @@
+class BloodChalice
+  class Chalice
+    include BloodChalice::Movable
+    include BloodChalice::TileValues
+
+    attr_accessor :position, :life, :blood, :map, :value
+
+    def initialize(options = {})
+      @position = options[:position]
+      @map = options[:map]
+      @life = 400
+      @blood = 0
+      @value = 'C'
+    end
+
+    def to_s
+      @value.to_s
+    end
+
+  end
+end

data/lib/bloodchalice/event_deck.rb

@@ -0,0 +1,38 @@
+class BloodChalice
+  class EventDeck
+    CARDS = [:new_zombie, :new_knight, :new_peasant]
+
+    attr_accessor :game, :map
+
+    def initialize(game)
+      @game = game
+      @map = game.map
+    end
+
+    def take_a_card()
+      modify_world(get_card())
+    end
+
+    def get_card()
+      CARDS.sample
+    end
+
+    def modify_world(card)
+      empty_tiles = @map.map.flatten.select { |t|  t.empty?}
+      case card
+        when :new_zombie
+          puts "New zombie!"
+          tile = empty_tiles.sample
+          @map.set_tile(tile.position, Zombie.new(map: @map, position: tile.position, game: @game))
+        when :new_knight
+          puts "New Knight!"
+          tile = empty_tiles.sample          
+          @map.set_tile(tile.position, Knight.new(map: @map, position: tile.position, game: @game))
+        when :new_peasant
+          puts "New Peasant!"                                                  
+          tile = empty_tiles.sample          
+          @map.set_tile(tile.position, Peasant.new(map: @map, position: tile.position, game: @game))
+      end
+    end
+  end
+end

data/lib/bloodchalice/game.rb

@@ -0,0 +1,133 @@
+class BloodChalice
+  class Game
+    include HighLine::SystemExtensions
+    
+    attr_accessor :map, :number_of_players, :players, :turn, :chalice, :non_playable_characters, :event_deck
+    
+    END_OF_THE_WORLD = 400
+
+    def initialize(options = {})
+      @non_playable_characters = []
+      @map = Map.new('map1')
+      @number_of_players = options[:number_of_players]
+      @players = generate_players(map)
+      generate_npc(map)
+      @turn = 1 
+      @event_deck = EventDeck.new(self)     
+    end
+
+    def next_turn()
+      event_deck.take_a_card
+      players.each do |player|
+        player.reset_moves
+        while player.moves?
+          show_interface(player)
+          ask_next_action(player)
+        end
+        show_interface(player)
+        ask "Next Player: hit enter"
+      end                 
+      
+      @non_playable_characters.each &:reset_moves
+      @non_playable_characters.each &:think      
+      
+      @turn += 1
+    end
+
+    def ask_next_action(player)
+      say "A   Move to the West"
+      say "D   Move to the East"
+      say "W   Move to the North"
+      say "S   Move to the South"
+      say "Q   Quit"
+
+      print 'Your order: '
+      action = get_character.chr.upcase
+
+      case action.strip
+      when 'W'
+        player.move(:north)
+      when 'D'
+        player.move(:east)
+      when 'S'
+        player.move(:south)
+      when 'A'
+        player.move(:west)
+      when 'Q'
+        exit()
+      end
+    end
+
+    def end_of_game?()
+      (@turn == END_OF_THE_WORLD) or all_players_dead? or @chalice.blood >= 50 
+    end
+
+    def all_players_dead?
+      @players.all? {|p| p.dead?}
+    end
+
+    def generate_players(number_of_players)
+      1.upto(number_of_players) { |i| @players << Player.new(number: i, map: @map) }
+    end
+
+    def show_interface(player)
+      system('clear')
+      say "It is the turn of Player #{player.number} and there are #{END_OF_THE_WORLD - @turn} turns until dawn."
+      say "The Blood Chalice has #{@chalice.blood} of 50 blood units"
+      show_map
+      say "You have #{player.moves}/#{Player::SPEED} moves left, #{player.blood} blood stored and #{player.life}/#{Player::MAX_LIFE} HP"
+      say 'What are your orders, my Liege?'
+    end
+
+    def show_map()
+      say @map.to_s
+    end
+
+    def active_player?(tile)
+      tile.value.to_i <= @number_of_players
+    end
+    
+    def remove_npc(npc)
+      @non_playable_characters.delete(npc)
+    end
+
+    def generate_npc(map)
+      map.map.each_with_index do |line, y|
+        line.each_with_index do |tile, x|
+          if tile.peasant?              
+            peasant = Peasant.new(map: map, position: [y, x], game: self)
+            @non_playable_characters << peasant
+            map.set_tile [y, x], peasant
+          elsif tile.zombie?        
+            zombie = Zombie.new(map: map, position: [y, x], game: self)
+            @non_playable_characters << zombie
+            map.set_tile [y, x], zombie
+          elsif tile.knight?        
+            knight = Knight.new(map: map, position: [y, x], game: self)
+            @non_playable_characters << knight
+            map.set_tile [y, x], knight
+          elsif tile.chalice?
+            @chalice = Chalice.new(map: map, position: [y, x], game: self)
+            map.set_tile [y, x], @chalice
+          end
+        end
+      end
+    end
+
+    def generate_players(map)
+      players = []
+
+      map.map.each_with_index do |line, y|
+        line.each_with_index do |tile, x|
+          if tile.player? && active_player?(tile)
+            players <<  map[y][x] = Player.new(map: map, position: [y, x], number: tile.value, game: self)
+          elsif tile.player?
+            map.set_tile [y, x], Tile.new([y, x], ' ')
+          end
+        end
+      end
+      players
+    end
+
+  end
+end

data/lib/bloodchalice/knight.rb

@@ -0,0 +1,44 @@
+class BloodChalice
+  class Knight
+    include BloodChalice::Movable
+    include BloodChalice::TileValues
+    include BloodChalice::ArtificialIntelligence
+
+    attr_accessor :position, :life, :blood, :map, :value, :speed, :game
+
+    MAX_LIFE = 5
+    SPEED = 3
+    ATTACK = 1
+    VISION = 6
+    MAXBLOOD = 1
+
+    def initialize(options = {})
+      @position = options[:position]
+      @map = options[:map]
+      @game = options[:game]
+      @life = MAX_LIFE
+      @blood = MAXBLOOD
+      @value = 'K'
+      @speed = SPEED
+    end
+
+    def reacts_to(tile)
+      if tile.wall?
+        return :stop
+      elsif tile.empty?
+        return :move
+      elsif tile.player?
+        tile.hit(ATTACK)
+        return :fight
+      elsif tile.zombie?
+        tile.hit(ATTACK)
+        return :fight
+      end
+    end
+
+    def to_s
+      @value.to_s
+    end
+
+  end
+end

data/lib/bloodchalice/map.rb

@@ -0,0 +1,43 @@
+class BloodChalice
+  class Map 
+    attr_accessor :map, :number_of_players    
+    
+    def initialize(path)
+      @map = load_map(path)
+    end
+    
+    def value(position)
+      @map[position[0]][position[1]]
+    end      
+    
+    def set_tile(position, value)
+      @map[position[0]][position[1]] = value
+    end
+        
+    def to_s
+      result = ''
+      @map.each do |line|            
+        line.each { |tile| result += tile.to_s }
+        result += "\n"
+      end            
+      result
+    end
+    
+    def[](value)
+      @map[value]
+    end         
+    
+    private
+    
+    def load_map(path)
+      filename = ASSETS_FOLDER + "world/#{path}"
+
+      map = File.readlines(filename).each_with_index.map do |line, y|
+        line.strip.split(//).each_with_index.map do |tile, x|
+          Tile.new([y, x], tile)
+        end
+      end
+    end                  
+    
+  end
+end

data/lib/bloodchalice/movable.rb

@@ -0,0 +1,56 @@
+class BloodChalice
+  module Movable
+    DIRECTIONS = {north: [-1, 0], east: [0, 1], south: [1, 0], west: [0, -1] }
+    
+    def move(direction)
+      case direction
+        when :north          
+          reactions sum_positions(@position, DIRECTIONS[:north])
+        when :south                                              
+          reactions sum_positions(@position, DIRECTIONS[:south])
+        when :east                                               
+          reactions sum_positions(@position, DIRECTIONS[:east])
+        when :west                                               
+          reactions sum_positions(@position, DIRECTIONS[:west])
+      end                        
+    end             
+    
+    def reactions(position)
+      case reacts_to(@map.value(position))
+        when :move
+          move!(position)
+        when :fight
+          @moves = 0
+      end      
+    end
+    
+    def hit(damage)
+      @life -= damage
+      if @life <= 0 
+        die()
+      end
+    end
+    
+    def reset_moves
+      @moves = self.speed
+    end
+
+    def move!(position)
+      @map.set_tile(@position, Tile.new(@position, ' '))
+      @position = position
+      @moves -= 1          
+      @map.set_tile(position, self)
+    end
+    
+    def moves?
+      self.moves > 0
+    end   
+    
+    private 
+    
+    def sum_positions(pos1, pos2)
+      [pos1[0] + pos2[0], pos1[1] + pos2[1]]
+    end
+        
+  end
+end

data/lib/bloodchalice/peasant.rb

@@ -0,0 +1,29 @@
+class BloodChalice
+  class Peasant
+    include BloodChalice::Movable
+    include BloodChalice::TileValues
+    include BloodChalice::ArtificialIntelligence
+
+    attr_accessor :position, :life, :blood, :map, :value, :speed, :game
+
+    MAX_LIFE = 2
+    SPEED = 2
+    ATTACK = 0
+    VISION = 6
+    MAXBLOOD = 3
+
+    def initialize(options = {})
+      @position = options[:position]
+      @map = options[:map]
+      @game = options[:game]
+      @life = MAX_LIFE
+      @blood = MAXBLOOD
+      @value = 'P'
+      @speed = SPEED
+    end
+
+    def to_s
+      @value.to_s
+    end
+  end
+end

data/lib/bloodchalice/player.rb

@@ -0,0 +1,68 @@
+class BloodChalice
+  class Player
+    include BloodChalice::Movable
+    include BloodChalice::TileValues
+
+    attr_accessor :position, :life, :blood, :number, :map, :moves, :value, :speed, :game
+
+    MAX_LIFE = 100
+    SPEED = 7
+    ATTACK = 3
+    VISION = 10
+
+    def initialize(options = {})
+      @position = options[:position]
+      @value = @number = options[:number]
+      @map = options[:map]
+      @game = options[:game]
+      @life = MAX_LIFE
+      @moves = SPEED
+      @blood = 0
+      @speed = SPEED
+    end
+
+    def reacts_to(tile)
+      if tile.wall?
+        return :stop
+      elsif tile.player?
+        return :stop
+      elsif tile.peasant?
+        bite(tile)
+        return :fight
+      elsif tile.zombie?
+        fight(tile)
+        return :fight
+      elsif tile.knight?
+        fight(tile)
+        return :fight
+      elsif tile.chalice?
+        pour_blood(tile)
+      elsif tile.empty?
+        return :move
+      end
+    end
+    
+    def pour_blood(chalice)
+      chalice.blood += @blood
+      @blood = 0
+    end
+    
+    def fight(enemy)
+      enemy.hit(ATTACK)
+    end
+
+    def bite(human)
+      human.bited
+      @blood += 1
+    end
+
+    def dead?
+      life < 1
+    end
+
+    def to_s
+      @number.to_s
+    end
+
+  end
+end

data/lib/bloodchalice/tile.rb

@@ -0,0 +1,46 @@
+class BloodChalice
+  module TileValues
+    def wall?
+      @value == '#'
+    end
+
+    def player?
+      @value.to_i > 0
+    end
+
+    def empty?
+      @value == ' '
+    end
+
+    def peasant?
+      @value == 'P'
+    end
+
+    def zombie?
+      @value == 'Z'
+    end
+    
+    def knight?
+      @value == 'K'
+    end           
+    
+    def chalice?
+      @value == 'C'
+    end
+  end
+
+  class Tile
+    include BloodChalice::TileValues
+    attr_accessor :value, :position
+
+    def initialize(position, value )
+      @value = value
+      @position = position
+    end                                  
+
+    def to_s
+      @value.to_s
+    end
+
+  end
+end

data/lib/bloodchalice/version.rb

@@ -0,0 +1,3 @@
+class BloodChalice
+  VERSION = '1.0.0'
+end

data/lib/bloodchalice/zombie.rb

@@ -0,0 +1,44 @@
+class BloodChalice
+  class Zombie
+    include BloodChalice::Movable
+    include BloodChalice::TileValues
+    include BloodChalice::ArtificialIntelligence
+
+    attr_accessor :position, :life, :blood, :map, :value, :speed, :game
+
+    MAX_LIFE = 2
+    SPEED = 2
+    ATTACK = 1
+    VISION = 5
+    MAXBLOOD = 0
+
+    def initialize(options = {})
+      @position = options[:position]
+      @map = options[:map]
+      @game = options[:game]
+      @life = MAX_LIFE
+      @blood = MAXBLOOD
+      @value = 'Z' 
+      @speed = SPEED
+    end
+    
+    def reacts_to(tile)
+      if tile.wall?
+        return :stop
+      elsif tile.empty?
+        return :move
+      elsif tile.player? or tile.knight?
+        tile.hit(ATTACK)
+        return :fight
+      elsif tile.peasant? # Will be changed
+        tile.hit(ATTACK)
+        return :fight
+      end
+    end
+
+    def to_s
+      @value.to_s
+    end
+
+  end
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: bloodchalice
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Gonzalo Rodriguez-Baltanas Diaz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-13 00:00:00.000000000 Z
+dependencies: []
+description: You and your friends will be vampires. Each turn you will be able to
+  move, fight, drink blood and transfer blood to the chalice.
+email: siotopo@gmail.com
+executables:
+- bloodchalice
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/bloodchalice/ai.rb
+- lib/bloodchalice/bloodchalice.rb
+- lib/bloodchalice/chalice.rb
+- lib/bloodchalice/event_deck.rb
+- lib/bloodchalice/game.rb
+- lib/bloodchalice/knight.rb
+- lib/bloodchalice/map.rb
+- lib/bloodchalice/movable.rb
+- lib/bloodchalice/peasant.rb
+- lib/bloodchalice/player.rb
+- lib/bloodchalice/tile.rb
+- lib/bloodchalice/version.rb
+- lib/bloodchalice/zombie.rb
+- lib/bloodchalice.rb
+- bin/bloodchalice
+- assets/world/map1
+homepage: https://github.com/Nerian/s9-e1
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A cooperative roleplaying videogame
+test_files: []