#include <iostream>
using namespace std;

const double TWOPI = 6.28319;

int main()
{
   // How many complete revolutions?
   int u{ 15.0 / TWOPI   };    // This warns in g++ and refuses in cl
   int v{ 15.0 / 6.28319 };    // This refuses
   int w = 15.0 / TWOPI;       // This does exactly what I wanted it to
}

#include <cstdlib>
#include <ctime>
#include <iostream>
#include <sstream>
#include <string>

int constexpr n_rooms     = 20;
int constexpr n_pits      = 2;
int constexpr n_bats      = 2;
int constexpr max_args    = 5;
int constexpr arrow_range = 3;

struct room { int a, b, c; enum { empty, wumpus, bat, pit } content = empty; };
struct command { char c; int n_args; int args[max_args]; };

room cave[n_rooms + 1] =
{ {  0,  0,  0 }, { 14, 17, 20 }, {  3,  9,  6 },
  {  2,  4, 11 }, {  3,  5, 13 }, {  4,  6, 15 },
  {  2,  5,  7 }, {  6,  8, 16 }, {  7,  9, 18 },
  {  2,  8, 10 }, {  9, 11, 19 }, {  3, 10, 12 },
  { 11, 13, 20 }, {  4, 12, 14 }, { 13, 15,  1 },
  {  5, 14, 16 }, {  7, 15, 17 }, { 16, 18,  1 },
  {  8, 17, 19 }, { 10, 18, 20 }, { 12, 19,  1 } };

[[nodiscard]] static room& random_room() { return cave[1 + (rand() % n_rooms)]; }
[[nodiscard]] static room& random_empty_room()
{
  room* r; do r = &random_room(); while (r->content != room::empty); return *r;
}

[[nodiscard]] static room& random_adjacent_room(room const& r)
{
  switch (rand() % 3) { case 0: return cave[r.a]; case 1: return cave[r.b]; default: return cave[r.c]; };
}

[[nodiscard]] static bool adjacent(room const& r, int n)
{ return (r.a == n) || (r.b == n) || (r.c == n); }

[[nodiscard]] static int count_adjacent_rooms_with_content(room const& r, int c)
{
  return (cave[r.a].content == c) + (cave[r.b].content == c) + (cave[r.c].content == c);
}

[[nodiscard]] static command prompt_read_command()
{
  command result {};
  
  for (std::string line; ;)
  {
    std::cout << "Move or shoot (m-s)? ";
    
    std::getline(std::cin, line);
    std::istringstream iss{line};

    if (std::string word; iss >> word)
    {
      result.c = word[0];
      while (result.n_args < max_args && iss >> result.args[result.n_args])
        ++result.n_args;
      
      break; // succeed, ignoring string->int conversion failures
    }
  }

  return result;
}

int main() try
{
#ifdef DETERMINISTIC_RANDOM_SEED
  std::srand(42);
#else
  std::srand(static_cast<unsigned>(std::time(0)));
#endif
  std::cin.exceptions(std::ios::failbit | std::ios::badbit | std::ios::eofbit);

  int n_arrows = 5;
  int wumpus_turns_awake = 0;
  bool wumpus_killed = false;
  bool player_killed = false;

  room* wumpus_room = &random_room();
  for (int i = 0; i < n_pits; ++i) random_empty_room().content = room::pit;
  for (int i = 0; i < n_bats; ++i) random_empty_room().content = room::bat;
  room* player_room = &random_empty_room();

  while (true)
  {
    // Is it "wumpuses" or "wumpi"?
    auto const [a, b, c, _] = *player_room;
    std::cout << "You're in room " << player_room - cave << ".\n";
    std::cout << "There are tunnels leading to rooms "
              << a << ", " << b << ", and " << c << ".\n";
    if (n_arrows > 0) std::cout << "You have " << n_arrows
                                << (n_arrows == 1? " arrow": " arrows") << " left.\n";
    else std::cout << "You're entirely out of arrows.  It's probably time to escape.\n";
    int const nearby_wumpuses = count_adjacent_rooms_with_content(*player_room, room::wumpus); 
    int const nearby_pits = count_adjacent_rooms_with_content(*player_room, room::pit);
    int const nearby_bats = count_adjacent_rooms_with_content(*player_room, room::bat);
    
    if (nearby_pits == 1) std::cout << "You feel a cold draught in the air.\n";
    if (nearby_pits >= 2) std::cout << "An icy wind blows from adjacent rooms.  Your torch flickers.\n";
    if (nearby_bats == 1) std::cout << "You hear a light rustle in the air.\n";
    if (nearby_bats >= 2) std::cout << "Quiet clicking can be heard through two of the nearby tunnels.\n";
    if (nearby_wumpuses >= 1) std::cout << "It smells somewhat. Maybe a wumpus is near.\n";

    command const cmd = prompt_read_command();

    if (cmd.c == 'q') { std::cout << "bye...\n"; return 0; }
    if (cmd.c == 'm')
    {
      int const r = cmd.n_args? cmd.args[rand() % cmd.n_args]: 0;
      
      if (cmd.n_args && adjacent(*player_room, r))
      {
        player_room = cave + r;
      }
      else
      {
        std::cout << "Disorientation has taken hold.  You squeeze into a nearby tunnel at random.\n";
        player_room = &random_adjacent_room(*player_room);
      }
    }
  
    if (cmd.c == 's')
    {
      if (++wumpus_turns_awake == 1)
        std::cout << "A thunderous roar echoes through the tunnels.\n";

      if (n_arrows == 0)
      {
        std::cout << "You reach for an arrow, but you have none.\n";
      }
      else
      {
        std::cout << "You loose an arrow.\n";
        --n_arrows;
    
        room* arrow_room = player_room;
        for (int i = 0; i < arrow_range; ++i)
        {
          arrow_room = (i < cmd.n_args && adjacent(*arrow_room, cmd.args[i]))
            ? cave + cmd.args[i]: &random_adjacent_room(*arrow_room);
      
          if (arrow_room == player_room) { player_killed = true; break; }
          if (arrow_room == wumpus_room) { wumpus_killed = true; break; }
        }
      }
    }

    if (wumpus_turns_awake >= 1)
    {
      wumpus_room->content = room::empty;
      wumpus_room = &random_adjacent_room(*wumpus_room);
      wumpus_room->content = room::wumpus;
    }

    if (player_room->content == room::bat)
    {
      std::cout << "Claws dig into your shoulders: a huge creature grabs you and carries you through the cave.\n";
      player_room->content = room::empty;
      player_room = &random_room();
      random_empty_room().content = room::bat;
    }
    if (player_room->content == room::pit)
    {
      std::cout << "The ground gives out, and you plummet to your death.\n";
      return 0;
    }
    if (player_room == wumpus_room)
    {
      std::cout << "The wumpus is upon you.  Your death is painful and swift.\n";
      return 0;
    }
    if (player_killed)
    {
      std::cout << "Your own arrow strikes you in the back.\nYou fall to the ground, dead.\n";
      return 0;
    }
    if (wumpus_killed)
    {
      std::cout << "You hear a mighty scream as your arrow strikes the wumpus.  You have slain your prey.\n";
      return 0;
    }
    std::cout << '\n';
  }
} catch (std::ios::failure const&) { return 0; }