galaxy 0.0.2

data/lib/galaxy/models/group.rb

@@ -0,0 +1,178 @@
+require 'galaxy/models/models'
+
+class Group < ActiveRecord::Base
+  virtual
+  tableless :columns => [
+  [:num, :integer],
+  [:xx, :float], 
+  [:yy, :float], 
+  [:num_ships, :integer ],
+  [:num_before, :integer], # Number of ships BEFORE battle (for Battle Groups only)
+  [:drive, :float], 
+  [:weapons, :float], 
+  [:shields, :float], 
+  [:cargo, :float],
+  [:cargo_type, :string],
+  [:qty, :float],
+  [:range, :float],
+  [:speed, :float],
+  [:mass, :float],
+  [:status, :string] # May cause problems with AR?
+  ]  
+  belongs_to :race 
+  belongs_to :product 
+  belongs_to :planet
+  belongs_to :fleet
+  belongs_to :from, :class_name => 'Planet'
+  
+  attr_accessor :battles
+  
+  def initialize match, state
+    super()
+    update_group match, state
+  end
+  
+  # Update information on this Group (based on match size and state hash given)
+  def update_group match, state
+    race = product = planet = from = fleet = nil
+    # Make attributes hash based on match size (many constructors)
+    hash = case match.size
+      when 16 # Your Group 
+      race = state[:race]
+      p 'No planet!', match, state unless planet = Planet.lookup(match[9])
+      p 'No from!', match, state unless from = Planet.lookup(match[10]) unless match[10] == '-'
+      p 'No fleet!', match, state unless fleet = Fleet.lookup(race.name + '.' + match[14]) unless match[14] == '-'
+      product = Product.lookup(race.name + '.' + match[2])
+      product = Product.lookup(race.name + '.' + match[2])
+      {:num=>match[0].to_i, :num_ships=>match[1].to_i, :drive=>match[3].to_f, :weapons=>match[4].to_f, 
+        :shields=>match[5].to_f, :cargo=>match[6].to_f, :cargo_type=>match[7], :qty=>match[8].to_f, 
+        :range=>match[11].to_f, :speed=>match[12].to_f, :mass=>match[13].to_f, :status=>match[15]}
+      
+      when 11 # (known) * Group 
+      race = state[:race]
+      p 'No planet!', match, state unless planet = Planet.lookup(match[8])
+      p 'No product!', match, state unless product = Product.lookup(race.name + '.' + match[1])
+      {:num_ships=>match[0].to_i, :drive=>match[2].to_f, :weapons=>match[3].to_f, :shields=>match[4].to_f, 
+        :cargo=>match[5].to_f, :cargo_type=>match[6], :qty=>match[7].to_f, :speed=>match[9].to_f, :mass=>match[10].to_f}
+      
+      when 10 # Battle Group
+      race = state[:race]
+      planet = state[:planet]
+      product = Product.lookup(race.name + '.' + match[1])
+      @battles = state[:battles]
+      {:num_before=>match[0].to_i, :drive=>match[2].to_f, :weapons=>match[3].to_f, 
+        :shields=>match[4].to_f, :cargo=>match[5].to_f, :cargo_type=>match[6], :qty=>match[7].to_f,
+        :num_ships=>match[8].to_i, :status=>match[9]}
+      
+      when 5 # Incoming Group
+      planet = Planet.new [match[1]], state.merge({:race=>nil,:product=>nil,:created_by=>self}) unless planet = Planet.lookup(match[1])
+      from = Planet.new [match[0]], state.merge({:race=>nil,:product=>nil,:created_by=>self}) unless from = Planet.lookup(match[0])
+      {:range=>match[2].to_f, :speed=>match[3].to_f, :mass=>match[4].to_f}
+      
+      when 2 # Unidentified Group - TODO implement track calculation
+      {:xx=>match[0].to_f, :yy=>match[1].to_f}
+      
+      when 0 # All init data given in a state hash
+      state 
+    else {}
+    end 
+    # Set all the attributes given in hash    
+    hash.each do |key, value| 
+      setter = key.to_s.concat('=').to_sym
+      if self.respond_to? setter then self.send setter, value else raise ArgumentError end
+    end
+    # Add this Group to appropriate collections it belongs to
+    # auto-delete from previous collection should be handled by Owner class through collection callbacks
+    race.groups << self if race
+    product.groups << self if product
+    planet.groups << self if planet
+    fleet.groups << self if fleet
+    from.sent_groups << self if from
+    add if self.class.dataset # Add instantiated model to dataset if it is established
+  end
+  
+  # Accessor methods
+  def eta ; from ? range/speed : 0 end
+  
+  def x 
+    return xx if xx 
+    return planet.x if planet and !from
+    return 0 if planet and from # game.geometry.group_pos(self)[0]
+    nil
+  end
+  
+  def y 
+    return yy if yy 
+    return planet.y if planet and !from
+    return 0 if planet and from # game.geometry.group_pos(self)[0]
+    nil
+  end
+  
+  def destination ; planet end
+  
+  def origin ; from end
+  alias source origin
+  
+  def key 
+    if num # Your Group or other known race from additional reports
+      race.name + '.' + num.to_s 
+    else # Impossible to define primary key (no combination of parameters is unique)
+      nil
+    end
+  end
+  
+  def distance planet
+    #game.geometry.distance (self, planet2)
+    0 
+  end
+  
+  # Boolean tests on Groups
+  def from_battle? ; @battles and @battles > 0 end # This Group is known from Battle
+  
+  def incoming? ; !your? and from and planet and planet.your? end
+  
+  def unidentified? ; !race end
+  alias unknown? unidentified?
+  
+  def active?
+    return true unless from_battle? # All Groups are "real", unless they are known only from Battle
+    !your? and num_ships > 0 and planet.unknown? and planet.battles == self.battles # Not killed Groups from LAST Battle on UNKNOWN PLanet are "real" too
+  end  
+  alias real? active?
+  
+  def your_active? ; active? and your? end # Only includes your "active" (NOT from_battle) groups
+
+  def drone? ; (product and product.drone?) or (incoming? and mass == 1) end
+  
+  def <=>(other) # Default comparable is num_ships
+    case other
+      when nil then 1
+      when Group then # key <=> other.key
+      return 0 if key and self.key == other.key
+      if num_ships and other.num_ships then num_ships <=> other.num_ships else -1 end
+      # Meaningful comparison only possible for groups with known num_ships
+      when Race then race ? race <=> other : -1
+    when Planet then
+      return 0 if from and from == other
+      planet ? planet <=> other : -1
+      when Product then product ? product <=> other : -1
+      when Fleet then fleet ? fleet <=> other : -1
+      when Integer then num_ships ? num_ships <=> other : -1
+      when String then self <=> other.downcase.to_sym
+      when Symbol then 
+      return active? ? 0 : 1 if other == :active or other == :real or other == :alive
+      return from_battle? ? 0 : 1 if other == :from_battle or other == :battle 
+      return incoming? ? 0 : 1 if other == :incoming
+      return unidentified? ? 0 : 1 if other == :unidentified or other == :unknown
+      return 0 if race and race == other 
+      return 0 if product and product == other
+      return 0 if planet and planet == other 
+      return 0 if from and from == other 
+      return 0 if fleet and fleet == other 
+      return 0 if status and status.downcase.include? other.to_s
+      return 0 if key and key.downcase.include? other.to_s
+      -1
+    else raise ArgumentError, 'Comparison with a wrong type'
+    end
+  end
+end #Group

data/lib/galaxy/models/models.rb

@@ -0,0 +1,16 @@
+# First, 'models.rb' serves as 'super-class-equivalent' for Models, activating all the 
+# VirtualBase enhancements that can be used in Model classes (macros, class methods, instance methods)
+require 'rubygems'
+require 'active_record'
+require 'galaxy/virtual_base.rb'
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ":memory:", :timeout => 500)
+ActiveRecord::Base.send(:include, ActiveRecord::VirtualBase)
+
+# Second, 'models.rb' serves as collector, allowing clients to require 'models.rb' instead of individual Model files
+require 'galaxy/models/race'
+require 'galaxy/models/product'
+require 'galaxy/models/planet'
+require 'galaxy/models/bombing'
+require 'galaxy/models/route'
+require 'galaxy/models/fleet'
+require 'galaxy/models/group'

data/lib/galaxy/models/planet.rb

@@ -0,0 +1,181 @@
+require 'galaxy/models/models'
+
+class Planet < ActiveRecord::Base
+  virtual
+  tableless :columns => [
+  [ :num, :integer],
+  [ :x, :float ], 
+  [ :y, :float ], 
+  [ :name, :string ], 
+  [ :size, :float ], 
+  [ :pop, :float ], 
+  [ :ind, :float ], 
+  [ :res, :float ], 
+  [ :cap, :float ], 
+  [ :mat, :float ], 
+  [ :col, :float ], 
+  [ :l, :float ]
+  ]
+  belongs_to :race 
+  belongs_to :product 
+  has_many_linked :bombings 
+  has_many_linked :fleets  
+  has_many_linked :groups 
+  has_many_linked :sent_fleets, :class_name => 'Fleet', :foreign_key => 'from_id'
+  has_many_linked :sent_groups, :class_name => 'Group', :foreign_key => 'from_id'
+  has_many_linked :routes, :before_add => :add_route, :after_remove => :remove_route #, after_remove => :remove_hmt 
+  has_many_linked :incoming_routes, :foreign_key => 'target_id', :class_name => 'Route', :after_remove => :remove_route #, :after_remove => :remove_hmt 
+  
+  attr_accessor :battles, :progress, :created_by
+  
+  def add_route(route)
+    # Find if target Route of this cargo type already exist, remove previous Route if found
+    routes.each do |r|
+      remove_route r if r == route.cargo 
+    end
+  end
+  
+  def remove_route(route)
+    route.kill
+  end
+  
+  def targets
+    routes.map {|r| r.target}
+  end
+  
+  def suppliers
+    incoming_routes.map {|r| r.planet}
+  end
+  
+  def Planet.new_or_update match, state
+    # Lookup by both num and name is necessary since Routes/Fleets/Bombings create planets by name only
+    num = match[0][0,1] == '#' ? match[0] : '#' + match[0].to_s
+    name = match[3]
+    planet = Planet.lookup(num)
+    planet ||= Planet.lookup(name) if name 
+    if planet
+      planet.update_planet match, state
+    else
+      new match, state
+    end
+  end
+  
+  def initialize match, state
+    super()
+    update_planet match, state
+  end
+  
+  # Update information on Planet (based on match size and state hash given)
+  def update_planet match, state
+    # Make attributes hash based on match size (4 possible constructors
+    hash = case match.size
+      when 13 # Your Planet/ * Planet
+      prod_name = match[8]
+      prod_key = state[:race] ? state[:race].name + '.' + prod_name : nil 
+      product = Product.lookup(prod_name)
+      product ||= Product.lookup(prod_key) if prod_key 
+      product.planets << self if product
+      {:num=>match[0].to_i, :x=>match[1].to_f, :y=>match[2].to_f, :name=>match[3], :size=>match[4].to_f, 
+        :pop=>match[5].to_f, :ind=>match[6].to_f, :res=>match[7].to_f, :cap=>match[9].to_f, 
+        :mat=>match[10].to_f, :col=>match[11].to_f, :l=>match[12].to_f}
+      
+      when 8 # Uninhabited Planet
+      {:num=>match[0].to_i, :x=>match[1].to_f, :y=>match[2].to_f, :name=>match[3], :size=>match[4].to_f, 
+        :res=>match[5].to_f, :cap=>match[6].to_f, :mat=>match[7].to_f}
+      
+      when 6 # Ships In Production
+      total_mass = match[3].to_f / 10 # Mass values given in "Material units", divide by 10
+      produced_mass = match[4].to_f / 10
+      percentage = produced_mass/total_mass # Calculate ship production progress
+      {:progress=>percentage}
+      
+      when 3 # Unidentified Planet
+      {:num=>match[0].to_i, :x=>match[1].to_f, :y=>match[2].to_f}
+      
+      when 2 # Battle/Bombing generated Planet (known num and name)
+      if state[:section] = 'Battle_planets'
+        self.battles = state[:battles] = self.battles ? self.battles + 1 : 1 
+        state[:planet] = self
+      end
+      {:num=>match[0].to_i, :name=>match[1]}
+      
+      when 1 # Route/Fleet/Bombing generated Planet (given EITHER #num or name)
+      match[0][0,1] == '#' ?  
+      {:num=>match[0][1..-1].to_s} : 
+      {:name=>match[0]}
+      
+      when 0 # All init data given in a state hash
+      state 
+    else {}
+    end 
+    # Set all the attributes given in hash    
+    hash.each do |key, value| 
+      setter = key.to_s.concat('=').to_sym
+      if self.respond_to? setter then self.send setter, value else raise ArgumentError end
+    end
+    state[:race].planets << self if state[:race]
+    num ? add(numkey) : add if self.class.dataset # Add instantiated/updated model to dataset if dataset established
+    @created_by = state[:created_by]
+    self
+  end
+  
+  def key ; name ? name : numkey end
+  def numkey ; num ? '#' + num.to_s : nil end
+  
+  def distance planet
+    #game.geometry.distance (planet1, planet2)
+    0 
+  end
+  
+  def produced_full_mat
+    @progress end
+  
+  def produced_by_mat
+    return nil unless self.product and self.product.ship?
+    produced_mass = @progress*self.product.mass 
+    available_mass = self.mat/10
+    missing_mass = self.product.mass - produced_mass - available_mass
+    if missing_mass < 0
+      @progress
+    else
+      missing_l = (1/self.res+10)*missing_mass #
+      return 1-(available_mass + missing_l/10)/(produced_mass+available_mass+missing_l/10)
+    end
+  end
+  alias produced produced_by_mat
+  
+  # Boolean tests on Planets
+  def aster? ; size and size < 1 end
+  
+  def max_size? ; size and size == 2500 end
+  
+  def uninhabited? ; !race and size end
+  alias free? uninhabited?
+  
+  def unidentified? ; !race and !size end
+  alias unknown? unidentified?
+  
+  def <=>(other)
+    case other
+      when nil then 1
+      when Planet then num <=> other.num
+      when Race then race ? race <=> other : -1
+      when Product then product ? product <=> other : -1
+      when Bombing then bombings.any? {|r| r == other} ? 0 : 1 #Planet is bigger than Bombing
+      when Fleet then fleets.any? {|r| r == other} ? 0 : sent_fleets.any? {|r| r == other} ? 0 : 1 #Planet is bigger than Fleet
+      when Route then routes.any? {|r| r == other} ? 0 : incoming_routes.any? {|r| r == other}? 0 : 1 #Planet is bigger than Route
+      when Integer then num <=> other
+      when String then self <=> other.downcase.to_sym
+      when Symbol then 
+      return aster? ? 0 : 1 if other == :aster or other == :asteroid or other == :min
+      return max_size? ? 0 : 1 if other == :max_size or other == :max 
+      return uninhabited? ? 0 : 1 if other == :uninhabited or other == :free or other == :empty
+      return unidentified? ? 0 : 1 if other == :unidentified or other == :unid or other == :unknown
+      return 0 if name and name.downcase.to_sym == other
+      return 0 if race and race == other 
+      return 0 if product and product == other
+      key <=> other.to_s
+    else raise ArgumentError, 'Comparison with a wrong type'
+    end
+  end
+end #Planet

data/lib/galaxy/models/product.rb

@@ -0,0 +1,84 @@
+require 'galaxy/models/models'
+
+class Product < ActiveRecord::Base
+  virtual
+  tableless :columns => [
+  [:name, :string], 
+  [:drive, :float], 
+  [:weapons, :float], 
+  [:shields, :float], 
+  [:cargo, :float],
+  [:guns, :integer],
+  [:mass, :float],
+  [:prod_type, :string]
+  ]
+  belongs_to :race
+  has_many_linked :bombings
+  has_many_linked :groups 
+  has_many_linked :planets 
+  
+  def initialize match, state
+    case match.size
+      when 7 then # This is a ship design
+      super({:name=>match[0], :drive=>match[1].to_f, :guns=>match[2].to_i, :weapons=>match[3].to_f, 
+        :shields=>match[4].to_f, :cargo=>match[5].to_f, :mass=>match[6].to_f, :prod_type=>'ship'})
+      
+      when 5 then # This is a science
+      super({:name=>match[0], :drive=>match[1].to_f, :weapons=>match[2].to_f, :shields=>match[3].to_f, 
+        :cargo=>match[4].to_f, :prod_type=>'research'})
+      
+      when 0 then # This is Cap/Mat/Col/Drive/Weapon/Shields/Cargo init, all init data given in a hash
+      super state # :name=>state[:name], :prod_type=>state[:prod_type]
+    end
+    # Add this Product to appropriate Race collections it belongs to
+    # auto-delete from previous collection should be handled by Race class through collection callbacks
+    state[:race].products << self if state[:race]
+    add if self.class.dataset # Add instantiated model to dataset if it is defined
+  end
+  
+  def key
+    full_name = research? ? name + '_Research' : name
+    full_name = race.name + '.' + full_name if race 
+    full_name
+  end
+  
+  # Boolean tests on Products
+  def cap? ; prod_type == 'cap' end
+  
+  def mat? ; prod_type == 'mat' end
+  
+  def terraforming? ; research? and name == '_TerraForming' end
+  
+  def moving? ; name[0..3].downcase == 'move' end
+  
+  def ship? ; mass != nil end
+  
+  def drone? ; drive == 1 and mass == 1 end
+  
+  def research? ; prod_type == 'research' end
+  
+  def in_use? ; !bombings.empty? or !planets.empty? or !groups.empty?  end
+  alias science? research?
+  
+  def <=>(other)
+    case other
+      when nil then 1
+      when Race then race ? race <=> other : -1
+      when Product then (ship? and mass != other.mass) ? mass <=> other.mass : key <=> other.key
+      when Bombing then bombings.any? {|r| r == other} ? 0 : 1 #Product is bigger than Bombing
+      when Planet then planets.any? {|r| r == other} ? 0 : 1 #Product is bigger than Planet
+      when Integer then ship? ? mass <=> other : 1 #Science is bigger than anything
+      when Float then ship? ? mass <=> other : 1 #Science is bigger than anything
+      when String then self <=> other.downcase.to_sym
+      when Symbol then 
+      return drone? ? 0 : 1 if other == :drone or other == :dron
+      return research? ? 0 : 1 if other == :research or other == :science or other == :tech 
+      return moving? ? 0 : 1 if other == :move or other == :moving 
+      return terraforming? ? 0 : 1 if other == :terraform or other == :terraforming
+      return 0 if prod_type.downcase.to_sym == other
+      return 0 if key.downcase.include? other.to_s
+      key <=> other.to_s
+    else raise ArgumentError, 'Comparison with a wrong type'
+    end
+  end
+end