SpaceConstruct/main.cpp

/*
    Space Construct v0.6-dev
    Beanzilla@21:4/110  on FsxNet
    Beanzilla@637:1/110 on HappyNet
*/

#define VERSION_MAJOR 0
#define VERSION_MINOR 6
#ifndef VERSION_TYPE
#define VERSION_TYPE "dev"
#endif

#define PATH_MAX 256
#define PATH_SEP "/"

//#include <MagiDoor.h> // Sorry Apam... as much as I would like to keep using your stuff it's just not fully functional
#include <OpenDoor.h> // Now using odoors for c++
#include <sqlite3.h>
#if defined(_MSC_VER) || defined(WIN32)
#define snprintf _snprintf
#define strcasecmp _stricmp
#include <winsock2.h>
#ifndef _MSC_VER
#define _MSC_VER 1
#endif
#else
#include <arpa/inet.h>
#endif

// Standard C
#include <time.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h> // stat
#include <string>

// sc.log ODoors has logging so why not use it!
int inuse = 0; // Are any other copies of us running? (We are a single user door!)
int debug = 0; // Are we in debug mode?

// Please change it for your system!
int allowDev = 1; // Allow "Beanzilla" to not need the password.
std::string sysop_pass = "spaceISbig"; // Case sensitive!

// LOGGING with file output

#include "zf_log.h"

FILE *g_log_file;

static void file_output_callback(const zf_log_message *msg, void *arg) {
  (void)arg;
  *msg->p = '\n';
  fwrite(msg->buf, msg->p - msg->buf + 1, 1, g_log_file);
  fflush(g_log_file);
}

static void file_output_close(void) { fclose(g_log_file); }

static int file_output_open(const char *const log_path) {
  g_log_file = fopen(log_path, "a");
  if (!g_log_file) {
    ZF_LOGW("Failed to open log file %s", log_path);
    return 0;
  }
  atexit(file_output_close);
  zf_log_set_output_v(ZF_LOG_PUT_STD, 0, file_output_callback);
  return 1;
}

void log_flush(void) { fflush(g_log_file); }

// END LOGGING

// Randrange
int randrange(int min, int max){
   return min + rand() / (RAND_MAX / (max - min + 1) + 1);
}

class user_info {
  // Privates... but why do we allow "friends" to access them too?
    int uid, experience, gun, fuel, metal, armor, shield, hitpoints, armorpoints, shieldpoints, shieldsup, laston;
    bool dirt;
    std::string nick;
    std::string real;
  public:
    void set_up(int uuid, std::string name, std::string realname, int exp, int lo, int a, int ap, int s, int sp, int su, int hp, int g, int m, int f) {
      // Setup values
      uid = uuid;
      nick = name;
      real = realname;
      experience = exp;
      laston = lo;
      armor = a;
      armorpoints = ap;
      shield = s;
      shieldpoints = sp;
      shieldsup = su;
      hitpoints = hp;
      gun = g;
      metal = m;
      fuel = f;
      dirt = false;
    }
    void set_new(std::string name, std::string realname) {
      // New User
      nick = name;
      real = realname;
      experience = 0;
      laston = 0;
      armor = 1;
      armorpoints = 8;
      shield = 0;
      shieldpoints = 0;
      shieldsup = 0;
      hitpoints = 4;
      gun = 1;
      metal = 0;
      fuel = 10;
      dirt = true;
    }
    bool dirty() {
      // Need to save?
      return dirt;
    }
    int calcArmor() {
      // How much metal to add one to armor
      return (3 * (armor + 1));
    }
    int calcShield() {
      // How much metal to add one to shield
      return (6 * (shield + 1));
    }
    int calcGun() {
      // How much metal to add one to gun
      return (4 * (gun + 1));
    }
    int calcHP() {
      // our total hitpoints
      return (gun + armor + shield + 2);
    }
    int calcSP() {
      // our total shieldpoints
      return (shield * 3);
    }
    int calcAP() {
      // our total armorpoints
      return (armor * 8);
    }
    void regen() {
      // Process Shields rebooting back online
      if(shieldsup != 0) {
        dirt = true;
        shieldsup -= 1;
      } // Process shieldpoints restoring
      if(shieldsup != 0) {
        dirt = true;
        shieldpoints += shield;
      } else {
        dirt = true;
        shieldpoints += 1;
      } // Establish limit
      if(shieldpoints > calcSP()) {
        dirt = true;
        shieldpoints = calcSP();
      }
    }
    void repair(bool docked) {
      // If we are not docked we are in combat so only repair 2 instead of 4
      int amount;
      if(docked) {
        amount = 4;
      } else {
        amount = 2;
      }
      if(armorpoints < calcAP()) {
        if(metal != 0) {
          dirt = true;
          metal -= 1;
          armorpoints += amount;
          if(armorpoints > calcAP()) {
            armorpoints = calcAP();
          }
        }
      }
    }
    void set_dirty(bool state) {
      // To manually change dirty state
      dirt = state;
    }
    int takeDamage(int dmg) {
      // Damage System,
      // First Shields, Then Armor, Finally Hull.
      // Returns any damage left over from target... target died and this is the left over damage
      if(shieldsup == 0) {
        if(shieldpoints >= dmg) {
          // Shields Absorbed all damage
          dirt = true;
          shieldpoints -= dmg;
          return 0;
        } else {
          // Shields took some damage but more damage to take
          dirt = true;
          dmg -= shieldpoints;
          shieldpoints = 0;
        }
      }
      if(dmg > 0) {
        if(armorpoints >= dmg) {
          // Armor took all remaining damage
          dirt = true;
          armorpoints -= dmg;
          return 0;
        } else {
          // Armor took some damage but more damage to take
          dirt = true;
          dmg -= armorpoints;
          armorpoints = 0;
        }
      }
      if(dmg > 0) {
        if(hitpoints > dmg) {
          // Hull took all remaining damage
          dirt = true;
          hitpoints -= dmg;
          return 0;
        } else {
          // Hull took some damage but more needed to be taken
          // Our ship is :boom: space debris.
          dirt = true;
          int temp = dmg;
          dmg -= hitpoints;
          hitpoints -= temp;
          temp = 0;
          return dmg;
        }
      }
    }
    // Exchange Systems
    void addEXP(int amount) {
      dirt = true;
      experience += amount;
    }
    void rmEXP(int amount) {
      dirt = true;
      experience -= amount;
    }
    void addMetal(int amount) {
      dirt = true;
      metal += amount;
    }
    void rmMetal(int amount) {
      dirt = true;
      metal -= amount;
    }
    void addFuel(int amount) {
      dirt = true;
      fuel += amount;
    }
    void rmFuel(int amount) {
      dirt = true;
      fuel -= amount;
    }
    void rmLaston(int amount) {
      dirt = true;
      laston -= amount;
      if(laston < 0) {
        laston = 0;
      }
    }
    // Another Combat() helper
    void addHP(int amount) {
      dirt = true;
      hitpoints += amount;
      if(hitpoints > calcHP()) {
        hitpoints = calcHP();
      }
    }
    void addGun(int amount) {
      dirt = true;
      gun += amount;
      addHP(1);
    }
    void addArmor(int amount) {
      dirt = true;
      armor += amount;
      armorpoints += (amount * calcAP());
      addHP(1);
    }
    void addShield(int amount) {
      dirt = true;
      shield += amount;
      if(shieldsup == 0) {
        shieldpoints += (amount * calcSP());
      } else {
        shieldpoints += amount;
      }
      addHP(1);
    }
    void rmSU(int amount) {
      dirt = true;
      shieldsup -= amount;
      if(shieldsup > 0) {
        shieldsup = 0;
      }
    }
    // Sets
    void set_laston(int lo) {laston = lo;}
    void set_uid(int uuid) {uid = uuid;}
    void set_nick(std::string name) {nick = name;}
    void set_real(std::string name) {real = name;}
    void set_experience(int exp) {experience = exp;}
    void set_metal(int m) {metal = m;}
    void set_fuel(int f) {fuel = f;}
    void set_gun(int g) {gun = g;}
    void set_armor(int a) {armor = a;}
    void set_shield(int s) {shield = s;}
    void set_shieldsup(int su) {shieldsup = su;}
    void set_armorpoints(int ap) {armorpoints = ap;}
    void set_shieldpoints(int sp) {shieldpoints = sp;}
    void set_hitpoints(int hp) {hitpoints = hp;}
    // Gets
    int get_laston() {return laston;}
    int get_uid() {return uid;}
    std::string get_nick() {return nick;}
    std::string get_real() {return real;}
    int get_experience() {return experience;}
    int get_metal() {return metal;}
    int get_fuel() {return fuel;}
    int get_gun() {return gun;}
    int get_armor() {return armor;}
    int get_shield() {return shield;}
    int get_armorpoints() {return armorpoints;}
    int get_shieldpoints() {return shieldpoints;}
    int get_shieldsup() {return shieldsup;}
    int get_hitpoints() {return hitpoints;}
};

// DateStamp Structure to provide date difference
typedef struct dateTamp {
  int year;  // YYYY, or number of years difference
  int month; // MM, or number of months difference
  int day;   // DD, or number of days difference.
  int age;   // Taking down to aproximate day count.
} dT; // YYYYMMDD it in int form

int dateStamp() {
  // YYYYMMDD \o/ In a INT so we can store it and compare against it!
  struct tm *time_now;
  time_t timen;
  int result = 0;
  timen = time(NULL);
  time_now = localtime(&timen);
  result += ((time_now->tm_year + 1900) * 10000);
  result += (time_now->tm_mon * 100) + 100;
  result += time_now->tm_mday;
  return result;
}

int compareDate(int dt) {
  // Returns integer of difference, from now.
  struct tm *time_now;
  time_t timen;
  int now = 0;
  timen = time(NULL);
  time_now = localtime(&timen);
  now += ((time_now->tm_year + 1900) * 10000);
  now += (time_now->tm_mon * 100) + 100;
  now += time_now->tm_mday;
  return (now - dt); // 10000 = 1 Year, 100 = 1 Month, 1 = 1 Day
}

dT fromDate(int diff) {
  // Reverse process so we can compare exact days or get the structure back out too.
  dT result;
  result.year = diff / 10000;
  result.month = (diff / 100) % 100;
  result.day = diff % 100;
  result.age = 0;
  // Process Aprox day count
  result.age += (365 * result.year);
  result.age += (30 * result.month);
  result.age += result.day;
  return result;
}

int db_test() {
  // Displays all users in the database
  sqlite3 *db;
  sqlite3_stmt *stmt;
  char sqlbuffer[256];
  char strbuffer[256];
  int sizeofdb = 0;
  int rc = sqlite3_open("spaceconstruct.db3", &db);
  if(rc) { // Did we do a successful open?
    ZF_LOGF("Failed opening database %s (%d)", sqlite3_errmsg(db), rc);
    sqlite3_close(db);
    od_exit(-1, FALSE);
  }
  sqlite3_busy_timeout(db, 5000);
  // DB open
  strcpy(sqlbuffer, "SELECT * FROM user;");
  sqlite3_prepare_v2(db, sqlbuffer, strlen(sqlbuffer), &stmt, NULL);
  while(sqlite3_step(stmt) == SQLITE_ROW) {
    ZF_LOGV("`white`%s=%d %s=%s %s=%s %s=%d %s=%d %s=%d %s=%d %s=%d %s=%d %s=%d %s=%d %s=%d %s=%d %s=%d\r\n",
      sqlite3_column_name(stmt, 0), // int,  uid
      sqlite3_column_int(stmt, 0),
      sqlite3_column_name(stmt, 1), // text, nick
      sqlite3_column_text(stmt, 1),
      sqlite3_column_name(stmt, 2), // text, real
      sqlite3_column_text(stmt, 2),
      sqlite3_column_name(stmt, 3), // int,  experiece
      sqlite3_column_int(stmt, 3),
      sqlite3_column_name(stmt, 4), // int,  metal
      sqlite3_column_int(stmt, 4),
      sqlite3_column_name(stmt, 5), // int,  fuel
      sqlite3_column_int(stmt, 5),
      sqlite3_column_name(stmt, 6), // int,  gun
      sqlite3_column_int(stmt, 6),
      sqlite3_column_name(stmt, 7), // int,  armor
      sqlite3_column_int(stmt, 7),
      sqlite3_column_name(stmt, 8), // int,  shield
      sqlite3_column_int(stmt, 8),
      sqlite3_column_name(stmt, 9), // int,  armorpoints
      sqlite3_column_int(stmt, 9),
      sqlite3_column_name(stmt, 10), // int, shieldpoints
      sqlite3_column_int(stmt, 10),
      sqlite3_column_name(stmt, 11), // int,  hitpoints
      sqlite3_column_int(stmt, 11),
      sqlite3_column_name(stmt, 12), // int,  shieldsup
      sqlite3_column_int(stmt, 12),
      sqlite3_column_name(stmt, 13), // int,  laston
      sqlite3_column_int(stmt, 13)
    );
    sizeofdb += 1;
  } // Clean up database
  ZF_LOGV("There are %d users", sizeofdb);
  sqlite3_finalize(stmt);
  sqlite3_close(db);
  return sizeofdb;
}

int check_lock() {
  // Checks stats of lock, (1 = Lock is in effect, 0 = No Lock established)
  struct stat s;
  if (stat("lock.flg", &s) == 0) {
    return 1;
  } else {
    return 0;
  }
}

int grab_lock() {
  // Attempt to grab lock, (0 = Already gotten, 1 = Success, -1 = Error)
  int valid = check_lock();
  FILE *fhandle;
  if (valid == 0) {
    fhandle = fopen("lock.flg", "w");
    if(!fhandle) {
      ZF_LOGE("Unable to make lock.flg!");
      ZF_LOGE("Something went wrong perhaps we don't have permissions?");
      return -1;
    }
    fprintf(fhandle, "I am in use already!\n");
    fclose(fhandle);
    ZF_LOGV("Lock Established");
    return 1;
  } else {
    ZF_LOGW("Lock already established!");
    return 0;
  }
}

void rel_lock() {
  // Attempt to release lock
  int valid = check_lock();
  if (valid == 1) {
    if (unlink("lock.flg") != 0) {
      ZF_LOGE("Unable to release lock.flg!");
      ZF_LOGE("Something went wrong! Players might not be able to play now!");
    }
  } else {
    ZF_LOGW("Lock already released!");
  }
}

void log_drop() {
  // Spits out info from Drop File:
  ZF_LOGV("`white`Name=%s Alias=%s TimeLeft=%d SecLevel=%d Location=%s Node=%d Sysop=%s\r\n",
    od_control.user_name,
    od_control.user_handle,
    od_control.user_timelimit,
    od_control.user_security,
    od_control.user_location,
    od_control.od_node,
    od_control.sysop_name
  );
}

void paws() {
  // Aaah, DRY
  od_printf("`white`Press any key to continue...");
  od_get_key(true);
  od_printf("\r\n");
}

int yesNo() {
  char ch;
  int done = 0;
  od_printf("`bright black`(`bright white`Y`bright black`)`white`es `bright black`(`bright red`N`bright black`)`red`o`white`");
  ch = od_get_answer("YyNn\r");
  od_printf("\r\n");
  switch(tolower(ch)) {
    case 'y':
      done = 1;
      break;
    case '\r':
    case 'n':
      break;
  }
  return done;
}

int locate_player(char name[]) {
  // returns user id for given real name and 0 for no record found
  sqlite3 *db;
  sqlite3_stmt *stmt;
  char sqlbuffer[256];
  int result = 0;
  int rc = sqlite3_open("spaceconstruct.db3", &db);
  if(rc) { // Did we do a successful open?
    ZF_LOGF("Failed opening database %s (%d)", sqlite3_errmsg(db), rc);
    sqlite3_close(db);
    od_exit(-1, FALSE);
  }
  sqlite3_busy_timeout(db, 5000);
  //od_printf("realname = '%s'\r\n", name);

  // Locating user with given name
  strcpy(sqlbuffer, "SELECT * from user where real=? COLLATE NOCASE;");
  sqlite3_prepare_v2(db, sqlbuffer, strlen(sqlbuffer) + 1, &stmt, NULL);
  sqlite3_bind_text(stmt, 1, name, strlen(name), SQLITE_STATIC);
  rc = sqlite3_step(stmt);
  if (rc == SQLITE_ROW) {
    // Return user id
    result = sqlite3_column_int(stmt, 0);
  } else {
    // User not found
    ZF_LOGW("Unable to locate user %s", name);
    result = 0;
  } // Clean Up, return results
  sqlite3_finalize(stmt);
  sqlite3_close(db);
  return result;
}

void check_database() {
  // If the table users does not exist make it.
  sqlite3 *db;
  sqlite3_stmt *stmt;
  char sqlbuffer[256];
  int rc = sqlite3_open("spaceconstruct.db3", &db);
  if(rc) {
    ZF_LOGF("Failed opening database %s (%d)", sqlite3_errmsg(db), rc);
    sqlite3_close(db);
    od_exit(-1, FALSE);
  }
  sqlite3_busy_timeout(db, 5000);
  strcpy(sqlbuffer, "SELCECT COUNT(*) FROM user;");
  sqlite3_prepare_v2(db, sqlbuffer, strlen(sqlbuffer) + 1, &stmt, NULL);
  rc = sqlite3_step(stmt);
  if(rc == SQLITE_ROW) {
    // Good
  } else {
    // Bad, Create table
    char *errmsg;
    rc = sqlite3_exec(db, "CREATE TABLE IF NOT EXISTS \"user\" (`uid`	INTEGER PRIMARY KEY AUTOINCREMENT,`nick`	TEXT,`real`	TEXT,`experience`	INTEGER,`metal`	INTEGER,`fuel`	INTEGER,`gun`	INTEGER,`armor`	INTEGER,`shield`	INTEGER,`armorpoints`	INTEGER,`shieldpoints`	INTEGER,`hitpoints`	INTEGER,`shieldsup`	INTEGER,`laston`	INTEGER);", NULL, NULL, &errmsg);
    ZF_LOGW("Users table did not exist created");
  }
  sqlite3_finalize(stmt);
  sqlite3_close(db);
}

user_info* load_player(int uuid) {
  // Returns a player Structure from database
  sqlite3 *db;
  sqlite3_stmt *stmt;
  char sqlbuffer[256];
  user_info *result;
  int rc = sqlite3_open("spaceconstruct.db3", &db);
  if(rc) { // Did we do a successful open?
    ZF_LOGF("Failed opening database %s (%d)", sqlite3_errmsg(db), rc);
    sqlite3_close(db);
    od_exit(-1, FALSE);
  }
  sqlite3_busy_timeout(db, 5000);
  strcpy(sqlbuffer, "SELECT * FROM user WHERE uid=?;");
  sqlite3_prepare_v2(db, sqlbuffer, strlen(sqlbuffer) + 1, &stmt, NULL);
  sqlite3_bind_int(stmt, 1, uuid);
  rc = sqlite3_step(stmt);
  if (rc == SQLITE_ROW) {
    std::string val1(sqlite3_column_text(stmt, 1));
    std::string val2(sqlite3_column_text(stmt, 2));
    result->set_up(sqlite3_column_int(stmt, 0), val1, val2, sqlite3_column_int(stmt, 3), sqlite3_column_int(stmt, 13), sqlite3_column_int(stmt, 7), sqlite3_column_int(stmt, 9), sqlite3_column_int(stmt, 8), sqlite3_column_int(stmt, 10), sqlite3_column_int(stmt, 12), sqlite3_column_int(stmt, 11), sqlite3_column_int(stmt, 6), sqlite3_column_int(stmt, 4), sqlite3_column_int(stmt, 5));
  } else {
    sqlite3_finalize(stmt);
    sqlite3_close(db);
    result->set_uid(0);
    return result;
  }
  sqlite3_finalize(stmt);
  sqlite3_close(db);
  return result;
}

user_info* highest_player() {
  // Used to find if someone may have fought the Unknown One and won the game already!
  int done = 0;
  user_info *test;
  int high = 0;
  int high_exp = 0;
  int id = 1;
  while(!done) {
    test = load_player(id);
    if(test->get_uid() != 0) {
      if(test->get_experience() > high_exp) {
        // Update highest player id and experience
        high_exp = test->get_experience();
        high = id;
      }
    } else {
      done = 1;
    }
    id += 1;
  } // Ok highest experiencing player found!
  test = load_player(high);
  return test;
}

void update_player(user_info *data) {
  sqlite3 *db;
  sqlite3_stmt *stmt;
  char sqlbuffer[1024];
  int rc = sqlite3_open("spaceconstruct.db3", &db);
  if(rc) { // Did we do a successful open?
    ZF_LOGF("Failed opening database %s (%d)", sqlite3_errmsg(db), rc);
    sqlite3_close(db);
    od_exit(-1, FALSE);
  }
  sqlite3_busy_timeout(db, 5000);
  // Bad, don't do this... opens to SQL injection!
  //snprintf(sqlbuffer, 1024, "UPDATE user SET nick = '%s', experience = %d, metal = %d, fuel = %d, guns = %d, armors = %d, shields = %d, armorpoints = %d, shieldpoints = %d, hitpoints = %d WHERE uid=%d;",
  //  data.nick, data.experience, data.metal, data.fuel, data.guns, data.armors, data.shields, data.armorpoints, data.shieldpoints, data.hitpoints, data.uid);
  strcpy(sqlbuffer, "UPDATE user SET nick=?, experience=?, metal=?, fuel=?, gun=?, armor=?, shield=?, armorpoints=?, shieldpoints=?, hitpoints=?, shieldsup=?, laston=? WHERE uid=?;");
  sqlite3_prepare_v2(db, sqlbuffer, strlen(sqlbuffer) + 1, &stmt, NULL);
  // Bind All data values
  sqlite3_bind_text(stmt, 1, data->get_nick().c_str(), data->get_nick().length(), SQLITE_STATIC);
  sqlite3_bind_int(stmt, 2, data->get_experience());
  sqlite3_bind_int(stmt, 3, data->get_metal());
  sqlite3_bind_int(stmt, 4, data->get_fuel());
  sqlite3_bind_int(stmt, 5, data->get_gun());
  sqlite3_bind_int(stmt, 6, data->get_armor());
  sqlite3_bind_int(stmt, 7, data->get_shield());
  sqlite3_bind_int(stmt, 8, data->get_armorpoints());
  sqlite3_bind_int(stmt, 9, data->get_shieldpoints());
  sqlite3_bind_int(stmt, 10, data->get_hitpoints());
  sqlite3_bind_int(stmt, 11, data->get_shieldsup());
  sqlite3_bind_int(stmt, 12, data->get_laston());
  sqlite3_bind_int(stmt, 13, data->get_uid());
  // Execute
  rc = sqlite3_step(stmt);
  if(rc != SQLITE_DONE) {
    ZF_LOGF("Failed updating player %s (%d)", sqlite3_errmsg(db), rc);
    sqlite3_finalize(stmt);
    sqlite3_close(db);
    od_exit(-1, FALSE);
  }
  sqlite3_finalize(stmt);
  sqlite3_close(db);
}

int create_player(user_info *data) {
  sqlite3 *db;
  sqlite3_stmt *stmt;
  char sqlbuffer[1024];
  int rc = sqlite3_open("spaceconstruct.db3", &db);
  if(rc) { // Did we do a successful open?
    ZF_LOGF("Failed opening database %s (%d)", sqlite3_errmsg(db), rc);
    sqlite3_close(db);
    od_exit(-1, FALSE);
  }
  sqlite3_busy_timeout(db, 5000);
  strcpy(sqlbuffer, "INSERT INTO user (nick, real, experience, metal, fuel, gun, armor, shield, armorpoints, shieldpoints, hitpoints, shieldsup, laston) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);");
  sqlite3_prepare_v2(db, sqlbuffer, strlen(sqlbuffer) + 1, &stmt, NULL);
  sqlite3_bind_text(stmt, 1, data->get_nick().c_str(), data->get_nick().length(), SQLITE_STATIC);
  sqlite3_bind_text(stmt, 2, data->get_real().c_str(), data->get_real().length(), SQLITE_STATIC);
  sqlite3_bind_int(stmt, 3, data->get_experience());
  sqlite3_bind_int(stmt, 4, data->get_metal());
  sqlite3_bind_int(stmt, 5, data->get_fuel());
  sqlite3_bind_int(stmt, 6, data->get_gun());
  sqlite3_bind_int(stmt, 7, data->get_armor());
  sqlite3_bind_int(stmt, 8, data->get_shield());
  sqlite3_bind_int(stmt, 9, data->get_armorpoints());
  sqlite3_bind_int(stmt, 10, data->get_shieldpoints());
  sqlite3_bind_int(stmt, 11, data->get_hitpoints());
  sqlite3_bind_int(stmt, 12, data->get_shieldsup());
  sqlite3_bind_int(stmt, 13, data->get_laston());
  rc = sqlite3_step(stmt);
  if(rc != SQLITE_DONE) {
    ZF_LOGF("Failed inserting player %s (%d)", sqlite3_errmsg(db), rc);
    sqlite3_finalize(stmt);
    sqlite3_close(db);
    od_exit(-1, FALSE);
  }
  sqlite3_finalize(stmt);
  sqlite3_close(db);
  return 1; // Good
}

void delete_player(int uuid) {
  sqlite3 *db;
  sqlite3_stmt *stmt;
  char sqlbuffer[256];
  int rc = sqlite3_open("spaceconstruct.db3", &db);
  if(rc) { // Did we do a successful open?
    ZF_LOGF("Failed opening database %s (%d)", sqlite3_errmsg(db), rc);
    sqlite3_close(db);
    od_exit(-1, FALSE);
  }
  sqlite3_busy_timeout(db, 5000);
  strcpy(sqlbuffer, "DELETE FROM user WHERE uid=?;");
  sqlite3_prepare_v2(db, sqlbuffer, strlen(sqlbuffer) + 1, &stmt, NULL);
  sqlite3_bind_int(stmt, 1, uuid);
  rc = sqlite3_step(stmt);
  if (rc != SQLITE_DONE){
    ZF_LOGF("Unable to locate user with id=%d got %s (%d)", uuid, sqlite3_errmsg(db), rc);
    sqlite3_finalize(stmt);
    sqlite3_close(db);
    od_exit(-1, FALSE);
  }
  sqlite3_finalize(stmt);
  sqlite3_close(db);
}

void delete_players() {
  sqlite3 *db;
  sqlite3_stmt *stmt;
  char sqlbuffer[256];
  int rc = sqlite3_open("spaceconstruct.db3", &db);
  if(rc) { // Did we do a successful open?
    ZF_LOGF("Failed opening database %s (%d)", sqlite3_errmsg(db), rc);
    sqlite3_close(db);
    od_exit(-1, FALSE);
  }
  sqlite3_busy_timeout(db, 5000);
  strcpy(sqlbuffer, "DELETE FROM user;");
  sqlite3_prepare_v2(db, sqlbuffer, strlen(sqlbuffer) + 1, &stmt, NULL);
  rc = sqlite3_step(stmt);
  if (rc != SQLITE_DONE){
    ZF_LOGF("Delete_players 1/2, Unexpected error %s (%d)", sqlite3_errmsg(db), rc);
    sqlite3_finalize(stmt);
    sqlite3_close(db);
    od_exit(-1, FALSE);
  }
  strcpy(sqlbuffer, "UPDATE sqlite_sequence SET seq = 0 WHERE name='user';");
  sqlite3_prepare_v2(db, sqlbuffer, strlen(sqlbuffer) + 1, &stmt, NULL);
  rc = sqlite3_step(stmt);
  if (rc != SQLITE_DONE){
    ZF_LOGF("Delete_players 2/2, Unexpected error %s (%d)", sqlite3_errmsg(db), rc);
    sqlite3_finalize(stmt);
    sqlite3_close(db);
    od_exit(-1, FALSE);
  }
  sqlite3_finalize(stmt);
  sqlite3_close(db);
}

int display_all_players() {
  sqlite3 *db;
  sqlite3_stmt *stmt;
  char sqlbuffer[1024];
  int rc = sqlite3_open("spaceconstruct.db3", &db);
  if(rc) { // Did we do a successful open?
    ZF_LOGF("Failed opening database %s (%d)", sqlite3_errmsg(db), rc);
    sqlite3_close(db);
    od_exit(-1, FALSE);
  }
  sqlite3_busy_timeout(db, 5000);
  strcpy(sqlbuffer, "SELECT * from user ORDER BY experience DESC, nick DESC;");
  sqlite3_prepare_v2(db, sqlbuffer, strlen(sqlbuffer) + 1, &stmt, NULL);
  int total = 0;
  od_printf("`bright green`___ The Players ___\r\n");
  while(sqlite3_step(stmt) == SQLITE_ROW) {
    od_printf("`bright white`  %s (%d)\r\n", sqlite3_column_text(stmt, 1), sqlite3_column_int(stmt, 3));
    total += 1;
  }
  if(total > 1) {
    od_printf("`green`There are a total of `bright green`%d`green` players\r\n", total);
  } else if(total == 0) {
    od_printf("`green`There are a total of `bright green`%d`green` players\r\n", total);
  } else {
    od_printf("`green`There are a total of `bright green`%d`green` player\r\n", total);
  }
  sqlite3_finalize(stmt);
  sqlite3_close(db);
  return total;
}

int display_all_opponents(int us) {
  sqlite3 *db;
  sqlite3_stmt *stmt;
  char sqlbuffer[1024];
  int rc = sqlite3_open("spaceconstruct.db3", &db);
  if(rc) { // Did we do a successful open?
    ZF_LOGF("Failed opening database %s (%d)", sqlite3_errmsg(db), rc);
    sqlite3_close(db);
    od_exit(-1, FALSE);
  }
  sqlite3_busy_timeout(db, 5000);
  strcpy(sqlbuffer, "SELECT * from user ORDER BY experience DESC, nick DESC;");
  sqlite3_prepare_v2(db, sqlbuffer, strlen(sqlbuffer) + 1, &stmt, NULL);
  int total = 1;
  od_printf("`bright green`___ Target List ___\r\n");
  while(sqlite3_step(stmt) == SQLITE_ROW) {
    if(total != us) {
      od_printf("`bright black`(`bright white`%d`bright black`) `bright white`%s (%d)\r\n", total, sqlite3_column_text(stmt, 1), sqlite3_column_int(stmt, 3));
    }
    total += 1;
  }
  total -= 1;
  sqlite3_finalize(stmt);
  sqlite3_close(db);
  return total;
}

user_info* build_menu(user_info *my) {
  int done = 0;
  char ch;
  if(my->get_metal() != 0) {
    while(!done) {
      od_clr_scr();
      od_send_file("ansis/sc_build.ans");
      // Paint over sc_build.ans file
      od_set_cursor(3, 15);
      od_printf("%5d", my->calcGun());
      od_set_cursor(4, 15);
      od_printf("%5d", my->calcArmor());
      od_set_cursor(5, 15);
      od_printf("%5d", my->calcShield());
      od_set_cursor(9, 1);
      // Resuming normal operations
      od_printf("`bright yellow`You have %8d metal\r\n", my->get_metal());
      ch = od_get_answer("GgAaSsCcRr\r");
      switch(tolower(ch)) {
        case 'g':
          if(my->get_metal() >= my->calcGun()) {
            my->rmMetal(my->calcGun());
            my->addGun(1);
            od_printf("`bright green`Added a new gun!\r\n`white`");
            paws();
          } else {
            od_printf("`bright red`You don't have the %d metal for this!\r\n`white`", my->calcGun());
            paws();
          }
          break;
        case 'a':
          if(my->get_metal() >= my->calcArmor()) {
            my->rmMetal(my->calcArmor());
            my->addArmor(1);
            od_printf("`bright green`Added a new armor!\r\n`white`");
            paws();
          } else {
            od_printf("`bright red`You don't have the %d metal for this!\r\n`white`", my->calcArmor());
            paws();
          }
          break;
        case 's':
          if(my->get_metal() >= my->calcShield()) {
            my->rmMetal(my->calcShield());
            my->addShield(1);
            od_printf("`bright green`Added a new shield!\r\n`white`");
            paws();
          } else {
            od_printf("`bright red`You don't have the %d metal for this!\r\n`white`", my->calcShield());
            paws();
          }
          break;
        case '\r':
        case 'c':
          done = 1;
          break;
        case 'r':
          if(my->get_experience() >= 25) {
            if(my->get_metal() >= 25) {
              my->rmEXP(25);
              my->rmMetal(25);
              my->addFuel(5);
              od_printf("`bright green`Made 5 fuel using 25 experience and 25 metal!\r\n");
              paws();
            } else {
              od_printf("`bright red`You need 25 experience and 25 metal to make fuel!\r\n");
              paws();
            }
          } else {
            od_printf("`bright red`You need 25 experience and 25 metal to make fuel!\r\n");
            paws();
          }
          break;
      }
    }
    update_player(my);
    return my;
  } else {
    return my;
  }
}

void pvp_menu(user_info *my, user_info *targ) {
  int done = 0;
  int playerWon = 0;
  char ch;
  // We need to set the targ's hit points and such to max and enable us to "restore" them
  int temp_hp = targ->get_hitpoints();
  int temp_ap = targ->get_armorpoints();
  int temp_sp = targ->get_shieldpoints();
  int temp_su = targ->get_shieldsup();
  // Set Offline to max values
  int targ_dmg = (targ->get_gun() + 1); // Add bonus damage for offline
  targ->set_hitpoints(targ->calcHP());
  targ->set_armorpoints(targ->calcAP());
  targ->set_shieldpoints(targ->calcSP());
  targ->set_shieldsup(0);
  // Prep Combat values
  int fire = 0;  // Fire Guns
  int flee = 0;  // Run away
  int regen = 0; // Shields
  int test = 0;
  int test2 = 0;
  while(!done) {
    // Process Shields up
    if(temp_su != 0) {
      temp_su -= 1;
    }
    if(my->get_shieldsup() != 0) {
      my->rmSU(1);
    }

    // Process Crew repairing hitpoints
    if(targ->get_hitpoints() < targ->calcHP()) {
      regen = randrange(0, 100);
      if(regen >= 85) { // 15%, offline get a bonus 5% on repairing hull.
        targ->addHP(1);
        od_printf("`bright green`%s`green`'s crew repaired their hull for 1 point!\r\n", targ->get_nick());
      }
    }
    if(my->get_hitpoints() < my->calcHP()) {
      regen = randrange(0, 100);
      if(regen >= 90) { // 10%
        my->addHP(1);
        od_printf("`bright green`Your crew repaired your hull for 1 point!\r\n");
      }
    }
    
  // Process Shields regenerating and display player stats
  regen = randrange(0, 100);
  if(regen >= 75) { // 25%
    targ->regen();
  }
  od_printf("`bright white`%s has `bright cyan`%d`bright white` shields, %d armor and %d hitpoints left\r\n", targ->get_nick(), temp_sp, temp_ap, temp_hp);
  // Online Players Shields
  regen = randrange(0, 100);
  if(regen >= 80) { // 20%
    my->regen();
  }
  od_printf("`bright white`Your ship has `bright cyan`%d`bright white` shields, %d armor and %d hitpoints left\r\n", my->get_shieldpoints(), my->get_armorpoints(), my->get_hitpoints());
  // Form combat menu (Not allowing online to repair since offline can't really repair either)
  od_printf("`bright black`(`bright white`A`bright black`)`white`ttack\r\n");
  od_printf("`bright black`(`bright white`F`bright black`)`white`lee\r\n");
  // Online Players action
  ch = od_get_answer("AaFf\r");
  switch(tolower(ch)) {
    case '\r':
    case 'a':
      fire = randrange(0, 100);
      if(fire >= 50) {
        // Proccess online dealing damage to offline
        test = targ->takeDamage(my->get_gun());
        if(test == 0) {
          od_printf("`bright red`%s took %d damage!\r\n", targ->get_nick(), my->get_gun());
        } else {
          od_printf("`bright red`%s took %d damage, and blew up!\r\n", targ->get_nick(), my->get_gun());
          playerWon = 1; // Online beat offline
        }
      } else { // Online missed
        od_printf("`white`You missed!\r\n");
      }
      break;
    case 'f':
      flee = randrange(0, 100);
      if(flee >= 80) { // 20% chance the online flees
        playerWon = 3; // Online ran away from Offline
        done = 1;
        od_printf("`bright green`You ran away from %s!\r\n", targ->get_nick());
      } else {
        od_printf("`bright red`%s found you!\r\n", targ->get_nick());
      }
      break;
  } // Now for Offline to attack
  if(!playerWon) {
    fire = randrange(0, 100);
    if(fire >= 45) { // 55%, 5% bonus for offline
      test2 = my->takeDamage(targ_dmg);
      if(test2 == 0) {
        od_printf("`bright red`You took %d damage!\r\n", targ_dmg);
      } else {
        od_printf("`bright red`You took %d damage, and blew up!\r\n", targ_dmg);
        playerWon = 2;
      }
    }
  }
  // Winning Move?
  if(playerWon) {
    switch(playerWon) {
      case 1: // Online won over offline
        ZF_LOGV("%s beat %s in pvp", my->get_nick(), targ->get_nick());
        if(targ->get_experience()) {
          my->addEXP((targ->get_experience() / 2));
          targ->rmEXP((targ->get_experience() / 2));
        }
        if(targ->get_metal()) {
          my->addMetal((targ->get_metal() / 2));
          targ->rmMetal((targ->get_metal() / 2));
        }
        my->rmFuel(4);
        if(my->get_fuel() < 0) {
          my->set_fuel(0);
        }
        od_printf("`bright green`Congrats on defeating %s!\r\n`white`", targ->get_nick());
        break;
      case 2: // Offline won over online!
        ZF_LOGV("%s beat %s in pvp", targ->get_nick(), my->get_nick());
        if(my->get_experience()) {
          targ->addEXP((my->get_experience() / 2));
          my->rmEXP((my->get_experience() / 2));
        }
        if(my->get_metal()) {
          targ->addMetal((my->get_metal() / 2));
          my->rmMetal((my->get_metal() / 2));
        }
        my->rmFuel(4);
        if(my->get_fuel() < 0) {
          my->set_fuel(0);
        }
        od_printf("`bright red`Sorry for your loss! (We rebuild your ship)\r\n");
        my->set_hitpoints(4);
        my->set_armorpoints(8);
        my->set_shieldpoints(0);
        my->set_shieldsup(0);
        my->set_armor(1);
        my->set_shield(0);
        my->set_gun(1);
        break;
      case 3:
        ZF_LOGV("%s ran away from %s in pvp", my->get_nick(), targ->get_nick());
        my->rmFuel(4);
        if(my->get_fuel() < 0) {
          my->set_fuel(0);
        }
        break;
    }
  }
  // Restore targ values from temps
  targ->set_shieldsup(temp_su);
  targ->set_armorpoints(temp_ap);
  targ->set_hitpoints(temp_hp);
  targ->set_shieldpoints(temp_sp);
  // DOne, save
  update_player(targ);
  update_player(my);
}
}

void combat_menu(user_info *my, int targ_hp, int targ_dmg, int asteroid) {
  int done = 0;
  int playerWon = 0; // Did the player win? (1 = Yes, 2 = No, 3 = Flee)
  char ch;
  int armorRep = 0; // Can armor be repaired?
  int temp = 0;
  int temp1 = 0;
  int temp2 = 0;
  int temp_hp = targ_hp;
  int flee = 0;
  int fire = 0;
  int regen = 0;
  while(!done) {
    if(asteroid == 0) {
      od_printf("`bright white`Pirate has %d hitpoints left\r\n", targ_hp);
    } else if(asteroid == 1) {
      od_printf("`bright white`Asteroid has %d hitpoints left\r\n", targ_hp);
    } else if(asteroid == 2) {
      od_printf("`bright white`Unknown One has %d hitpoints left\r\n", targ_hp);
    }
    // Proccess Shields comming back online
    if(my->get_shieldsup() != 0) {
      my->rmSU(1);
    }
    // Proccess Crew repairing hull
    if(my->get_hitpoints() < my->calcHP()) {
      regen = randrange(0, 100);
      if(regen >= 90) {
        my->addHP(1);
      }
    }
    // Proccess Shields Regen
    regen = randrange(0, 100);
    if(regen >= 80) { // 20%
      my->regen();
    }
    od_printf("`bright white`Your ship has `bright cyan`%d`bright white` shields, %d armor and %d hitpoints left:\r\n", my->get_shieldpoints(), my->get_armorpoints(), my->get_hitpoints());
    // Forming Combat Menu
    od_printf("`bright black`(`bright white`A`bright black`)`white`ttack\r\n");
    if(my->get_armorpoints() < my->calcAP()) {
      od_printf("`bright black`(`bright white`R`bright black`)`white`epair Armor\r\n");
      armorRep = 1; // Yes we can repair armor
    }
    od_printf("`bright black`(`bright white`F`bright black`)`white`lee\r\n");
    // Proccess User action
    ch = od_get_answer("AaRrFf\r");
    switch(tolower(ch)) {
      case '\r':
      case 'a':
        fire = rand() % 100;
        if(asteroid == 1) { // Its a rock so allow player to hit it more frequent
          fire -= 15;
        }
        if(fire >= 50) {
          targ_hp -= my->get_gun();
          if(targ_hp <= 0) {
            od_printf("`bright red`Target Destroyed!\r\n");
            done = 1;
            playerWon = 1;
          } else {
            od_printf("`bright red`Target took %d damage!\r\n", my->get_gun());
          }
        } else {
          od_printf("`white`You Missed!\r\n");
        }
        break;
      case 'r':
        if(armorRep) {
          my->repair(false);
        } else {
          od_printf("`bright yellow`You don't seem to need repairs!\r\n");
        }
        break;
      case 'f':
        flee = rand() % 100;
        if(asteroid == 1) {
          flee = 100; // Always allow fleeing from asteroid
        } else if(asteroid == 2) {
          flee = 0; // Never allow fleeing from Unknown One
        }
        if(flee >= 82) {
          playerWon = 3;
          done = 1;
          od_printf("`bright green`You ran away!\r\n");
        } else {
          od_printf("`bright red`Target found you!\r\n");
        }
        break;
    } // If Enemy is alive proccess incomming attack
    if(targ_hp > 0) {
      targ_dmg;
      fire = rand() % 100;
      if(asteroid == 1) { // Yup it doesn't have gunz cuz it's rock.
        fire = 0;
      } else if(asteroid == 2) { // This is the Unknown One
        fire += 5;
      }
      if(fire >= 40) {
        temp = my->takeDamage(targ_dmg);
        if(temp == 0) {
          od_printf("`bright red`You took %d damage!\r\n", targ_dmg);
        } else {
          od_printf("`bright red`You took %d damage, and blew up!\r\n", targ_dmg);
          playerWon = 2;
        }
      }
      // firing
    }
    // Winning move?
    if(playerWon) {
      if(playerWon == 1) {
        std::string who;
        switch(asteroid) {
          case 0:
            //Pirate
            who = "Pirate";
            break;
          case 1:
            // Asteroid
            who = "Asteroid";
            break;
          case 2:
            // Unknown One
            who = "Unkown One";
            break;
        }
        ZF_LOGV("%s beat %s", my->get_nick(), who);
        // Player won
        my->addEXP((temp_hp + targ_dmg));
        my->addMetal(temp_hp);
        if(asteroid == 1) { // If asteroid reward more experience and metal!
          my->addEXP(2);
          my->addMetal(2);
        } else if(asteroid == 2) { // If it was the boss!
          my->addEXP(6000); // Ensure the game triggers a reset!
          my->set_metal(0); // Stop the player!
          my->set_fuel(2); // Prevent the player from doing anything else
        }
        my->rmFuel(2);
        if(my->get_fuel() < 0) {
          my->set_fuel(0);
        }
        od_printf("`bright green`Congrats on your victory!\r\n`white`");
      } else if(playerWon == 2) {
        std::string who;
        switch(asteroid) {
          case 0:
            //Pirate
            who = "Pirate";
            break;
          case 1:
            // Asteroid
            who = "Asteroid";
            break;
          case 2:
            // Unknown One
            who = "Unkown One";
            break;
        }
        ZF_LOGV("%s beat %s", who, my->get_nick());
        // Target won
        my->rmEXP((temp_hp + targ_dmg));
        my->rmMetal(temp_hp);
        my->rmFuel(3);
        if(my->get_experience() < 0) {
          my->set_experience(0);
        }
        if(my->get_metal() < 0) {
          my->set_metal(0);
        }
        if(my->get_fuel() < 0) {
          my->set_fuel(0);
        }
        od_printf("`bright red`Sorry for your loss! (We rebuild your ship)\r\n");
        my->set_hitpoints(4);
        my->set_armorpoints(8);
        my->set_shieldpoints(0);
        my->set_shieldsup(0);
        my->set_armor(1);
        my->set_shield(0);
        my->set_gun(1);
      } else if(playerWon == 3) {
        std::string who;
        switch(asteroid) {
          case 0:
            //Pirate
            who = "Pirate";
            break;
          case 1:
            // Asteroid
            who = "Asteroid";
            break;
          case 2:
            // Unknown One
            who = "Unkown One";
            break;
        }
        ZF_LOGV("%s ran away from %s", my->get_nick(), who);
        // Chicken!
        my->rmFuel(1);
      }
    }
  }
  update_player(my);
}

void about_game() {
  int done = 0;
  int page = 1;
  while(!done) {
    switch(page) {
      case 1:
        od_clr_scr();
        od_send_file("ansis/sc_doc_1.ans");
        paws();
        break;
      case 2:
        od_clr_scr();
        od_send_file("ansis/sc_doc_2.ans");
        paws();
        break;
      case 3:
        od_clr_scr();
        od_send_file("ansis/sc_doc_3.ans");
        paws();
        break;
      case 4:
        od_clr_scr();
        od_send_file("ansis/sc_doc_4.ans");
        paws();
        break;
      case 5:
        od_clr_scr();
        od_send_file("ansis/sc_doc_5.ans");
        paws();
        break;
      case 6:
        done = 1;
        break;
    }
    od_clr_scr();
    page += 1;
  }
}

void play_game() {
  int done = 0;
  char ch;
  char ch1[256];
  user_info *myself;
  user_info *myself2;
  user_info *testing;
  int reset = 0;
  int doRefuel = 0;
  int pirate_encounter = 0;
  int pirate_hp = 0; // Reused for asteroid
  int pirate_dmg = 0; // Reused for asteroid
  int asteroid = 0; // 1 means yes we need to remove damage... completely.
  int me = locate_player(od_control.user_name);
  int abort = 0;
  if(me != 0) {
    //myself = load_player(me);
    testing = load_player(me);
    if(testing->get_uid() != 0) {
      myself = load_player(me);
    }
    dT age = fromDate(compareDate(myself->get_laston()));
    // Process player inactivity
    if(age.age >= 30) { // 30 days
      od_printf("`bright green`Since you haven't played a while we have reset your account!\r\n");
      ZF_LOGW("%s was reset for expiring", od_control.user_name);
      me = 0;
      reset = 1;
    }
    // Processing fuel regeneration
    if(age.age != 0) {
      doRefuel = 1;
    }
  }
  if(me != 0) {
    od_printf("`bright white`Welcome back `bright green`%s\r\n", myself->get_nick());
    ZF_LOGV("%s is back again", od_control.user_name);
    dT age = fromDate(compareDate(myself->get_laston()));
    myself->set_laston(dateStamp());
    if(age.day != 0 || age.month != 0 || age.year != 0) {
      od_printf("`bright yellow`Haven't seen you for");
    }
    if(age.day != 0) {
      if(age.day > 1) {
        od_printf(" %d days", age.day);
      } else {
        od_printf(" %d day", age.day);
      }
    }
    if(age.month != 0) {
      if(age.month > 1) {
        od_printf(" %d months", age.month);
      } else {
        od_printf(" %d month", age.month);
      }
    }
    if(age.year != 0) {
      if(age.year > 1) {
        od_printf(" %d years", age.year);
      } else {
        od_printf(" %d year", age.year);
      }
    }
    if(age.day != 0 || age.month != 0 || age.year != 0) {
      od_printf("\r\n");
    }
    if(doRefuel) {
      if(myself->get_fuel() != 0) {
        myself->addFuel((age.age * 2));
      } else {
        myself->addFuel(((age.age * 2) + 10));
        od_printf("`bright green`For using all your fuel last time you get bonus fuel today!\r\n");
      }
      od_printf("`bright green`You now have %d fuel\r\n", myself->get_fuel());
    }
    update_player(myself);
    paws();
  } else {
    od_printf("`bright white`You look new here. (Hit Enter to abort)\r\n");
    ZF_LOGV("%s is a new player", od_control.user_name);
    while(done == 0) {
      od_printf("`bright yellow`What's your name: ");
      od_input_str(ch1, 26, 32, 126);
      od_printf("\r\n");
      if(strlen(ch1) > 0) {
        //od_input_str(ch1, 256, 32, 126);
        myself->set_nick(ch1);
      } else {
        od_clr_scr();
        abort = 1;
        done = 1;
        od_printf("`bright red`Ok, come back later then...`white`\r\n");
        paws();
      }
      if(abort == 0) {
        od_printf("`bright white`Are you sure you want to be called `bright green`%s\r\n");
        done = yesNo();
        if(done) {
          if(reset) { // So we are reseting the user, this wipes all values and uses update instead of create
            myself->set_up(myself->get_uid(), myself->get_nick(), myself->get_real(), 0, dateStamp(), 1, 8, 0, 0, 0, 4, 1, 0, 10);
            update_player(myself);
          } else { // Brand new user
            myself2->set_new(myself->get_nick(), od_control.user_name);
            create_player(myself2);
            myself = load_player(locate_player(od_control.user_name));
          }
        }
      }
    }
    done = 0; // Reset this for our next loop.
  }
  // Ok user is here now lets ask what they want to do... build/attack
  if(abort == 0) {
    od_clr_scr();
    while(!done) {
      od_printf("`bright yellow`You have %d fuel left for today,\r\n", myself->get_fuel());
      if(myself->get_shieldsup() == 0) {
        od_printf("`bright yellow`Your ship has `bright cyan`%d`bright yellow` shields, %d armor  and %d hitpoints left:\r\n", myself->get_shieldpoints(), myself->get_armorpoints(), myself->get_hitpoints());
      } else {
        od_printf("`bright yellow`Your ship has %d armor, `bright cyan`%d`bright yellow` shields and %d hitpoints left:\r\n", myself->get_shieldpoints(), myself->get_armorpoints(), myself->get_hitpoints());
      }
      if(myself->get_armorpoints() < myself->calcAP()) {
        od_printf("`bright black`(`bright white`R`bright black`)`white`epair Armor\r\n");
      }
      if(myself->get_shieldpoints() < myself->calcSP() || myself->get_shieldsup() != 0) {
        od_printf("`bright black`(`bright white`G`bright black`)`white`enerate Shields\r\n");
      }
      if(myself->get_fuel() >= 2) {
        od_send_file("ansis/sc_gameh.ans");
        ch = od_get_answer("SsHhBbQqRrGgLlVv");
      } else {
        od_send_file("ansis/sc_gamel.ans");
        ch = od_get_answer("BbQqRrGgLlVv");
      }
      od_clr_scr();
      switch(tolower(ch)) {
        case 's':
          if(myself->get_fuel() >= 1) {
            pirate_encounter = rand() % 100;
            if(pirate_encounter >= 75) { // 25% chance to encounter a Pirate, or Unknown One
              if(myself->get_experience() > 3000) {
                if(pirate_encounter >= 95) { // 5% chance to encounter unknown one
                  od_printf("`bright yellow`You encounter the `bright red`Unknown One\r\n`white`");
                  asteroid = 2;
                } else {
                  od_printf("`bright yellow`You encounter a `bright red`Pirate\r\n`white`");
                  asteroid = 0;
                }
              } else { // The player is not skilled enough to fight the unknown one
                od_printf("`bright yellow`You encounter a `bright red`Pirate\r\n`white`");
                asteroid = 0;
              }
            } else { // 75% chance to encounter a Asteroid
              od_printf("`bright yellow`You encounter a `bright red`Asteroid\r\n`white`");
              asteroid = 1;
            }
            if(asteroid == 0 || asteroid == 2) {
              pirate_hp = ((myself->get_hitpoints() + 1) + (randrange(0, 4)));
              if(asteroid == 2) { // Increase boss hitpoints
                pirate_hp += 10; 
              }
              // Increase difficulty based on experience...
              pirate_dmg = (myself->get_experience() / 500);
              if(pirate_dmg == 0) { // Always deal damage
                pirate_dmg = 1;
              }
              if(asteroid == 2) { // Increase boss damage
                pirate_dmg += 2;
              }
              // Send off to combat menu
              combat_menu(myself, pirate_hp, pirate_dmg, asteroid);
            } else {
              pirate_hp = (myself->get_hitpoints() + 1) + (rand() % 10);
              // Send off to combat menu
              combat_menu(myself, pirate_hp, 0, asteroid);
            }
          }
          break;
        case 'h':
          if(myself->get_fuel() >= 4) {
            int targs = display_all_opponents(myself->get_uid());
            int targg = 1;
            int done2 = 0;
            if(targg == myself->get_uid()) {
              targg += 1;
            }
            while(!done2) {
              od_printf("`bright red`Targetting: %d\r\n", targg);
              if(yesNo()) {
                done2 = 1;
              } else if(targg < targs){
                targg += 1;
              } else {
                done2 = 1;
                od_printf("`bright red`ABORTED!\r\n");
                break;
              }
            }
            user_info *targ = load_player(targg);
            if(targ->get_uid() != 0) {
              // I need to add some limits in here else someone could attack weaker players!
              int proceed = 0;
              int temp = targ->get_experience() + 1000; // Prevent the person from selecting a player that is higher than them
              int temp1 = targ->get_experience() - 500; // Prevent the person from selecting a player that is lower than them
              if(temp1 > 0) {
                temp1 = 0;
              }
              if(temp > myself->get_experience() && temp1 < myself->get_experience()) {
                proceed = 1;
              }
              if(proceed) {
                pvp_menu(myself, targ);
              } else {
                od_printf("`bright white`Please select a opponent within your range of expertise!\r\n");
                break;
              }
            }
          } else {
            od_printf("`bright white`You need 4 fuel to fight another player!\r\n`white`");
          }
          break;
        case 'b':
          if(myself->get_metal() != 0) {
            // Send off to build menu
            od_clr_scr();
            //od_send_file("ansis/sc_build.ans", FALSE);
            myself = build_menu(myself);
          } else {
            od_printf("`bright white`I am sorry you have no metal go fight.`white`\r\n");
          }
          break;
        case 'q':
          done = 1;
          break;
        case 'r':
          if(myself->get_armorpoints() < (myself->get_armor() * 8)) {
            myself->repair(true);
            update_player(myself);
          } else {
            od_printf("`bright yellow`You don't seem to need repairs!\r\n`white`");
          }
          break;
        case 'g':
          if(myself->get_shieldpoints() < myself->calcSP() || myself->get_shieldsup() != 0) {
            myself->regen();
            update_player(myself);
          } else {
            od_printf("`bright yellow`You don't seem to need to regenerate shields!\r\n`white`");
          }
          break;
        case 'v':
          od_printf("`bright white` ___ %s's Ship Status ___\r\n", myself->get_nick());
          od_printf("`bright white`Items:       # Installed:   Metal to Upgrade:\r\n");
          od_printf("`bright red`Guns:           %8d            %8d\r\n", myself->get_gun(), myself->calcGun());
          od_printf("`bright yellow`Armor:          %8d            %8d\r\n", myself->get_armor(), myself->calcArmor());
          od_printf("`bright cyan`Shields:        %8d            %8d\r\n", myself->get_shield(), myself->calcShield());
          od_printf("`bright white`\r\n ___ Situation Report ___\r\n");
          od_printf("`bright white`Items:       Maximum:    Current:\r\n");
          od_printf("`bright green`Hitpoints:  %8d    %8d\r\n", myself->calcHP(), myself->get_hitpoints());
          od_printf("`bright yellow`Armor:      %8d    %8d\r\n", myself->calcAP(), myself->get_armorpoints());
          od_printf("`bright cyan`Shields:    %8d    %8d\r\n", myself->calcSP(), myself->get_shieldpoints());
          od_printf("`bright magenta`Experience:             %8d\r\n", myself->get_experience());
          od_printf("`bright magenta`Fuel:                   %8d\r\n", myself->get_fuel());
          od_printf("`white`Metal:                  %8d\r\n", myself->get_metal());
          paws();
          od_clr_scr();
          break;
      }
    }
  }
}

void sysop_menu() {
  int done = 0;
  char ch;
  int targ_ply = 1;
  int targ_max = 0;
  int done1 = 0;
  user_info *targ;
  while(!done) {
    od_clr_scr();
    od_send_file("ansis/sc_sysop.ans");
    ch = od_get_answer("RrNnQq");
    //od_printf("\r\n");
    switch(tolower(ch)) {
      case 'q':
        done = 1;
        break;
      case 'r':
        od_printf("`bright red`__ Reset ___\r\n");
        od_printf("`bright red`DANGER THIS WILL DELETE ALL PLAYERS IN GAME\r\n");
        if(yesNo() == 0) {
          od_printf("`bright red`ABORTED!\r\n");
          paws();
          break;
        }
        ZF_LOGW("%s issued reset", od_control.user_name);
        delete_players();
        paws();
        break;
      case 'n':
        od_printf("`bright red`__ New Day ___\r\n");
        while(!done1) {
          targ = load_player(targ_ply);
          if(targ->get_uid() != 0) {
            targ->rmLaston(1); // Travel back 1 day
            update_player(targ); // Save
          } else {
            done1 = 1;
          }
          targ_ply += 1;
          targ_max += 1;
        }
        od_printf("`bright red`%d players affected\r\n", (targ_max - 1));
        targ_ply = 1;
        targ_max = 0;
        done1 = 0;
        ZF_LOGW("%s issued new day", od_control.user_name);
        paws();
        break;
    }
  }
  od_clr_scr();
}

void cleanMe() {
  rel_lock();
  od_exit(0, FALSE);
}

void main_menu() {
  // Main menu for once things are done being initalized
  int done = 0;
  int done1 = 0; // For Reset Game and for New Day... also for Debug
  int targ_ply = 1; // Target player to perform op!
  int targ_max = 0; // Total number of players affected!
  user_info *targ; // Player Struct
  user_info *test;
  dT targ_age; // Date Struct
  dT test2;
  char targ_real[256];
  char ch;
  int auth; // Security
  char sys[48]; // Security
  // 0 means we got the lock first, 1 means someone else has it already!
  while(!done) {
    od_clr_scr();
    od_send_file("ansis/sc_main.ans");
    ch = od_get_answer("PpLlVvQqSsAa");
    od_clr_scr();
    switch(tolower(ch)){
      case 'q':
        // Quit
        done = 1;
        break;
      case 'p':
        // Play Game (Default if the player just hits enter)
        // Check to see if we have a winner if so refuse to let anyone on! (Wait 3 days then reset the game!)
        test = highest_player();
        test2 = fromDate(compareDate(test->get_laston()));
        if(test->get_experience() >= 8000) { // If the player has the minimum of 3000 exp to fight the Unkown One and wins earning 5000 thats 8000 minimum
          if(test2.age >= 3) { // Auto reset the game or not allow the player to play!
            delete_players();
            ZF_LOGW("Auto-Reset Occured");
            od_printf("`bright green`Game has been reset!\r\n");
            paws();
          } else { // And the lucky winner is!
            int resetage = 3 - test2.age;
            od_printf("`bright green`%s has won the game!\r\n", test->get_nick());
            od_printf("`bright green`The Game will reset in %d days!\r\n", resetage);
            ZF_LOGV("Auto-Reset will occur in %d days", resetage);
            paws();
            break;
          }
        }
        play_game();
        break;
      case 'a':
        about_game();
        break;
      case 'l':
        // List Players in the game
        display_all_players();
        paws();
        break;
      case 'v':
        // Version
        od_clr_scr();
        od_printf("`bright yellow`_____________________________\r\n");
        od_printf("`bright yellow`  Space Construct v%d.%d-%s\r\n", VERSION_MAJOR, VERSION_MINOR, VERSION_TYPE);
        od_printf("`bright yellow`  By: Beanzilla\r\n");
        od_printf("`bright yellow`  FsxNet   21:4/110\r\n");
        od_printf("`bright yellow`  HappyNet 637:1/110\r\n");
        od_printf("`bright yellow`_____________________________\r\n");
        paws();
        break;
      case 's':
        auth = 0;
        if(allowDev && strcmp(od_control.user_handle, "Beanzilla") == 0) {
          od_printf("`bright green`Access Granted\r\n");
          ZF_LOGV("Dev accessed sysop menu");
          auth = 1;
        } else {
          od_printf("`bright red`Sysop Password: ");
          strcpy(sys, "");
          od_input_str(sys, 32, 32, 126);
          od_clr_scr(); // Add a bit of protecton
          if(sys == sysop_pass) {
            od_printf("`bright green`Access Granted\r\n");
            ZF_LOGV("%s accessed sysop menu", od_control.user_name);
            auth = 1;
          }
        }
        // Give only Sysop and dev access to restricted commands
        if(auth) {
          paws();
          sysop_menu();
        } else {
          od_printf("`bright red`Access Denied\r\n");
          ZF_LOGW("%s tried to access sysop menu", od_control.user_name);
          paws();
        }
        break;
    }
  }
}

int main(int argc, char *argv[]) {
  od_parse_cmd_line(argc, argv);
  // Initiate Door
  od_init();
  od_clr_scr();

  // Debug System
  if (debug) {
    ZF_LOGV("=== Debug ===");
    ZF_LOGV("DropFile...\r\n");
    log_drop();
    int test = check_lock();
    if (test == 0) {
      ZF_LOGV("Lock is: Avalible\r\n");
      ZF_LOGV("Database...\r\n");
      db_test();
    } else {
      ZF_LOGV("Lock is: Taken\r\n");
      ZF_LOGV("CANCELED Database Dump\r\n");
    }
  } else {
    ZF_LOGV("--- Debug ---");
  }

  // Normal Operations
  inuse = check_lock();
  if(!inuse) {
    int lock = grab_lock();
    if(!lock) {
      od_printf("`white`Something went wrong getting the lock.\r\n");
      ZF_LOGF("Lock issue");
      paws();
      od_exit(0, FALSE);
    } else {
      atexit(cleanMe);
      check_database(); // Ensure the users table exists.
      main_menu();
    }
  } else {
    od_send_file("ansis/sc_inuse.ans");
    ZF_LOGI("In use");
    paws();
    od_exit(0, FALSE);
  } 

  // Odoors testing
  // Screensaving
  /*char screen[4096]; // 4MB buffer

  // Draw box
  if(od_draw_box(5, 1, 20, 15) == true) {
    od_set_cursor(3, 7);
    od_printf("`white`Box is `bright green`GOOD");
  } else {
    od_set_cursor(3, 7);
    od_printf("`white`Box is `bright red`BAD");
  }
  od_set_cursor(25, 1);
  paws();
  od_save_screen(screen);
  od_clr_scr();
  od_set_cursor(1, 1);

  // Popup
  int run = 1;
  while(run)
  {
    switch(od_popup_menu("Main Menu",
      "^Files|^Electronic Mail|^News|E^xit",
      20, 5, 0, MENU_NORMAL | MENU_KEEP))
    {
      case 1:
        od_set_cursor(25, 1);
        od_printf("Files");
        od_popup_menu("Files Menu",
          "^Search For Files|^Download|^Upload",
          30, 7, 1, MENU_NORMAL | MENU_ALLOW_CANCEL | MENU_KEEP);
        break;
      case 2:
        od_set_cursor(25, 1);
        od_printf("Email");
        od_popup_menu("EMail Menu",
          "Get ^New Mail|^Send Mail|Send ^Fax",
          30, 8, 2, MENU_NORMAL | MENU_ALLOW_CANCEL | MENU_KEEP);
        break;
      case 3:
        od_set_cursor(25, 1);
        od_printf("News");
        od_popup_menu("News Menu",
          "Choose News^Group|^Read News|^Post News",
          30, 9, 3, MENU_NORMAL | MENU_ALLOW_CANCEL | MENU_KEEP);
        break;
      case 4:
        od_set_cursor(25, 1);
        od_printf("Exit");
        od_popup_menu(NULL, NULL, 0, 0, 0, MENU_DESTROY);
        run = 0;
        break;
      case POPUP_ERROR:
        od_set_cursor(25, 1);
        od_printf("ERROR");
        break;
      case POPUP_ESCAPE:
        od_set_cursor(25, 1);
        od_printf("ESCAPE");
        break;
      case POPUP_LEFT:
        od_set_cursor(25, 1);
        od_printf("LEFT");
        break;
      case POPUP_RIGHT:
        od_set_cursor(25, 1);
        od_printf("RIGHT");
        break;
      default:
        od_set_cursor(25, 1);
        od_printf("DEFAULT");
        break;
    }
  }

  paws();
  od_restore_screen(screen); */
  od_exit(0, false);
}