src/app/runtime.cpp

   1 #include "Application.hpp"
   2 #include "Environment.hpp"
   3 #include "Runtime.hpp"
   4
   5 #include "init.hpp"
   6 #include "../client/MasterState.hpp"
   7 #include "../io/filesystem.hpp"
   8 #include "../io/TokenStreamReader.hpp"
   9 #include "../io/WorldSave.hpp"
  10 #include "../server/ServerState.hpp"
  11 #include "../standalone/MasterState.hpp"
  12
  13 #include <cctype>
  14 #include <cstdlib>
  15 #include <fstream>
  16 #include <iostream>
  17 #include <SDL.h>
  18
  19 using namespace std;
  20
  21
  22 namespace {
  23
  24 string default_asset_path() {
  25         char *base = SDL_GetBasePath();
  26         string assets(base);
  27         assets += "assets/";
  28         SDL_free(base);
  29         return assets;
  30 }
  31
  32 string default_save_path() {
  33 #ifndef NDEBUG
  34         char *base = SDL_GetBasePath();
  35         string save(base);
  36         save += "saves/";
  37         SDL_free(base);
  38         return save;
  39 #else
  40         char *pref = SDL_GetPrefPath("localhorst", "blank");
  41         string save(pref);
  42         SDL_free(pref);
  43         return save;
  44 #endif
  45 }
  46
  47 }
  48
  49 namespace blank {
  50
  51 void Config::Load(std::istream &is) {
  52         TokenStreamReader in(is);
  53         std::string name;
  54         while (in.HasMore()) {
  55                 if (in.Peek().type == Token::STRING) {
  56                         in.ReadString(name);
  57                 } else {
  58                         in.ReadIdentifier(name);
  59                 }
  60                 in.Skip(Token::EQUALS);
  61                 if (name == "audio.enabled") {
  62                         in.ReadBoolean(audio.enabled);
  63                 } else if (name == "input.keyboard") {
  64                         in.ReadBoolean(input.keyboard);
  65                 } else if (name == "input.mouse") {
  66                         in.ReadBoolean(input.mouse);
  67                 } else if (name == "input.pitch_sensitivity") {
  68                         in.ReadNumber(input.pitch_sensitivity);
  69                 } else if (name == "input.yaw_sensitivity") {
  70                         in.ReadNumber(input.yaw_sensitivity);
  71                 } else if (name == "net.host") {
  72                         in.ReadString(net.host);
  73                 } else if (name == "net.port") {
  74                         int port;
  75                         in.ReadNumber(port);
  76                         net.port = port;
  77                 } else if (name == "player.name") {
  78                         in.ReadString(player.name);
  79                 } else if (name == "video.dblbuf") {
  80                         in.ReadBoolean(video.dblbuf);
  81                 } else if (name == "video.vsync") {
  82                         in.ReadBoolean(video.vsync);
  83                 } else if (name == "video.msaa") {
  84                         in.ReadNumber(video.msaa);
  85                 } else if (name == "video.hud") {
  86                         in.ReadBoolean(video.hud);
  87                 } else if (name == "video.world") {
  88                         in.ReadBoolean(video.world);
  89                 } else if (name == "video.debug") {
  90                         in.ReadBoolean(video.debug);
  91                 }
  92                 if (in.HasMore() && in.Peek().type == Token::SEMICOLON) {
  93                         in.Skip(Token::SEMICOLON);
  94                 }
  95         }
  96 }
  97
  98 void Config::Save(std::ostream &out) {
  99         out << "audio.enabled = " << (audio.enabled ? "yes" : "no") << ';' << std::endl;
 100         out << "input.keyboard = " << (input.keyboard ? "on" : "off") << ';' << std::endl;
 101         out << "input.mouse = " << (input.keyboard ? "on" : "off") << ';' << std::endl;
 102         out << "input.pitch_sensitivity = " << input.pitch_sensitivity << ';' << std::endl;
 103         out << "input.yaw_sensitivity = " << input.yaw_sensitivity << ';' << std::endl;
 104         out << "net.host = \"" << net.host << "\";" << std::endl;
 105         out << "net.port = " << net.port << ';' << std::endl;
 106         out << "player.name = \"" << player.name << "\";" << std::endl;
 107         out << "video.dblbuf = " << (video.dblbuf ? "on" : "off") << ';' << std::endl;
 108         out << "video.vsync = " << (video.vsync ? "on" : "off") << ';' << std::endl;
 109         out << "video.msaa = " << net.port << ';' << std::endl;
 110         out << "video.hud = " << (video.hud ? "on" : "off") << ';' << std::endl;
 111         out << "video.world = " << (video.world ? "on" : "off") << ';' << std::endl;
 112         out << "video.debug = " << (video.world ? "on" : "off") << ';' << std::endl;
 113 }
 114
 115
 116 HeadlessEnvironment::HeadlessEnvironment(const Config &config)
 117 : config(config)
 118 , loader(config.asset_path)
 119 , counter()
 120 , state() {
 121
 122 }
 123
 124 string HeadlessEnvironment::Config::GetWorldPath(const string &world_name) const {
 125         return save_path + "worlds/" + world_name + '/';
 126 }
 127
 128 string HeadlessEnvironment::Config::GetWorldPath(const string &world_name, const string &host_name) const {
 129         return save_path + "cache/" + host_name + '/' + world_name + '/';
 130 }
 131
 132 Environment::Environment(Window &win, const Config &config)
 133 : HeadlessEnvironment(config)
 134 , assets(loader)
 135 , audio()
 136 , viewport()
 137 , window(win)
 138 , keymap()
 139 , msg_state(*this) {
 140         viewport.Clear();
 141         window.Flip();
 142         keymap.LoadDefault();
 143
 144         string keys_path = config.save_path + "keys.conf";
 145         if (!is_file(keys_path)) {
 146                 std::ofstream file(keys_path);
 147                 keymap.Save(file);
 148         } else {
 149                 std::ifstream file(keys_path);
 150                 keymap.Load(file);
 151         }
 152 }
 153
 154 void Environment::ShowMessage(const char *msg) {
 155         cout << msg << endl;
 156         msg_state.SetMessage(msg);
 157         state.Push(&msg_state);
 158 }
 159
 160
 161 Runtime::Runtime() noexcept
 162 : name("blank")
 163 , mode(NORMAL)
 164 , target(STANDALONE)
 165 , n(0)
 166 , t(0)
 167 , config() {
 168
 169 }
 170
 171
 172 void Runtime::ReadArgs(int argc, const char *const *argv) {
 173         if (argc <= 0) return;
 174         name = argv[0];
 175
 176         bool options = true;
 177         bool error = false;
 178
 179         for (int i = 1; i < argc; ++i) {
 180                 const char *arg = argv[i];
 181                 if (!arg || arg[0] == '\0') {
 182                         cerr << "warning: found empty argument at position " << i << endl;
 183                         continue;
 184                 }
 185                 if (options && arg[0] == '-') {
 186                         if (arg[1] == '\0') {
 187                                 cerr << "warning: incomplete option list at position " << i << endl;
 188                         } else if (arg[1] == '-') {
 189                                 if (arg[2] == '\0') {
 190                                         // stopper
 191                                         options = false;
 192                                 } else {
 193                                         const char *param = arg + 2;
 194                                         // long option
 195                                         if (strcmp(param, "no-vsync") == 0) {
 196                                                 config.game.video.vsync = false;
 197                                         } else if (strcmp(param, "no-keyboard") == 0) {
 198                                                 config.game.input.keyboard = false;
 199                                         } else if (strcmp(param, "no-mouse") == 0) {
 200                                                 config.game.input.mouse = false;
 201                                         } else if (strcmp(param, "no-hud") == 0) {
 202                                                 config.game.video.hud = false;
 203                                         } else if (strcmp(param, "no-audio") == 0) {
 204                                                 config.game.audio.enabled = false;
 205                                         } else if (strcmp(param, "standalone") == 0) {
 206                                                 target = STANDALONE;
 207                                         } else if (strcmp(param, "server") == 0) {
 208                                                 target = SERVER;
 209                                         } else if (strcmp(param, "client") == 0) {
 210                                                 target = CLIENT;
 211                                         } else if (strcmp(param, "asset-path") == 0) {
 212                                                 ++i;
 213                                                 if (i >= argc || argv[i] == nullptr || argv[i][0] == '\0') {
 214                                                         cerr << "missing argument to --asset-path" << endl;
 215                                                         error = true;
 216                                                 } else {
 217                                                         config.env.asset_path = argv[i];
 218                                                 }
 219                                         } else if (strcmp(param, "host") == 0) {
 220                                                 ++i;
 221                                                 if (i >= argc || argv[i] == nullptr || argv[i][0] == '\0') {
 222                                                         cerr << "missing argument to --host" << endl;
 223                                                         error = true;
 224                                                 } else {
 225                                                         config.game.net.host = argv[i];
 226                                                 }
 227                                         } else if (strcmp(param, "port") == 0) {
 228                                                 ++i;
 229                                                 if (i >= argc || argv[i] == nullptr || argv[i][0] == '\0') {
 230                                                         cerr << "missing argument to --port" << endl;
 231                                                         error = true;
 232                                                 } else {
 233                                                         config.game.net.port = strtoul(argv[i], nullptr, 10);
 234                                                 }
 235                                         } else if (strcmp(param, "player-name") == 0) {
 236                                                 ++i;
 237                                                 if (i >= argc || argv[i] == nullptr || argv[i][0] == '\0') {
 238                                                         cerr << "missing argument to --player-name" << endl;
 239                                                         error = true;
 240                                                 } else {
 241                                                         config.game.player.name = argv[i];
 242                                                 }
 243                                         } else if (strcmp(param, "save-path") == 0) {
 244                                                 ++i;
 245                                                 if (i >= argc || argv[i] == nullptr || argv[i][0] == '\0') {
 246                                                         cerr << "missing argument to --save-path" << endl;
 247                                                         error = true;
 248                                                 } else {
 249                                                         config.env.save_path = argv[i];
 250                                                 }
 251                                         } else if (strcmp(param, "world-name") == 0) {
 252                                                 ++i;
 253                                                 if (i >= argc || argv[i] == nullptr || argv[i][0] == '\0') {
 254                                                         cerr << "missing argument to --world-name" << endl;
 255                                                         error = true;
 256                                                 } else {
 257                                                         config.world.name = argv[i];
 258                                                 }
 259                                         } else {
 260                                                 cerr << "unknown option " << arg << endl;
 261                                                 error = true;
 262                                         }
 263                                 }
 264                         } else {
 265                                 // short options
 266                                 for (int j = 1; arg[j] != '\0'; ++j) {
 267                                         switch (arg[j]) {
 268                                                 case 'd':
 269                                                         config.game.video.dblbuf = false;
 270                                                         break;
 271                                                 case 'm':
 272                                                         ++i;
 273                                                         if (i >= argc || argv[i] == nullptr || argv[i][0] == '\0') {
 274                                                                 cerr << "missing argument to -m" << endl;
 275                                                                 error = true;
 276                                                         } else {
 277                                                                 config.game.video.msaa = strtoul(argv[i], nullptr, 10);
 278                                                         }
 279                                                         break;
 280                                                 case 'n':
 281                                                         ++i;
 282                                                         if (i >= argc || argv[i] == nullptr || argv[i][0] == '\0') {
 283                                                                 cerr << "missing argument to -n" << endl;
 284                                                                 error = true;
 285                                                         } else {
 286                                                                 n = strtoul(argv[i], nullptr, 10);
 287                                                         }
 288                                                         break;
 289                                                 case 's':
 290                                                         ++i;
 291                                                         if (i >= argc || argv[i] == nullptr || argv[i][0] == '\0') {
 292                                                                 cerr << "missing argument to -s" << endl;
 293                                                                 error = true;
 294                                                         } else {
 295                                                                 config.gen.seed = strtoul(argv[i], nullptr, 10);
 296                                                         }
 297                                                         break;
 298                                                 case 't':
 299                                                         ++i;
 300                                                         if (i >= argc || argv[i] == nullptr || argv[i][0] == '\0') {
 301                                                                 cerr << "missing argument to -t" << endl;
 302                                                                 error = true;
 303                                                         } else {
 304                                                                 t = strtoul(argv[i], nullptr, 10);
 305                                                         }
 306                                                         break;
 307                                                 case '-':
 308                                                         // stopper
 309                                                         options = false;
 310                                                         break;
 311                                                 default:
 312                                                         cerr << "unknown option " << arg[j] << endl;
 313                                                         error = true;
 314                                                         break;
 315                                         }
 316                                 }
 317                         }
 318                 } else {
 319                         cerr << "unable to interpret argument "
 320                                 << i << " (" << arg << ")" << endl;
 321                         error = true;
 322                 }
 323         }
 324
 325         if (error) {
 326                 mode = ERROR;
 327                 return;
 328         }
 329
 330         if (config.env.asset_path.empty()) {
 331                 config.env.asset_path = default_asset_path();
 332         } else if (
 333                 config.env.asset_path[config.env.asset_path.size() - 1] != '/' &&
 334                 config.env.asset_path[config.env.asset_path.size() - 1] != '\\'
 335         ) {
 336                 config.env.asset_path += '/';
 337         }
 338         if (config.env.save_path.empty()) {
 339                 config.env.save_path = default_save_path();
 340         } else if (
 341                 config.env.save_path[config.env.save_path.size() - 1] != '/' &&
 342                 config.env.save_path[config.env.save_path.size() - 1] != '\\'
 343         ) {
 344                 config.env.save_path += '/';
 345         }
 346
 347         if (n > 0) {
 348                 if (t > 0) {
 349                         mode = FIXED_FRAME_LIMIT;
 350                 } else {
 351                         mode = FRAME_LIMIT;
 352                 }
 353         } else if (t > 0) {
 354                 mode = TIME_LIMIT;
 355         } else {
 356                 mode = NORMAL;
 357         }
 358 }
 359
 360 int Runtime::Execute() {
 361         if (mode == ERROR) {
 362                 return 1;
 363         }
 364
 365         InitHeadless init_headless;
 366
 367         switch (target) {
 368                 default:
 369                 case STANDALONE:
 370                         RunStandalone();
 371                         break;
 372                 case SERVER:
 373                         RunServer();
 374                         break;
 375                 case CLIENT:
 376                         RunClient();
 377                         break;
 378         }
 379
 380         return 0;
 381 }
 382
 383 void Runtime::RunStandalone() {
 384         Init init(config.game.video.dblbuf, config.game.video.msaa);
 385
 386         Environment env(init.window, config.env);
 387         env.viewport.VSync(config.game.video.vsync);
 388
 389         WorldSave save(config.env.GetWorldPath(config.world.name));
 390         if (save.Exists()) {
 391                 save.Read(config.world);
 392                 save.Read(config.gen);
 393         } else {
 394                 save.Write(config.world);
 395                 save.Write(config.gen);
 396         }
 397
 398         Application app(env);
 399         standalone::MasterState world_state(env, config.game, config.gen, config.world, save);
 400         app.PushState(&world_state);
 401         Run(app);
 402 }
 403
 404 void Runtime::RunServer() {
 405         HeadlessEnvironment env(config.env);
 406
 407         WorldSave save(config.env.GetWorldPath(config.world.name));
 408         if (save.Exists()) {
 409                 save.Read(config.world);
 410                 save.Read(config.gen);
 411         } else {
 412                 save.Write(config.world);
 413                 save.Write(config.gen);
 414         }
 415
 416         HeadlessApplication app(env);
 417         server::ServerState server_state(env, config.gen, config.world, save, config.game);
 418         app.PushState(&server_state);
 419         Run(app);
 420 }
 421
 422 void Runtime::RunClient() {
 423         Init init(config.game.video.dblbuf, config.game.video.msaa);
 424
 425         Environment env(init.window, config.env);
 426         env.viewport.VSync(config.game.video.vsync);
 427
 428         Application app(env);
 429         client::MasterState client_state(env, config.game, config.world);
 430         app.PushState(&client_state);
 431         Run(app);
 432 }
 433
 434 void Runtime::Run(HeadlessApplication &app) {
 435         switch (mode) {
 436                 default:
 437                 case NORMAL:
 438                         app.Run();
 439                         break;
 440                 case FRAME_LIMIT:
 441                         app.RunN(n);
 442                         break;
 443                 case TIME_LIMIT:
 444                         app.RunT(t);
 445                         break;
 446                 case FIXED_FRAME_LIMIT:
 447                         app.RunS(n, t);
 448                         break;
 449         }
 450 }
 451
 452 }