RCRPG/Oz

RCRPG/Oz is part of RCRPG. You may find other members of RCRPG at Category:RCRPG.

This Oz version of RCRPG implements a text interface.

It is a purely functional implementation, i.e. the state of the world is passed as an argument to functions. If a function modifies the world, a new version is returned.

It implements the same commands as the other implementations (no "alias", "name" or "help" commands, though).

Code

<lang Oz>declare

 %% Basic data structures

 fun {CreateWorld Goal}
    world(goal:Goal
          position:[0 0 0]
          equipped:empty
          inventory:nil
          status:nil
          %% initially we only have one room
          %% coords: X      Y      Z
          rooms:unit(0:unit(0:unit(0:{CreateRoom sledge})))
         )
 end
 
 fun {CreateRoom InitialItem}
    room(items:[InitialItem]
         north:wall
         south:wall
         east:wall
         west:wall
         up:wall
         down:wall)
 end
 
 %% COMMANDS (and shortcuts)
 fun {CreateCommandTable}
    Commands =
    unit(north: {Curry1of2 Go north}  n:Commands.north
         south: {Curry1of2 Go south}  s:Commands.south
         east:  {Curry1of2 Go east}   e:Commands.east
         west:  {Curry1of2 Go west}   w:Commands.west
         up:    {Curry1of2 Go up}     u:Commands.up
         down:  {Curry1of2 Go down}   d:Commands.down
         attack:Attack                a:Commands.attack
         drop:  Drop
         take:  Take
         inventory:Inventory         i:Commands.inventory
         inv:   Commands.inventory
         equip: Equip
        )
 in
    Commands
 end
 CommandTable = {Value.byNeed CreateCommandTable}
 
 %% The game loop.
 proc {Loop World0}
    {PrintStatus World0}
    World = {SetStatus World0 nil}
 in
    if World.position == World.goal then
       {System.showInfo "You are now in the goal room. You have won the game!"}
    else
       {System.printInfo ">"}
       %% Read and parse user input
       Tokens = {Map {String.tokens {ReadLine} & } String.toAtom}
    in
       if Tokens == nil then %% repeat room description when user just presses enter
          {Loop World}
       else
          ComName|Args = Tokens
       in
          if {Not {HasFeature CommandTable ComName}} then
             {Loop {SetStatus World "Unknown command."}}
          else
             ComFunction = CommandTable.ComName
          in
             %% check for number of args (+2: "World" in and out)
             if {Procedure.arity ComFunction} \= 2 + {Length Args} then
                {Loop {SetStatus World "Wrong number of arguments."}}
             else
                WorldAfterCommand
             in
                %% dynamically call ComFunction
                %% (statically unknown number of arguments)
                {Procedure.apply ComFunction World|{Append Args [WorldAfterCommand]}}
                {Loop WorldAfterCommand}
             end
          end
       end
    end
 end

 %% IMPLEMENTATION OF COMMANDS
 %% All commands take the "world" as their first argument.
 %% They might take additional arguments (from the user).
 %% All commands return the new world.

 %% Try to go one step into the specified direction.
 %% Direction: atom like 'north'
 %% (Go is not a real command; it only becomes one after currying.)
 fun {Go Direction World}
    CR = {GetCurrentRoom World}
 in
    if CR.Direction == open then
       if Direction == up andthen {Not {Member ladder CR.items}} then
          {SetStatus World "There is no ladder in this room."}
       else
          {AdjoinAt World position {MovePos World.position Direction}}
       end
    else
       {SetStatus World "There is a wall in that direction."}
    end
 end

 fun {Attack World Direction}
    if {Not {IsDirection Direction}} then
       {SetStatus World "Unknown direction"}
    elseif World.equipped == sledge then
       case {GetCurrentRoom World}.Direction
       of wall then
          {SetStatus {ConnectCurrentRoomTo World Direction}
           "I made a hole in the wall."}
       [] open then
          {SetStatus World "There is already a connection in that direction."}
       end
    else
       {SetStatus World "Can't attack with this item."}
    end
 end

 %% Item: name of item as atom
 fun {Drop World Item}
    if Item == all then {FoldL World.inventory Drop World}
    else
       if {Member Item World.inventory} then
          CR = {GetCurrentRoom World}
          %% add to room
          NewRoom = {AdjoinAt CR items Item|CR.items}
          World2 = {SetRoom World World.position NewRoom}
          %% remove from inventory
          RemainingItems = {Remove World2.inventory Item}
          World3 = {AdjoinAt World3 inventory RemainingItems}
          %% possibly update "equipped"
          World4 = if {Not {Member World3.equipped RemainingItems}} then
                      {AdjoinAt World3 equipped empty}
                   else
                      World3
                   end
       in
          {Inventory World4}
       else
          {SetStatus World "Not carrying such an item."}
       end
    end
 end

 %% Item: item name as an atom
 fun {Take World Item}
    CR = {GetCurrentRoom World}
 in
    if Item == all then {FoldL CR.items Take World}
    else
       if {Member Item CR.items} then
          %% remove from room
          NewRoom = {AdjoinAt CR items {Remove CR.items Item}}
          World2 = {SetRoom World World.position NewRoom}
          %% add to inventory
          World3 = {AdjoinAt World2 inventory Item|World2.inventory}
       in
          {Inventory World3}
       else
          {SetStatus World "There is no such item in this room."}
       end
    end
 end

 fun {Equip World Item}
    if {Member Item World.inventory} then
       {SetStatus {AdjoinAt World equipped Item}
        "Equipped with "#Item}
    else
       {SetStatus World "No such item in inventory."}
    end
 end

 %% Shows the inventory as the status.
 fun {Inventory World}
    {SetStatus World "inventory: "#{ListToString World.inventory}}
 end

 %% Operations on basic data structures (the "world" and rooms)

 proc {PrintStatus World}
    if World.status == nil then %% describe room if no status
       [X Y Z] = World.position
    in
       {System.showInfo
        "You are in room ("#X#", "#Y#", "#Z#").\n"#
        "The following items are in this room: "#
        {ListToString {GetCurrentRoom World}.items}#"."}
    else
       {System.showInfo World.status}
    end
 end

 fun {SetStatus World Status}
    {AdjoinAt World status Status}
 end

 fun {NewRoom}
    {CreateRoom {RandomlySelect [sledge gold ladder]}}
 end

 %% Returns the room at the given position.
 %% Might modify the world (if the room does not yet exist) and returns the new world
 %% in 'NewWorld'.
 fun {GetRoom World Position ?NewWorld}
    {CondGet World rooms|Position NewRoom ?NewWorld}
 end
 
 fun {GetCurrentRoom World}
    [X Y Z] = World.position
 in
    World.rooms.X.Y.Z
 end

 %% Replaces a room. Returns the new world.
 fun {SetRoom World Pos NewRoom}
    {Set World rooms|Pos NewRoom}
 end

 local
    %% Maps directions to movement deltas.
    DirPos = unit(east: [~1 0 0] west: [1 0 0]
                  north:[0 ~1 0] south:[0 1 0]
                  up:   [0 0 ~1] down: [0 0 1])
 in
    %% Returns the position that results from going one step
    %% into the specified direction.
    fun {MovePos Pos Dir}
       {List.zip Pos DirPos.Dir Number.'+'}
    end
 end

 local
    OppositeDir = unit(east:west west:east
                       north:south south:north
                       up:down down:up)
 in
    fun {IsDirection X} {HasFeature OppositeDir X} end

    %% Connects the current room to a neighbouring room.
    %% Returns the new world.
    fun {ConnectCurrentRoomTo World Direction}
       World2 = {OpenRoom World World.position Direction}
       OtherPos = {MovePos World2.position Direction}
    in
       {OpenRoom World2 OtherPos OppositeDir.Direction}
    end
 end
 
 fun {OpenRoom World RoomPosition Direction}
    World2
    Room = {GetRoom World RoomPosition ?World2}
 in
    {SetRoom World2 RoomPosition {AdjoinAt Room Direction open}}
 end
 
 
 %% general helpers

 %% Creates a one-argument function from a two-argument function.
 fun {Curry1of2 Fun Arg1}
    fun {$ Arg2}
       Return
    in
       {Procedure.apply Fun [Arg1 Arg2 Return]}
       Return
    end
 end

 %% Removes the first occurance of Y from the list Xs.
 fun {Remove Xs Y}
    case Xs of !Y|Yr then Yr
    [] X|Xr then X|{Remove Xr Y}
    [] nil then nil
    end
 end

 %% Returns a randomly picked element of Xs.
 fun {RandomlySelect Xs}
    Idx = {OS.rand} * {Length Xs} div {OS.randLimits _} + 1
 in
    {Nth Xs Idx}
 end

 %% Reads a line from stdin.
 local
    StdIn = {New class $ from Open.file Open.text end init(name:stdin)}
 in
    fun {ReadLine}
       {StdIn getS($)}
    end
 end

 fun {ListToString Xs}
    {Value.toVirtualString Xs 1000 1000}
 end
 
 
 %% Support for using nested records as multidimensional immutable arrays

 Nothing = {NewName}

 %% Returns a value from an array where Fs is a list of array indices.
 %% If the specified entry does not exist, it is created by calling Otherwise
 %% and the new array is returned in NewArr.
 %% Example: Val = {CondGet a(1:b(3:42)) [1 3] _ _} == 42
 fun {CondGet Arr Fs Otherwise ?NewArr}
    case Fs of F|Fr then
       Arr2 = if Arr == Nothing then unit else Arr end
       NewArrF
       Res = {CondGet {CondSelect Arr2 F Nothing} Fr Otherwise ?NewArrF}
    in
       NewArr = {AdjoinAt Arr2 F NewArrF}
       Res
    [] nil then
       NewArr = if Arr == Nothing then {Otherwise} else Arr end
       NewArr
    end
 end

 %% Sets a (new or existing) entry in Arr to V.
 %% Returns the new array.
 fun {Set Arr Fs V}
    case Fs of F|Fr then
       Arr2 = if Arr == Nothing then unit else Arr end
    in
       {AdjoinAt Arr2 F {Set {CondSelect Arr2 F Nothing} Fr V}}
    [] nil then
       V
    end
 end

in

 %% Start game
 {Loop {CreateWorld [1 1 5]}}</lang>