SteamID.cpp

#include "SteamID.hpp"

SteamID::SteamID(const std::string &id) {
    if (id.empty()) {
        this->universe = UNIVERSE_INVALID;
        this->type = TYPE_INVALID;
        this->instance = INSTANCE_ALL;
        this->accountId = 0;
        return;
    }

    // check if steam2 rendered
    std::regex patternSteam2("^STEAM_([0-5]):([0-1]):([0-9]+)$");
    std::smatch matches;
    if (std::regex_search(id, matches, patternSteam2)) {
        if (matches.size() < 4) {
            return;
        }
        // matches[0]: full steam id
        // matches[1]: universe type
        // matches[2]: instance type
        // matches[3]: account id
        try {
            int _universe = std::stoi(matches[1].str());
            int _instance = std::stoi(matches[2].str());
            int _account = std::stoi(matches[3].str());

            this->universe = _universe;
            if (_universe <= UNIVERSE_PUBLIC) {
                this->universe = UNIVERSE_PUBLIC;
            }

            this->type = TYPE_INDIVIDUAL;
            this->instance = INSTANCE_DESKTOP;
            this->accountId = _account * 2 + _instance;
        } catch (const std::exception &e) {
            // throw a custom exception?
            throw std::invalid_argument("invalid steam id");
        }

        return;
    }

    // check if steam3 rendered
    std::regex patternSteam3("^\\[([a-zA-Z]):([0-5]):([0-9]+)(:[0-9]+)?\\]$");
    if (std::regex_search(id, matches, patternSteam3)) {
        if (matches.size() < 5) {
            return;
        }
        // matches[0]: full steam id
        // matches[1]: type char
        // matches[2]: universe type
        // matches[3]: account id
        // matches[4]: instance type
        try {
            int _universe = std::stoi(matches[2].str());
            std::string _typeChar = matches[1].str();
            int _account = std::stoi(matches[3].str());
            std::string _instance = matches[4].str();

            this->universe = _universe;
            this->accountId = _account;
            if (!_instance.empty()) {
                std::string instanceStr = _instance.substr(1);
                this->instance = std::stoi(instanceStr);
            } else {
                this->instance = INSTANCE_DESKTOP;
                if (_typeChar == "g" || _typeChar == "T" || _typeChar == "c" || _typeChar == "L") {
                    this->instance = INSTANCE_ALL;
                }
            }

            if (_typeChar == "c") {
                this->instance |= CHAT_INSTANCE_FLAG_CLAN;
                this->type = TYPE_CHAT;
            } else if (_typeChar == "L") {
                this->instance |= CHAT_INSTANCE_FLAG_LOBBY;
                this->type = TYPE_CHAT;
            } else {
                this->type = getTypeFromChar(_typeChar[0]);
            }

        } catch (const std::exception &e) {
            // throw a custom exception?
            throw std::invalid_argument("invalid steam id");
        }

        return;
    }

    //check if steam 64
    try {
        long long _id = std::stoll(id);
        this->universe = static_cast<int>(_id >> 56);
        this->type = static_cast<int>((_id >> 52) & 0xF);
        this->instance = static_cast<int>((_id >> 32) & 0xFFFFF);
        this->accountId = _id & 0xFFFFFFFF;
    } catch (const std::exception &e) {
        throw std::invalid_argument("invalid steam id");
    }
}

std::string SteamID::getIdSteam2Rendered(bool newerFormat = false) const {
    if (this->type != TYPE_INDIVIDUAL) {
        throw std::runtime_error("Can't get Steam2 rendered ID for non-individual ID");
    }

    long long _universe = this->universe;
    if (_universe == 1 && !newerFormat) {
        _universe = 0;
    }

    std::string steam2;
    steam2.append("STEAM_")
            .append(std::to_string(_universe))
            .append(":")
            .append(std::to_string((this->accountId & 1)))
            .append(":")
            .append(std::to_string((int) (this->accountId / 2)));

    return steam2;
}

std::string SteamID::getIdSteam3Rendered() const {
    char typeChar = getCharFromType(this->type) != '\0' ? getCharFromType(this->type) : 'i';
    if (this->instance & CHAT_INSTANCE_FLAG_LOBBY) {
        typeChar = 'c';
    } else if (this->instance & CHAT_INSTANCE_FLAG_LOBBY) {
        typeChar = 'L';
    }

    bool renderInstance = (this->type == TYPE_ANON_GAMESERVER || this->type == TYPE_MULTISEAT ||
                           (this->type == TYPE_INDIVIDUAL && this->instance != INSTANCE_DESKTOP));
    std::string steam3;
    steam3.append("[")
            .append(std::string(1, typeChar))
            .append(":")
            .append(std::to_string(this->universe))
            .append(":")
            .append(std::to_string(this->accountId));

    if (renderInstance) {
        steam3.append(":");
        steam3.append(std::to_string(this->instance));
    }
    steam3.append("]");

    return steam3;
}

long long SteamID::getIdSteam64() const {
    return ((this->universe << 56) | (this->type << 52) | (this->instance << 32) | (this->accountId));
}

int SteamID::getTypeFromChar(char c) {
    const char typeChars[] = {'I', 'U', 'M', 'G', 'A', 'P', 'C', 'g', 'T', 'a'};
    for (int i = 0; i < sizeof typeChars; i++) {
        if (c == typeChars[i]) {
            return i;
        }
    }
    return TYPE_INVALID;
}

char SteamID::getCharFromType(long long t) {
    const char typeChars[] = {'I', 'U', 'M', 'G', 'A', 'P', 'C', 'g', 'T', 'a'};
    if (t < 0 || t > sizeof typeChars) {
        return '\0';
    }
    return typeChars[t];
}

bool SteamID::isValid() const {
    if (this->type <= TYPE_INVALID || this->type > TYPE_ANON_USER) {
        return false;
    }
    if (this->universe <= UNIVERSE_INVALID || this->universe > UNIVERSE_DEV) {
        return false;
    }
    if (this->type == TYPE_INDIVIDUAL && (this->accountId == 0 || this->instance > INSTANCE_WEB)) {
        return false;
    }
    if (this->type == TYPE_CLAN && (this->accountId == 0 || this->instance != INSTANCE_ALL)) {
        return false;
    }
    if (this->type == TYPE_GAMESERVER && this->accountId == 0) {
        return false;
    }

    return true;
}

bool SteamID::isClanChat() const {
    return this->type == TYPE_CHAT && (this->instance & CHAT_INSTANCE_FLAG_CLAN);
}

bool SteamID::isLobbyChat() const {
    return this->type == TYPE_CHAT && (this->instance & CHAT_INSTANCE_FLAG_LOBBY);
}

bool SteamID::isMMSLobbyChat() const {
    return this->type == TYPE_CHAT && (this->instance & CHAT_INSTANCE_FLAG_MMSLOBBY);
}

long long SteamID::getAccountId() const {
    return this->accountId;
}