-record(room, {name, description, items, exits}).

start() ->
Room1 = #room{name = “Entrance Hall”, description = “You are in a dimly lit entrance hall. There are doors to the north and east.”, items = [“key”], exits = [{north, “Library”}, {east, “Kitchen”}]},
Room2 = #room{name = “Library”, description = “You are in a dusty library filled with old books. You can see a ladder leading up.”, items = [], exits = [{south, “Entrance Hall”}]},
Room3 = #room{name = “Kitchen”, description = “The kitchen is filled with the smell of something delicious. A chef is here cooking.”, items = [“potion”], exits = [{west, “Entrance Hall”}]},
Rooms = #{
“Entrance Hall” => Room1,
“Library” => Room2,
“Kitchen” => Room3
},
main_loop(“Entrance Hall”, Rooms).

main_loop(CurrentRoomName, Rooms) ->
Room = Maps:get(CurrentRoomName, Rooms),
describe_room(Room),
Input = get_user_input(),
process_input(Input, Room).

describe_room(Room) ->
io:format(“You are in ~s.~n~s~nItems: ~s~nExits: ~s~n”,
[Room#room.name, Room#room.description, string:join(Room#room.items, “, “), string:join(lists:map(fun {Dir, Dest} -> atom_to_list(Dir) ++ ” -> ” ++ Dest end, Room#room.exits), “, “)]).

get_user_input() ->
io:format(“What do you want to do? (go , take , or quit)~n”),
case io:get_line(“”) of
{ok, Line} -> string:trim(Line);
_ -> “quit”
end.

process_input(“quit”, _) ->
io:format(“Thanks for playing!~n”),
halt();

process_input(Input, Room) ->
case string:tokens(Input, ” “) of
[“go”, Direction] ->
handle_exit(Direction, Room);
[“take”, Item] ->
handle_item(Item, Room);
_ ->
io:format(“Invalid command. Try again.~n”),
main_loop(Room#room.name, Rooms)
end.

handle_exit(Direction, Room) ->
case lists:keyfind(atom_to_list(Direction), 1, Room#room.exits) of
false ->
io:format(“You can’t go that way.~n”),
main_loop(Room#room.name, Rooms);
{_, NextRoomName} ->
main_loop(NextRoomName, Rooms)
end.

handle_item(Item, Room) ->
case lists:member(Item, Room#room.items) of
false ->
io:format(“There is no such item here.~n”),
main_loop(Room#room.name, Rooms);
true ->
io:format(“You picked up the ~s.~n”, [Item]),
NewItems = lists:delete(Item, Room#room.items),
Room#room{items = NewItems},
main_loop(Room#room.name, Rooms)
end.

let start () =
let room1 = { name = “Entrance Hall”; description = “You are in a dimly lit entrance hall. There are doors to the north and east.”; items = [“key”]; exits = [(“north”, “Library”); (“east”, “Kitchen”)] } in
let room2 = { name = “Library”; description = “You are in a dusty library filled with old books. You can see a ladder leading up.”; items = []; exits = [(“south”, “Entrance Hall”)] } in
let room3 = { name = “Kitchen”; description = “The kitchen is filled with the smell of something delicious. A chef is here cooking.”; items = [“potion”]; exits = [(“west”, “Entrance Hall”)] } in
let rooms = [
(“Entrance Hall”, room1);
(“Library”, room2);
(“Kitchen”, room3)
] |> List.to_seq |> Hashtbl.of_seq in
main_loop “Entrance Hall” rooms

let rec main_loop current_room_name rooms =
let room = Hashtbl.find rooms current_room_name in
describe_room room;
let input = get_user_input () in
process_input input room rooms

let describe_room room =
let items = String.concat “, ” room.items in
let exits = String.concat “, ” (List.map (fun (dir, dest) -> dir ^ ” -> ” ^ dest) room.exits) in
Printf.printf “You are in %s.n%snItems: %snExits: %sn” room.name room.description items exits

let get_user_input () =
Printf.printf “What do you want to do? (go , take , or quit)n”;
match read_line () with
| line -> String.trim line
| exception End_of_file -> “quit”

let rec process_input input room rooms =
match String.split_on_char ‘ ‘ input with
| [“quit”] ->
Printf.printf “Thanks for playing!n”;
exit 0
| [“go”; direction] -> handle_exit direction room rooms
| [“take”; item] -> handle_item item room rooms
| _ ->
Printf.printf “Invalid command. Try again.n”;
main_loop room.name rooms

and handle_exit direction room rooms =
match List.assoc_opt direction room.exits with
| None ->
Printf.printf “You can’t go that way.n”;
main_loop room.name rooms
| Some next_room_name ->
main_loop next_room_name rooms

and handle_item item room rooms =
if List.mem item room.items then
let new_items = List.filter ((<>) item) room.items in
Printf.printf “You picked up the %s.n” item;
let updated_room = { room with items = new_items } in
main_loop room.name (Hashtbl.add rooms room.name updated_room; rooms)
else
Printf.printf “There is no such item here.n”;
main_loop room.name rooms
end

start() ->
{ok, ListenSocket} = gen_tcp:listen(4040, [binary, active, {packet, line}, {reuseaddr, true}]),
io:format(“Chat server started on port 4040~n”, []),
accept(ListenSocket).

accept(ListenSocket) ->
{ok, Socket} = gen_tcp:accept(ListenSocket),
spawn(fun() -> handle_client(Socket, []) end),
accept(ListenSocket).

handle_client(Socket, Clients) ->
case gen_tcp:recv(Socket, 0) of
{ok, Message} ->
io:format(“Received: ~s~n”, [Message]),
NewClients = [Socket | Clients],
broadcast(Message, NewClients),
handle_client(Socket, NewClients);
{error, closed} ->
io:format(“Client disconnected~n”, [])
end.

broadcast(Message, Clients) ->
lists:foreach(fun(Socket) ->
gen_tcp:send(Socket, Message)
end, Clients).

% To start the server, run the following in the Erlang shell:
% c(chat_server).
% chat_server:start().

let port = 4040

let rec accept listen_socket clients =
let%lwt socket = Lwt_unix.accept listen_socket in
let new_clients = socket :: clients in
Lwt.ignore_result (Lwt_unix.sleep 0.1 >>= fun () -> handle_client socket new_clients);
accept listen_socket new_clients

and handle_client socket clients =
let rec receive_message () =
let buffer = Bytes.create 1024 in
let%lwt bytes_received = Lwt_unix.recv socket buffer 0 1024 [] in
if bytes_received = 0 then (
print_endline “Client disconnected”;
Lwt.return ()
) else (
let message = Bytes.sub_string buffer 0 bytes_received in
Printf.printf “Received: %sn%!” message;
broadcast message clients;
receive_message ()
)
in
receive_message ()

and broadcast message clients =
List.iter (fun socket ->
let%lwt () = Lwt_unix.send socket (Bytes.of_string message) 0 (String.length message) [] in
()
) clients

let start () =
let%lwt listen_socket = Lwt_unix.socket Lwt_unix.PF_INET Lwt_unix.SOCK_STREAM 0 in
let addr = Lwt_unix.ADDR_INET (Unix.inet_addr_any, port) in
Lwt_unix.bind listen_socket addr >>= fun () ->
Lwt_unix.listen listen_socket 10;
Printf.printf “Chat server started on port %dn%!” port;
accept listen_socket []

let () =
let _ = Lwt_main.run (start ()) in
()
end