418 lines
13 KiB
Ruby
418 lines
13 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
# Space game server engine.
|
|
# Coordinates game state, player connections, and world simulation.
|
|
|
|
require 'game/player'
|
|
require 'game/planet'
|
|
require 'thread'
|
|
require 'securerandom'
|
|
|
|
# Main file for the Game module
|
|
module Game
|
|
|
|
# Controls how frequently autosaves are created (seconds)
|
|
SAVE_INTERVAL = 15
|
|
|
|
# Controls how frequently updates are sent to the client about the player (seconds)
|
|
PLAYER_UPDATE_INTERVAL = 2
|
|
|
|
# Controls how fast the game scales with player count. Bigger means more
|
|
# players required to change the speed.
|
|
GAME_SPEED_FACTOR = 1
|
|
|
|
##
|
|
# The central server object that keeps track of players, planets, and
|
|
# game-time.
|
|
#
|
|
# @api public
|
|
class Game
|
|
# The name of the game
|
|
attr_reader :name
|
|
|
|
# Returns the width of the game space
|
|
attr_reader :width
|
|
|
|
# Returns the height of the game space
|
|
attr_reader :height
|
|
|
|
# Returns the depth of the game space
|
|
attr_reader :depth
|
|
|
|
# Collection of players in the game
|
|
attr_reader :players
|
|
|
|
# Create the game
|
|
##
|
|
# Initialize the game from a configuration hash. The hash is expected
|
|
# to be the result of parsing the YAML file `game_data/game_conf.yaml`.
|
|
#
|
|
# @param conf_data [Hash] The parsed configuration
|
|
# @raise [ArgumentError] if the configuration is missing a required key
|
|
#
|
|
def initialize(conf_data)
|
|
# Validate that the correct keys exist
|
|
['name', 'width', 'height', 'depth', 'players', 'planets', 'ships', 'time', 'player_defaults'].each do |key|
|
|
if conf_data[key].nil?
|
|
raise ArgumentError, "Missing toplevel key '#{key}' in configuration"
|
|
end
|
|
end
|
|
@conf_data = conf_data
|
|
@name = conf_data['name']
|
|
@width = conf_data['width']
|
|
@height = conf_data['height']
|
|
@depth = conf_data['depth']
|
|
@to_load_players = conf_data['players']
|
|
@to_load_planets = conf_data['planets']
|
|
@game_time = conf_data['time']
|
|
@player_defaults = @conf_data['player_defaults']
|
|
@connected_players = [] # When we start up we do not have any players connected.
|
|
|
|
# Load the players:
|
|
@players = []
|
|
@to_load_players.each do |player_id|
|
|
@players.append(Player.load_from_save(player_id))
|
|
end
|
|
|
|
# If we are an integer then we need to create new planets.
|
|
@planets = []
|
|
if @to_load_planets.is_a? Integer
|
|
puts "Appears to be the first time running. Creating #{@to_load_planets} planets"
|
|
@to_load_planets.times do
|
|
@planets.append(Planet.new(@width, @height, @depth))
|
|
end
|
|
else
|
|
@to_load_planets.length.times do |idx|
|
|
planet = Planet.load_from_save(@to_load_planets[idx])
|
|
@planets.append(planet)
|
|
end
|
|
end
|
|
|
|
# Load ships
|
|
@ships = []
|
|
conf_data['ships'].each do
|
|
require 'byebug'; debugger
|
|
end
|
|
end
|
|
|
|
##
|
|
# Register a client connection. This method sccepts a TCP docket and a hash
|
|
# that must comtain a `player_id`. If the player already exists in the game
|
|
# it is reconnected otherwise a new `Player` is created and added to the
|
|
# game if possible (There must be at least one free planet)
|
|
#
|
|
# @param client [TCPSocket] The client socket
|
|
# @param command [Hash] JSON parsed command from the client.
|
|
# @option command [String] :player_id Required, The player ID
|
|
# @option command [String] :faction Required, The faction the player should join as.
|
|
#
|
|
# @return [Hash] status hash that will be converted to JSON before being
|
|
# sent back to the client
|
|
#
|
|
def player_connect(client, command)
|
|
player_id = command.dig('payload', 'player_id')
|
|
faction = command.dig('payload', 'faction')
|
|
raise ArgumentError, 'player_id missing in command' unless player_id
|
|
raise ArgumentError, 'faction is missing in command' unless faction
|
|
|
|
player = player_registered?(player_id)
|
|
|
|
if player
|
|
# Re-connect an existing but disconnected player
|
|
if player.connected?
|
|
raise GameError, 'Player already connected!'
|
|
end
|
|
player.connect(client)
|
|
else
|
|
# Create a brand new player and claim a planet for them
|
|
player = create_player(player_id, faction)
|
|
return player if player.is_a?(Hash) && player['type'] == 'error' # error returned
|
|
|
|
player.connect(client)
|
|
@players << player
|
|
end
|
|
|
|
{ 'type' => 'update', 'payload' => 'success' }
|
|
end
|
|
|
|
|
|
##
|
|
# Create a new player from scratch. The new player is assigned a free
|
|
# planet and receives the default starting resources.
|
|
#
|
|
# @param player_id [String] the unique identifier that will be stored
|
|
# on the new player; if `nil` a random hex string will be generated
|
|
# @param faction [String] The faction that the player belongs too.
|
|
#
|
|
# @return [Player, Hash] The new player object on success or an error
|
|
# hash if no free planet is available.
|
|
#
|
|
def create_player(player_id, faction)
|
|
free_planets = @planets.select { |p| p.owner.nil? }
|
|
|
|
if free_planets.empty?
|
|
return {
|
|
'type' => 'error',
|
|
'payload' => 'Unable to allocate a planet for a new player'
|
|
}
|
|
end
|
|
|
|
home = free_planets.sample
|
|
player = Player.new(player_id || SecureRandom.hex, faction)
|
|
|
|
player.set_resources(
|
|
@player_defaults['credits'],
|
|
@player_defaults['metal'],
|
|
@player_defaults['crystals'],
|
|
@player_defaults['fuel'],
|
|
)
|
|
|
|
player.claim_planet(home)
|
|
player.make_home_planet(home)
|
|
player
|
|
end
|
|
|
|
##
|
|
# The entry point for all messages that arrive from a client. The
|
|
# payload must be a hash decoded from JSON and contain a `type` field.
|
|
#
|
|
# @param client [TCPSocket] The socket that the client used.
|
|
# @param command [Hash] The parsed client command
|
|
#
|
|
# @return [String] JSON-encoded response
|
|
#
|
|
def parse_command(client, command)
|
|
return error_response('Player not registered!') unless command['player_id']
|
|
|
|
case command['type']
|
|
when 'hello'
|
|
parse_hello(client, command)
|
|
when 'query'
|
|
parse_query(command)
|
|
when 'command'
|
|
error_response('Command handling not implemented')
|
|
else
|
|
error_response('Unknown type')
|
|
end
|
|
end
|
|
|
|
##
|
|
# Dispatch a `query` command to the appropriate helper. Only a small
|
|
# subset of query types is required for the test-suite; all others
|
|
# return a generic error.
|
|
#
|
|
# @param query [Hash] The query to be parsed
|
|
#
|
|
# @return [String] JSON-encoded response
|
|
#
|
|
def parse_query(query)
|
|
return error_response('Missing query payload') unless query['payload']
|
|
player = player_registered?(query['player_id'])
|
|
return error_response('Player not found') unless player
|
|
|
|
case query['domain']
|
|
when 'player'
|
|
case query['payload']
|
|
when 'update'
|
|
return player.update(query['payload']['request_id'])
|
|
else
|
|
error_response('Unknown payload for player domain')
|
|
end
|
|
else
|
|
error_response('Unknown domain')
|
|
end
|
|
end
|
|
|
|
##
|
|
# Return a status hash that contains a friendly error message. The
|
|
# helper exists only to keep the body of all error branches short.
|
|
#
|
|
# @param msg [String] The error message
|
|
# @return [String] JSON-encoded error response
|
|
#
|
|
def error_response(msg)
|
|
{ 'type' => 'error', 'request_id' => -1, 'payload' => msg }.to_json
|
|
end
|
|
|
|
##
|
|
# Return an update response to the client
|
|
def update_response(request_id, domain, payload)
|
|
{'type' => 'update', 'domain' => domain, 'request_id' => request_id, 'payload' => payload}.to_json
|
|
end
|
|
|
|
# Return an event response to the client
|
|
def event_response(request_id, domain, payload)
|
|
{'type' => 'event', 'domain' => domain, 'request_id' => request_id, 'payload' => payload}.to_json
|
|
end
|
|
|
|
##
|
|
# Return a JSON object that tells a client about the current
|
|
# server-time. Useful for debugging or “ping” operations.
|
|
#
|
|
# @return [String] JSON-encoded hash
|
|
#
|
|
def info(request_id)
|
|
{
|
|
'type' => 'update',
|
|
'domain' => 'game',
|
|
'request_id' => request_id,
|
|
'payload' => {
|
|
'name' => @name,
|
|
'width' => @width,
|
|
'height' => @height,
|
|
'depth' => @depth,
|
|
'time' => @game_time
|
|
}
|
|
}.to_json
|
|
end
|
|
|
|
# Actually start running the game
|
|
def run()
|
|
# Main game loop
|
|
last_time = Time.now # The delta time will be very small on the first one.
|
|
next_save = @game_time + SAVE_INTERVAL
|
|
next_client_update = @game_time + PLAYER_UPDATE_INTERVAL
|
|
while true
|
|
# This is the **ONLY** place where Time.now should be used
|
|
delta_time = (Time.now - last_time)
|
|
last_time = Time.now
|
|
|
|
# Here is where we do our time scaling. Count the number of players in the game then use that mult
|
|
player_count = @players.map {|player| player.connected?}.count true
|
|
@game_speed = (player_count / GAME_SPEED_FACTOR)
|
|
delta_time * (player_count / GAME_SPEED_FACTOR)
|
|
@game_time += delta_time
|
|
|
|
# Order here is important, We must update the buildings first (To
|
|
# accrew resources for this delta) Because planets hold the buildings
|
|
# they must be first.
|
|
@planets.each do |planet|
|
|
planet.update(delta_time)
|
|
end
|
|
|
|
@ships.each do |ship|
|
|
ship.update(delta_time)
|
|
end
|
|
|
|
@players.each do |player|
|
|
player.update(delta_time)
|
|
end
|
|
|
|
# Perform game saves (Or not for now...)
|
|
if (@game_time) > next_save
|
|
puts 'Trying to save...'
|
|
next_save = @game_time + SAVE_INTERVAL
|
|
save_game_state
|
|
end
|
|
|
|
# Send out regular updates to the clients (Every 2 seconds)
|
|
if @game_time > next_client_update
|
|
next_client_update = @game_time + PLAYER_UPDATE_INTERVAL
|
|
@players.each do |player|
|
|
if player.connected?
|
|
player.send_update
|
|
end
|
|
end
|
|
end
|
|
|
|
if player_count == 0
|
|
puts 'No players connected, pausing time'
|
|
while 0 == (@players.map {|player| player.connected?}.count true)
|
|
sleep(1)
|
|
end
|
|
end
|
|
#sleep(0.05) # About 20 TPS/FPS
|
|
sleep(1)
|
|
end
|
|
end
|
|
|
|
##
|
|
# Persist the current state of the game to the disk. The method is
|
|
# fully unit-tested via a double that captures the YAML payload
|
|
# instead of actually writing a file.
|
|
#
|
|
# @return [void]
|
|
#
|
|
def save_game_state
|
|
config = {
|
|
'name' => @name,
|
|
'width' => @width,
|
|
'height' => @height,
|
|
'depth' => @depth,
|
|
'players' => @players.map(&:player_id),
|
|
'planets' => @planets.map(&:planet_id),
|
|
'ships' => @ships.map(&:ship_id),
|
|
'time' => @game_time,
|
|
'player_defaults' => @player_defaults
|
|
}
|
|
|
|
File.open('game_data/game_conf.yaml', 'w') { |f| f.write(YAML.dump(config)) }
|
|
|
|
# Save the planets
|
|
@planets.each do |planet|
|
|
planet.save_to_file
|
|
end
|
|
|
|
# Save the ships
|
|
@ships.each do |ship|
|
|
ship.save_to_file
|
|
end
|
|
|
|
# Save the players
|
|
@players.each do |player|
|
|
player.save_to_file
|
|
end
|
|
end
|
|
|
|
##
|
|
# Determine whether a player with a given id is known to the game.
|
|
#
|
|
# @param player_id [String] the id that the caller is looking for
|
|
#
|
|
# @return [Player, false] the `Player` instance if found or `false`
|
|
# otherwise
|
|
#
|
|
def player_registered?(player_id)
|
|
@players.find { |p| p.player_id == player_id } || false
|
|
end
|
|
|
|
# Loads players from a list of IDs.
|
|
|
|
# @param ids [Array<String>] list of player IDs.
|
|
|
|
# @return [Array<Player>] the loaded players.
|
|
def load_players(ids)
|
|
ids.map { |id| Player.load_from_id(id) }
|
|
end
|
|
|
|
# Loads planets from a configuration list or creates new ones.
|
|
|
|
# @param planets [Integer, Array<String>] number of planets to create or list of planet IDs.
|
|
|
|
# @return [Array<Planet>] the loaded or created planets.
|
|
def load_planets(planets)
|
|
if planets.is_a?(Integer) # legacy config - integer means “create N”
|
|
Array.new(planets) { Planet.new }
|
|
else
|
|
planets.map { |id| Planet.load_from_id(id) }
|
|
end
|
|
end
|
|
|
|
# Loads ships from a list of IDs.
|
|
|
|
# @param ids [Array<String>] list of ship IDs.
|
|
|
|
# @return [Array<Ship>] the loaded ships.
|
|
def load_ships(ids)
|
|
ids.map { |id| Ship.load_from_id(id) } # Ship is a placeholder
|
|
end
|
|
end
|
|
|
|
##
|
|
# Raised when an invalid operation is attempted (e.g. reconnecting a
|
|
# player that already has a socket). The tests catch this error
|
|
# to confirm that the server protects against accidental double
|
|
# connections.
|
|
class GameError < StandardError; end
|
|
end
|