Making an On-Demand Game Loop Using Go Pt. 2
In my previous post of this series I talked about moving bots in an HTTP server without having to provide constant updates the way a traditional game loop would. However, I didn't address a critical problem of handling more than one movement request for the same bot.
Inspired by how a blockchain stores a wallet balance as a sum of transactions, I created a SQL database ledger where a bot's position was the sum of the position vectors created by client requests.
CREATE TABLE public.bot_movement_ledger (
id bigserial PRIMARY KEY,
created_at timestamp with time zone,
updated_at timestamp with time zone,
deleted_at timestamp with time zone,
time_action_started timestamp with time zone,
new_x numeric,
new_y numeric
);
When a client sends a GET request to a bot, the server loads the bot_movement_ledger from the database:
SELECT bot_movement_ledger.new_x, bot_movement_ledger.new_y,
bot_movement_ledger.time_action_started
FROM bots
ORDER BY bot_movement_ledger.Time_Action_Started ASC
Then the server then converts the records to an array of structs, and traverses this ledger from the earliest Time_Action_Started to the latest. For each record the server calculates the bot's position (see pt. 1) using the time and coordinates of the next record. Within GetBotLocation each one of these position vectors is added to the previous one. When the last record arrives the server calculates the final position using the time of the GET request and sends that back to the client.
func GetBotsFromLedger(ledger []BotsWithActions, currentDatetime time.Time) []api.Bot {
var bots []api.Bot
currentBotCoords := api.Coordinates{X: ledger[0].New_X, Y: ledger[0].New_Y}
for i := range ledger {
// check if the next record exists
if i < len(ledger)-1 {
// continue calculating velocity
var err error
currentBotCoords, err = GetBotLocation(
currentBotCoords,
api.Coordinates{X: ledger[i+1].New_X, Y: ledger[i+1].New_Y},
ledger[i].Time_Action_Started,
ledger[i+1].Time_Action_Started,
botVelocity,
)
if err != nil {
logger.Fatal(err)
}
} else {
// We need the final position of the bot based on the last action
// it has recieved
var err error
currentBotCoords, err = GetBotLocation(
currentBotCoords,
api.Coordinates{X: ledger[i].New_X, Y: ledger[i].New_Y},
ledger[i].Time_Action_Started,
currentDatetime,
botVelocity,
)
if err != nil {
logger.Fatal(err)
}
var botStatus api.BotStatus
bot := api.Bot{
// other struct values left out for brevity
Coordinates: currentBotCoords,
}
bots = append(bots, bot)
}
}
return bots
}
This handles the case of a single bot, but the player will often be commanding multiple bots with different unique identifiers. We handle that by creating a new table with records of individual bot metadata and adding a foreign key from the bot_movement_ledger table to this new bots table, creating a many-to-one relationship.
CREATE TABLE public.bots (
id bigserial PRIMARY KEY,
created_at timestamp with time zone,
updated_at timestamp with time zone,
deleted_at timestamp with time zone,
identifier text UNIQUE NOT NULL,
-- other data ignored for brevity
);
CREATE TABLE public.bot_movement_ledger (
id bigserial PRIMARY KEY,
created_at timestamp with time zone,
updated_at timestamp with time zone,
deleted_at timestamp with time zone,
bot_id bigint references bots(id) NOT NULL,
time_action_started timestamp with time zone NOT NULL,
new_x numeric NOT NULL,
new_y numeric NOT NULL
);
From here, we join the movement leger to the bots table and order it by identifier. This ensures the ledger records for each unique identifier are contiguous, which will be important when we traverse the ledger.
SELECT bots.Identifier
bot_movement_ledger.new_x, bot_movement_ledger.new_y,
bot_movement_ledger.time_action_started
FROM bots
LEFT JOIN bot_movement_ledger ON bots.ID = bot_movement_ledger.bot_id
ORDER BY bots.Identifier ASC, bot_movement_ledger.Time_Action_Started ASC
We now traverse the ledger as before, summing displacement vectors until we reach a record with a new identifier. When we reach a new bot's record, we run the final position calculation for the current bot using the current time, place it in memory, then move on to the new bot.
func GetBotsFromLedger(ledger []BotsWithActions, currentDatetime time.Time) []api.Bot {
var bots []api.Bot
currentBotCoords := api.Coordinates{X: ledger[0].New_X, Y: ledger[0].New_Y}
for i := range ledger {
// check if the next record exists and refers to the same bot
if i < len(ledger)-1 && ledger[i].Identifier == ledger[i+1].Identifier {
// continue calculating velocity
var err error
currentBotCoords, err = GetBotLocation(
currentBotCoords,
api.Coordinates{X: ledger[i+1].New_X, Y: ledger[i+1].New_Y},
ledger[i].TimeActionStarted,
ledger[i+1].TimeActionStarted,
botVelocity,
)
if err != nil {
logger.Fatal(err)
}
} else {
// We need the final position of the bot based on the last action
// it has recieved
var err error
currentBotCoords, err = GetBotLocation(
currentBotCoords,
api.Coordinates{X: ledger[i].New_X, Y: ledger[i].New_Y},
ledger[i].TimeActionStarted,
currentDatetime,
botVelocity,
)
if err != nil {
logger.Fatal(err)
}
var botStatus api.BotStatus
// Set bot to idle if it is at the coordinates of its last move action
if reflect.DeepEqual(
currentBotCoords, api.Coordinates{
X: ledger[i].New_X,
Y: ledger[i].New_Y,
}) {
botStatus = api.IDLE
} else {
botStatus = api.MOVING
}
bot := api.Bot{
Coordinates: currentBotCoords,
Identifier: ledger[i].Identifier,
// additional fields left out for brevity
}
bots = append(bots, bot)
}
}
return bots
}
There's a performance issue with this solution in that the time it takes to calculate a bot's position scales linearly with the number of move actions POST-ed to the server. I have a few ideas on how to address this, but I am going to look to scale my users first :)