pugnacious_juices 1.0.1 → 1.0.2

data/bin/{pugnacious.rb → pugnacious}

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
 require_relative '../lib/pugnacious'
 
-Pugnacious::Application.run
+Pugnacious::Application.run(ARGV)

data/lib/pugnacious/application.rb

@@ -1,15 +1,17 @@
 module Pugnacious
   MAP_SIZE = 500
-  MOLECULE_SIZE = 5
+  MOLECULE_SIZE = 3
 
-  class Application
-    def self.run
+  class Application         
+    attr_accessor :number_of_molecules
+    def self.run(argv)            
       Ray.game "Pugnacious Juices", :size => [MAP_SIZE, MAP_SIZE] do
-        frames_per_second = 16
         register { add_hook :quit, method(:exit!) }
+        
+        number_of_molecules = argv[0].to_i | 250
 
         FightScene.bind(self)
-        scenes << :fight_scene
+        push_scene(:fight_scene, number_of_molecules)
       end
     end
   end

data/lib/pugnacious/fight_scene.rb

@@ -2,53 +2,22 @@ module Pugnacious
   class FightScene < Ray::Scene
     scene_name :fight_scene
 
-    def setup
-      @gc_counter = 0
-      #self.frames_per_second = 5
+    def setup(number_of_molecules)
       @player1 = Player.new(
         color: Ray::Color.blue,
         position: [0, 0],
-        control_keys: [:up, :right, :down, :left])
+        control_keys: {:up => :up, :right => :right, :down => :down, :left => :left})
 
       @player2 = Player.new(
         color: Ray::Color.red,
         position: [0, 0],
-        control_keys: [:w, :d, :s, :a])
+        control_keys: {:up => :w, :right => :d, :down => :s, :left => :a})
 
-      @player2.pointer.pos = [300, 300]
-      @player1.pointer.pos = [400, 300]
+      @player2.pointer.pos = [50, 300]
+      @player1.pointer.pos = [450, 300]
 
       @game_map = GameMap.generate_empty_map(MAP_SIZE, MAP_SIZE)
-
-      @molecules = []
-
-      @game_map.size.times do |i|
-        @molecules << Molecule.new(
-          :player    => @player1,
-          :rival     => @player2,
-          :molecules => @molecules,
-          :pos       => [i,10],
-          :map       => @game_map)
-        @molecules << Molecule.new(
-          :player    => @player1,
-          :rival     => @player2,
-          :molecules => @molecules,
-          :pos       => [i,11],
-          :map       => @game_map)
-
-        @molecules << Molecule.new(
-          :player    => @player2,
-          :rival     => @player1,
-          :molecules => @molecules,
-          :pos       => [i,72],
-          :map       => @game_map)
-        @molecules << Molecule.new(
-          :player    => @player2,
-          :rival     => @player1,
-          :molecules => @molecules,
-          :pos       => [i,75],
-          :map       => @game_map)
-      end
+      @molecules = GameMap.generate_molecules(@game_map, @player1, @player2, number_of_molecules)
 
       @players = [@player1, @player2]
     end
@@ -56,18 +25,22 @@ module Pugnacious
     def register
       always do
         @players.each do |player|
-          player.control_keys.each do |direction|
+          player.control_keys.values.each do |direction|
             if holding? direction then player.move direction end
           end
         end
 
-        @molecules.each &:move
+        @molecules.each &:move        
+        if @molecules.all?{|m| m.player == @player1} or @molecules.all?{|m| m.player == @player2}
+          @winner = text("You are the winner!!", :at => [200, 200], :size => 30)
+        end
       end
     end
 
     def render(window)
       @molecules.each { |molecule| window.draw molecule.body}
       @players.each { |player| window.draw player.pointer }
+      window.draw(@winner) unless @winner.nil?
     end
 
     def clean_up
@@ -78,6 +51,6 @@ module Pugnacious
       @players = nil
 
       Ray::ImageSet.clear
-    end
+    end   
   end
 end

data/lib/pugnacious/game_map.rb

@@ -1,21 +1,49 @@
 module Pugnacious
   class GameMap
-    attr_accessor :map
-
-    def initialize(number_of_lines, number_of_columns)
-      generate_empty_map(number_of_lines, number_of_columns)
-    end
 
     def self.generate_empty_map(number_of_lines, number_of_columns)
       game_map = []
       (number_of_columns/MOLECULE_SIZE).times do |l|
         game_map << []
         (number_of_lines/MOLECULE_SIZE).times do |c|
-          game_map[l][c] = :empty
+          game_map[l][c] = [l, c]
         end
       end
       game_map
     end
 
+    def self.generate_molecules(map, player1, player2, number)
+      molecules = []
+
+      positions = map.flatten(1).sample(number)
+
+      positions[0..(number/2)].each do |p|
+        molecules << Molecule.new(
+          :player    => player1,
+          :rival     => player2,
+          :molecules => molecules,
+          :pos       => p,
+          :map       => map)
+      end 
+
+      positions[(number/2)..number].each do |p|
+        molecules << Molecule.new(
+          :player    => player2,
+          :rival     => player1,
+          :molecules => molecules,
+          :pos       => p,
+          :map       => map)
+      end
+      
+      map.each do |l|
+        l.each_with_index do |c, index| 
+          if c.kind_of?(Array)
+            l[index] = :empty
+          end
+        end
+      end
+
+      molecules
+    end
   end
 end

data/lib/pugnacious/molecule.rb

@@ -4,7 +4,7 @@ module Pugnacious
 
     attr_accessor :player, :life, :body, :molecules, :pointer, :position, :game_map, :life, :rival
 
-    MAX_LIFE     = 40
+    MAX_LIFE     = 30
 
     def initialize(options = {})
       @player    = options[:player]
@@ -21,9 +21,9 @@ module Pugnacious
     end
 
     def receive_damage()
-      @life -=1
+      @life -=3
       if @life <= 0
-        @player = @rival
+        @rival, @player = @player, @rival
         @body.color = Ray::Color.new(100, 100, 0) + @player.color
         @life = MAX_LIFE
         @pointer = @player.pointer

data/lib/pugnacious/movable.rb

@@ -11,42 +11,76 @@ module Pugnacious
       :north_west => [-1, -1]}
 
     def move
-      try_to_go(where_is_the_pointer?) unless where_is_the_pointer? == :here
+      unless pointer_direction() == :here 
+        posible_directions = posible_directions(pointer_direction())
+      
+        posible_directions.each do |direction|
+          case check_tile(direction)
+            when :empty
+              move!(direction)
+              return
+            when :enemy
+              fight(direction)
+              return
+          end
+        end 
+      end
+    end
+    
+    def fight(direction)
+      xw, yw = DIRECTIONS[direction]
+
+      x = xw + @position[0]
+      y = yw + @position[1]
+
+      tile = @game_map[x][y]
+      
+      tile.receive_damage      
     end
 
-    def try_to_go(direction)
-      directions = DIRECTIONS.keys
-      intention_index = directions.find_index(direction)
-      directions.push(:north)
-
-      if can_i_move_there?(direction)
-        move_there(direction)
-      elsif can_i_move_there?(directions[intention_index+1])
-        move_there(directions[intention_index+1])
-      elsif can_i_move_there?(directions[intention_index-1])
-        move_there(directions[intention_index-1])
+    def posible_directions(direction)
+      directions = []
+      index = DIRECTIONS.keys.find_index(direction)
+      indexes = []
+                   
+      # The order is important. 
+      indexes << index
+      indexes << index - 1
+      indexes << index + 1
+      indexes << index - 2
+      indexes << index + 2
+      
+      directions = indexes.map do |i|
+        if i>7  
+          DIRECTIONS.keys[i-7]          
+        else
+          DIRECTIONS.keys[i]
+        end
       end
+
+      directions
     end
 
-    def can_i_move_there?(direction)
+    def check_tile(direction)
       xw, yw = DIRECTIONS[direction]
 
       x = xw + @position[0]
       y = yw + @position[1]
 
-      if @game_map[x][y] == :empty
-        return true
-      elsif @game_map[x][y].class == Molecule
-        if @game_map[x][y].player != self.player
-          @game_map[x][y].receive_damage()
-        end
-        return false
-      else
-        return false
+      tile = @game_map[x][y]
+
+      if tile == :empty
+        return :empty
+      elsif tile.class == Molecule
+        if tile.player != self.player
+          return :enemy
+        else
+          return :friend
+        end 
       end
     end
 
-    def move_there(direction)
+    def move!(direction)
       xw, yw =  DIRECTIONS[direction]
 
       x = xw + @position[0]
@@ -59,51 +93,62 @@ module Pugnacious
       @position = [x, y]
     end
 
-    def where_is_the_pointer?
-      if pointer_at_south then return :south end
-      if pointer_at_north then return :north end
-      if pointer_at_east then return :east end
-      if pointer_at_west then return :west end
-      if pointer_at_south_east then return :south_east end
-      if pointer_at_north_east then return :north_east end
-      if pointer_at_south_west then return :south_west end
-      if pointer_at_north_west then return :north_west end
-      if here then return :here end
+    def pointer_direction()
+      case
+        when pointer_at_south
+          :south
+        when pointer_at_north 
+          :north
+        when pointer_at_east 
+          :east
+        when pointer_at_west 
+          :west
+        when pointer_at_south_east
+          :south_east
+        when pointer_at_north_east 
+          :north_east
+        when pointer_at_south_west
+          :south_west
+        when pointer_at_north_west
+          :north_west
+        when here
+          :here
+      end
     end
 
-    def pointer_at_south
+    def pointer_at_south()
       @pointer.x == body.x and @pointer.y > body.y
     end
 
-    def pointer_at_north
+    def pointer_at_north()
       @pointer.x == body.x and @pointer.y < body.y
     end
 
-    def pointer_at_east
+    def pointer_at_east()
       @pointer.x > body.x and @pointer.y == body.y
     end
 
-    def pointer_at_west
+    def pointer_at_west()
       @pointer.x < body.x and @pointer.y == body.y
     end
 
-    def pointer_at_south_east
+    def pointer_at_south_east()
       @pointer.x > body.x and @pointer.y > body.y
     end
 
-    def pointer_at_north_east
+    def pointer_at_north_east()
       @pointer.x > body.x and @pointer.y < body.y
     end
 
-    def pointer_at_south_west
+    def pointer_at_south_west()
       @pointer.x < body.x and @pointer.y > body.y
     end
 
-    def pointer_at_north_west
+    def pointer_at_north_west()
       @pointer.x < body.x and @pointer.y < body.y
     end
 
-    def here
+    def here()
       @pointer.x == body.x and @pointer.y == body.y
     end
   end

data/lib/pugnacious/player.rb

@@ -10,7 +10,6 @@ module Pugnacious
       position        = options[:position] || [200, 200]
 
       @control_keys   = options[:control_keys]
-      @control_keys ||= [:up, :right, :down, :left]
 
       @pointer = Ray::Polygon.circle(position, POINTER_SIZE, @color , 3, @color)
       @pointer.filled = false
@@ -18,36 +17,15 @@ module Pugnacious
 
     def move(direction)
       case direction
-        when control_keys_up
+        when control_keys[:up]
           pointer.y -= SPEED unless (pointer.pos.y -= SPEED) < 0 + POINTER_SIZE
-        when control_keys_right
+        when control_keys[:right]
           pointer.x += SPEED unless (pointer.pos.x += SPEED) > MAP_SIZE - POINTER_SIZE
-        when control_keys_down
+        when control_keys[:down]
           pointer.y += SPEED unless (pointer.pos.y += SPEED) > MAP_SIZE - POINTER_SIZE
-        when control_keys_left
+        when control_keys[:left]
           pointer.x -= SPEED unless (pointer.pos.x -= SPEED) < 0 + POINTER_SIZE
       end
     end
-
-    ########################
-    # Control keys aliases
-    #######################
-
-    def control_keys_up
-      control_keys[0]
-    end
-
-    def control_keys_right
-      control_keys[1]
-    end
-
-    def control_keys_down
-      control_keys[2]
-    end
-
-    def control_keys_left
-      control_keys[3]
-    end
-
   end
 end

data/lib/pugnacious/version.rb

@@ -1,3 +1,3 @@
 module Pugnacious
-  VERSION = '1.0.1'
+  VERSION = '1.0.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pugnacious_juices
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2011-09-14 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ray
-  requirement: &70118925055960 !ruby/object:Gem::Requirement
+  requirement: &70135957685520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,11 +21,11 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70118925055960
+  version_requirements: *70135957685520
 description: It is a clone of Liquid Wars.
 email: siotopo@gmail.com
 executables:
-- pugnacious.rb
+- pugnacious
 extensions: []
 extra_rdoc_files: []
 files:
@@ -37,7 +37,7 @@ files:
 - lib/pugnacious/player.rb
 - lib/pugnacious/version.rb
 - lib/pugnacious.rb
-- bin/pugnacious.rb
+- bin/pugnacious
 homepage: https://github.com/Nerian/Pugnacious-Juices
 licenses: []
 post_install_message: