323 lines
11 KiB
C++
323 lines
11 KiB
C++
#include <cstdio>
|
|
#include <memory>
|
|
#include <sstream>
|
|
#include <thread>
|
|
#include <chrono>
|
|
|
|
#include "gfx/types.h"
|
|
#include "net/constants.h"
|
|
#include "net/message_protocol.h"
|
|
#include "client_network.h"
|
|
#include "network_manager.h"
|
|
#include "game_state.h"
|
|
#include "terminal.h"
|
|
#include "ui/desktop.h"
|
|
#include "ui/i_window_content.h"
|
|
#include "ui/ui_window.h"
|
|
#include "ui/editor.h"
|
|
#include "ui/login_screen.h"
|
|
#include <SDL3/SDL_events.h>
|
|
#include <ui/main_menu.h>
|
|
#include <ui/boot_sequence.h>
|
|
#include "debug/debug_overlay.h"
|
|
|
|
void GameState::_init_desktop(void) {
|
|
_desktop = std::make_unique<Desktop>(_screen_width, _screen_height, this);
|
|
|
|
auto term = std::make_unique<Terminal>(this);
|
|
auto term_window = std::make_unique<UIWindow>("Terminal", 100, 100, 800, 500);
|
|
term_window->set_content(std::move(term));
|
|
_desktop->add_window(std::move(term_window));
|
|
}
|
|
|
|
void GameState::_run_server(void) {
|
|
try {
|
|
NetworkManager server("bettola_sp.db");
|
|
server.start(SINGLE_PLAYER_PORT);
|
|
/*
|
|
* Server's start() method is non-blocking, but NetworkManager
|
|
* object must be kept alive. We'll just loop forever and let the OS
|
|
* clean up the thread when main exits ;)
|
|
*/
|
|
while(true) {
|
|
std::this_thread::sleep_for(std::chrono::seconds(5));
|
|
}
|
|
} catch(const std::exception& e) {
|
|
fprintf(stderr, "Single-player server thread exception: %s\n", e.what());
|
|
}
|
|
}
|
|
|
|
GameState::GameState(void) :
|
|
_current_screen(Screen::MAIN_MENU),
|
|
_screen_width(0),
|
|
_screen_height(0),
|
|
_is_single_player(false),
|
|
_show_debug_overlay(false) {_debug_overlay = std::make_unique<DebugOverlay>();}
|
|
|
|
GameState::~GameState(void) = default;
|
|
|
|
void GameState::init(int screen_width, int screen_height) {
|
|
_screen_width = screen_width;
|
|
_screen_height = screen_height;
|
|
/* Create and connect the network client. */
|
|
_network = std::make_unique<ClientNetwork>();
|
|
|
|
_main_menu = std::make_unique<MainMenu>(screen_width, screen_height);
|
|
}
|
|
|
|
void GameState::start_single_player_now(int screen_width, int screen_height) {
|
|
_is_single_player = true;
|
|
_screen_width = screen_width;
|
|
_screen_height = screen_height;
|
|
fprintf(stdout, "Starting in single-player mode...\n");
|
|
std::thread server_thread(&GameState::_run_server, this);
|
|
server_thread.detach();
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(200));
|
|
|
|
_network = std::make_unique<ClientNetwork>();
|
|
if(!_network->connect("127.0.0.1", SINGLE_PLAYER_PORT)) {
|
|
/* TODO: Handle connection failure. */
|
|
}
|
|
_current_screen = Screen::DESKTOP;
|
|
_init_desktop();
|
|
}
|
|
|
|
void GameState::handle_event(SDL_Event* event, int screen_width, int screen_height) {
|
|
if(event->type == SDL_EVENT_KEY_DOWN && event->key.key == SDLK_D &&
|
|
(event->key.mod & SDL_KMOD_CTRL)) {
|
|
_show_debug_overlay = !_show_debug_overlay;
|
|
return; /* Consume the event. */
|
|
}
|
|
switch(_current_screen) {
|
|
case Screen::MAIN_MENU:
|
|
if(_main_menu) {
|
|
_main_menu->handle_event(event);
|
|
}
|
|
break;
|
|
case Screen::LOGIN:
|
|
if(_login_screen) {
|
|
_login_screen->handle_event(event);
|
|
}
|
|
break;
|
|
case Screen::BOOTING:
|
|
/* TODO: */
|
|
break;
|
|
case Screen::DESKTOP:
|
|
if(_desktop) {
|
|
_desktop->handle_event(event, screen_width, screen_height);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
void GameState::update(float dt, int draw_calls, int shape_verts, int text_verts) {
|
|
_debug_overlay->update(dt, draw_calls, shape_verts, text_verts);
|
|
switch(_current_screen) {
|
|
case Screen::MAIN_MENU: {
|
|
if(!_main_menu) break;
|
|
Screen next_screen = _main_menu->update(dt);
|
|
if(next_screen != Screen::MAIN_MENU) {
|
|
const MenuButton* clicked_button = _main_menu->get_clicked_button();
|
|
if(clicked_button) {
|
|
_is_single_player = clicked_button->is_single_player;
|
|
}
|
|
_current_screen = next_screen;
|
|
_main_menu.reset(); /* Free mem. */
|
|
|
|
if(_current_screen == Screen::LOGIN) {
|
|
/* Connect to server. */
|
|
if(_is_single_player) {
|
|
fprintf(stdout, "Starting in single-player mode...\n");
|
|
std::thread server_thread(&GameState::_run_server, this);
|
|
server_thread.detach();
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(200));
|
|
if(!_network->connect("127.0.0.1", SINGLE_PLAYER_PORT)) {
|
|
/* TODO: Handle connection failure. */
|
|
}
|
|
} else {
|
|
if(!_network->connect("127.0.0.1", MULTIPLAYER_PORT)) {
|
|
/* TODO: Handle connection failure. */
|
|
}
|
|
}
|
|
_login_screen = std::make_unique<LoginScreen>(_screen_width, _screen_height);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case Screen::LOGIN: {
|
|
if(_login_screen && _login_screen->is_login_attempted()) {
|
|
std::string username = _login_screen->get_username();
|
|
std::string password = _login_screen->get_password();
|
|
|
|
if(_login_screen->is_new_account_mode()) {
|
|
std::string hostname = _login_screen->get_hostname();
|
|
_network->send(net_protocol::build_message(net_protocol::Opcode::C2S_CREATE_ACCOUNT,
|
|
{username, password, hostname}));
|
|
} else {
|
|
_network->send(net_protocol::build_message(net_protocol::Opcode::C2S_LOGIN,
|
|
{username, password}));
|
|
}
|
|
_login_screen->clear_login_attempt(); /* Try to spam my server now b.tch! */
|
|
}
|
|
|
|
/* Check for server response to our login attempt. */
|
|
std::string server_msg;
|
|
while(_network->poll_message(server_msg)) {
|
|
net_protocol::Opcode opcode;
|
|
std::vector<std::string> args;
|
|
net_protocol::parse_message(server_msg, opcode, args);
|
|
|
|
switch(opcode) {
|
|
case net_protocol::Opcode::S2C_LOGIN_SUCCESS:
|
|
case net_protocol::Opcode::S2C_CREATE_ACCOUNT_SUCCESS:
|
|
_current_screen = Screen::BOOTING;
|
|
_login_screen.reset(); /* Free mem. */
|
|
_boot_sequence = std::make_unique<BootSequence>();
|
|
break;
|
|
case net_protocol::Opcode::S2C_LOGIN_FAIL:
|
|
_login_screen->set_error_message(args.empty() ? "Login failed." : args[0]);
|
|
break;
|
|
case net_protocol::Opcode::S2C_CREATE_ACCOUNT_FAIL:
|
|
_login_screen->set_error_message(args.empty() ? "Account creation failed." :
|
|
args[0]);
|
|
break;
|
|
default:
|
|
fprintf(stderr, "Recieved unexpected opcode %d during login.\n",
|
|
static_cast<int>(opcode));
|
|
break;
|
|
}
|
|
/* If we successfully changed screen, stop processing messages for this frame. */
|
|
if(_current_screen == Screen::BOOTING) {
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case Screen::BOOTING: {
|
|
if(!_boot_sequence) break; /* Shouldn't happen. */
|
|
if(_boot_sequence->is_finished()) {
|
|
_current_screen = Screen::DESKTOP;
|
|
_init_desktop();
|
|
_boot_sequence.reset(); /* Free mem. */
|
|
}
|
|
break;
|
|
}
|
|
case Screen::DESKTOP: {
|
|
std::string server_msg;
|
|
while(_network->poll_message(server_msg)) {
|
|
net_protocol::Opcode opcode;
|
|
std::vector<std::string> args;
|
|
net_protocol::parse_message(server_msg, opcode, args);
|
|
|
|
switch(opcode) {
|
|
case net_protocol::Opcode::S2C_FILE_DATA:
|
|
if(args.size() == 2) {
|
|
auto editor = std::make_unique<Editor>(args[0]);
|
|
editor->set_buffer_content(args[1]);
|
|
auto editor_window = std::make_unique<UIWindow>(args[0].c_str(),
|
|
200, 200, 600, 400);
|
|
editor_window->set_content(std::move(editor));
|
|
_desktop->add_window(std::move(editor_window));
|
|
}
|
|
break;
|
|
case net_protocol::Opcode::S2C_DISCONNECT: {
|
|
IWindowContent* content = _desktop->get_focused_window() ?
|
|
_desktop->get_focused_window()->get_content() : nullptr;
|
|
Terminal* terminal = dynamic_cast<Terminal*>(content);
|
|
|
|
if(terminal) {
|
|
terminal->add_history("Connection closed.");
|
|
}
|
|
}
|
|
break;
|
|
case net_protocol::Opcode::S2C_CLOSE_WINDOW: {
|
|
if(_desktop) {
|
|
UIWindow* focused_window = _desktop->get_focused_window();
|
|
if(focused_window) { focused_window->close(); }
|
|
}
|
|
}
|
|
break;
|
|
case net_protocol::Opcode::S2C_COMMAND_RESPONSE: {
|
|
if(!args.empty()) {
|
|
IWindowContent* content = _desktop->get_focused_window() ?
|
|
_desktop->get_focused_window()->get_content() : nullptr;
|
|
Terminal* terminal = dynamic_cast<Terminal*>(content);
|
|
if(!terminal) continue;
|
|
|
|
/* Server sends "output\nprompt", split them. */
|
|
size_t last_newline = args[0].find_last_of('\n');
|
|
if(last_newline != std::string::npos) {
|
|
std::string prompt = args[0].substr(last_newline+1);
|
|
terminal->set_prompt(prompt);
|
|
|
|
std::string output = args[0].substr(0, last_newline);
|
|
if(!output.empty()) {
|
|
/* Split multiline output and push each line to history. */
|
|
std::stringstream ss(output);
|
|
std::string line;
|
|
while(std::getline(ss, line, '\n')) {
|
|
terminal->add_history(line);
|
|
}
|
|
}
|
|
} else {
|
|
terminal->add_history(args[0]);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if(_desktop) {
|
|
_desktop->update(dt, _screen_width, _screen_height);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void GameState::send_network_command(const std::string& command) {
|
|
if(_network && _network->is_connected()) {
|
|
_network->send(net_protocol::build_message(net_protocol::Opcode::C2S_COMMAND,
|
|
{command}));
|
|
}
|
|
}
|
|
|
|
void GameState::render(const RenderContext& context) {
|
|
switch(_current_screen) {
|
|
case Screen::MAIN_MENU:
|
|
if(_main_menu) {
|
|
_main_menu->render(context.ui_renderer);
|
|
}
|
|
break;
|
|
case Screen::LOGIN:
|
|
if(_login_screen) {
|
|
_login_screen->render(context);
|
|
}
|
|
break;
|
|
case Screen::BOOTING:
|
|
if(_boot_sequence) {
|
|
_boot_sequence->render(context.ui_renderer);
|
|
}
|
|
break;
|
|
case Screen::DESKTOP:
|
|
if(_desktop) {
|
|
_desktop->render(context);
|
|
}
|
|
break;
|
|
}
|
|
|
|
if(_show_debug_overlay) {
|
|
_debug_overlay->render(context.ui_renderer);
|
|
}
|
|
}
|
|
|
|
void GameState::send_file_write_request(const std::string& path, const std::string& content) {
|
|
_network->send(net_protocol::build_message(net_protocol::Opcode::C2S_WRITE_FILE,
|
|
{path, content}));
|
|
}
|
|
|
|
void GameState::send_file_read_request(const std::string& path) {
|
|
_network->send(net_protocol::build_message(net_protocol::Opcode::C2S_READ_FILE,
|
|
{path}));
|
|
}
|