Tag bot

#include "VP.h"

#include <ctime>
#include <iostream>
#include <list>
#include <map>
#include <sstream>
#include <string>

using namespace std;

const char* UNIVERSE_HOST = "universe.virtualparadise.org";
int UNIVERSE_PORT = 57000;

struct User {
  int mSession;
  int mUserId;
  string mName;
  float mX;
  float mY;
  float mZ;

  User() {}

  User(int session, int userId, string name, float x, float y, float z) :
      mSession(session), mUserId(userId), mName(name), mX(x), mY(y), mZ(z) {
  }
};

class TagBot {
  public:
    TagBot(VPInstance instance) : mInstance(instance), mItUserId(-1) {
    }

    void onAvatarAdd(const string& name, int session, int userId,
        float x, float y, float z) {
      User u(session, userId, name, x, y, z);
      mUsersBySession[session] = u;
      mUsersById[userId] = u;
      // Make this poor sap the first it.
      if (mItUserId < 0) {
        changeIt(u);
      }
    }

    void onAvatarDelete(int session) {
      mUsersBySession.erase(session);
    }

    void onAvatarChange(string name, int session, float x, float y, float z) {
      User u = mUsersBySession[session];
      u.mName = name;
      u.mX = x;
      u.mY = y;
      u.mZ = z;
      mUsersBySession[session] = u;
      mUsersById[u.mUserId] = u;
    }

    void onAvatarClick(int clickerSession, int clickeeSession) {
      User& a = mUsersBySession[clickerSession];
      User& b = mUsersBySession[clickeeSession];
      if (a.mUserId != mItUserId) {
        return;
      }

      float distSq = ((a.mX - b.mX) * (a.mX - b.mX)) +
          ((a.mY - b.mY) * (a.mY - b.mY)) +
          ((a.mZ - b.mZ) * (a.mZ - b.mZ));
      cout << a.mName << " clicked " << b.mName
          << " at a sq. distance of " << distSq << endl;

      if (b.mUserId == mItTaggedByUserId) {
        vp_console_message(mInstance, clickerSession, "Smoke'n'tagger",
          "You can't tag the person who tagged you!", 0, 255, 0, 0);
        return;
      }

      if (distSq < 4.0) {
        changeIt(b);
        return;
      }

      if (distSq < 10.0) {
        string msg = string("Watch out! ") + a.mName + " tried to tag you, ";
        msg += "but they were too far away.";
        vp_console_message(mInstance, clickeeSession, "Smoke'n'tagger",
          msg.c_str(), 0, 0, 200, 50);
      }
      vp_console_message(mInstance, clickerSession, "Smoke'n'tagger",
          "You were too far away!", 0, 255, 0, 0);
    }

    void onChat(int session, string name, string message) {
      if (message == "!whosit") {
        announceIt();
      }
      if (message == "!tagme") {
        changeIt(mUsersBySession[session]);
      }
    }

    void onUserAttributes(int userId, string name) {
      if (mItUserId == userId) {
        User u = mUsersById[mItUserId];
        u.mName = name;
        mUsersById[mItUserId] = u;
      }
    }

    void announceIt() {
      string msg = mUsersById[mItUserId].mName + " has been IT for " +
        formatTimeSince(mItSetTime, true);
      vp_say(mInstance, msg.c_str());
    }

    void fetchItData() {
      vp_user_attributes_by_id(mInstance, mItUserId);
    }

  private:
    VPInstance mInstance;

    int mItUserId;
    int mItTaggedByUserId;
    time_t mItSetTime;

    map<int, User> mUsersBySession;
    map<int, User> mUsersById;

    void changeIt(User& newIt) {
      mItTaggedByUserId = mItUserId;
      mItUserId = newIt.mUserId;
      string msg;

      if (mItTaggedByUserId >= 0) {
        string oldItName = mUsersById[mItTaggedByUserId].mName;
        string timeStr = formatTimeSince(mItSetTime, false);
        msg = oldItName + " tagged " + newIt.mName + "; IT for " + timeStr +
          "\n" + newIt.mName + " is now IT!";
        cout << "Old it: " << oldItName << endl;
      } else {
        msg = newIt.mName + " is IT!";
      }
      cout << "New it: " << newIt.mName;
      vp_say(mInstance, msg.c_str());

      mItUserId = newIt.mUserId;
      mItSetTime = time(0);
    }

    string formatTimeSince(time_t oldTime, bool counting) {
      time_t now = time(0);
      int deltaSeconds = (int) (now - oldTime);
      return formatDeltaFromDays(deltaSeconds) +
        (counting ? "and counting!" : "but no more!");
    }

    string formatDeltaFromDays(int seconds) {
      const int secondsPerDay = 60 * 60 * 24;
      int days = seconds / secondsPerDay;
      seconds = seconds - (days * secondsPerDay);
      if (days > 0) {
        stringstream s;
        s << days << " days, " << formatDeltaFromHours(seconds);
        return s.str();
      }
      return formatDeltaFromHours(seconds);
    }

    string formatDeltaFromHours(int seconds) {
      const int secondsPerHour = 60 * 60;
      int hours = seconds / secondsPerHour;
      seconds = seconds - (hours * secondsPerHour);
      if (hours > 0) {
        stringstream s;
        s << hours << " hours, " << formatDeltaFromMinutes(seconds);
        return s.str();
      }
      return formatDeltaFromMinutes(seconds);
    }

    string formatDeltaFromMinutes(int seconds) {
      const int secondsPerMinute = 60;
      int minutes = seconds / secondsPerMinute;
      seconds = seconds - (minutes * secondsPerMinute);
      if (minutes > 0) {
        stringstream s;
        s << minutes << " minutes, " << formatDeltaFromSeconds(seconds);
        return s.str();
      }
      return formatDeltaFromSeconds(seconds);
    }

    string formatDeltaFromSeconds(int seconds) {
      stringstream s;
      s << seconds << " seconds, ";
      return s.str();
    }
};

TagBot *BOT;

void event_avatar_add(VPInstance instance) {
  string avatarName(vp_string(instance, VP_AVATAR_NAME));
  int avatarSession = vp_int(instance, VP_AVATAR_SESSION);
  int userId = vp_int(instance, VP_USER_ID);
  float avatarX = vp_float(instance, VP_AVATAR_X);
  float avatarY = vp_float(instance, VP_AVATAR_Y);
  float avatarZ = vp_float(instance, VP_AVATAR_Z);
  BOT->onAvatarAdd(avatarName, avatarSession, userId,
    avatarX, avatarY, avatarZ);
}

void event_chat(VPInstance instance) {
  int session = vp_int(instance, VP_AVATAR_SESSION);
  string name = vp_string(instance, VP_AVATAR_NAME);
  string message = vp_string(instance, VP_CHAT_MESSAGE);
  BOT->onChat(session, name, message);
}

void event_avatar_delete(VPInstance instance) {
  int session = vp_int(instance, VP_AVATAR_SESSION);
  BOT->onAvatarDelete(session);
}

void event_avatar_change(VPInstance instance) {
  string avatarName(vp_string(instance, VP_AVATAR_NAME));
  int avatarSession = vp_int(instance, VP_AVATAR_SESSION);
  float avatarX = vp_float(instance, VP_AVATAR_X);
  float avatarY = vp_float(instance, VP_AVATAR_Y);
  float avatarZ = vp_float(instance, VP_AVATAR_Z);
  BOT->onAvatarChange(avatarName, avatarSession, avatarX, avatarY, avatarZ);
}

void event_avatar_click(VPInstance instance) {
  int clickerSession = vp_int(instance, VP_AVATAR_SESSION);
  int clickeeSession = vp_int(instance, VP_CLICKED_SESSION);
  BOT->onAvatarClick(clickerSession, clickeeSession);
}

void event_user_attributes(VPInstance instance) {
  int userId = vp_int(instance, VP_USER_ID);
  string name = vp_string(instance, VP_USER_NAME);
  BOT->onUserAttributes(userId, name);
}

int main(int argc, const char* argv[]) {
  int rc;
  if (rc = vp_init()) {
    cout << "Unable to initialize API: " << rc << endl;
    return -1;
  }

  VPInstance instance = vp_create();

  if (rc = vp_connect_universe(instance, UNIVERSE_HOST, UNIVERSE_PORT)) {
    cout << "Couldn't connect to universe: " << rc << endl;
    return -1;
  }

  // Sorry guys, old-school.
  string username, password, world;
  cout << "Username: ";
  cin >> username;
  cout << "Password: ";
  cin >> password;
  cout << "World: ";
  cin >> world;
  if (rc = vp_login(instance, username.c_str(), password.c_str(), "Smoke'n'tagger")) {
    cout << "Couldn't login: " << rc << endl;
    return -1;
  }

  if (rc = vp_enter(instance, world.c_str())) {
    cout << "Couldn't enter world: " << rc << endl;
    return -1;
  }

  vp_event_set(instance, VP_EVENT_AVATAR_ADD, event_avatar_add);
  vp_event_set(instance, VP_EVENT_CHAT, event_chat);
  vp_event_set(instance, VP_EVENT_AVATAR_DELETE, event_avatar_delete);
  vp_event_set(instance, VP_EVENT_AVATAR_CHANGE, event_avatar_change);
  vp_event_set(instance, VP_EVENT_AVATAR_CLICK, event_avatar_click);
  vp_event_set(instance, VP_EVENT_USER_ATTRIBUTES, event_user_attributes);

  vp_state_change(instance);

  BOT = new TagBot(instance);

  time_t lastRollCall = time_t(0);

  while (!vp_wait(instance, 10)) {
    time_t now = time_t(0);
    int difference = (int)now - lastRollCall;
    if (difference > 60 * 60 * 24) {
      BOT->announceIt();
      // Make sure our 'it' isn't changing their name to get out of the shame.
      BOT->fetchItData();
    }
  }
}