CC Chat Adventure

c=peripheral.wrap("top")

local tBiomes = {
    "in a forest",
    "in a pine forest",
    "knee deep in a swamp",

    "in a mountain range",
    "in a desert",
    "in a grassy plain",
    "in frozen tundra",

    --"in the ocean",
}

local function hasTrees( _nBiome )
    return _nBiome <= 3
end

local function hasStone( _nBiome )
    return _nBiome == 4
end

local function hasRivers( _nBiome )
    return _nBiome ~= 3 and _nBiome ~= 5
end

local items = {
    ["no tea"] = {
        droppable = false,
        desc = "Pull yourself together man.",
    },
    ["a pig"] = {
        heavy = true,
        creature = true,
        drops = { "some pork" },
        aliases = { "pig" },
        desc = "The pig has a square nose.",
    },
    ["a cow"] = {
        heavy = true,
        creature = true,
        aliases = { "cow" },
        desc = "The cow stares at you blankly.",
    },
    ["a sheep"] = {
        heavy = true,
        creature = true,
        hitDrops = { "some wool" },
        aliases = { "sheep" },
        desc = "The sheep is fluffy.",
    },
    ["a chicken"] = {
        heavy = true,
        creature = true,
        drops = { "some chicken" },
        aliases = { "chicken" },
        desc = "The chicken looks delicious.",
    },
    ["a creeper"] = {
        heavy = true,
        creature = true,
        monster = true,
        aliases = { "creeper" },
        desc = "The creeper needs a hug.",
    },
    ["a skeleton"] = {
        heavy = true,
        creature = true,
        monster = true,
        aliases = { "skeleton" },
        nocturnal = true,
        desc = "The head bone's connected to the neck bone, the neck bones connected to the chest bone, the chest bones connected to the arm bone, the arm bones connected to the bow, and the bow is pointed at you.",
    },
    ["a zombie"] = {
        heavy = true,
        creature = true,
        monster = true,
        aliases = { "zombie" },
        nocturnal = true,
        desc = "All he wants to do is eat your brains.",
    },
    ["a spider"] = {
        heavy = true,
        creature = true,
        monster = true,
        aliases = { "spider" },
        desc = "Dozens of eyes stare back at you.",
    },
    ["a cave entrance"] = {
        heavy = true,
        aliases = { "cave entance", "cave", "entrance" },
        desc = "The entrance to the cave is dark, but it looks like you can climb down.",
    },
    ["an exit to the surface"] = {
        heavy = true,
        aliases = { "exit to the surface", "exit", "opening" },
        desc = "You can just see the sky through the opening.",
    },
    ["a river"] = {
        heavy = true,
        aliases = { "river" },
        desc = "The river flows majestically towards the horizon.",
    },
    ["some wood"] = {
        aliases = { "wood" },
        material = true,
        desc = "You could easilly craft this wood into planks.",
    },
    ["some planks"] = {
        aliases = { "planks", "wooden planks", "wood planks" },
        desc = "You could easilly craft these planks into sticks.",
    },
    ["some sticks"] = {
        aliases = { "sticks", "wooden sticks", "wood sticks" },
        desc = "A perfect handle for torches or a pickaxe.",
    },
    ["a crafting table"] = {
        aliases = { "crafting table", "craft table", "work bench", "workbench", "crafting bench", "table", },
        desc = "It's a crafting table. I shouldn't tell you this, but these don't actually do anything in this game, you can craft tools whenever you like.",
    },
    ["a furnace"] = {
        aliases = { "furnace" },
        desc = "It's a furnace. Between you and me, these don't actually do anything in this game.",
    },
    ["a wooden pickaxe"] = {
        aliases = { "pickaxe", "pick", "wooden pick", "wooden pickaxe", "wood pick", "wood pickaxe" },
        tool = true,
        toolLevel = 1,
        toolType = "pick",
        desc = "The pickaxe looks good for breaking stone and coal.",
    },
    ["a stone pickaxe"] = {
        aliases = { "pickaxe", "pick", "stone pick", "stone pickaxe" },
        tool = true,
        toolLevel = 2,
        toolType = "pick",
        desc = "The pickaxe looks good for breaking iron.",
    },
    ["an iron pickaxe"] = {
        aliases = { "pickaxe", "pick", "iron pick", "iron pickaxe" },
        tool = true,
        toolLevel = 3,
        toolType = "pick",
        desc = "The pickaxe looks strong enough to break diamond.",
    },
    ["a diamond pickaxe"] = {
        aliases = { "pickaxe", "pick", "diamond pick", "diamond pickaxe" },
        tool = true,
        toolLevel = 4,
        toolType = "pick",
        desc = "Best. Pickaxe. Ever.",
    },
    ["a wooden sword"] = {
        aliases = { "sword", "wooden sword", "wood sword" },
        tool = true,
        toolLevel = 1,
        toolType = "sword",
        desc = "Flimsy, but better than nothing.",
    },
    ["a stone sword"] = {
        aliases = { "sword", "stone sword" },
        tool = true,
        toolLevel = 2,
        toolType = "sword",
        desc = "A pretty good sword.",
    },
    ["an iron sword"] = {
        aliases = { "sword", "iron sword" },
        tool = true,
        toolLevel = 3,
        toolType = "sword",
        desc = "This sword can slay any enemy.",
    },
    ["a diamond sword"] = {
        aliases = { "sword", "diamond sword" },
        tool = true,
        toolLevel = 4,
        toolType = "sword",
        desc = "Best. Sword. Ever.",
    },
    ["a wooden shovel"] = {
        aliases = { "shovel", "wooden shovel", "wood shovel" },
        tool = true,
        toolLevel = 1,
        toolType = "shovel",
        desc = "Good for digging holes.",
    },
    ["a stone shovel"] = {
        aliases = { "shovel", "stone shovel" },
        tool = true,
        toolLevel = 2,
        toolType = "shovel",
        desc = "Good for digging holes.",
    },
    ["an iron shovel"] = {
        aliases = { "shovel", "iron shovel" },
        tool = true,
        toolLevel = 3,
        toolType = "shovel",
        desc = "Good for digging holes.",
    },
    ["a diamond shovel"] = {
        aliases = { "shovel", "diamond shovel" },
        tool = true,
        toolLevel = 4,
        toolType = "shovel",
        desc = "Good for digging holes.",
    },
    ["some coal"] = {
        aliases = { "coal" },
        ore = true,
        toolLevel = 1,
        toolType = "pick",
        desc = "That coal looks useful for building torches, if only you had a pickaxe to mine it.",
    },
    ["some dirt"] = {
        aliases = { "dirt" },
        material = true,
        desc = "Why not build a mudhut?",
    },
    ["some stone"] = {
        aliases = { "stone", "cobblestone" },
        material = true,
        ore = true,
        infinite = true,
        toolLevel = 1,
        toolType = "pick",
        desc = "Stone is useful for building things, and making stone pickaxes.",
    },
    ["some iron"] = {
        aliases = { "iron" },
        material = true,
        ore = true,
        toolLevel = 2,
        toolType = "pick",
        desc = "That iron looks mighty strong, you'll need a stone pickaxe to mine it.",
    },
    ["some diamond"] = {
        aliases = { "diamond", "diamonds" },
        material = true,
        ore = true,
        toolLevel = 3,
        toolType = "pick",
        desc = "Sparkly, rare, and impossible to mine without an iron pickaxe.",
    },
    ["some torches"] = {
        aliases = { "torches", "torch" },
        desc = "These won't run out for a while.",
    },
    ["a torch"] = {
        aliases = { "torch" },
        desc = "Fire, fire, burn so bright, won't you light my cave tonight?",
    },
    ["some wool"] = {
        aliases = { "wool" },
        material = true,
        desc = "Soft and good for building.",
    },
    ["some pork"] = {
        aliases = { "pork", "porkchops" },
        food = true,
        desc = "Delicious and nutricious.",
    },
    ["some chicken"] = {
        aliases = { "chicken" },
        food = true,
        desc = "Finger licking good.",
    },
}

local tAnimals = {
    "a pig", "a cow", "a sheep", "a chicken",
}

local tMonsters = {
    "a creeper", "a skeleton", "a zombie", "a spider"
}

local tRecipes = {
    ["some planks"] = { "some wood" },
    ["some sticks"] = { "some planks" },
    ["some sticks"] = { "some planks" },
    ["a crafting table"] = { "some planks" },
    ["a furnace"] = { "some stone" },
    ["some torches"] = { "some sticks", "some coal" },

    ["a wooden pickaxe"] = { "some planks", "some sticks" },
    ["a stone pickaxe"] = { "some stone", "some sticks" },
    ["an iron pickaxe"] = { "some iron", "some sticks" },
    ["a diamond pickaxe"] = { "some diamond", "some sticks" },

    ["a wooden sword"] = { "some planks", "some sticks" },
    ["a stone sword"] = { "some stone", "some sticks" },
    ["an iron sword"] = { "some iron", "some sticks" },
    ["a diamond sword"] = { "some diamond", "some sticks" },

    ["a wooden shovel"] = { "some planks", "some sticks" },
    ["a stone shovel"] = { "some stone", "some sticks" },
    ["an iron shovel"] = { "some iron", "some sticks" },
    ["a diamond shovel"] = { "some diamond", "some sticks" },
}

local tGoWest = {
    "(life is peaceful there)",
    "(lots of open air)",
    "(to begin life anew)",
    "(this is what we'll do)",
    "(sun in winter time)",
    "(we will do just fine)",
    "(where the skies are blue)",
    "(this and more we'll do)",
}
local nGoWest = 0

local bRunning = true
local tMap = { { {}, }, }
local x,y,z = 0,0,0
local inventory = {
    ["no tea"] = items["no tea"],
}

local nTurn = 0
local nTimeInRoom = 0
local bInjured = false

local tDayCycle = {
    "It is daytime.",
    "It is daytime.",
    "It is daytime.",
    "It is daytime.",
    "It is daytime.",
    "It is daytime.",
    "It is daytime.",
    "It is daytime.",
    "The sun is setting.",
    "It is night.",
    "It is night.",
    "It is night.",
    "It is night.",
    "It is night.",
    "The sun is rising.",
}

local function getTimeOfDay()
    return math.fmod( math.floor(nTurn/3), #tDayCycle ) + 1
end

local function isSunny()
    return (getTimeOfDay() < 10)
end

local function getRoom( x, y, z, dontCreate )
    tMap[x] = tMap[x] or {}
    tMap[x][y] = tMap[x][y] or {}
    if not tMap[x][y][z] and dontCreate ~= true then
        local room = {
            items = {},
            exits = {},
            nMonsters = 0,
        }
        tMap[x][y][z] = room

        if y == 0 then
            -- Room is above ground

            -- Pick biome
            room.nBiome = math.random( 1, #tBiomes )
            room.trees = hasTrees( room.nBiome )

            -- Add animals
            if math.random(1,3) == 1 then
                for n = 1,math.random(1,2) do
                    local sAnimal = tAnimals[ math.random( 1, #tAnimals ) ]
                    room.items[ sAnimal ] = items[ sAnimal ]
                end
            end

            -- Add surface ore
            if math.random(1,5) == 1 or hasStone( room.nBiome ) then
                room.items[ "some stone" ] = items[ "some stone" ]
            end
            if math.random(1,8) == 1 then
                room.items[ "some coal" ] = items[ "some coal" ]
            end
            if math.random(1,8) == 1 and hasRivers( room.nBiome ) then
                room.items[ "a river" ] = items[ "a river" ]
            end

            -- Add exits
            room.exits = {
                ["north"] = true,
                ["south"] = true,
                ["east"] = true,
                ["west"] = true,
            }
            if math.random(1,8) == 1 then
                room.exits["down"] = true
                room.items["a cave entrance"] = items["a cave entrance"]
            end

        else
            -- Room is underground
            -- Add exits
            local function tryExit( sDir, sOpp, x, y, z )
                local adj = getRoom( x, y, z, true )
                if adj then
                    if adj.exits[sOpp] then
                        room.exits[sDir] = true
                    end
                else
                    if math.random(1,3) == 1 then
                        room.exits[sDir] = true
                    end
                end
            end

            if y == -1 then
                local above = getRoom( x, y + 1, z )
                if above.exits["down"] then
                    room.exits["up"] = true
                    room.items["an exit to the surface"] = items["an exit to the surface"]
                end
            else
                tryExit( "up", "down", x, y + 1, z )
            end

            if y > -3 then
                tryExit( "down", "up", x, y - 1, z )
            end

            tryExit( "east", "west", x - 1, y, z )
            tryExit( "west", "east", x + 1, y, z )
            tryExit( "north", "south", x, y, z + 1 )
            tryExit( "south", "north", x, y, z - 1 )

            -- Add ores
            room.items[ "some stone" ] = items[ "some stone" ]
            if math.random(1,3) == 1 then
                room.items[ "some coal" ] = items[ "some coal" ]
            end
            if math.random(1,8) == 1 then
                room.items[ "some iron" ] = items[ "some iron" ]
            end
            if y == -3 and math.random(1,15) == 1 then
                room.items[ "some diamond" ] = items[ "some diamond" ]
            end

            -- Turn out the lights
            room.dark = true
        end
    end
    return tMap[x][y][z]
end

local function itemize( t )
    local item = next( t )
    if item == nil then
        return "nothing"
    end

    local text = ""
    while item do
        text = text .. item

        local nextItem = next( t, item )
        if nextItem ~= nil then
            local nextNextItem = next( t, nextItem )
            if nextNextItem == nil then
                text = text .. " and "
            else
                text = text .. ", "
            end
        end
        item = nextItem
    end
    return text
end

function findItem( _tList, _sQuery )
    for sItem, tItem in pairs( _tList ) do
        if sItem == _sQuery then
            return sItem
        end
        if tItem.aliases ~= nil then
            for n, sAlias in pairs( tItem.aliases ) do
                if sAlias == _sQuery then
                    return sItem
                end
            end
        end
    end
    return nil
end

local tMatches = {
    ["wait"] = {
        "wait",
    },
    ["look"] = {
        "look at the ([%a ]+)",
        "look at ([%a ]+)",
        "look",
        "inspect ([%a ]+)",
        "inspect the ([%a ]+)",
        "inspect",
    },
    ["inventory"] = {
        "check self",
        "check inventory",
        "inventory",
        "i",
    },
    ["go"] = {
        "go (%a+)",
        "travel (%a+)",
        "walk (%a+)",
        "run (%a+)",
        "go",
    },
    ["dig"] = {
        "dig (%a+) using ([%a ]+)",
        "dig (%a+) with ([%a ]+)",
        "dig (%a+)",
        "dig",
    },
    ["take"] = {
        "pick up the ([%a ]+)",
        "pick up ([%a ]+)",
        "pickup ([%a ]+)",
        "take the ([%a ]+)",
        "take ([%a ]+)",
        "take",
    },
    ["drop"] = {
        "put down the ([%a ]+)",
        "put down ([%a ]+)",
        "drop the ([%a ]+)",
        "drop ([%a ]+)",
        "drop",
    },
    ["place"] = {
        "place the ([%a ]+)",
        "place ([%a ]+)",
        "place",
    },
    ["cbreak"] = {
        "punch the ([%a ]+)",
        "punch ([%a ]+)",
        "punch",
        "break the ([%a ]+) with the ([%a ]+)",
        "break ([%a ]+) with ([%a ]+) ",
        "break the ([%a ]+)",
        "break ([%a ]+)",
        "break",
    },
    ["mine"] = {
        "mine the ([%a ]+) with the ([%a ]+)",
        "mine ([%a ]+) with ([%a ]+)",
        "mine ([%a ]+)",
        "mine",
    },
    ["attack"] = {
        "attack the ([%a ]+) with the ([%a ]+)",
        "attack ([%a ]+) with ([%a ]+)",
        "attack ([%a ]+)",
        "attack",
        "kill the ([%a ]+) with the ([%a ]+)",
        "kill ([%a ]+) with ([%a ]+)",
        "kill ([%a ]+)",
        "kill",
        "hit the ([%a ]+) with the ([%a ]+)",
        "hit ([%a ]+) with ([%a ]+)",
        "hit ([%a ]+)",
        "hit",
    },
    ["craft"] = {
        "craft a ([%a ]+)",
        "craft some ([%a ]+)",
        "craft ([%a ]+)",
        "craft",
        "make a ([%a ]+)",
        "make some ([%a ]+)",
        "make ([%a ]+)",
        "make",
    },
    ["build"] = {
        "build ([%a ]+) out of ([%a ]+)",
        "build ([%a ]+) from ([%a ]+)",
        "build ([%a ]+)",
        "build",
    },
    ["eat"] = {
        "eat a ([%a ]+)",
        "eat the ([%a ]+)",
        "eat ([%a ]+)",
        "eat",
    },
    ["help"] = {
        "help me",
        "help",
    },
    ["exit"] = {
        "exit",
        "quit",
        "goodbye",
        "good bye",
        "bye",
        "farewell",
    },
}

local commands = {}
function doCommand( text )
    if text == "" then
        commands[ "noinput" ]()
        return
    end

    for sCommand, t in pairs( tMatches ) do
        for n, sMatch in pairs( t ) do
            local tCaptures = { string.match( text, "^" .. sMatch .. "$" ) }
            if #tCaptures ~= 0 then
                local fnCommand = commands[ sCommand ]
                if #tCaptures == 1 and tCaptures[1] == sMatch then
                    fnCommand()
                else
                    fnCommand( unpack( tCaptures ) )
                end
                return
            end
        end
    end
    commands[ "badinput" ]()
end

function commands.wait()
    sleep(0.5)  c.say( "Time passes..." )
end

function commands.look( _sTarget )
    local room = getRoom( x,y,z )
    if room.dark then
        sleep(0.5)  c.say( "It is pitch dark." )
        return
    end

    if _sTarget == nil then
        -- Look at the world
        if y == 0 then
            sleep(0.5)  c.say( "You are standing " .. tBiomes[room.nBiome] .. ". " )
            sleep(0.5)  c.say( tDayCycle[ getTimeOfDay() ] )
        else
            sleep(0.5)  c.say( "You are underground. " )
            if next( room.exits ) ~= nil then
                sleep(0.5)  c.say( "You can travel "..itemize( room.exits ).."." )
            else
                sleep(0.5)  c.say()
            end
        end
        if next( room.items ) ~= nil then
            sleep(0.5)  c.say( "There is " .. itemize( room.items ) .. " here." )
        end
        if room.trees then
            sleep(0.5)  c.say( "There are trees here." )
        end

    else
        -- Look at stuff
        if room.trees and (_sTarget == "tree" or _sTarget == "trees") then
            sleep(0.5)  c.say( "The trees look easy to break." )
        elseif _sTarget == "self" or _sTarget == "myself" then
            sleep(0.5)  c.say( "Very handsome." )
        else
            local tItem = nil
            local sItem = findItem( room.items, _sTarget )
            if sItem then
                tItem = room.items[sItem]
            else
                sItem = findItem( inventory, _sTarget )
                if sItem then
                    tItem = inventory[sItem]
                end
            end

            if tItem then
                sleep(0.5)  c.say( tItem.desc or ("You see nothing special about "..sItem..".") )
            else
                sleep(0.5)  c.say( "You don't see any ".._sTarget.." here." )
            end
        end
    end
end

function commands.go( _sDir )
    local room = getRoom( x,y,z )
    if _sDir == nil then
        sleep(0.5)  c.say( "Go where?" )
        return
    end

    if nGoWest ~= nil then
        if _sDir == "west" then
            nGoWest = nGoWest + 1
            if nGoWest > #tGoWest then
                nGoWest = 1
            end
            sleep(0.5)  c.say( tGoWest[ nGoWest ] )
        else
            if nGoWest > 0 or nTurn > 6 then
                nGoWest = nil
            end
        end
    end

    if room.exits[_sDir] == nil then
        sleep(0.5)  c.say( "You can't go that way." )
        return
    end

    if _sDir == "north" then
        z = z + 1
    elseif _sDir == "south" then
        z = z - 1
    elseif _sDir == "east" then
        x = x - 1
    elseif _sDir == "west" then
        x = x + 1
    elseif _sDir == "up" then
        y = y + 1
    elseif _sDir == "down" then
        y = y - 1
    else
        sleep(0.5)  c.say( "I don't understand that direction." )
        return
    end

    nTimeInRoom = 0
    doCommand( "look" )
end

function commands.dig( _sDir, _sTool )
    local room = getRoom( x,y,z )
    if _sDir == nil then
        sleep(0.5)  c.say( "Dig where?" )
        return
    end

    local sTool = nil
    local tTool = nil
    if _sTool ~= nil then
        sTool = findItem( inventory, _sTool )
        if not sTool then
            sleep(0.5)  c.say( "You're not carrying a ".._sTool.."." )
            return
        end
        tTool = inventory[ sTool ]
    end

    local room = getRoom( x, y, z )
    local bActuallyDigging = (room.exits[ _sDir ] ~= true)
    if bActuallyDigging then
        if sTool == nil or tTool.toolType ~= "pick" then
            sleep(0.5)  c.say( "You need to use a pickaxe to dig through stone." )
            return
        end
    end

    if _sDir == "north" then
        room.exits["north"] = true
        z = z + 1
        getRoom( x, y, z ).exits["south"] = true

    elseif _sDir == "south" then
        room.exits["south"] = true
        z = z - 1
        getRoom( x, y, z ).exits["north"] = true

    elseif _sDir == "east" then
        room.exits["east"] = true
        x = x - 1
        getRoom( x, y, z ).exits["west"] = true

    elseif _sDir == "west" then
        room.exits["west"] = true
        x = x + 1
        getRoom( x, y, z ).exits["east"] = true

    elseif _sDir == "up" then
        if y == 0 then
            sleep(0.5)  c.say( "You can't dig that way." )
            return
        end

        room.exits["up"] = true
        if y == -1 then
            room.items[ "an exit to the surface" ] = items[ "an exit to the surface" ]
        end
        y = y + 1

        room = getRoom( x, y, z )
        room.exits["down"] = true
        if y == 0 then
            room.items[ "a cave entrance" ] = items[ "a cave entrance" ]
        end

    elseif _sDir == "down" then
        if y <= -3 then
            sleep(0.5)  c.say( "You hit bedrock." )
            return
        end

        room.exits["down"] = true
        if y == 0 then
            room.items[ "a cave entrance" ] = items[ "a cave entrance" ]
        end
        y = y - 1

        room = getRoom( x, y, z )
        room.exits["up"] = true
        if y == -1 then
            room.items[ "an exit to the surface" ] = items[ "an exit to the surface" ]
        end

    else
        sleep(0.5)  c.say( "I don't understand that direction." )
        return
    end

    --
    if bActuallyDigging then
        if _sDir == "down" and y == -1 or
           _sDir == "up" and y == 0 then
            inventory[ "some dirt" ] = items[ "some dirt" ]
            inventory[ "some stone" ] = items[ "some stone" ]
            sleep(0.5)  c.say( "You dig ".._sDir.." using "..sTool.." and collect some dirt and stone." )
        else
            inventory[ "some stone" ] = items[ "some stone" ]
            sleep(0.5)  c.say( "You dig ".._sDir.." using "..sTool.." and collect some stone." )
        end
    end

    nTimeInRoom = 0
    doCommand( "look" )
end

function commands.inventory()
    sleep(0.5)  c.say( "You are carrying " .. itemize( inventory ) .. "." )
end

function commands.drop( _sItem )
    if _sItem == nil then
        sleep(0.5)  c.say( "Drop what?" )
        return
    end

    local room = getRoom( x,y,z )
    local sItem = findItem( inventory, _sItem )
    if sItem then
        local tItem = inventory[ sItem ]
        if tItem.droppable == false then
            sleep(0.5)  c.say( "You can't drop that." )
        else
            room.items[ sItem ] = tItem
            inventory[ sItem ] = nil
            sleep(0.5)  c.say( "Dropped." )
        end
    else
        sleep(0.5)  c.say( "You don't have a ".._sItem.."." )
    end
end

function commands.place( _sItem )
    if _sItem == nil then
        sleep(0.5)  c.say( "Place what?" )
        return
    end

    if _sItem == "torch" or _sItem == "a torch" then
        local room = getRoom( x,y,z )
        if inventory["some torches"] or inventory["a torch"] then
            inventory["a torch"] = nil
            room.items["a torch"] = items["a torch"]
            if room.dark then
                sleep(0.5)  c.say( "The cave lights up under the torchflame." )
                room.dark = false
            elseif y == 0 and not isSunny() then
                sleep(0.5)  c.say( "The night gets a little brighter." )
            else
                sleep(0.5)  c.say( "Placed." )
            end
        else
            sleep(0.5)  c.say( "You don't have torches." )
        end
        return
    end

    commands.drop( _sItem )
end

function commands.take( _sItem )
    if _sItem == nil then
        sleep(0.5)  c.say( "Take what?" )
        return
    end

    local room = getRoom( x,y,z )
    local sItem = findItem( room.items, _sItem )
    if sItem then
        local tItem = room.items[ sItem ]
        if tItem.heavy == true then
            sleep(0.5)  c.say( "You can't carry "..sItem.."." )
        elseif tItem.ore == true then
            sleep(0.5)  c.say( "You need to mine this ore." )
        else
            if tItem.infinite ~= true then
                room.items[ sItem ] = nil
            end
            inventory[ sItem ] = tItem

            if inventory["some torches"] and inventory["a torch"] then
                inventory["a torch"] = nil
            end
            if sItem == "a torch" and y < 0 then
                room.dark = true
                sleep(0.5)  c.say( "The cave plunges into darkness." )
            else
                sleep(0.5)  c.say( "Taken." )
            end
        end
    else
        sleep(0.5)  c.say( "You don't see a ".._sItem.." here." )
    end
end

function commands.mine( _sItem, _sTool )
    if _sItem == nil then
        sleep(0.5)  c.say( "Mine what?" )
        return
    end
    if _sTool == nil then
        sleep(0.5)  c.say( "Mine ".._sItem.." with what?" )
        return
    end
    commands.cbreak( _sItem, _sTool )
end

function commands.attack( _sItem, _sTool )
    if _sItem == nil then
        sleep(0.5)  c.say( "Attack what?" )
        return
    end
    commands.cbreak( _sItem, _sTool )
end

function commands.cbreak( _sItem, _sTool )
    if _sItem == nil then
        sleep(0.5)  c.say( "Break what?" )
        return
    end

    local sTool = nil
    if _sTool ~= nil then
        sTool = findItem( inventory, _sTool )
        if sTool == nil then
            sleep(0.5)  c.say( "You're not carrying a ".._sTool.."." )
            return
        end
    end

    local room = getRoom( x,y,z )
    if _sItem == "tree" or _sItem == "trees" or _sItem == "a tree" then
        sleep(0.5)  c.say( "The tree breaks into blocks of wood, which you pick up." )
        inventory[ "some wood" ] = items[ "some wood" ]
        return
    elseif _sItem == "self" or _sItem == "myself" then
        if term.isColour() then
            term.setTextColour( colours.red )
        end
        sleep(0.5)  c.say( "You have died." )
        sleep(0.5)  c.say( "Score: &e0" )
        term.setTextColour( colours.white )
        bRunning = false
        return
    end

    local sItem = findItem( room.items, _sItem )
    if sItem then
        local tItem = room.items[ sItem ]
        if tItem.ore == true then
            -- Breaking ore
            if not sTool then
                sleep(0.5)  c.say( "You need a tool to break this ore." )
                return
            end
            local tTool = inventory[ sTool ]
            if tTool.tool then
                if tTool.toolLevel < tItem.toolLevel then
                    sleep(0.5)  c.say( sTool .." is not strong enough to break this ore." )
                elseif tTool.toolType ~= tItem.toolType then
                    sleep(0.5)  c.say( "You need a different kind of tool to break this ore." )
                else
                    sleep(0.5)  c.say( "The ore breaks, dropping "..sItem..", which you pick up." )
                    inventory[ sItem ] = items[ sItem ]
                    if tItem.infinite ~= true then
                        room.items[ sItem ] = nil
                    end
                end
            else
                sleep(0.5)  c.say( "You can't break "..sItem.." with "..sTool..".")
            end

        elseif tItem.creature == true then
            -- Fighting monsters (or pigs)
            local toolLevel = 0
            local tTool = nil
            if sTool then
                tTool = inventory[ sTool ]
                if tTool.toolType == "sword" then
                    toolLevel = tTool.toolLevel
                end
            end

            local tChances = { 0.2, 0.4, 0.55, 0.8, 1 }
            if math.random() <= tChances[ toolLevel + 1 ] then
                room.items[ sItem ] = nil
                sleep(0.5)  c.say( "The "..tItem.aliases[1].." dies." )

                if tItem.drops then
                    for n, sDrop in pairs( tItem.drops ) do
                        if not room.items[sDrop] then
                            sleep(0.5)  c.say( "The "..tItem.aliases[1].." dropped "..sDrop.."." )
                            room.items[sDrop] = items[sDrop]
                        end
                    end
                end

                if tItem.monster then
                    room.nMonsters = room.nMonsters - 1
                end
            else
                sleep(0.5)  c.say( "The "..tItem.aliases[1].." is injured by your blow." )
            end

            if tItem.hitDrops then
                for n, sDrop in pairs( tItem.hitDrops ) do
                    if not room.items[sDrop] then
                        sleep(0.5)  c.say( "The "..tItem.aliases[1].." dropped "..sDrop.."." )
                        room.items[sDrop] = items[sDrop]
                    end
                end
            end

        else
            sleep(0.5)  c.say( "You can't break "..sItem.."." )
        end
    else
        sleep(0.5)  c.say( "You don't see a ".._sItem.." here." )
    end
end

function commands.craft( _sItem )
    if _sItem == nil then
        sleep(0.5)  c.say( "Craft what?" )
        return
    end

    if _sItem == "computer" or _sItem == "a computer" then
        sleep(0.5)  c.say( "By creating a computer in a computer in a computer, you tear a hole in the spacetime continuum from which no mortal being can escape." )
        if term.isColour() then
            term.setTextColour( colours.red )
        end
        sleep(0.5)  c.say( "You have died." )
        sleep(0.5)  c.say( "Score: &e0" )
        term.setTextColour( colours.white )
        bRunning = false
        return
    end

    local room = getRoom( x,y,z )
    local sItem = findItem( items, _sItem )
    local tRecipe = (sItem and tRecipes[ sItem ]) or nil
    if tRecipe then
        for n,sReq in ipairs( tRecipe ) do
            if inventory[sReq] == nil then
                sleep(0.5)  c.say( "You don't have the items you need to craft "..sItem.."." )
                return
            end
        end

        for n,sReq in ipairs( tRecipe ) do
            inventory[sReq] = nil
        end
        inventory[ sItem ] = items[ sItem ]
        if inventory["some torches"] and inventory["a torch"] then
            inventory["a torch"] = nil
        end
        sleep(0.5)  c.say( "Crafted." )
    else
        sleep(0.5)  c.say( "You don't know how to make "..(sItem or _sItem).."." )
    end
end

function commands.build( _sThing, _sMaterial )
    if _sThing == nil then
        sleep(0.5)  c.say( "Build what?" )
        return
    end

    local sMaterial = nil
    if _sMaterial == nil then
        for sItem, tItem in pairs( inventory ) do
            if tItem.material then
                sMaterial = sItem
                break
            end
        end
        if sMaterial == nil then
            sleep(0.5)  c.say( "You don't have any building materials." )
            return
        end
    else
        sMaterial = findItem( inventory, _sMaterial )
        if not sMaterial then
            sleep(0.5)  c.say( "You don't have any ".._sMaterial )
            return
        end

        if inventory[sMaterial].material ~= true then
            sleep(0.5)  c.say( sMaterial.." is not a good building material." )
            return
        end
    end

    local alias = nil
    if string.sub(_sThing, 1, 1) == "a" then
        alias = string.match( _sThing, "a ([%a ]+)" )
    end

    local room = getRoom( x,y,z )
    inventory[sMaterial] = nil
    room.items[ _sThing ] = {
        heavy = true,
        aliases = { alias },
        desc = "As you look at your creation (made from "..sMaterial.."), you feel a swelling sense of pride.",
    }

    sleep(0.5)  c.say( "Your construction is complete." )
end

function commands.help()
    local sText =
        "Welcome to adventure, the greatest text adventure game on CraftOS. " ..
        "To get around the world, type actions, and the adventure will " ..
        "be read back to you. The actions availiable to you are go, look, inspect, inventory, " ..
        "take, drop, place, punch, attack, mine, dig, craft, build, eat and exit."
    sleep(0.5)  c.say( sText )
end

function commands.eat( _sItem )
    if _sItem == nil then
        sleep(0.5)  c.say( "Eat what?" )
        return
    end

    local sItem = findItem( inventory, _sItem )
    if not sItem then
        sleep(0.5)  c.say( "You don't have any ".._sItem.."." )
        return
    end

    local tItem = inventory[sItem]
    if tItem.food then
        sleep(0.5)  c.say( "That was delicious!" )
        inventory[sItem] = nil

        if bInjured then
            sleep(0.5)  c.say( "You are no longer injured." )
            bInjured = false
        end
    else
        sleep(0.5)  c.say( "You can't eat "..sItem.."." )
    end
end

function commands.exit()
    bRunning = false
end

function commands.badinput()
    local tResponses = {
        "I don't understand.",
        "I don't understand you.",
        "You can't do that.",
        "Nope.",
        "Huh?",
        "Say again?",
        "That's crazy talk.",
        "Speak clearly.",
        "I'll think about it.",
        "Let me get back to you on that one.",
        "That doesn't make any sense.",
        "What?",
    }
    sleep(0.5)  c.say( tResponses[ math.random(1,#tResponses) ] )
end

function commands.noinput()
    local tResponses = {
        "Speak up.",
        "Enunciate.",
        "Project your voice.",
        "Don't be shy.",
        "Use your words.",
    }
    sleep(0.5)  c.say( tResponses[ math.random(1,#tResponses) ] )
end

local function simulate()
    local bNewMonstersThisRoom = false

    -- Spawn monsters in nearby rooms
    for sx = -2,2 do
        for sy = -1,1 do
            for sz = -2,2 do
                local h = y + sy
                if h >= -3 and h <= 0 then
                    local room = getRoom( x + sx, h, z + sz )

                    -- Spawn monsters
                    if room.nMonsters < 2 and
                       ((h == 0 and not isSunny() and not room.items["a torch"]) or room.dark) and
                       math.random(1,6) == 1 then

                        local sMonster = tMonsters[ math.random(1,#tMonsters) ]
                        if room.items[ sMonster ] == nil then
                            room.items[ sMonster ] = items[ sMonster ]
                            room.nMonsters = room.nMonsters + 1

                            if sx == 0 and sy == 0 and sz == 0 and not room.dark then
                                sleep(0.5)  c.say( "From the shadows, "..sMonster.." appears." )
                                bNewMonstersThisRoom = true
                            end
                        end
                    end

                    -- Burn monsters
                    if h == 0 and isSunny() then
                        for n,sMonster in ipairs( tMonsters ) do
                            if room.items[sMonster] and items[sMonster].nocturnal then
                                room.items[sMonster] = nil
                                if sx == 0 and sy == 0 and sz == 0 and not room.dark then
                                    sleep(0.5)  c.say( "With the sun high in the sky, the "..items[sMonster].aliases[1].." bursts into flame and dies." )
                                end
                                room.nMonsters = room.nMonsters - 1
                            end
                        end
                    end
                end
            end
        end
    end

    -- Make monsters attack
    local room = getRoom( x, y, z )
    if nTimeInRoom >= 2 and not bNewMonstersThisRoom then
        for n,sMonster in ipairs( tMonsters ) do
            if room.items[sMonster] then
                if math.random(1,4) == 1 and
                   not (y == 0 and isSunny() and (sMonster == "a spider")) then
                    if sMonster == "a creeper" then
                        if room.dark then
                            sleep(0.5)  c.say( "A creeper explodes." )
                        else
                            sleep(0.5)  c.say( "The creeper explodes." )
                        end
                        room.items[sMonster] = nil
                        room.nMonsters = room.nMonsters - 1
                    else
                        if room.dark then
                            sleep(0.5)  c.say( "A "..items[sMonster].aliases[1].." attacks you." )
                        else
                            sleep(0.5)  c.say( "The "..items[sMonster].aliases[1].." attacks you." )
                        end
                    end

                    if bInjured then
                        if term.isColour() then
                            term.setTextColour( colours.red )
                        end
                        sleep(0.5)  c.say( "You have died." )
                        sleep(0.5)  c.say( "Score: &e0" )
                        term.setTextColour( colours.white )
                        bRunning = false
                        return
                    else
                        bInjured = true
                    end

                    break
                end
            end
        end
    end

    -- Always sleep(0.5)  c.say this
    if bInjured then
        if term.isColour() then
            term.setTextColour( colours.red )
        end
        sleep(0.5)  c.say( "You are injured." )
        term.setTextColour( colours.white )
    end

    -- Advance time
    nTurn = nTurn + 1
    nTimeInRoom = nTimeInRoom + 1
end

doCommand( "look" )
simulate()

local tCommandHistory = {}
while bRunning do
    if term.isColour() then
        term.setTextColour( colours.yellow )
    end
    write( "? " )
    term.setTextColour( colours.white )

    --local sRawLine = read( nil, tCommandHistory )
    event,player,sRawLine=os.pullEvent("chat")
    table.insert( tCommandHistory, sRawLine )

    local sLine = nil
    for match in string.gmatch(sRawLine, "%a+") do
        if sLine then
            sLine = sLine .. " " .. string.lower(match)
        else
            sLine = string.lower(match)
        end
    end

    doCommand( sLine or "" )
    if bRunning then
        simulate()
    end
end