driving_physics 0.0.0.2 → 0.0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b32478386d13b88eb67f9d2bb826c23dd06dd5100d807aa918cea6af962c6e3
-  data.tar.gz: 3ebcad787d058dac2d36718d46e5cf400dcc968f06427d2f65af4d1682f99166
+  metadata.gz: ec6ff08e7731aa8bcb419efee9ab1a96ef7642f3426c7b8a501dae764692d777
+  data.tar.gz: ae217c0e452a764392e5a4df9a0b3280369e21b92d6018ef8d8753c0a6f5f594
 SHA512:
-  metadata.gz: 4ce4c55bbb0e9e5f12146856c45df05860443b18d7fd54c173e8b3026e55e1c8ccdfa3e9d48a6974af5f28c79e6df04b487c9728d5a831ec88d657a7ce997db1
-  data.tar.gz: 28ea2e0361cc180a5a405ed66caffcced3d1669ec18b87ce14f3ab0d77d130de9bd92864a2b78bddbcee236fff7bd982d66272456c4ba81eec43b863691e044d
+  metadata.gz: b8844bf3f8c45aae742bc27cbfe8307b7f61f21a600d1eac7f34248aa9a980f9942f6e4ce51ec2b58834978e4ba1a06aa0153ba4323d4e3448b1f038c39495e2
+  data.tar.gz: b41f09936f696ef4afe82f3be701409abddd6b92add4f39d5d1d42a1a412ce4204b08a411818c339bba6820858a0aae3d5324cdbabff76e2b2256e9228ae1120

data/Rakefile

@@ -32,10 +32,13 @@ rescue LoadError
 end
 
 begin
-  require 'flay_task'
-  FlayTask.new do |t|
-    t.dirs = ['lib']
-    t.verbose = true
+  # need to stop looking in old/ and also the scoring seems wack
+  if false
+    require 'flay_task'
+    FlayTask.new do |t|
+      t.dirs = ['lib']
+      t.verbose = true
+    end
   end
 rescue LoadError
   warn 'flay_task unavailable'
@@ -49,6 +52,10 @@ rescue LoadError
   warn "roodi_task unavailable"
 end
 
+#
+# GEM BUILD / PUBLISH
+#
+
 begin
   require 'buildar'
 

data/VERSION

@@ -1 +1 @@
-0.0.0.2
+0.0.0.3

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: driving_physics
 version: !ruby/object:Gem::Version
-  version: 0.0.0.2
+  version: 0.0.0.3
 platform: ruby
 authors:
 - Rick Hull
@@ -19,24 +19,18 @@ files:
 - README.md
 - Rakefile
 - VERSION
-- demo/car.rb
 - demo/scalar_force.rb
-- demo/tire.rb
 - demo/vector_force.rb
 - demo/wheel.rb
 - driving_physics.gemspec
 - lib/driving_physics.rb
-- lib/driving_physics/car.rb
 - lib/driving_physics/environment.rb
 - lib/driving_physics/imperial.rb
 - lib/driving_physics/scalar_force.rb
-- lib/driving_physics/tire.rb
 - lib/driving_physics/vector_force.rb
 - lib/driving_physics/wheel.rb
-- test/car.rb
 - test/driving_physics.rb
 - test/scalar_force.rb
-- test/tire.rb
 - test/vector_force.rb
 - test/wheel.rb
 homepage: https://github.com/rickhull/driving_physics

data/demo/car.rb

@@ -1,28 +0,0 @@
-require 'driving_physics/car'
-
-DP = DrivingPhysics
-
-env = DP::Environment.new
-car = DP::Car.new(env)
-car.add_fuel 10
-duration = 120 # seconds
-
-puts env
-puts
-puts car
-
-car.controls.drive_pedal = 1.0
-
-(duration * env.hz).times { |i|
-  car.tick!
-  if i % env.hz == 0
-    if car.sum_forces.magnitude < 1
-      car.controls.drive_pedal = 0.0
-      car.controls.brake_pedal = 1.0
-    end
-    puts
-    puts "[t = #{i / env.hz}]"
-    puts car
-    gets if i % (env.hz * 10) == 0
-  end
-}

data/demo/tire.rb

@@ -1,169 +0,0 @@
-require 'driving_physics/tire'
-
-include DrivingPhysics
-
-t = Tire.new
-t.condition.debug_temp = false
-
-# drive time
-mins = 45
-
-drive_map = {
-  acc: {
-    label: "ACCELERATING",
-    g: 0.5,
-    fuel: 0.0002, # kg consumed / tick
-    small_slide: 1, # m/s of wheelspin
-    big_slide: 10,
-    seconds: 1,
-    next_sector: :brake,
-  },
-  brake: {
-    label: "BRAKING",
-    g: 1.0,
-    fuel: 0.00001,
-    small_slide: 0.5,
-    big_slide: 2,
-    seconds: 1,
-    next_sector: :corner,
-  },
-  corner: {
-    label: "CORNERING",
-    g: 0.8,
-    fuel: 0.0001,
-    small_slide: 0.5,
-    big_slide: 5,
-    seconds: 2,
-    next_sector: :acc,
-  },
-}
-
-slide_speed = 0
-sliding = false
-mass = 900.0
-ambient_temp = 25
-critical_temp = 100
-
-drive_time = 0   # how many ticks elapsed in the current sector
-sector_map = drive_map[:acc]
-puts "ACCELERATING"
-puts "---"
-
-cooldown = false
-pushing = false
-
-# 100 ticks / sec
-(mins * 60 * 100).times { |i|
-  drive_time += 1
-
-  dynamic_g = sector_map[:g]
-
-  if t.condition.temp_c <= 80 and cooldown
-    puts "ENDING COOLDOWN"
-    cooldown = false
-  elsif t.condition.temp_c >= 110 and Random.rand(100) >= 90
-    puts "COOLING DOWN"
-    cooldown = true
-  end
-  dynamic_g -= 0.2 if cooldown
-
-  if pushing
-    # stop pushing at very high temp
-    # 1/1000 chance to stop pushing
-    if cooldown
-      puts "ENDING PUSH BECAUSE COOLDOWN"
-      pushing = false
-    else
-      if t.condition.temp_c >= critical_temp and Random.rand(1000) >= 999
-        puts "ENDING PUSH"
-        pushing = false
-      else
-        dynamic_g += 0.2
-      end
-    end
-  else
-    if !cooldown and
-      t.condition.temp_c <= critical_temp and
-      Random.rand(1000) >= 999
-
-      puts "PUSHING!"
-      pushing = true
-      dynamic_g += 0.2
-    end
-  end
-
-  if sliding
-    # 5% chance to end the slide
-    if Random.rand(100) >= 95
-      puts "   -= CAUGHT THE SLIDE! =-"
-      sliding = false
-      slide_speed = 0
-    end
-  else
-    # 1% chance to start a small slide
-    # 0.1% chance to start a big slide
-    if Random.rand(100) >= 99
-      puts "   -= SMALL SLIDE! =-"
-      sliding = true
-      slide_speed = sector_map[:small_slide]
-    elsif Random.rand(1000) >= 999
-      puts "   -= BIG SLIDE! =-"
-      sliding = true
-      slide_speed = sector_map[:big_slide]
-    end
-  end
-
-  # fuel consumption
-  # 5L of fuel should last 5 minutes
-  # ~3.5 kg of fuel consumption
-  # 1.2e-4 kg / tick
-  mass -= sector_map[:fuel]
-
-  begin
-    t.condition.tick!(ambient_temp: ambient_temp, g: dynamic_g,
-                      slide_speed: slide_speed,
-                      mass: mass, tire_mass: 12, critical_temp: critical_temp)
-
-    if i % 10 == 0
-      condition = if pushing
-                    "Pushing"
-                  elsif cooldown
-                    "Cooldown"
-                  else
-                    "Normal"
-                  end
-
-      puts [sector_map[:label].ljust(12, ' '),
-            '%.2f' % dynamic_g,
-            '%.1f' % slide_speed,
-            '%.3f' % t.condition.temp_c,
-           ].join('  ')
-    end
-    if i % 600 == 0
-      puts
-      puts "Condition: #{condition}"
-      puts "Mass: #{'%.2f' % mass} kg"
-      if t.condition.tread_mm > 0
-        puts "Tread remaining: #{'%.3f' % t.condition.tread_mm}"
-      else
-        puts "Cords remaining: #{'%.3f' % t.condition.cords_mm}"
-      end
-      puts "Heat cycles: #{t.condition.heat_cycles}"
-      puts DrivingPhysics.elapsed_display(i * 10)
-      puts "[Enter] to continue"
-      gets
-    end
-  rescue Tire::Condition::Error => e
-    puts "FATAL:"
-    puts [e.class, e.message].join(': ')
-    break
-  end
-
-  if drive_time > sector_map[:seconds] * 100
-    sector_map = drive_map[sector_map[:next_sector]]
-    drive_time = 0
-    puts
-    puts sector_map[:label]
-    puts '---'
-  end
-}

data/lib/driving_physics/car.rb

@@ -1,294 +0,0 @@
-require 'driving_physics/environment'
-require 'driving_physics/vector_force'
-require 'driving_physics/tire'
-
-module DrivingPhysics
-  # treat instances of this class as immutable
-  class Car
-    attr_accessor :mass, :min_turn_radius,
-                  :max_drive_force, :max_brake_clamp, :max_brake_force,
-                  :fuel_capacity, :brake_pad_depth, :driver_mass,
-                  :frontal_area, :cd, :fuel_consumption,
-                  :tires, :controls, :condition
-
-    def initialize(environment)
-      @environment = environment
-      @mass             = 1000  # kg, without fuel or driver
-      @min_turn_radius = 10     # meters
-      @max_drive_force = 7000   # N - 1000kg car at 0.7g acceleration
-      @max_brake_clamp = 100    # N
-      @max_brake_force = 40_000 # N - 2000kg car at 2g braking
-      @fuel_capacity   = 40     # L
-      @brake_pad_depth = 10     # mm
-      @driver_mass     = 75     # kg
-      @fuel_consumption = 0.02  # L/s at full throttle
-
-      @frontal_area = DrivingPhysics::FRONTAL_AREA # m^2
-      @cd = DrivingPhysics::DRAG_COF
-
-      @tires = Tire.new
-      @controls = Controls.new
-      @condition = Condition.new(brake_temp: @environment.air_temp,
-                                 brake_pad_depth: @brake_pad_depth)
-
-      # consider downforce
-      # probably area * angle
-      # goes up with square of velocity
-
-      yield self if block_given?
-    end
-
-    def to_s
-      [[format("Mass: %.1f kg", total_mass),
-        format("Power: %.1f kN", @max_drive_force.to_f / 1000),
-        format("Brakes: %.1f kN", @max_brake_force.to_f / 1000),
-        format("Fr.A: %.2f m^2", @frontal_area),
-        format("cD: %.2f", @cd),
-       ].join(' | '),
-       [format("Op: %d N", drive_force - brake_force),
-        format("Drive: %d N", drive_force),
-        format("Brake: %d N", brake_force),
-       ].join(' | '),
-       [format("Net: %.1f N", sum_forces.magnitude),
-        format("Air: %.1f N", air_resistance.magnitude),
-        format("Rot: %.1f N", rotational_resistance.magnitude),
-        format("Roll: %.1f N", rolling_resistance.magnitude),
-       ].join(' | '),
-        @controls, @condition, @tires,
-      ].join("\n")
-    end
-
-    def tick!
-      @condition.tick!(force: sum_forces,
-                       mass: total_mass,
-                       tire: @tires,
-                       env: @environment)
-
-      @condition.consume_fuel(@fuel_consumption *
-                              @controls.drive_pedal *
-                              @environment.tick)
-    end
-
-    def drive_force
-      @condition.fuel > 0.0 ? (@max_drive_force * @controls.drive_pedal) : 0.0
-    end
-
-    def drive_force_vector
-      @condition.dir * drive_force
-    end
-
-    def brake_force
-      @max_brake_force * @controls.brake_pedal
-    end
-
-    def brake_force_vector
-      -1 * @condition.movement_dir * brake_force
-    end
-
-    def fuel_mass
-      @condition.fuel * @environment.petrol_density
-    end
-
-    def total_mass
-      @mass + fuel_mass + @driver_mass
-    end
-
-    def weight
-      total_mass * @environment.g
-    end
-
-    def add_fuel(liters)
-      sum = @condition.fuel + liters
-      overflow = sum > @fuel_capacity ? sum - @fuel_capacity : 0
-      @condition.add_fuel(liters - overflow)
-      overflow
-    end
-
-    def air_resistance
-      # use default air density for now
-      VectorForce.air_resistance(@condition.vel,
-                                 frontal_area: @frontal_area,
-                                 drag_cof: @cd)
-    end
-
-    def rotational_resistance
-      # uses default ROT_COF
-      VectorForce.rotational_resistance(@condition.vel)
-    end
-
-    def rolling_resistance
-      # TODO: downforce
-      VectorForce.rolling_resistance(weight,
-                                     dir: @condition.movement_dir,
-                                     roll_cof: @tires.roll_cof)
-    end
-
-    def applied_force
-      drive_force_vector + brake_force_vector
-    end
-
-    def natural_force
-      air_resistance + rotational_resistance + rolling_resistance
-    end
-
-    def sum_forces
-      applied_force + natural_force
-    end
-
-    class Controls
-      attr_reader :drive_pedal, :brake_pedal, :steering_wheel
-
-      def initialize
-        @drive_pedal = 0.0     # up to 1.0
-        @brake_pedal = 0.0     # up to 1.0
-        @steering_wheel = 0.0  # -1.0 to 1.0
-      end
-
-      def drive_pedal=(flt)
-        @drive_pedal = flt.clamp(0.0, 1.0)
-      end
-
-      def brake_pedal=(flt)
-        @brake_pedal = flt.clamp(0.0, 1.0)
-      end
-
-      def steering_wheel=(flt)
-        @steering_wheel = steering_wheel.clamp(-1.0, 1.0)
-      end
-
-      def to_s
-        [format("Throttle: %d%%", @drive_pedal * 100),
-         format("Brake: %d%%", @brake_pedal * 100),
-         format("Steering: %d%%", @steering_wheel * 100),
-        ].join(" | ")
-      end
-    end
-
-    class Condition
-      unless Vector.method_defined?(:zero?)
-        using VectorZeroBackport
-      end
-
-      attr_reader :dir, :pos, :vel, :acc, :fuel, :lat_g, :lon_g,
-                  :wheelspeed, :brake_temp, :brake_pad_depth
-
-      def initialize(dir: DrivingPhysics.random_unit_vector,
-                     brake_temp: AIR_TEMP,
-                     brake_pad_depth: )
-        @dir = dir  # maybe rename to @heading ?
-        @pos = Vector[0, 0]
-        @vel = Vector[0, 0]
-        @acc = Vector[0, 0]
-        @fuel = 0.0   # L
-        @lat_g = 0.0  # g
-        @lon_g = 0.0  # g
-        @wheelspeed = 0.0 # m/s (sliding when it differs from @speed)
-        @brake_temp = brake_temp
-        @brake_pad_depth = brake_pad_depth   # mm
-      end
-
-      def to_s
-        [[compass,
-          format('P(%d, %d)', @pos[0], @pos[1]),
-          format('V(%.1f, %.1f)', @vel[0], @vel[1]),
-          format('A(%.2f, %.2f)', @acc[0], @acc[1]),
-         ].join(' | '),
-         [format('%.1f m/s', speed),
-          format('LatG: %.2f', lat_g),
-          format('LonG: %.2f', lon_g),
-          format('Whl: %.1f m/s', @wheelspeed),
-          format('Slide: %.1f m/s', slide_speed),
-         ].join(' | '),
-         [format('Brakes: %.1f C %.1f mm', @brake_temp, @brake_pad_depth),
-          format('Fuel: %.2f L', @fuel),
-         ].join(' | ')
-        ].join("\n")
-      end
-
-      # left is negative, right is positive
-      def lat_dir
-        DrivingPhysics.rot_90(@dir, clockwise: true)
-      end
-
-      # note, we might be moving backwards, so not always @dir
-      # and we can't normalize a zero vector if we're not moving
-      def movement_dir
-        (speed == 0.0) ? @dir : @vel.normalize
-      end
-
-      def tick!(force:, mass:, tire:, env:)
-        # take the longitudinal component of the force, relative to vel dir
-        vel_dir = @vel.zero? ? @dir : @vel.normalize
-        lon_force = force.dot(vel_dir)
-        @wheelspeed = nil
-
-        if lon_force < 0.0
-          is_stopping = true
-          if @vel.zero?
-            @acc = Vector[0,0]
-            @wheelspeed = 0.0
-            @lon_g = 0.0
-
-            # TODO: update any other physical vars
-            return
-          end
-        else
-          is_stopping = false
-        end
-
-        # now detect sliding
-        nominal_acc = DrivingPhysics.acc(force, mass)
-        init_v = @vel
-
-        if nominal_acc.magnitude > tire.max_g * env.g
-          nominal_v = DrivingPhysics.vel(@vel, nominal_acc, dt: env.tick)
-
-          # check for reversal of velocity; could be wheelspin while
-          # moving backwards, so can't just look at is_stopping
-          if nominal_v.dot(@vel) < 0 and is_stopping
-            @wheelspeed = 0.0
-          else
-            @wheelspeed = nominal_v.magnitude
-          end
-          @acc = nominal_acc.normalize * tire.max_g * env.g
-        else
-          @acc = nominal_acc
-        end
-
-        @vel = DrivingPhysics.vel(@vel, @acc, dt: env.tick)
-        @wheelspeed ||= @vel.magnitude
-
-        # finally, detect velocity reversal when stopping
-        if is_stopping and @vel.dot(init_v) < 0
-          puts "crossed zero; stopping!"
-          @vel = Vector[0, 0]
-          @wheelspeed = 0.0
-          @lon_g = 0.0
-        end
-
-        @lon_g = @acc.dot(@dir) / env.g
-        @pos = DrivingPhysics.pos(@pos, @vel, dt: env.tick)
-      end
-
-      def add_fuel(liters)
-        @fuel += liters
-      end
-
-      def consume_fuel(liters)
-        @fuel -= liters
-      end
-
-      def speed
-        @vel.magnitude
-      end
-
-      def slide_speed
-        (speed - @wheelspeed).abs
-      end
-
-      def compass
-        DrivingPhysics.compass_dir(@dir)
-      end
-    end
-  end
-end

data/lib/driving_physics/tire.rb

@@ -1,288 +0,0 @@
-# NOTE: This entire file will likely be replaced or removed.
-#       It was created early on, before taking a true physics / formulaic
-#       approach.  Just treat it as a toy / PoC for now.  It does not
-#       currently behave as desired.
-#
-
-require 'driving_physics'
-
-# treat instances of this class as immutable
-# Tire::Condition has mutable attributes
-#
-module DrivingPhysics
-  class Tire
-    class Error < RuntimeError; end
-
-    attr_accessor :roll_cof,
-                  :tread_mm,
-                  :cords_mm,
-                  :radius_mm,
-                  :g_factor,
-                  :max_heat_cycles,
-                  :temp_profile,
-                  :condition
-
-    def initialize
-      @roll_cof = ROLL_COF
-      @tread_mm = 10
-      @cords_mm = 1
-      @radius_mm = 350
-      @g_factor = 1.0
-      @max_heat_cycles = 50
-      @temp_profile = TemperatureProfile.new
-
-      yield self if block_given?
-      @condition = Condition.new(tread_mm: @tread_mm, cords_mm: @cords_mm)
-    end
-
-    def to_s
-      [[format("Grip: %.2f / %.1f G", max_g, @g_factor),
-        format("Radius: %d mm", @radius_mm),
-        format("cRR: %.3f", @roll_cof),
-       ].join(' | '),
-       @condition,
-      ].join("\n")
-    end
-
-    def tread_left?
-      @condition.tread_mm > 0.0
-    end
-
-    # cords give half the traction as tread
-    def tread_factor
-      tread_left? ? 1.0 : 0.5 * @condition.cords_mm / @cords_mm
-    end
-
-    # up to max_heat_cycles, the grip decays down to 80%
-    # beyond max_heat_cycles, the grip decay plateaus at 80%
-    def heat_cycle_factor
-      heat_cycles = [@condition.heat_cycles, @max_heat_cycles].min.to_f
-      heat_pct = heat_cycles / @max_heat_cycles
-      1.0 - 0.2 * heat_pct
-    end
-
-    def temp_factor
-      @temp_profile.grip_factor(@condition.temp_c)
-    end
-
-    def max_g
-      @g_factor * temp_factor * heat_cycle_factor * tread_factor
-    end
-
-    # treat instances of this class as immutable
-    class TemperatureProfile
-      class Error < DrivingPhysics::Tire::Error; end
-
-      TEMPS = [-100, 0, 25, 50, 75, 80, 85, 95, 100, 105, 110, 120, 130, 150]
-      GRIPS = [0.1, 0.5, 0.75, 0.8, 0.9, 0.95, 1.0,
-               0.95, 0.9, 0.75, 0.5, 0.25, 0.1, 0.05]
-      MIN_GRIP = 0.01
-
-      attr_reader :critical_temp
-
-      def initialize(deg_ary = TEMPS, grip_ary = GRIPS)
-        if !deg_ary.is_a?(Array) or !grip_ary.is_a?(Array)
-          raise(ArgumentError, "two arrays are required")
-        end
-        if deg_ary.count != grip_ary.count
-          raise(ArgumentError, "arrays don't match")
-        end
-        @deg_c = deg_ary
-        @grip_pct = grip_ary
-        @critical_temp = nil
-        determine_critical_temp!
-      end
-
-      def grip_factor(temp_c)
-        pct = MIN_GRIP
-        @deg_c.each_with_index { |deg, i|
-          pct = @grip_pct[i] if temp_c >= deg
-          break if temp_c < deg
-        }
-        pct
-      end
-
-      def to_s
-        lines = []
-        @deg_c.each_with_index { |deg, i|
-          lines << [deg, @grip_pct[i]].join("\t")
-        }
-        lines.join("\n")
-      end
-
-      private
-      def determine_critical_temp!
-        return @critical_temp if @critical_temp
-        reached_100 = false
-        # go up to 100% grip, then back down to less than 80%
-        @deg_c.each_with_index { |deg, i|
-          next if !reached_100 and @grip_pct[i] < 1.0
-          reached_100 = true if @grip_pct[i] == 1.0
-          if reached_100 and @grip_pct[i] <= 0.8
-            @critical_temp = deg
-            break
-          end
-        }
-        raise(Error, "bad profile, can't find 100% grip") unless reached_100
-        raise(Error, "bad profile, no critical temp") unless @critical_temp
-      end
-    end
-
-    # treat attributes of this class as *mutable*
-    class Condition
-      class Error < DrivingPhysics::Tire::Error; end
-      class Destroyed < Error; end
-
-      attr_accessor :tread_mm,
-                    :cords_mm,
-                    :temp_c,
-                    :heat_cycles,
-                    :debug_temp,
-                    :debug_wear
-
-      def initialize(temp_c: AIR_TEMP, tread_mm:, cords_mm:)
-        @tread_mm = tread_mm.to_f
-        @cords_mm = cords_mm.to_f
-        @temp_c = temp_c.to_f
-        @heat_cycles = 0
-        @hottest_temp = @temp_c
-        @debug_temp = false
-        @debug_wear = false
-      end
-
-      def to_s
-        [format("Temp: %.1f C", @temp_c),
-         format("Tread: %.2f (%.1f) mm", @tread_mm, @cords_mm),
-         format("Cycles: %d", @heat_cycles),
-        ].join(' | ')
-      end
-
-      def temp_tick(ambient_temp:, g:, slide_speed:,
-                    mass:, tire_mass:, critical_temp:)
-        # env:
-        # * mass (kg) (e.g. 1000 kg)
-        # * tire_mass (kg) (e.g. 10 kg)
-        # * critical temp (c) (e.g. 100c)
-        # * g (e.g. 1.0 g)
-        # * slide_speed (m/s) (typically 0.1, up to 1 or 10 or 50)
-        # * ambient_temp (c) (e.g. 30c)
-
-        # g gives a target temp between 25 and 100
-        # at 0g, tire tends to ambient temp
-        # at 1g, tire tends to 100 c
-        # that 100c upper target also gets adjusted due to ambient temps
-
-        target_hot = critical_temp + 5
-        ambient_diff = AIR_TEMP - ambient_temp
-        target_hot -= (ambient_diff / 2)
-        puts "target_hot=#{target_hot}" if @debug_temp
-
-        if slide_speed <= 0.1
-          target_g_temp = ambient_temp + (target_hot - ambient_temp) * g
-        else
-          target_g_temp = target_hot
-        end
-        puts "target_g_temp=#{target_g_temp}" if @debug_temp
-
-        slide_factor = slide_speed * 5
-        target_slide_temp = target_g_temp + slide_factor
-
-        puts "target_slide_temp=#{target_slide_temp}" if @debug_temp
-
-        # temp_tick is presumed to be +1.0 or -1.0 (100th of a degree)
-        # more mass biases towards heat
-        # more tire mass biases for smaller tick
-
-        tick = @temp_c < target_slide_temp ? 1.0 : -1.0
-        tick += slide_speed / 10
-        puts "base tick: #{tick}" if @debug_temp
-
-        mass_factor = (mass - 1000).to_f / 1000
-        if mass_factor < 0
-          # lighter car cools quicker; heats slower
-          tick += mass_factor
-        else
-          # heavier car cools slower, heats quicker
-          tick += mass_factor / 10
-        end
-        puts "mass tick: #{tick}" if @debug_temp
-
-        tire_mass_factor = (tire_mass - 10).to_f / 10
-        if tire_mass_factor < 0
-          # lighter tire has bigger tick
-          tick -= tire_mass_factor
-        else
-          # heavier tire has smaller tick
-          tire_mass_factor = (tire_mass - 10).to_f / 100
-          tick -= tire_mass_factor
-        end
-        puts "tire mass tick: #{tick}" if @debug_temp
-        puts if @debug_temp
-
-        tick
-      end
-
-      def wear_tick(g:, slide_speed:, mass:, critical_temp:)
-        # cold tires wear less
-        tick = [0, @temp_c.to_f / critical_temp].max
-        puts "wear tick: #{tick}" if @debug_wear
-
-        # lower gs reduce wear in the absence of sliding
-        tick *= g if slide_speed <= 0.1
-        puts "g wear tick: #{tick}" if @debug_wear
-
-        # slide wear
-        tick += slide_speed
-        puts "slide wear tick: #{tick}" if @debug_wear
-        puts if @debug_wear
-        tick
-      end
-
-
-      def tick!(ambient_temp:, g:, slide_speed:,
-                mass:, tire_mass:, critical_temp:)
-
-        # heat cycle:
-        # when the tire goes above the critical temp and then
-        # cools significantly below the critical temp
-        # track @hottest_temp
-
-        @temp_c += temp_tick(ambient_temp: ambient_temp,
-                             g: g,
-                             slide_speed: slide_speed,
-                             mass: mass,
-                             tire_mass: tire_mass,
-                             critical_temp: critical_temp) / 100
-        @hottest_temp = @temp_c if @temp_c > @hottest_temp
-        if @hottest_temp > critical_temp and @temp_c < critical_temp * 0.8
-          @heat_cycles += 1
-          @hottest_temp = @temp_c
-        end
-
-        # a tire should last for 30 minutes at 1g sustained
-        # with minimal sliding
-        # 100 ticks / sec
-        # 6000 ticks / min
-        # 180_000 ticks / 30 min
-        # 10mm = 180_000 ticks
-        # wear_tick is nominally 1 / 18_000 mm
-
-        wt = wear_tick(g: g,
-                       slide_speed: slide_speed,
-                       mass: mass,
-                       critical_temp: critical_temp)
-
-        if @tread_mm > 0
-          @tread_mm -= wt / 18000
-          @tread_mm = 0 if @tread_mm < 0
-        else
-          # cords wear 2x faster
-          @cords_mm -= wt * 2 / 18000
-          if @cords_mm <= 0
-            raise(Destroyed, "no more cords")
-          end
-        end
-      end
-    end
-  end
-end

data/test/car.rb

@@ -1,156 +0,0 @@
-require 'minitest/autorun'
-require 'driving_physics/car'
-
-C = DrivingPhysics::Car
-
-describe C do
-  before do
-    @env = DrivingPhysics::Environment.new
-    @c = C.new(@env)
-  end
-
-  def get_moving
-    @c.controls.brake_pedal = 0.0
-    @c.controls.drive_pedal = 1.0
-    @c.add_fuel 10
-    50.times { @c.tick! }
-    expect(@c.condition.speed).must_be :>, 0.0
-  end
-
-
-  it "initializes" do
-    expect(@c).must_be_instance_of C
-  end
-
-  it "has a string representation" do
-    str = @c.to_s
-    expect(str).must_be_instance_of String
-    expect(str.length).must_be(:>, 5)
-  end
-
-  it "adds fuel and reports overflow" do
-    expect(@c.condition.fuel).must_equal 0.0
-    @c.add_fuel 10.0
-    expect(@c.condition.fuel).must_equal 10.0
-    overflow = @c.add_fuel @c.fuel_capacity
-    expect(@c.condition.fuel).must_equal @c.fuel_capacity
-    expect(overflow).must_equal 10.0
-  end
-
-  it "varies drive_force based on drive_pedal and available fuel" do
-    expect(@c.drive_force).must_equal 0.0  # no pedal
-    @c.controls.drive_pedal = 1.0
-    expect(@c.drive_force).must_equal 0.0  # no fuel
-    @c.add_fuel 10
-
-    expect(@c.drive_force).must_equal @c.max_drive_force  # vroom!
-  end
-
-  it "has a drive vector in direction of @dir" do
-    @c.add_fuel 10
-    @c.controls.drive_pedal = 1.0
-    dv = @c.drive_force_vector
-    expect(dv).must_be_instance_of Vector
-    dvn = dv.normalize
-    [0,1].each { |dim|
-      expect(dvn[dim]).must_be_within_epsilon @c.condition.dir[dim]
-    }
-  end
-
-  it "varies brake_force based on brake_pedal" do
-    expect(@c.brake_force).must_equal 0.0  # no pedal
-    @c.controls.brake_pedal = 1.0
-    expect(@c.brake_force).must_equal @c.max_brake_force
-  end
-
-  it "has a brake vector opposing movement or @dir" do
-    # hmm, no good way to go in reverse
-    # just test against forward movement for now
-    @c.controls.brake_pedal = 1.0
-    bv = @c.brake_force_vector
-    expect(bv).must_be_instance_of Vector
-    bvn = bv.normalize
-    [0,1].each { |dim|
-      expect(bvn[dim]).must_be_within_epsilon @c.condition.dir[dim] * -1
-    }
-
-    get_moving
-
-    @c.controls.drive_pedal = 0.0
-    @c.controls.brake_pedal = 1.0
-    bdir = @c.brake_force_vector.normalize
-    vdir = @c.condition.vel.normalize
-    [0,1].each { |dim|
-      expect(bdir[dim]).must_be_within_epsilon vdir[dim] * -1
-    }
-  end
-
-  it "tracks the mass of remaining fuel" do
-    expect(@c.fuel_mass).must_equal 0.0
-    @c.add_fuel 10
-    expect(@c.fuel_mass).must_be_within_epsilon 7.1
-  end
-
-  it "tracks total_mass including fuel and driver" do
-    expect(@c.total_mass).must_equal @c.mass + @c.driver_mass
-    @c.add_fuel 10
-    expect(@c.total_mass).must_equal @c.mass + @c.fuel_mass + @c.driver_mass
-  end
-
-  it "computes the total weight based on G" do
-    expect(@c.weight).must_be_within_epsilon 10535.0
-  end
-
-  it "computes resistance forces based on instance variables" do
-    air = @c.air_resistance
-    expect(air).must_be_kind_of Vector
-    expect(air.magnitude).must_equal 0.0
-
-    rot = @c.rotational_resistance
-    expect(rot).must_be_kind_of Vector
-    expect(rot.magnitude).must_equal 0.0
-
-    roll = @c.rolling_resistance
-    expect(roll).must_be_kind_of Vector
-    expect(roll.magnitude).must_be :>, 0
-  end
-
-  describe C::Condition do
-    before do
-      @cond = @c.condition
-    end
-
-    it "intializes" do
-      expect(@cond).must_be_kind_of C::Condition
-    end
-
-    it "has a string representation" do
-      str = @cond.to_s
-      expect(str).must_be_kind_of String
-      expect(str.length).must_be :>, 5
-    end
-
-    it "has a lateral direction clockwise from @dir" do
-      lat = @cond.lat_dir
-      expect(lat).must_be_kind_of Vector
-      expect(lat.magnitude).must_be_within_epsilon 1.0
-      expect(lat.independent?(@cond.dir)).must_equal true
-    end
-
-    it "has a movement_dir based on velocity, or @dir when stopped" do
-      md = @cond.movement_dir
-      expect(md).must_be_kind_of Vector
-      expect(md.magnitude).must_be_within_epsilon 1.0
-      expect(md).must_equal @cond.dir
-
-      get_moving
-      md = @cond.movement_dir
-      expect(md).must_be_kind_of Vector
-      expect(md.magnitude).must_be_within_epsilon 1.0
-      vd = @cond.vel.normalize
-      [0,1].each { |dim|
-        expect(md[dim]).must_be_within_epsilon vd[dim]
-      }
-    end
-  end
-end

data/test/tire.rb

@@ -1,125 +0,0 @@
-require 'driving_physics/tire'
-require 'minitest/autorun'
-
-include DrivingPhysics
-
-describe Tire do
-  TP = Tire::TemperatureProfile
-
-  describe TP do
-    before do
-      @tp = TP.new
-    end
-
-    it "initializes with two same-sized arrays" do
-      expect(@tp).must_be_kind_of TP
-      expect(TP.new([0,1,2,3], [0,1.0,0.7,0.4])).wont_be_nil
-      expect { TP.new('', '') }.must_raise ArgumentError
-      expect { TP.new([]) }.must_raise ArgumentError
-      expect { TP.new([0], []) }.must_raise ArgumentError
-      expect { TP.new([], [0.0]) }.must_raise ArgumentError
-    end
-
-    it "determines a grip number from a temp number" do
-      { -500 => TP::MIN_GRIP,
-        -100 => 0.1,
-        -0.0001 => 0.1,
-        0.0 => 0.5
-      }.each { |temp, gf| expect(@tp.grip_factor(temp)).must_equal gf }
-    end
-
-    it "has a critical_temp above the temp for 100%" do
-      expect(@tp.critical_temp).must_be(:>, 90)
-      expect(@tp.critical_temp).must_equal 105
-    end
-
-    it "has a map that increases to 100% and decreases below 80%" do
-      expect {
-        TP.new([0,1,2,3,4], [0.0,0.1,0.2,0.3,0.4])
-      }.must_raise TP::Error
-
-      expect {
-        TP.new([0,1,2,3,4], [0.0, 1.0, 0.99, 0.98, 0.97])
-      }.must_raise TP::Error
-    end
-  end
-
-  before do
-    @t = Tire.new
-  end
-
-  it "initializes with default values without a block" do
-    expect(@t).must_be_kind_of Tire
-  end
-
-  it "accepts a block to initialize with custom values" do
-    t = Tire.new { |x|
-      x.tread_mm = 9999
-      x.g_factor = -0.1234
-    }
-
-    expect(t.tread_mm).must_equal 9999
-    expect(t.g_factor).must_equal(-0.1234)
-  end
-
-  it "knows when the tread is gone" do
-    expect(@t.tread_left?).must_equal true
-
-    @t.condition.tread_mm = 0.00001
-    expect(@t.tread_left?).must_equal true
-
-    @t.condition.tread_mm = 0.0
-    expect(@t.tread_left?).must_equal false
-  end
-
-  it "has 50% grip when down to the cords" do
-    expect(@t.tread_factor).must_equal 1.0
-
-    @t.condition.tread_mm = 0.0
-    expect(@t.tread_factor).must_be_within_epsilon 0.5
-  end
-
-  it "has less than 10% tread factor when the cords start to wear" do
-    expect(@t.tread_factor).must_equal 1.0
-
-    @t.condition.tread_mm = 5.0
-    expect(@t.tread_factor).must_equal 1.0
-
-    @t.condition.tread_mm = 0.0
-    expect(@t.tread_factor).must_be_within_epsilon 0.5
-
-    @t.condition.cords_mm = 0.9
-    expect(@t.tread_factor).must_be_within_epsilon 0.45
-  end
-
-  it "has decreasing heat cycle factor" do
-    expect(@t.condition.heat_cycles).must_equal 0
-    expect(@t.heat_cycle_factor).must_equal 1.0
-
-    @t.condition.heat_cycles = 20
-    expect(@t.heat_cycle_factor).must_be(:<, 1.0)
-  end
-
-  it "has a temp factor according to temperature profile" do
-    expect(@t.condition.temp_c).must_equal 25
-    expect(@t.temp_factor).must_equal 0.75
-
-    @t.condition.temp_c = 90
-    expect(@t.temp_factor).must_equal 1.0
-  end
-
-  it "incorporates temp, heat_cycles, and tread depth into available grip" do
-    @t.condition.temp_c = 60
-    expect(@t.temp_factor).must_be_within_epsilon 0.8
-
-    @t.condition.heat_cycles = 10
-    expect(@t.heat_cycle_factor).must_be_within_epsilon 0.96
-
-    @t.condition.tread_mm = 5.0
-    expect(@t.tread_factor).must_equal 1.0
-    expect(@t.max_g).must_be_within_epsilon 0.768
-
-    @t.condition.tread_mm = 0.0
-    expect(@t.max_g).must_be_within_epsilon 0.384
-  end
-end