mirror of
https://github.com/edo9300/ygopro-core
synced 2026-08-25 16:23:07 -04:00
134 lines
3.3 KiB
C++
134 lines
3.3 KiB
C++
/*
|
|
* Copyright (c) 2010-2015, Argon Sun (Fluorohydride)
|
|
* Copyright (c) 2016-2025, Edoardo Lolletti (edo9300) <edoardo762@gmail.com>
|
|
*
|
|
* SPDX-License-Identifier: AGPL-3.0-or-later
|
|
*/
|
|
#ifndef DUEL_H_
|
|
#define DUEL_H_
|
|
|
|
#include <deque>
|
|
#include <set>
|
|
#include <unordered_map>
|
|
#include <unordered_set>
|
|
#include <utility> //std::forward
|
|
#include <vector>
|
|
#include "common.h"
|
|
#include "group.h"
|
|
#include "interpreter.h"
|
|
#include "lua_obj.h"
|
|
#include "ocgapi_types.h"
|
|
#include "RNG/Xoshiro256.hpp"
|
|
|
|
class card;
|
|
class effect;
|
|
class field;
|
|
struct loc_info;
|
|
|
|
struct card_data {
|
|
uint32_t code{};
|
|
uint32_t alias{};
|
|
std::set<uint16_t> setcodes;
|
|
uint32_t type{};
|
|
uint32_t level{};
|
|
uint32_t attribute{};
|
|
uint64_t race{};
|
|
int32_t attack{};
|
|
int32_t defense{};
|
|
uint32_t lscale{};
|
|
uint32_t rscale{};
|
|
uint32_t link_marker{};
|
|
card_data(const OCG_CardData& data);
|
|
card_data() = default;
|
|
};
|
|
|
|
class duel {
|
|
public:
|
|
class duel_message {
|
|
private:
|
|
template<typename T>
|
|
void write_internal(T data) {
|
|
write(&data, sizeof(T));
|
|
}
|
|
public:
|
|
std::vector<uint8_t> data;
|
|
explicit duel_message(uint8_t _message);
|
|
void write(const void* buff, size_t size);
|
|
void write(loc_info loc);
|
|
template<typename T, typename T2>
|
|
ForceInline void write(T2 data) {
|
|
write_internal<T>(static_cast<T>(data));
|
|
}
|
|
};
|
|
std::vector<uint8_t> buff;
|
|
std::vector<uint8_t> query_buffer;
|
|
field* game_field{};
|
|
interpreter* lua{};
|
|
std::unordered_set<card*> cards;
|
|
std::unordered_set<card*> assumes;
|
|
std::unordered_set<group*> groups;
|
|
std::unordered_set<effect*> effects;
|
|
std::unordered_set<effect*> uncopy;
|
|
|
|
std::unordered_map<uint32_t, card_data> data_cache;
|
|
|
|
enum class SCRIPT_LOAD_STATUS : uint8_t {
|
|
NOT_LOADED,
|
|
LOAD_SUCCEDED,
|
|
LOAD_FAILED,
|
|
LOADING,
|
|
};
|
|
|
|
std::unordered_map<uint32_t/* hashed string */, SCRIPT_LOAD_STATUS> loaded_scripts;
|
|
|
|
duel() = delete;
|
|
explicit duel(const OCG_DuelOptions& options, bool& valid_lua_lib);
|
|
~duel();
|
|
void clear();
|
|
|
|
card* new_card(uint32_t code);
|
|
template<typename... Args>
|
|
owned_lua<group> new_group(Args&&... args) {
|
|
auto pgroup = [&]() {
|
|
auto* pgroup = new group(this, std::forward<Args>(args)...);
|
|
groups.insert(pgroup);
|
|
lua->register_group(pgroup);
|
|
return owned_lua<group>{pgroup};
|
|
}();
|
|
if(groups.size() > 2048) {
|
|
lua->collect();
|
|
}
|
|
return pgroup;
|
|
}
|
|
effect* new_effect();
|
|
void delete_card(card* pcard);
|
|
void delete_group(group* pgroup);
|
|
void delete_effect(effect* peffect);
|
|
void restore_assumes();
|
|
void generate_buffer();
|
|
void write_buffer(const void* data, size_t size);
|
|
void clear_buffer();
|
|
void set_response(const void* resp, size_t len);
|
|
int32_t get_next_integer(int32_t l, int32_t h);
|
|
duel_message* new_message(uint8_t message);
|
|
const card_data& read_card(uint32_t code);
|
|
inline void handle_message(const char* message, OCG_LogTypes type) {
|
|
handle_message_callback(handle_message_payload, message, type);
|
|
}
|
|
inline int read_script(const char* name) {
|
|
return read_script_callback(read_script_payload, this, name);
|
|
}
|
|
private:
|
|
std::deque<duel_message> messages;
|
|
RNG::Xoshiro256StarStar random;
|
|
OCG_DataReader read_card_callback;
|
|
OCG_ScriptReader read_script_callback;
|
|
OCG_LogHandler handle_message_callback;
|
|
OCG_DataReaderDone read_card_done_callback;
|
|
void* read_card_payload;
|
|
void* read_script_payload;
|
|
void* handle_message_payload;
|
|
void* read_card_done_payload;
|
|
};
|
|
|
|
#endif /* DUEL_H_ */
|