Skip to content

Commit

Permalink
Merge branch 'master' of github.com:Fluorohydride/ygopro-core
Browse files Browse the repository at this point in the history
  • Loading branch information
@purerosefallen
purerosefallen committed May 14, 2024
2 parents c5d7267 + 476c889 commit 6a61bc1
Show file tree
Hide file tree
Showing 5 changed files with 140 additions and 126 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
181 changes: 80 additions & 101 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 @@ -97,35 +98,34 @@ bool card::card_operation_sort(card* c1, card* c2) {
else
return c1->current.sequence < c2->current.sequence;
} else if (c1->current.location & LOCATION_DECK && !pduel->game_field->core.select_deck_seq_preserved) {
// faceup deck cards should go at the very first
if(c1->current.position != c2->current.position) {
if(c1->current.position & POS_FACEUP)
return false;
else
return true;
}
// if deck reversed and the card being at the top, it should go first
if(pduel->game_field->core.deck_reversed) {
if(c1->current.sequence == pduel->game_field->player[cp1].list_main.size() - 1)
return false;
if(c2->current.sequence == pduel->game_field->player[cp2].list_main.size() - 1)
return true;
}
// faceup deck cards should go at the very first
if(c1->current.position != c2->current.position) {
if(c1->current.position & POS_FACEUP)
return false;
else
return true;
}
// sort deck as card property
auto c1_type = c1->data.type & 0x7;
auto c2_type = c2->data.type & 0x7;
// monster should go before spell, and then trap
if(c1_type != c2_type)
return c1_type > c2_type;
if(c1_type & TYPE_MONSTER) {
// sort monster by level, then code
if(c1->data.level != c2->data.level)
return c1->data.level < c2->data.level;
else
return c1->data.code > c2->data.code;
} else
// spell and trap should go by code
if (c1->data.level != c2->data.level)
return c1->data.level > c2->data.level;
// TODO: more sorts here
}
if(c1->data.code != c2->data.code)
return c1->data.code > c2->data.code;
return c1->current.sequence > c2->current.sequence;
} else {
if(c1->current.location & (LOCATION_DECK | LOCATION_EXTRA | LOCATION_GRAVE | LOCATION_REMOVED))
return c1->current.sequence > c2->current.sequence;
Expand Down Expand Up @@ -176,17 +176,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 +195,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 +210,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 +288,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 +323,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 +401,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
Loading

0 comments on commit 6a61bc1

Please sign in to comment.