Skip to content

Commit

Permalink
Merge remote-tracking branch 'upstream/master'
Browse files Browse the repository at this point in the history
  • Loading branch information
@Wind2009-Louse
Wind2009-Louse committed May 12, 2024
2 parents 31b093d + 607a170 commit 8bf1dd2
Show file tree
Hide file tree
Showing 4 changed files with 117 additions and 112 deletions.
37 changes: 37 additions & 0 deletions buffer.h
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,37 @@
#ifndef BUFFER_H
#define BUFFER_H

#include <cstring>
#include <vector>

inline void buffer_read_block(unsigned char*& p, void* dest, size_t size) {
std::memcpy(dest, p, size);
p += size;
}
template<typename T>
inline T buffer_read(unsigned char*& p) {
T ret{};
buffer_read_block(p, &ret, sizeof(T));
return ret;
}

inline void buffer_write_block(unsigned char*& p, const void* src, size_t size) {
std::memcpy(p, src, size);
p += size;
}
template<typename T>
inline void buffer_write(unsigned char*& p, T value) {
buffer_write_block(p, &value,sizeof(T));
}

inline void vector_write_block(std::vector<unsigned char>& buffer, const void* src, size_t size) {
const auto len = buffer.size();
buffer.resize(len + size);
std::memcpy(&buffer[len], src, size);
}
template<typename T>
inline void vector_write(std::vector<unsigned char>& buffer, T value) {
vector_write_block(buffer, &value, sizeof(T));
}

#endif //BUFFER_H
154 changes: 67 additions & 87 deletions card.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -12,6 +12,7 @@
#include "group.h"
#include "interpreter.h"
#include "ocgapi.h"
#include "buffer.h"
#include <algorithm>

const std::unordered_map<uint32, uint32> card::second_code = {
Expand Down Expand Up @@ -176,17 +177,16 @@ card::card(duel* pd) {
xyz_materials_previous_count_onfield = 0;
current.controler = PLAYER_NONE;
}
inline void update_cache(uint32& tdata, uint32& cache, int32*& p, uint32& query_flag, const uint32 flag) {
inline void update_cache(uint32& tdata, uint32& cache, byte*& p, uint32& query_flag, const uint32 flag) {
if (tdata != cache) {
cache = tdata;
*p = tdata;
++p;
buffer_write<uint32_t>(p, tdata);
}
else
query_flag &= ~flag;
}
int32 card::get_infos(byte* buf, uint32 query_flag, int32 use_cache) {
int32* p = (int32*)buf;
byte* p = buf;
std::pair<int32, int32> atk_def(-10, -10);
std::pair<int32, int32> base_atk_def(-10, -10);
if ((query_flag & QUERY_ATTACK) || (query_flag & QUERY_DEFENSE)) {
Expand All @@ -196,15 +196,13 @@ int32 card::get_infos(byte* buf, uint32 query_flag, int32 use_cache) {
base_atk_def = get_base_atk_def();
}
//first 8 bytes: data length, query flag
p += 2;
p += 8;
if (query_flag & QUERY_CODE) {
*p = data.code;
++p;
buffer_write<uint32_t>(p, data.code);
}
if (query_flag & QUERY_POSITION) {
uint32 tdata = get_info_location();
*p = tdata;
++p;
buffer_write<uint32_t>(p, tdata);
if (q_cache.info_location != tdata) {
q_cache.clear_cache();
q_cache.info_location = tdata;
Expand All @@ -213,59 +211,54 @@ int32 card::get_infos(byte* buf, uint32 query_flag, int32 use_cache) {
}
if(!use_cache) {
if (query_flag & QUERY_ALIAS) {
*p = get_code();
q_cache.current_code = *p;
++p;
uint32 tdata = get_code();
buffer_write<uint32_t>(p, tdata);
q_cache.current_code = tdata;
}
if (query_flag & QUERY_TYPE) {
*p = get_type();
q_cache.type = *p;
++p;
uint32 tdata = get_type();
buffer_write<uint32_t>(p, tdata);
q_cache.type = tdata;
}
if (query_flag & QUERY_LEVEL) {
*p = get_level();
q_cache.level = *p;
++p;
uint32 tdata = get_level();
buffer_write<uint32_t>(p, tdata);
q_cache.level = tdata;
}
if (query_flag & QUERY_RANK) {
*p = get_rank();
q_cache.rank = *p;
++p;
uint32 tdata = get_rank();
buffer_write<uint32_t>(p, tdata);
q_cache.rank = tdata;
}
if (query_flag & QUERY_ATTRIBUTE) {
*p = get_attribute();
q_cache.attribute = *p;
++p;
uint32 tdata = get_attribute();
buffer_write<uint32_t>(p, tdata);
q_cache.attribute = tdata;
}
if (query_flag & QUERY_RACE) {
*p = get_race();
q_cache.race = *p;
++p;
uint32 tdata = get_race();
buffer_write<uint32_t>(p, tdata);
q_cache.race = tdata;
}
if (query_flag & QUERY_ATTACK) {
*p = atk_def.first;
buffer_write<int32_t>(p, atk_def.first);
q_cache.attack = atk_def.first;
++p;
}
if (query_flag & QUERY_DEFENSE) {
*p = atk_def.second;
buffer_write<int32_t>(p, atk_def.second);
q_cache.defense = atk_def.second;
++p;
}
if (query_flag & QUERY_BASE_ATTACK) {
*p = base_atk_def.first;
buffer_write<int32_t>(p, base_atk_def.first);
q_cache.base_attack = base_atk_def.first;
++p;
}
if (query_flag & QUERY_BASE_DEFENSE) {
*p = base_atk_def.second;
buffer_write<int32_t>(p, base_atk_def.second);
q_cache.base_defense = base_atk_def.second;
++p;
}
if (query_flag & QUERY_REASON) {
*p = current.reason;
buffer_write<uint32_t>(p, current.reason);
q_cache.reason = current.reason;
++p;
}
}
else {
Expand Down Expand Up @@ -296,35 +289,31 @@ int32 card::get_infos(byte* buf, uint32 query_flag, int32 use_cache) {
if((query_flag & QUERY_ATTACK)) {
if (atk_def.first != q_cache.attack) {
q_cache.attack = atk_def.first;
*p = atk_def.first;
++p;
buffer_write<int32_t>(p, atk_def.first);
}
else
query_flag &= ~QUERY_ATTACK;
}
if((query_flag & QUERY_DEFENSE)) {
if (atk_def.second != q_cache.defense) {
q_cache.defense = atk_def.second;
*p = atk_def.second;
++p;
buffer_write<int32_t>(p, atk_def.second);
}
else
query_flag &= ~QUERY_DEFENSE;
}
if((query_flag & QUERY_BASE_ATTACK)) {
if (base_atk_def.first != q_cache.base_attack) {
q_cache.base_attack = base_atk_def.first;
*p = base_atk_def.first;
++p;
buffer_write<int32_t>(p, base_atk_def.first);
}
else
query_flag &= ~QUERY_BASE_ATTACK;
}
if((query_flag & QUERY_BASE_DEFENSE)) {
if (base_atk_def.second != q_cache.base_defense) {
q_cache.base_defense = base_atk_def.second;
*p = base_atk_def.second;
++p;
buffer_write<int32_t>(p, base_atk_def.second);
}
else
query_flag &= ~QUERY_BASE_DEFENSE;
Expand All @@ -335,73 +324,68 @@ int32 card::get_infos(byte* buf, uint32 query_flag, int32 use_cache) {
}
}
if (query_flag & QUERY_REASON_CARD) {
*p = current.reason_card ? current.reason_card->get_info_location() : 0;
++p;
uint32 tdata = current.reason_card ? current.reason_card->get_info_location() : 0;
buffer_write<uint32_t>(p, tdata);
}
if(query_flag & QUERY_EQUIP_CARD) {
if (equiping_target) {
*p = equiping_target->get_info_location();
++p;
uint32 tdata = equiping_target->get_info_location();
buffer_write<uint32_t>(p, tdata);
}
else
query_flag &= ~QUERY_EQUIP_CARD;
}
if(query_flag & QUERY_TARGET_CARD) {
*p = (int32)effect_target_cards.size();
++p;
buffer_write<int32_t>(p, (int32_t)effect_target_cards.size());
for (auto& pcard : effect_target_cards) {
*p = pcard->get_info_location();
++p;
uint32 tdata = pcard->get_info_location();
buffer_write<uint32_t>(p, tdata);
}
}
if(query_flag & QUERY_OVERLAY_CARD) {
*p = (int32)xyz_materials.size();
++p;
buffer_write<int32_t>(p, (int32_t)xyz_materials.size());
for (auto& xcard : xyz_materials) {
*p = xcard->data.code;
++p;
buffer_write<uint32_t>(p, xcard->data.code);
}
}
if(query_flag & QUERY_COUNTERS) {
*p = (int32)counters.size();
++p;
buffer_write<int32_t>(p, (int32_t)counters.size());
for (const auto& cmit : counters) {
*p = cmit.first + ((cmit.second[0] + cmit.second[1]) << 16);
++p;
int32 tdata = cmit.first + ((cmit.second[0] + cmit.second[1]) << 16);
buffer_write<int32_t>(p, tdata);
}
}
if (query_flag & QUERY_OWNER) {
*p = owner;
++p;
int32 tdata = owner;
buffer_write<int32_t>(p, tdata);
}
if(query_flag & QUERY_STATUS) {
uint32 tdata = status & (STATUS_DISABLED | STATUS_FORBIDDEN | STATUS_PROC_COMPLETE);
if(!use_cache || (tdata != q_cache.status)) {
q_cache.status = tdata;
*p = tdata;
++p;
buffer_write<uint32_t>(p, tdata);
}
else
query_flag &= ~QUERY_STATUS;
}
if(!use_cache) {
if (query_flag & QUERY_LSCALE) {
*p = get_lscale();
q_cache.lscale = *p;
++p;
uint32 tdata = get_lscale();
buffer_write<uint32_t>(p, tdata);
q_cache.lscale = tdata;
}
if (query_flag & QUERY_RSCALE) {
*p = get_rscale();
q_cache.rscale = *p;
++p;
uint32 tdata = get_rscale();
buffer_write<uint32_t>(p, tdata);
q_cache.rscale = tdata;
}
if(query_flag & QUERY_LINK) {
*p = get_link();
q_cache.link = *p;
++p;
*p = get_link_marker();
q_cache.link_marker = *p;
++p;
uint32 tdata = get_link();
buffer_write<uint32_t>(p, tdata);
q_cache.link = tdata;
tdata = get_link_marker();
buffer_write<uint32_t>(p, tdata);
q_cache.link_marker = tdata;
}
}
else {
Expand All @@ -418,22 +402,18 @@ int32 card::get_infos(byte* buf, uint32 query_flag, int32 use_cache) {
uint32 link_marker = get_link_marker();
if((link != q_cache.link) || (link_marker != q_cache.link_marker)) {
q_cache.link = link;
*p = (int32)link;
++p;
buffer_write<uint32_t>(p, link);
q_cache.link_marker = link_marker;
*p = (int32)link_marker;
++p;
buffer_write<uint32_t>(p, link_marker);
}
else
query_flag &= ~QUERY_LINK;
}
}
int32* finalize = (int32*)buf;
*finalize = (byte*)p - buf;
++finalize;
*finalize = query_flag;
++finalize;
return (byte*)p - buf;
byte* finalize = buf;
buffer_write<int32_t>(finalize, p - buf);
buffer_write<uint32_t>(finalize, query_flag);
return (int32)(p - buf);
}
uint32 card::get_info_location() {
if(overlay_target) {
Expand Down
17 changes: 5 additions & 12 deletions duel.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -13,14 +13,7 @@
#include "effect.h"
#include "group.h"
#include "ocgapi.h"

inline void write_buffer_vector(std::vector<byte>& buffer, const void* data, int size) {
if (size > 0) {
const auto len = buffer.size();
buffer.resize(len + size);
std::memcpy(&buffer[len], data, size);
}
}
#include "buffer.h"

duel::duel() {
lua = new interpreter(this);
Expand Down Expand Up @@ -125,16 +118,16 @@ void duel::restore_assumes() {
assumes.clear();
}
void duel::write_buffer(const void* data, int size) {
write_buffer_vector(message_buffer, data, size);
vector_write_block(message_buffer, data, size);
}
void duel::write_buffer32(uint32 value) {
write_buffer(&value, sizeof(value));
vector_write<uint32_t>(message_buffer, value);
}
void duel::write_buffer16(uint16 value) {
write_buffer(&value, sizeof(value));
vector_write<uint16_t>(message_buffer, value);
}
void duel::write_buffer8(uint8 value) {
write_buffer(&value, sizeof(value));
vector_write<unsigned char>(message_buffer, value);
}
void duel::clear_buffer() {
message_buffer.clear();
Expand Down
Loading

0 comments on commit 8bf1dd2

Please sign in to comment.