147 lines
4.0 KiB
Ruby
147 lines
4.0 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require './universe'
|
|
require './planet'
|
|
require './position'
|
|
require './universe_array'
|
|
|
|
require './spec/stdout_helper'
|
|
|
|
RSpec.describe Universe do
|
|
|
|
let(:name) { 'Test Universe' }
|
|
let(:universe_size) { 3 }
|
|
let(:seed) { 12345 }
|
|
|
|
subject(:universe) do
|
|
Universe.new(
|
|
name,
|
|
universe_size: universe_size,
|
|
seed: seed,
|
|
create_chances: { planet: 1 } # force a planet at every valid spot
|
|
)
|
|
end
|
|
|
|
describe '#initialize' do
|
|
it 'stores all expected instance variables' do
|
|
expect(universe.name).to eq(name)
|
|
expect(universe.instance_variable_get(:@universe_size)).to eq(universe_size)
|
|
expect(universe.instance_variable_get(:@seed)).to eq(seed)
|
|
end
|
|
|
|
it 'creates a deterministic Random object when a seed is given' do
|
|
rng = universe.instance_variable_get(:@random)
|
|
expect(rng).to be_a(Random)
|
|
expect(rng.rand(100)).to eq(Random.new(seed).rand(100))
|
|
end
|
|
|
|
it 'initializes the random if no seed is passed in' do
|
|
uni = Universe.new(name)
|
|
rng = uni.instance_variable_get(:@random)
|
|
expect(rng).to be_a(Random)
|
|
end
|
|
end
|
|
|
|
describe '#create_universe' do
|
|
|
|
end
|
|
|
|
describe '#distance' do
|
|
it 'is symmetric' do
|
|
a = Position.new(0, 0)
|
|
b = Position.new(4, 2)
|
|
expect(universe.distance(a, b)).to eq(universe.distance(b, a))
|
|
end
|
|
|
|
it 'returns 0 when both points are identical' do
|
|
p = Position.new(1, 1)
|
|
expect(universe.distance(p, p)).to eq(0)
|
|
end
|
|
|
|
it 'correctly computes known hex distances' do
|
|
p0 = Position.new(0, 0)
|
|
p1 = Position.new(2, 0)
|
|
p2 = Position.new(4, 2)
|
|
p3 = Position.new(2, 2)
|
|
# (0,0) to (2,0) → 1
|
|
expect(universe.distance(p0, p1)).to eq(1)
|
|
# (0,0) to (4,2) → 3
|
|
expect(universe.distance(p0, p2)).to eq(3)
|
|
# (0,0) to (2,2) → 2
|
|
expect(universe.distance(p0, p3)).to eq(2)
|
|
end
|
|
end
|
|
|
|
describe '#map generation' do
|
|
it 'creates the expected dimensions' do
|
|
universe.create_universe
|
|
map = universe.instance_variable_get(:@universe_map)
|
|
# Each valid (x,y) pair inside the radius contains a Planet
|
|
# (our stub) and every other entry is nil.
|
|
expect(map).to be_a(UniverseArray)
|
|
# Check how may nodes were created:
|
|
expect(map.flatten.compact.length).to eq(19) # 1 + 1*6 + 2*6
|
|
end
|
|
|
|
it 'contains a planet at every valid point when create_chances is 1' do
|
|
universe.create_universe
|
|
map = universe.instance_variable_get(:@universe_map)
|
|
map.each do |row|
|
|
row.each do |idx|
|
|
# The indexes are allowed to be nil
|
|
if !idx.nil?
|
|
expect(idx).to be_a(Planet)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
it 'is deterministic when the same seed is used' do
|
|
first_universe = Universe.new(
|
|
name,
|
|
universe_size: universe_size,
|
|
seed: seed,
|
|
create_chances: { planet: 0.1 }
|
|
)
|
|
first_map = first_universe.instance_variable_get(:@universe_map)
|
|
|
|
second_universe = Universe.new(
|
|
name,
|
|
universe_size: universe_size,
|
|
seed: seed,
|
|
create_chances: { planet: 0.1 }
|
|
)
|
|
second_map = second_universe.instance_variable_get(:@universe_map)
|
|
|
|
expect(first_map).to eq(second_map)
|
|
end
|
|
end
|
|
|
|
describe '#print_universe' do
|
|
it 'prints the center point as “O”' do
|
|
out = capture_stdout do
|
|
universe.create_universe
|
|
universe.print_universe
|
|
end
|
|
expect(out).to include('O')
|
|
end
|
|
|
|
it 'can print blank spaces for nothing' do
|
|
out = capture_stdout do
|
|
uni = Universe.new(name, create_chances: {planet: 0.0})
|
|
uni.create_universe
|
|
uni.print_universe
|
|
end
|
|
expect(out).to include('O')
|
|
expect(out).to include('- -')
|
|
end
|
|
end
|
|
|
|
describe '#planets' do
|
|
it 'lists all of the generated planets' do
|
|
universe.create_universe
|
|
expect(universe.planets.length).to eq(19)
|
|
end
|
|
end
|
|
end
|