debugger.hpp

Go to the documentation of this file.

#pragma once
#include "server/game/servergamestate.hpp"
#include "server/game/constants.hpp"
 
const std::string NO_SHORTHAND = "NO_SHORTHAND";
 
class Command {
public:
    std::string name;
 
    std::string shorthand;
 
    virtual void run(std::vector<std::string> arguments, ServerGameState& state) = 0;
};
 
//  Vector of all commands known by the debugger
extern std::vector<Command*> commands;
 
//  Hashmap of string names / shorthands -> Command references (used for command
//  lookup)
extern std::unordered_map<std::string, Command&> command_map;
 
void initialize_commands(std::vector<Command*>& commands);
 
void free_commands(const std::vector<Command*>& commands);
 
//  Debugger Commands
 
class QuitCommand : public Command {
public:
    QuitCommand() {
        this->name = "quit";
        this->shorthand = "q";
    }
 
    void run(std::vector<std::string> arguments, ServerGameState& state) override { //cppcheck-suppress passedByValue
        //  This command ignores arguments
        std::cout << "Quitting gsdb..." << std::endl;
 
        free_commands(commands);
        exit(0);
    }
};
 
class StepCommand : public Command {
public:
    StepCommand() {
        this->name = "step";
        this->shorthand = "s";
        //this->num_expected_args = 0;
    }
 
    void run(std::vector<std::string> arguments, ServerGameState& state) override { // cppcheck-suppress passedByValue
        //  Possible variations:
        //  step - call GameState::update() once on the given state instance.
        //  step n - call update() n times.
 
        //  TODO: Figure out how to incorporate clientside events to the 
        //  debugger (perhaps this can be simulated by sending events via the 
        //  command line which would be handled by the ServerGameState when the
        //  StepCommand is called by the debugger user)
        //  For now, just pass in an empty EventList
        EventList incoming_events;
 
        if (arguments.size() == 1) {
            //  step variation
            //  Update to the next timestep
            state.update(incoming_events);
            std::cout << "Current timestep: " << state.getTimestep() << std::endl;
        }
        else if (arguments.size() == 2) {
            //  step n variation
 
            //  Verify that second argument is an integer
            unsigned int n;
            try {
                n = std::stoi(arguments.at(1));
            }
            catch (...) {
                std::cout << "Error: invalid argument for 'step' command - expected an integer.\n";
                return;
            }
 
            //  Call update() n times
            for (unsigned int i = 0; i < n; i++) {
                state.update(incoming_events);
            }
 
            std::cout << "Called update() " << arguments.at(1) << " times." << std::endl;
            std::cout << "Current timestep: " << state.getTimestep() << std::endl;
        }
        else {
            std::cout << "Error: Incorrect number of arguments for 'step' command.\n";
        }
    }
};
 
class StateCommand : public Command {
public:
    StateCommand() {
        this->name = "state";
        this->shorthand = NO_SHORTHAND;
    }
 
    void run(std::vector<std::string> arguments, ServerGameState& state) override { // cppcheck-suppress passedByValue
        //  This command ignores arguments
 
        //  Print GameState instance' state
        std::cout << state.to_string() << std::endl;
    }
};
 
class PrintCommand : public Command {
public:
    PrintCommand() {
        this->name = "print";
        this->shorthand = "p";
    }
 
    void run(std::vector<std::string> arguments, ServerGameState& state) override { //cppcheck-suppress passedByValue
        //  Variations:
        //  print [global id number] - print state of object with given id
        //  print [global id number] [property] - print state of given property
 
        if (arguments.size() == 1) {
            std::cout << "Error: Incorrect number of arguments for 'print' command\n";
        }
        else if (arguments.size() >= 2 && arguments.size() < 4) {
            //  print [global id number]
            //  Verify that second argument is an integer
            unsigned int id;
            try {
                id = std::stoi(arguments.at(1));
            }
            catch (...) {
                std::cout << "Error: invalid argument for 'print' command - expected an integer.\n";
                return;
            }
 
            Object* object = state.objects.getObject(id);
 
            if (object == nullptr) {
                std::cout << "No object with id " << arguments.at(1) << " exists.\n";
                return;
            }
 
            if (arguments.size() == 2) {
                //  Print entire object state
                std::cout << object->to_string() << std::endl;
            }
            else if (arguments.size() == 3) {
                //  print [global id number] [property]
 
                //  Attempt to print object's given property (must be a better
                //  way to do this)
                std::string property = arguments.at(2);
 
                if (property.compare("globalID") == 0) {
                    std::cout << object->globalID << std::endl;
                }
                else if (property.compare("typeID") == 0) {
                    std::cout << object->typeID << std::endl;
                }
                else if (property.compare("type") == 0) {
                    std::cout << objectTypeString(object->type) << std::endl;
                }
                else if (property.compare("physics") == 0) {
                    std::cout << object->physics.to_string() << std::endl;
                }
                else if (property.compare("physics.movable") == 0) {
                    std::cout << (object->physics.movable ? "true" : "false") << std::endl;
                }
                else if (property.compare("physics.velocity") == 0) {
                    std::cout << glm::to_string(object->physics.velocity) << std::endl;
                }
                else if (property.compare("physics.acceleration") == 0) {
                    std::cout << glm::to_string(object->physics.velocityMultiplier) << std::endl;
                }
                else if (property.compare("physics.shared.facing") == 0) {
                    std::cout << glm::to_string(object->physics.shared.facing) << std::endl;
                }
                else {
                    std::cout << "Error: Didn't recognize object property '" << property << "'.\n";
                }
            }
        }
        else {
            std::cout << "Error: Incorrect number of arguments for 'print' command.\n";
        }
    }
};
 
class HelpCommand : public Command {
public:
    HelpCommand() {
        this->name = "help";
        this->shorthand = NO_SHORTHAND;
    }
 
    void run(std::vector<std::string> arguments, ServerGameState& state) override { //cppcheck-suppress passedByValue
        //  This command ignores arguments (though it may make sense to have
        //  command descriptors, e.g. help step -> "the step command does ..."
 
        std::cout << "The GameState Debugger understands the following commands:\n";
 
        for (Command* command : commands) {
            std::cout << command->name;
 
            if (command->shorthand.compare(NO_SHORTHAND) != 0)
                std::cout << " (" << command->shorthand << ")";
 
            std::cout << std::endl;
        }
    }
};
 
class CreateCommand : public Command {
public:
    CreateCommand() {
        this->name = "create";
        this->shorthand = "c";
    }
 
    void run(std::vector<std::string> arguments, ServerGameState& state) override { // cppcheck-suppress passedByValue
        //  This command ignores arguments
 
        //  Create a new base object in the game state
        //SpecificID typeID = state.objects.createObject(ObjectType::Object);
        SpecificID typeID = state.objects.createObject(new Object(ObjectType::Object,
            Physics(true, Collider::None, glm::vec3(0, 0, 0), glm::vec3(0, 1, 0), Object::models.find(ModelType::Cube)->second),
            ModelType::Cube));
        Object* obj = state.objects.getBaseObject(typeID);
 
        std::cout << "Created new object (global id " << obj->globalID << ")" << std::endl;
    }
};
 
class DeleteCommand : public Command {
public:
    DeleteCommand() {
        this->name = "delete";
        this->shorthand = "d";
    }
 
    void run(std::vector<std::string> arguments, ServerGameState& state) override { // cppcheck-suppress passedByValue
        //  delete [object global id]
        if (arguments.size() != 2) {
            std::cout << "Error: Incorrect number of arguments for 'delete' command.\n";
            return;
        }
 
        //  Get global id argument
        EntityID id;
        try {
            id = (EntityID) std::stoi(arguments.at(1));
        }
        catch (...) {
            std::cout << "Error: invalid argument for 'delete' command - expected an integer.\n";
            return;
        }
 
        //  Attempt to remove object with the given id
        bool success = state.objects.removeObject(id);
 
        if (success) {
            std::cout << "Deleted object (global id " << id << ")" << std::endl;
        }
        else {
            std::cout << "Failed to delete object (global id " << id << ") - object does not exist.\n";
        }
    }
};
 
class SetCommand : public Command {
public:
    SetCommand() {
        this->name = "set";
        this->shorthand = NO_SHORTHAND;
    }
 
    void run(std::vector<std::string> arguments, ServerGameState& state) override { //cppcheck-suppress passedByValue
        //  set [object global id] [property] [new value]
        if (arguments.size() != 4) {
            std::cout << "Error: Incorrect number of arguments for 'set' command.\n";
            return;
        }
 
        //  Get global id argument
        unsigned int id;
        try {
            id = std::stoi(arguments.at(1));
        }
        catch (...) {
            std::cout << "Error: invalid argument for 'set' command - expected an integer.\n";
            return;
        }
 
        //  Get property
        std::string property = arguments.at(2);
 
        //  Get new value
        int value;
        try {
            value = std::stoi(arguments.at(3));
        }
        catch (...) {
            std::cout << "Error: invalid argument for 'set' command - expected an integer.\n";
            return;
        }
 
        //  Try to get object
        Object* obj = state.objects.getObject(id);
 
        if (obj == nullptr) {
            std::cout << "No object with global id " << id << " exists.\n";
            return;
        }
 
        //  Set property
        else if (property.compare("physics.velocity.x") == 0) {
            obj->physics.velocity.x = value;
            std::cout << "Set object (global id " << id << ") velocity.x to " << value << ".\n";
        }
        else if (property.compare("physics.velocity.y") == 0) {
            obj->physics.velocity.y = value;
            std::cout << "Set object (global id " << id << ") velocity.y to " << value << ".\n";
        }
        else if (property.compare("physics.velocity.z") == 0) {
            obj->physics.velocity.z = value;
            std::cout << "Set object (global id " << id << ") velocity.z to " << value << ".\n";
        }
        else if (property.compare("physics.acceleration.x") == 0) {
            obj->physics.velocityMultiplier.x = value;
            std::cout << "Set object (global id " << id << ") acceleration.x to " << value << ".\n";
        }
        else if (property.compare("physics.acceleration.y") == 0) {
            obj->physics.velocityMultiplier.y = value;
            std::cout << "Set object (global id " << id << ") acceleration.y to " << value << ".\n";
        }
        else if (property.compare("physics.acceleration.z") == 0) {
            obj->physics.velocityMultiplier.z = value;
            std::cout << "Set object (global id " << id << ") acceleration.z to " << value << ".\n";
        }
        else {
            std::cout << "Error: Didn't recognize object property '" << property << "'.\n";
        }
    }
};
 
//  Utility Functions for Debugger Parsing
 
std::vector<std::string> get_string_tokens(std::string input, char delimeter);
 
void initialize_command_map(std::unordered_map<std::string, Command&>& command_map, const std::vector<Command*>& commands);