Forensics and crime scenes

The problem

When I joined Diverge Networks, the server already had a forensics plugin, written by an earlier developer and never finished. Bodies duplicated or vanished, evidence didn’t survive a map change, and some fingerprints couldn’t be lifted at all. Police and criminal roleplay leaned on it anyway.

Over nearly two years and about 70 commits, I turned it into the system the roleplay needed: crime scenes that persist, evidence that holds up, and case files detectives can actually work from. I kept the original author’s credit in the code.

Bodies and crime scenes

• Bodies persist where the person died, across restarts and map changes, with a recorded time of death.
• Inspecting a body shows how the person died, their recent wounds and the weapons they were carrying at the time. Hunger and withdrawal no longer show up as violent injuries.
• Criminals can dispose of a body: dismember it into separate body-part items, burn it with gasoline so the corpse visibly chars, or zip it into a body bag. Bodies taken back out of a bag keep everything they had.
• Dragging a body slows you down, and the slowdown always clears, even if the body is deleted mid-drag.
• The killer’s faction is logged on the body. Only the police and that faction can move it, and only that faction can sweep up the casings, so bystanders can’t destroy the evidence out of character.
• Blood can be cleaned up through a short minigame, and blood older than seven days fades away.
• Staff can create the body for a past death after the fact.

Evidence

• Fingerprints are left on items when they’re picked up or dropped, and on doors, unless you wear gloves.
• Prints on items fade after a week and on doors after an hour, and the same person can only leave one print per item per hour, so items don’t fill up with noise.
• Detectives lift prints with kits and cards, test hands for gunshot residue, mark scenes with numbered markers, police tape and chalk outlines, and collect bullet casings and blood.
• Regular officers can seal evidence in evidence bags, so casings reach a detective with their prints intact.
• Used-up kits and empty cases can be disposed of instead of cluttering inventories.

Case files and the database

• Every sample goes into a forensics database that detectives can search, compare against and export reports from.
• Detectives open case files and attach evidence to them, by case number or by part of the case name.
• Case reports are items: copying or returning one keeps it linked to the underlying case, and edits to a fingerprint card’s backing card are stored in the database, so they survive being returned and pulled again.
• Recent cases are worked out on the server, and searches page through results so the lists stay usable as the database grows.

Built for a live server

• Lifting a print needs a one-time authorisation from the server that’s tied to that card and that item, expires after a minute, and only works within arm’s reach. The print itself is looked up on the server, never taken from the request.
• Edits to a backing card only accept known fields, each capped in length, and are stored on the server.
• Every action checks the player’s forensics level, from civilian to detective to forensic expert, on the server.
• Scenes are saved to MySQL through the shared plugin data store, with an autosave every five minutes, replacing the file saves that lost entities on map changes.
• I built internal tools for testing scenes quickly and for debugging where bullet casings land.

-- Step 1, on the server: the player uses a fingerprint card while looking at an item.
-- If there's a choice of prints, the server grants a one-time authorisation tied
-- to this card and this item, and sends the list to choose from.
onRun = function(card)
    local ply = card.player
    local target = ply:GetEyeTrace().Entity
    if (target:GetClass() ~= "nut_item") then return false end

    local prints = Forensics:GetValidFingerprints(target)   -- decayed prints already filtered out
    -- ... zero prints and single-print shortcuts omitted

    ply.authFingerprintCard = card.id
    ply.authFingerprintItem = target.nutItemID
    ply.authFingerprintCardTime = SysTime()
    -- ... send the choices to the client
    return false
end

-- Step 2: the client answers with the card and the index of the print it picked.
net.Receive("Forensics:FingerprintCard", function(_, ply)
    local card = nut.item.instances[net.ReadUInt(32)]
    local printIndex = net.ReadUInt(32)
    local target = ply:GetEyeTrace().Entity

    -- The authorisation must match this card and be under a minute old.
    if (not card or card.uniqueID ~= "fingerprintcard"
        or ply.authFingerprintCard ~= card.id
        or SysTime() - ply.authFingerprintCardTime > 60) then
        return
    end

    -- Still looking at the same item, and within arm's reach.
    if (not IsValid(target) or target:GetClass() ~= "nut_item"
        or target.nutItemID ~= ply.authFingerprintItem
        or target:GetPos():DistToSqr(ply:GetPos()) > 100 * 100) then
        return
    end

    -- The prints are looked up again on the server. The client only picks an index.
    local prints = Forensics:GetValidFingerprints(nut.item.instances[target.nutItemID])

    -- One use only.
    ply.authFingerprintCard = nil
    ply.authFingerprintItem = nil
    ply.authFingerprintCardTime = nil

    local chosen = prints[printIndex]
    if (not chosen) then return end

    -- The card must still be in this player's inventory.
    if (not ply:getChar():getInv():getItems()[card.id]) then return end

    ply:notify("You peel off a fingerprint and imprint it onto the card.")
    -- ... write the lifted print to the forensics database (omitted)
end)

Still being untangled

Some of the original design is still underneath, and it still surfaces as the occasional odd bug. Each fix is a chance to replace another piece of it.