-record(room, {description, objects, exits}).
-record(player, {inventory}).

start() ->
Room = #room{description = “You are in a dimly lit room. You see a shiny key on the table and a door to the north.”,
objects = [“key”],
exits = [{north, “You leave through the door.”}]},

Player = #player{inventory = []},

io:format(“~s~n”, [Room#room.description]),
loop({Room, Player}).

loop({Room, Player}) ->
io:format(“>”)
Command = string:strip(io:get_line(“”)),
handle_command(Command, Room, Player).

handle_command(“look”, Room, Player) ->
io:format(“~s~n”, [Room#room.description]),
loop({Room, Player});
handle_command(“take key”, Room, Player) ->
case lists:member(“key”, Room#room.objects) of
true ->
NewRoom = Room#room{objects = lists:delete(“key”, Room#room.objects)},
NewPlayer = Player#player{inventory = [“key” | Player#player.inventory]},
io:format(“You have taken the key.~n”, []),
loop({NewRoom, NewPlayer});
false ->
io:format(“There’s no key here!~n”, []),
loop({Room, Player})
end;
handle_command(“open door”, Room, Player) ->
case lists:member(“key”, Player#player.inventory) of
true ->
io:format(“You use the key to open the door and discover the treasure! You win!~n”, []),
ok;
false ->
io:format(“You need a key to open the door!~n”, []),
loop({Room, Player})
end;
handle_command(“inventory”, Room, Player) ->
io:format(“You have: ~s~n”, [Player#player.inventory]),
loop({Room, Player});
handle_command(“exit”, _, _) ->
io:format(“Thanks for playing!~n”, []),
ok;
handle_command(_, Room, Player) ->
io:format(“Invalid command.~n”, []),
loop({Room, Player}).

class Room {
constructor(description, objects, exits) {
this.description = description;
this.objects = objects;
this.exits = exits;
}
}

class Player {
constructor(inventory) {
this.inventory = inventory;
}
}

function start() {
const room = new Room(
“You are in a dimly lit room. You see a shiny key on the table and a door to the north.”,
[“key”],
[{ direction: “north”, message: “You leave through the door.” }]
);

const player = new Player([]);

console.log(room.description);
loop({ room, player });
}

function loop({ room, player }) {
process.stdout.write(“> “);
const readline = require(‘readline’).createInterface({
input: process.stdin,
output: process.stdout
});

readline.question(”, (command) => {
command = command.trim();
handleCommand(command, room, player, readline);
});
}

function handleCommand(command, room, player, readline) {
switch (command) {
case “look”:
console.log(room.description);
loop({ room, player });
break;
case “take key”:
if (room.objects.includes(“key”)) {
room.objects.splice(room.objects.indexOf(“key”), 1);
player.inventory.push(“key”);
console.log(“You have taken the key.”);
loop({ room, player });
} else {
console.log(“There’s no key here!”);
loop({ room, player });
}
break;
case “open door”:
if (player.inventory.includes(“key”)) {
console.log(“You use the key to open the door and discover the treasure! You win!”);
readline.close();
} else {
console.log(“You need a key to open the door!”);
loop({ room, player });
}
break;
case “inventory”:
console.log(`You have: ${player.inventory.join(“, “)}`);
loop({ room, player });
break;
case “exit”:
console.log(“Thanks for playing!”);
readline.close();
break;
default:
console.log(“Invalid command.”);
loop({ room, player });
break;
}
}

start() ->
{ok, ListenSocket} = gen_tcp:listen(8080, [binary, {active, false}, {reuseaddr, true}]),
io:format(“Listening on port 8080…~n”),
accept(ListenSocket).

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

init(Socket) ->
{ok, Request} = gen_tcp:recv(Socket, 0),
Response = handle_request(Request),
gen_tcp:send(Socket, Response),
gen_tcp:close(Socket).

handle_request(Request) ->
%% Assuming the request is a valid HTTP request
%% You may want to check the request format and method here
%% For simplicity, we just respond to all requests
CurrentDateTime = calendar:local_time(),
JsonResponse = <<"{"current_datetime":">> ++ io_lib:format(“~p”, [CurrentDateTime]) ++ <<" }">>,
ResponseHeader = <<"HTTP/1.1 200 OKrnContent-Type: application/jsonrnContent-Length: ">>,
ResponseLength = byte_size(JsonResponse),
HeaderWithLength = binary:list_to_binary(binary_to_list(ResponseHeader) ++ integer_to_list(ResponseLength) ++ <<"rnrn">>),
<>.

integer_to_list(Int) when Int >= 0 ->
lists:reverse(integer_to_list(Int, [])).
integer_to_list(0, Acc) -> [0|Acc];
integer_to_list(Int, Acc) ->
integer_to_list(Int div 10, [Int rem 10|Acc]).

const start = () => {
const server = net.createServer();
server.listen(8080, () => {
console.log(“Listening on port 8080…”);
});

server.on(‘connection’, (socket) => {
init(socket);
});
};

const init = (socket) => {
socket.on(‘data’, (request) => {
const response = handleRequest(request);
socket.write(response);
socket.end();
});
};

const handleRequest = (request) => {
const currentDateTime = new Date();
const jsonResponse = JSON.stringify({ current_datetime: format(currentDateTime, ‘yyyy-MM-dd HH:mm:ss’) });

const responseHeader = ‘HTTP/1.1 200 OKrnContent-Type: application/jsonrnContent-Length: ‘;
const responseLength = Buffer.byteLength(jsonResponse);
const headerWithLength = responseHeader + responseLength + ‘rnrn’;

return headerWithLength + jsonResponse;
};

start();