Skip to content

Y
ygopro-core
Commit 287dd26c authored by mercury233's avatar mercury233
Browse files
Options

Merge branch 'master' into patch-skip-confirm

parents b05c44a7 6b81a1af
Show whitespace changes
Inline Side-by-side
Showing with 10006 additions and 8321 deletions
.github/workflows/build.yml 0 → 100644
View file @ 287dd26c
name: Automated Test Build
on:
push:
branches: [ "master" ]
pull_request:
branches: [ "master" ]
jobs:
build-windows:
runs-on: windows-2022
steps:
- name: Checkout
uses: actions/checkout@v4
with:
fetch-depth: 0
- name: Download lua
id: lua
uses: mercury233/action-cache-download-file@v1.0.0
with:
url: https://www.lua.org/ftp/lua-5.4.8.tar.gz
- name: Lua
run: |
tar -xzf ${{ steps.lua.outputs.filepath }}
move lua-5.4.8 lua
- name: Download premake
id: premake
uses: mercury233/action-cache-download-file@v1.0.0
with:
url: https://github.com/premake/premake-core/releases/download/v5.0.0-beta7/premake-5.0.0-beta7-windows.zip
- name: Premake
run: |
mkdir premake-5
tar -C premake-5 -xzf ${{ steps.premake.outputs.filepath }}
copy premake\lua.lua lua\premake5.lua
copy premake\dll.lua dll.lua
.\premake-5\premake5.exe vs2022 --file=dll.lua
- name: Add msbuild to PATH
uses: microsoft/setup-msbuild@v2
- name: Build x32
run: |
msbuild build\ocgcoredll.sln /t:Build /p:"Configuration=Release;Platform=Win32"
- name: Build x64
run: |
msbuild build\ocgcoredll.sln /t:Build /p:"Configuration=Release;Platform=x64"
- name: Upload build artifacts
uses: actions/upload-artifact@v4
with:
name: ocgcore-windows
path: |
build\bin\x32\Release\ocgcore.dll
build\bin\x64\Release\ocgcore.dll
- name: GitHub Release
if: github.event_name == 'push'
uses: salix5/action-automatic-releases@node20
with:
repo_token: "${{ secrets.GITHUB_TOKEN }}"
automatic_release_tag: "latest"
prerelease: true
title: "Development Build"
files: |
build/bin/x64/Release/ocgcore.dll
build-linux:
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v4
with:
fetch-depth: 0
- name: Install Dependencies
run: |
sudo apt-get update
sudo apt-get install -y gcc-multilib g++-multilib
- name: Download lua
id: lua
uses: mercury233/action-cache-download-file@v1.0.0
with:
url: https://www.lua.org/ftp/lua-5.4.8.tar.gz
- name: Lua
run: |
tar -xzf ${{ steps.lua.outputs.filepath }}
mv lua-5.4.8 lua
- name: Download premake
id: premake
uses: mercury233/action-cache-download-file@v1.0.0
with:
url: https://github.com/premake/premake-core/releases/download/v5.0.0-beta7/premake-5.0.0-beta7-linux.tar.gz
- name: Premake
run: |
mkdir premake-5
tar -C premake-5 -xzf ${{ steps.premake.outputs.filepath }}
cp premake/lua.lua lua/premake5.lua
cp premake/dll.lua dll.lua
chmod +x premake-5/premake5
./premake-5/premake5 gmake --file=dll.lua
- name: Build x32
run: |
cd build
make -j 4 config=release_x32
cd ..
- name: Build x64
run: |
cd build
make -j 4 config=release_x64
cd ..
- name: Upload build artifacts
uses: actions/upload-artifact@v4
with:
name: ocgcore-linux
path: |
build/bin/x32/Release/libocgcore.so
build/bin/x64/Release/libocgcore.so
.gitignore 0 → 100644
View file @ 287dd26c
/.vscode/
/build/
/lua/
/temp/
/premake-5/
/premake5.exe
README.md
View file @ 287dd26c
......@@ -4,64 +4,71 @@
The core logic and lua script processor of YGOPro. This library can be made external of the project and used to power server technologies. It maintains a state engine that is manipulated by Lua scripts using manipulation functions it exposes.
## Compiling
### 1.) Download Fluorohydride/ygopro
Start by downloading the most parent of the source code. The team developing this project are the defacto edge and experts in our community. The most upto date `ocgcore` is a compiled dll version of the `Fluorohydride/ygopro/ocgcore` folders project.
In most cases, what you want to compile is the main program of YGOPro. You should refer to the main YGOPro project's [wiki](https://github.com/Fluorohydride/ygopro/wiki).
If you want to compile the dynamic link library of this repository (ocgcore.dll), you can refer to [this script](https://github.com/Fluorohydride/ygopro-core/blob/master/.github/workflows/build.yml).
### 2.) Install Premake4 and Visual Studio 2010 (or later).
Download premake4.exe, put it in `c:\windows` or a similar folder that is globally accessible via `cmd` or PowerShell. Install Visual Studio 2010, it is the system used for the guide because other parts of the project use C# and most the development team are Windows users.
## Exposed Functions
### 3.) Download dependencies
Dependencies are absent from the main project. There is information on how to build them but the easiest thing to do is to download the following folders from a [soarqin/ygopro](https://github.com/soarqin/ygopro) fork and simply copy them into the `Fluorohydride/ygopro` folder.
The 3 functions need to be provided to the core so it can get card and database information.
- `void set_script_reader(script_reader f);`
Interface provided returns scripts based on number that corresponds to a lua file, send in a string.
* event
* freetype
* irrlicht
* lua
* sqlite3
- `void set_card_reader(card_reader f);`
Interface provided function that provides database information from the `data` table of `cards.cdb`.
### 4.) Create the project files
Run the following commands from the command line in the `Fluorohydride/ygopro` folder.
- `void set_message_handler(message_handler f);`
Interface provided function that handles error messages.
` premake4 /help `
` premake4 vs2010 `
These functions create the game itself and then manipulate it.
- `intptr_t create_duel(uint_fast32_t seed);`
Create a the instance of the duel with a PRNG seed.
If you are not using Visual Studio 2010 or higher, make the needed adjustments. In the file system open `Fluorohydride/ygopro/build` folder open the `ygo` project.
- `void start_duel(intptr_t pduel, uint32_t options);`
Start the duel.
### 5.) Build the system
Make sure the code actually compiles. Compile them in the following order one by one:
- `void end_duel(intptr_t pduel);`
End the duel.
* lua
* sqlite3
* ocgcore
- `void set_player_info(intptr_t pduel, int32_t playerid, int32_t lp, int32_t startcount, int32_t drawcount);`
Set up the duel information.
This should provide you with `ocgcore.lib` in the build output folder. `YGOCore` requires a `*.dll`; in `ocgcore` project properties change it to a dynamically linked library. Recompile, it should fail with an error indicating missing dependencies. Right click the project, add an existing file. Add `lua.lib` from the build folder to the project. It should now compile.
- `void get_log_message(intptr_t pduel, char* buf);`
## Exposed Functions
- `int32_t get_message(intptr_t pduel, byte* buf);`
These three function need to be provided to the core so it can get card and database information.
- `void set_script_reader(script_reader f);` : Interface provided returns scripts based on number that corresponds to a lua file, send in a string.
- `int32_t process(intptr_t pduel);`
Do a game tick.
- `void set_card_reader(card_reader f);` : Interface provided function that provides database information from the `data` table of `cards.cdb`.
- `void new_card(intptr_t pduel, uint32_t code, uint8_t owner, uint8_t playerid, uint8_t location, uint8_t sequence, uint8_t position);`
Add a card to the duel state.
- `void set_message_handler(message_handler f);` : Interface provided function that handles errors
- `void new_tag_card(intptr_t pduel, uint32_t code, uint8_t owner, uint8_t location);`
Add a new card to the tag pool.
These functions create the game itself and then manipulate it.
- `ptr create_duel(uint32 seed);` : Create a the instance of the duel using a random number.
- `void start_duel(ptr pduel, int32 options);` : Starts the duel
- `void end_duel(ptr pduel);` : ends the duel
- `void set_player_info(ptr pduel, int32 playerid, int32 lp, int32 startcount, int32 drawcount);` sets the duel up
- `void get_log_message(ptr pduel, byte* buf);`
- `int32 get_message(ptr pduel, byte* buf);`
- `int32 process(ptr pduel);` : do a game tick
- `void new_card(ptr pduel, uint32 code, uint8 owner, uint8 playerid, uint8 location, uint8 sequence, uint8 position);` : add a card to the duel state.
- `void new_tag_card(ptr pduel, uint32 code, uint8 owner, uint8 location);` : add a new card to the tag pool.
- `int32 query_card(ptr pduel, uint8 playerid, uint8 location, uint8 sequence, int32 query_flag, byte* buf, int32 use_cache);` : find out about a card in a specific spot.
- `int32 query_field_count(ptr pduel, uint8 playerid, uint8 location);` : Get the number of cards in a specific field/zone.
- `int32 query_field_card(ptr pduel, uint8 playerid, uint8 location, int32 query_flag, byte* buf, int32 use_cache);`
- `int32 query_field_info(ptr pduel, byte* buf);`
- `void set_responsei(ptr pduel, int32 value);`
- `void set_responseb(ptr pduel, byte* buf);`
- `int32 preload_script(ptr pduel, char* script, int32 len);`
- `int32_t query_field_card(intptr_t pduel, uint8_t playerid, uint8_t location, uint32_t query_flag, byte* buf, int32_t use_cache);`
Get a card in a specific location.
- `int32_t query_field_count(intptr_t pduel, uint8_t playerid, uint8_t location);`
Get the number of cards in a specific location.
- `int32_t query_field_card(intptr_t pduel, uint8_t playerid, uint8_t location, uint32_t query_flag, byte* buf, int32_t use_cache);`
Get all cards in some location.
- `int32_t query_field_info(intptr_t pduel, byte* buf);`
- `void set_responsei(intptr_t pduel, int32_t value);`
- `void set_responseb(intptr_t pduel, byte* buf);`
- `int32_t preload_script(intptr_t pduel, const char* script_name);`
- `byte* default_script_reader(const char* script_name, int* len);`
The default script reader using `fread`.
# Lua functions
`interpreter.cpp`
- `libcard.cpp`
- `libdebug.cpp`
- `libduel.cpp`
- `libeffect.cpp`
- `libgroup.cpp`
buffer.h 0 → 100644
View file @ 287dd26c
#ifndef CORE_BUFFER_H
#define CORE_BUFFER_H
#include <cstdio>
#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{};
std::memcpy(&ret, p, sizeof(T));
p += 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) {
std::memcpy(p, &value, sizeof(T));
p += 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));
}
inline void vector_fread(std::vector<unsigned char>& buffer, FILE* fp) {
unsigned char temp[4096]{};
while (size_t len = std::fread(temp, 1, sizeof temp, fp))
vector_write_block(buffer, temp, len);
std::fclose(fp);
}
#endif // !CORE_BUFFER_H
card.cpp
View file @ 287dd26c
This source diff could not be displayed because it is too large. You can view the blob instead.
card.h
View file @ 287dd26c
......@@ -10,6 +10,8 @@
#include "common.h"
#include "effectset.h"
#include "card_data.h"
#include "sort.h"
#include <set>
#include <map>
#include <unordered_set>
......@@ -22,120 +24,109 @@ class effect;
class group;
struct chain;
struct card_data {
uint32 code;
uint32 alias;
uint64 setcode;
uint32 type;
uint32 level;
uint32 attribute;
uint32 race;
int32 attack;
int32 defense;
uint32 lscale;
uint32 rscale;
uint32 link_marker;
using card_set = std::set<card*, card_sort>;
using card_vector = std::vector<card*>;
using effect_container = std::multimap<uint32_t, effect*>;
using effect_indexer = std::unordered_map<effect*, effect_container::iterator>;
using effect_collection = std::unordered_set<effect*>;
void clear();
};
using effect_filter = bool(*)(card* self, effect* peffect);
using effect_filter_target = bool(*)(card* self, effect* peffect, card* target);
struct card_state {
card_state()
: code(0), code2(0), type(0), level(0), rank(0), link(0), lscale(0), rscale(0), attribute(0), race(0), attack(0), defense(0), base_attack(0), base_defense(0),
controler(PLAYER_NONE), location(0), sequence(0), position(0), reason(0), pzone(false), reason_card(nullptr), reason_player(PLAYER_NONE), reason_effect(nullptr) {}
uint32_t code{ 0 };
uint32_t code2{ 0 };
std::vector<uint16_t> setcode;
uint32_t type{ 0 };
uint32_t level{ 0 };
uint32_t rank{ 0 };
uint32_t link{ 0 };
uint32_t lscale{ 0 };
uint32_t rscale{ 0 };
uint32_t attribute{ 0 };
uint32_t race{ 0 };
int32_t attack{ 0 };
int32_t defense{ 0 };
int32_t base_attack{ 0 };
int32_t base_defense{ 0 };
uint8_t controler{ PLAYER_NONE };
uint8_t location{ 0 };
uint8_t sequence{ 0 };
uint8_t position{ 0 };
uint32_t reason{ 0 };
card* reason_card{ nullptr };
effect* reason_effect{ nullptr };
uint8_t reason_player{ PLAYER_NONE };
bool pzone{ false };
uint32 code;
uint32 code2;
std::vector<uint32> setcode;
uint32 type;
uint32 level;
uint32 rank;
uint32 link;
uint32 lscale;
uint32 rscale;
uint32 attribute;
uint32 race;
int32 attack;
int32 defense;
int32 base_attack;
int32 base_defense;
uint8 controler;
uint8 location;
uint8 sequence;
uint8 position;
uint32 reason;
bool pzone;
card* reason_card;
uint8 reason_player;
effect* reason_effect;
bool is_location(int32 loc) const;
bool is_location(uint32_t loc) const;
bool is_main_mzone() const {
return location == LOCATION_MZONE && sequence >= 0 && sequence <= 4;
}
bool is_stzone() const {
return location == LOCATION_SZONE && sequence >= 0 && sequence <= 4;
}
void init_state();
};
struct query_cache {
uint32 code;
uint32 alias;
uint32 type;
uint32 level;
uint32 rank;
uint32 link;
uint32 attribute;
uint32 race;
int32 attack;
int32 defense;
int32 base_attack;
int32 base_defense;
uint32 reason;
int32 status;
uint32 lscale;
uint32 rscale;
uint32 link_marker;
uint32_t info_location{ UINT32_MAX };
uint32_t current_code{ UINT32_MAX };
uint32_t type{ UINT32_MAX };
uint32_t level{ UINT32_MAX };
uint32_t rank{ UINT32_MAX };
uint32_t link{ UINT32_MAX };
uint32_t attribute{ UINT32_MAX };
uint32_t race{ UINT32_MAX };
int32_t attack{ -1 };
int32_t defense{ -1 };
int32_t base_attack{ -1 };
int32_t base_defense{ -1 };
uint32_t reason{ UINT32_MAX };
uint32_t status{ UINT32_MAX };
uint32_t lscale{ UINT32_MAX };
uint32_t rscale{ UINT32_MAX };
uint32_t link_marker{ UINT32_MAX };
void clear_cache();
};
struct material_info {
// Synchron
card* limit_tuner;
group* limit_syn;
int32 limit_syn_minc;
int32 limit_syn_maxc;
card* limit_tuner{ nullptr };
group* limit_syn{ nullptr };
int32_t limit_syn_minc{ 0 };
int32_t limit_syn_maxc{ 0 };
// Xyz
group* limit_xyz;
int32 limit_xyz_minc;
int32 limit_xyz_maxc;
group* limit_xyz{ nullptr };
int32_t limit_xyz_minc{ 0 };
int32_t limit_xyz_maxc{ 0 };
// Link
group* limit_link;
card* limit_link_card;
int32 limit_link_minc;
int32 limit_link_maxc;
material_info()
: limit_tuner(nullptr), limit_syn(nullptr), limit_syn_minc(0), limit_syn_maxc(0), limit_xyz(nullptr), limit_xyz_minc(0), limit_xyz_maxc(0),
limit_link(nullptr), limit_link_card(nullptr), limit_link_minc(0), limit_link_maxc(0) {}
group* limit_link{ nullptr };
card* limit_link_card{ nullptr };
int32_t limit_link_minc{ 0 };
int32_t limit_link_maxc{ 0 };
};
const material_info null_info;
class card {
public:
struct effect_relation_hash {
inline std::size_t operator()(const std::pair<effect*, uint16>& v) const {
return std::hash<uint16>()(v.second);
std::size_t operator()(const std::pair<effect*, uint16_t>& v) const {
return std::hash<uint16_t>()(v.second);
}
};
using card_vector = std::vector<card*>;
using effect_container = std::multimap<uint32, effect*>;
using card_set = std::set<card*, card_sort>;
using effect_indexer = std::unordered_map<effect*, effect_container::iterator>;
using effect_relation = std::unordered_set<std::pair<effect*, uint16>, effect_relation_hash>;
using relation_map = std::unordered_map<card*, uint32>;
using counter_map = std::map<uint16, std::array<uint16, 2>>;
using effect_count = std::map<uint32, int32>;
class attacker_map : public std::unordered_map<uint16, std::pair<card*, uint32>> {
using effect_relation = std::unordered_set<std::pair<effect*, uint16_t>, effect_relation_hash>;
using relation_map = std::unordered_map<card*, uint32_t>;
using counter_map = std::map<uint16_t, uint16_t>;
using effect_count = std::map<uint32_t, int32_t>;
class attacker_map : public std::unordered_map<uint32_t, std::pair<card*, uint32_t>> {
public:
void addcard(card* pcard);
uint32 findcard(card* pcard);
uint32_t findcard(card* pcard);
};
struct sendto_param_t {
void set(uint8 p, uint8 pos, uint8 loc, uint8 seq = 0) {
void set(uint8_t p, uint8_t pos, uint8_t loc, uint8_t seq = 0) {
playerid = p;
position = pos;
location = loc;
......@@ -147,52 +138,55 @@ public:
location = 0;
sequence = 0;
}
uint8 playerid;
uint8 position;
uint8 location;
uint8 sequence;
uint8_t playerid{ 0 };
uint8_t position{ 0 };
uint8_t location{ 0 };
uint8_t sequence{ 0 };
};
int32 ref_handle;
duel* pduel;
int32_t ref_handle{};
duel* pduel{};
card_data data;
card_state previous;
card_state temp;
card_state current;
card_state spsummon;
query_cache q_cache;
uint8 owner;
uint8 summon_player;
uint32 summon_info;
uint32 status;
uint8_t owner{ PLAYER_NONE };
uint8_t summon_player{ PLAYER_NONE };
uint32_t summon_info{};
uint32_t status{};
sendto_param_t sendto_param;
uint32 release_param;
uint32 sum_param;
uint32 position_param;
uint32 spsummon_param;
uint32 to_field_param;
uint8 attack_announce_count;
uint8 direct_attackable;
uint8 announce_count;
uint8 attacked_count;
uint8 attack_all_target;
uint8 attack_controler;
uint16 cardid;
uint32 fieldid;
uint32 fieldid_r;
uint16 turnid;
uint16 turn_counter;
uint8 unique_pos[2];
uint32 unique_fieldid;
uint32 unique_code;
uint32 unique_location;
int32 unique_function;
effect* unique_effect;
uint32 spsummon_code;
uint16 spsummon_counter[2];
uint8 assume_type;
uint32 assume_value;
card* equiping_target;
card* pre_equip_target;
card* overlay_target;
uint32_t release_param{};
uint32_t sum_param{};
uint32_t position_param{};
uint32_t spsummon_param{};
uint32_t to_field_param{};
uint8_t attack_announce_count{};
uint8_t direct_attackable{};
uint8_t announce_count{};
uint8_t attacked_count{};
uint8_t attack_all_target{};
uint8_t attack_controler{};
uint64_t cardid{};
uint32_t fieldid{};
uint32_t fieldid_r{}; //real field id, updated when moving to new location
uint32_t activate_count_id{}; //updated when moving to new location or flipping
uint16_t turnid{};
uint16_t turn_counter{};
uint8_t unique_pos[2]{};
uint32_t unique_fieldid{};
uint32_t unique_code{};
uint32_t unique_location{};
int32_t unique_function{};
effect* unique_effect{};
uint32_t spsummon_code{};
uint16_t spsummon_counter[2]{};
uint8_t assume_type{};
uint32_t assume_value{};
card* equiping_target{};
card* pre_equip_target{};
card* overlay_target{};
relation_map relations;
counter_map counters;
effect_count indestructable_effects;
......@@ -204,6 +198,7 @@ public:
card_set effect_target_owner;
card_set effect_target_cards;
card_vector xyz_materials;
int32_t xyz_materials_previous_count_onfield{};
effect_container single_effect;
effect_container field_effect;
effect_container equip_effect;
......@@ -212,197 +207,230 @@ public:
effect_indexer indexer;
effect_relation relate_effect;
effect_set_v immune_effect;
effect_collection initial_effect;
effect_collection owning_effect;
explicit card(duel* pd);
~card() = default;
static bool card_operation_sort(card* c1, card* c2);
const bool is_extra_deck_monster() { return !!(data.type & (TYPE_FUSION | TYPE_SYNCHRO | TYPE_XYZ | TYPE_LINK)); }
static bool check_card_setcode(uint32_t code, uint32_t value);
bool is_extra_deck_monster() const { return !!(data.type & TYPES_EXTRA_DECK); }
uint32 get_infos(byte* buf, int32 query_flag, int32 use_cache = TRUE);
uint32 get_info_location();
uint32 second_code(uint32 code);
uint32 get_code();
uint32 get_another_code();
int32 is_set_card(uint32 set_code);
int32 is_origin_set_card(uint32 set_code);
int32 is_pre_set_card(uint32 set_code);
int32 is_fusion_set_card(uint32 set_code);
int32 is_link_set_card(uint32 set_code);
uint32 get_type();
uint32 get_fusion_type();
uint32 get_synchro_type();
uint32 get_xyz_type();
uint32 get_link_type();
std::pair<int32, int32> get_base_atk_def();
std::pair<int32, int32> get_atk_def();
int32 get_base_attack();
int32 get_attack();
int32 get_base_defense();
int32 get_defense();
int32 get_battle_attack();
int32 get_battle_defense();
uint32 get_level();
uint32 get_rank();
uint32 get_link();
uint32 get_synchro_level(card* pcard);
uint32 get_ritual_level(card* pcard);
uint32 check_xyz_level(card* pcard, uint32 lv);
uint32 get_attribute();
uint32 get_fusion_attribute(uint8 playerid);
uint32 get_link_attribute(uint8 playerid);
uint32 get_grave_attribute(uint8 playerid);
uint32 get_race();
uint32 get_link_race(uint8 playerid);
uint32 get_grave_race(uint8 playerid);
uint32 get_lscale();
uint32 get_rscale();
uint32 get_link_marker();
int32 is_link_marker(uint32 dir);
uint32 get_linked_zone();
int32_t get_infos(byte* buf, uint32_t query_flag, int32_t use_cache = TRUE);
uint32_t get_info_location() const;
uint32_t get_original_code() const;
std::tuple<uint32_t, uint32_t> get_original_code_rule() const;
uint32_t get_code();
uint32_t get_another_code();
int32_t is_set_card(uint32_t set_code);
int32_t is_origin_set_card(uint32_t set_code);
int32_t is_pre_set_card(uint32_t set_code);
int32_t is_fusion_set_card(uint32_t set_code);
int32_t is_link_set_card(uint32_t set_code);
int32_t is_special_summon_set_card(uint32_t set_code);
uint32_t get_type();
uint32_t get_fusion_type();
uint32_t get_synchro_type();
uint32_t get_xyz_type();
uint32_t get_link_type();
std::pair<int32_t, int32_t> get_base_atk_def();
std::pair<int32_t, int32_t> get_atk_def();
int32_t get_base_attack();
int32_t get_attack();
int32_t get_base_defense();
int32_t get_defense();
int32_t get_battle_attack();
int32_t get_battle_defense();
uint32_t get_level();
uint32_t get_rank();
uint32_t get_link();
uint32_t get_mat_level_from_effect(card* pcard, uint32_t effect_code);
uint32_t get_mat_level(card* pcard, uint32_t level_effect_code, uint32_t allow_effect_code = 0);
uint32_t get_synchro_level(card* pcard);
uint32_t get_ritual_level(card* pcard);
uint32_t check_xyz_level(card* pcard, uint32_t lv);
uint32_t get_attribute();
uint32_t get_fusion_attribute(uint8_t playerid);
uint32_t get_link_attribute(uint8_t playerid);
uint32_t get_grave_attribute(uint8_t playerid);
uint32_t get_race();
uint32_t get_link_race(uint8_t playerid);
uint32_t get_grave_race(uint8_t playerid);
uint32_t get_lscale();
uint32_t get_rscale();
uint32_t get_link_marker();
uint32_t is_link_marker(uint32_t dir);
uint32_t get_linked_zone();
void get_linked_cards(card_set* cset);
uint32 get_mutual_linked_zone();
uint32_t get_mutual_linked_zone();
void get_mutual_linked_cards(card_set * cset);
int32 is_link_state();
int32 is_extra_link_state();
int32 is_position(int32 pos);
void set_status(uint32 status, int32 enabled);
int32 get_status(uint32 status);
int32 is_status(uint32 status);
uint32 get_column_zone(int32 location);
int32_t is_link_state();
int32_t is_extra_link_state();
int32_t is_position(uint32_t pos) const;
void set_status(uint32_t x, int32_t enabled);
int32_t get_status(uint32_t x) const;
int32_t is_status(uint32_t x) const;
uint32_t get_column_zone(int32_t location);
void get_column_cards(card_set* cset);
int32 is_all_column();
int32_t is_all_column();
uint8_t get_select_sequence(uint8_t *deck_seq_pointer);
uint32_t get_select_info_location(uint8_t *deck_seq_pointer);
int32_t is_treated_as_not_on_field() const;
void equip(card *target, uint32 send_msg = TRUE);
void equip(card* target, uint32_t send_msg = TRUE);
void unequip();
int32 get_union_count();
int32 get_old_union_count();
void xyz_overlay(card_set* materials);
int32_t get_union_count();
int32_t get_old_union_count();
void xyz_overlay(const card_set& materials);
void xyz_add(card* mat);
void xyz_remove(card* mat);
void apply_field_effect();
void cancel_field_effect();
void enable_field_effect(bool enabled);
int32 add_effect(effect* peffect);
void remove_effect(effect* peffect);
void remove_effect(effect* peffect, effect_container::iterator it);
int32 copy_effect(uint32 code, uint32 reset, uint32 count);
int32 replace_effect(uint32 code, uint32 reset, uint32 count);
void reset(uint32 id, uint32 reset_type);
int32_t add_effect(effect* peffect);
effect_indexer::iterator remove_effect(effect* peffect);
int32_t copy_effect(uint32_t code, uint32_t reset, int32_t count);
int32_t replace_effect(uint32_t code, uint32_t reset, int32_t count);
void reset(uint32_t id, uint32_t reset_type);
void reset_effect_count();
void refresh_disable_status();
std::tuple<uint8, effect*> refresh_control_status();
std::tuple<uint8_t, effect*> refresh_control_status();
void count_turn(uint16 ct);
void create_relation(card* target, uint32 reset);
int32 is_has_relation(card* target);
void count_turn(uint16_t ct);
void create_relation(card* target, uint32_t reset);
int32_t is_has_relation(card* target);
void release_relation(card* target);
void create_relation(const chain& ch);
int32 is_has_relation(const chain& ch);
int32_t is_has_relation(const chain& ch);
void release_relation(const chain& ch);
void clear_relate_effect();
void create_relation(effect* peffect);
int32 is_has_relation(effect* peffect);
int32_t is_has_relation(effect* peffect);
void release_relation(effect* peffect);
int32 leave_field_redirect(uint32 reason);
int32 destination_redirect(uint8 destination, uint32 reason);
int32 add_counter(uint8 playerid, uint16 countertype, uint16 count, uint8 singly);
int32 remove_counter(uint16 countertype, uint16 count);
int32 is_can_add_counter(uint8 playerid, uint16 countertype, uint16 count, uint8 singly, uint32 loc);
int32 is_can_have_counter(uint16 countertype);
int32 get_counter(uint16 countertype);
int32_t leave_field_redirect(uint32_t reason);
int32_t destination_redirect(uint8_t destination, uint32_t reason);
int32_t add_counter(uint8_t playerid, uint16_t countertype, uint16_t count, uint8_t singly);
int32_t remove_counter(uint16_t countertype, uint16_t count);
int32_t is_can_add_counter(uint8_t playerid, uint16_t countertype, uint16_t count, uint8_t singly, uint32_t loc);
int32_t is_can_have_counter(uint16_t countertype);
int32_t get_counter(uint16_t countertype);
void set_material(card_set* materials);
void add_card_target(card* pcard);
void cancel_card_target(card* pcard);
void delete_card_target(uint32_t send_msg);
void clear_card_target();
void set_special_summon_status(effect* peffect);
void filter_effect(int32 code, effect_set* eset, uint8 sort = TRUE);
void filter_single_continuous_effect(int32 code, effect_set* eset, uint8 sort = TRUE);
void filter_self_effect(int32 code, effect_set* eset, uint8 sort = TRUE);
template<typename T>
void filter_effect_container(const effect_container& container, uint32_t code, effect_filter f, T& eset);
void filter_effect_container(const effect_container& container, uint32_t code, effect_filter f, effect_collection& eset);
void filter_effect(uint32_t code, effect_set* eset, uint8_t sort = TRUE);
void filter_single_continuous_effect(uint32_t code, effect_set* eset, uint8_t sort = TRUE);
void filter_self_effect(uint32_t code, effect_set* eset, uint8_t sort = TRUE);
void filter_immune_effect();
void filter_disable_related_cards();
int32 filter_summon_procedure(uint8 playerid, effect_set* eset, uint8 ignore_count, uint8 min_tribute, uint32 zone);
int32 check_summon_procedure(effect* proc, uint8 playerid, uint8 ignore_count, uint8 min_tribute, uint32 zone);
int32 filter_set_procedure(uint8 playerid, effect_set* eset, uint8 ignore_count, uint8 min_tribute, uint32 zone);
int32 check_set_procedure(effect* proc, uint8 playerid, uint8 ignore_count, uint8 min_tribute, uint32 zone);
void filter_spsummon_procedure(uint8 playerid, effect_set* eset, uint32 summon_type, material_info info = null_info);
void filter_spsummon_procedure_g(uint8 playerid, effect_set* eset);
effect* is_affected_by_effect(int32 code);
effect* is_affected_by_effect(int32 code, card* target);
int32 fusion_check(group* fusion_m, card* cg, uint32 chkf, uint8 not_material);
void fusion_select(uint8 playerid, group* fusion_m, card* cg, uint32 chkf, uint8 not_material);
int32 check_fusion_substitute(card* fcard);
int32 is_not_tuner(card* scard);
int32_t filter_summon_procedure(uint8_t playerid, effect_set* eset, uint8_t ignore_count, uint8_t min_tribute, uint32_t zone);
int32_t check_summon_procedure(effect* proc, uint8_t playerid, uint8_t ignore_count, uint8_t min_tribute, uint32_t zone);
int32_t filter_set_procedure(uint8_t playerid, effect_set* eset, uint8_t ignore_count, uint8_t min_tribute, uint32_t zone);
int32_t check_set_procedure(effect* proc, uint8_t playerid, uint8_t ignore_count, uint8_t min_tribute, uint32_t zone);
void filter_spsummon_procedure(uint8_t playerid, effect_set* eset, uint32_t summon_type, material_info info = null_info);
void filter_spsummon_procedure_g(uint8_t playerid, effect_set* eset);
effect* find_effect(const effect_container& container, uint32_t code, effect_filter f);
effect* find_effect_with_target(const effect_container& container, uint32_t code, effect_filter_target f, card* target);
effect* is_affected_by_effect(uint32_t code);
effect* is_affected_by_effect(int32_t code, card* target);
int32_t fusion_check(group* fusion_m, card* cg, uint32_t chkf, uint8_t not_material);
void fusion_select(uint8_t playerid, group* fusion_m, card* cg, uint32_t chkf, uint8_t not_material);
int32_t check_fusion_substitute(card* fcard);
int32_t is_not_tuner(card* scard);
int32_t is_tuner(card* scard);
int32 check_unique_code(card* pcard);
void get_unique_target(card_set* cset, int32 controler, card* icard = 0);
int32 check_cost_condition(int32 ecode, int32 playerid);
int32 check_cost_condition(int32 ecode, int32 playerid, int32 sumtype);
int32 is_summonable_card();
int32 is_spsummonable_card();
int32 is_fusion_summonable_card(uint32 summon_type);
int32 is_spsummonable(effect* proc, material_info info = null_info);
int32 is_summonable(effect* proc, uint8 min_tribute, uint32 zone = 0x1f, uint32 releasable = 0xff00ff);
int32 is_can_be_summoned(uint8 playerid, uint8 ingore_count, effect* peffect, uint8 min_tribute, uint32 zone = 0x1f);
int32 get_summon_tribute_count();
int32 get_set_tribute_count();
int32 is_can_be_flip_summoned(uint8 playerid);
int32 is_special_summonable(uint8 playerid, uint32 summon_type, material_info info = null_info);
int32 is_can_be_special_summoned(effect* reason_effect, uint32 sumtype, uint8 sumpos, uint8 sumplayer, uint8 toplayer, uint8 nocheck, uint8 nolimit, uint32 zone);
uint8 get_spsummonable_position(effect* reason_effect, uint32 sumtype, uint8 sumpos, uint8 sumplayer, uint8 toplayer);
int32 is_setable_mzone(uint8 playerid, uint8 ignore_count, effect* peffect, uint8 min_tribute, uint32 zone = 0x1f);
int32 is_setable_szone(uint8 playerid, uint8 ignore_fd = 0);
int32 is_affect_by_effect(effect* reason_effect);
int32 is_can_be_disabled_by_effect(effect* reason_effect);
int32 is_destructable();
int32 is_destructable_by_battle(card* pcard);
effect* check_indestructable_by_effect(effect* reason_effect, uint8 playerid);
int32 is_destructable_by_effect(effect* reason_effect, uint8 playerid);
int32 is_removeable(uint8 playerid, uint8 pos, uint32 reason);
int32 is_removeable_as_cost(uint8 playerid, uint8 pos);
int32 is_releasable_by_summon(uint8 playerid, card* pcard);
int32 is_releasable_by_nonsummon(uint8 playerid);
int32 is_releasable_by_effect(uint8 playerid, effect* reason_effect);
int32 is_capable_send_to_grave(uint8 playerid);
int32 is_capable_send_to_hand(uint8 playerid);
int32 is_capable_send_to_deck(uint8 playerid);
int32 is_capable_send_to_extra(uint8 playerid);
int32 is_capable_cost_to_grave(uint8 playerid);
int32 is_capable_cost_to_hand(uint8 playerid);
int32 is_capable_cost_to_deck(uint8 playerid);
int32 is_capable_cost_to_extra(uint8 playerid);
int32 is_capable_attack();
int32 is_capable_attack_announce(uint8 playerid);
int32 is_capable_change_position(uint8 playerid);
int32 is_capable_change_position_by_effect(uint8 playerid);
int32 is_capable_turn_set(uint8 playerid);
int32 is_capable_change_control();
int32 is_control_can_be_changed(int32 ignore_mzone, uint32 zone);
int32 is_capable_be_battle_target(card* pcard);
int32 is_capable_be_effect_target(effect* reason_effect, uint8 playerid);
int32 is_capable_overlay(uint8 playerid);
int32 is_can_be_fusion_material(card* fcard, uint32 summon_type);
int32 is_can_be_synchro_material(card* scard, card* tuner = 0);
int32 is_can_be_ritual_material(card* scard);
int32 is_can_be_xyz_material(card* scard);
int32 is_can_be_link_material(card* scard);
int32_t check_unique_code(card* pcard);
void get_unique_target(card_set* cset, int32_t controler, card* icard = nullptr);
int32_t check_cost_condition(int32_t ecode, int32_t playerid);
int32_t check_cost_condition(int32_t ecode, int32_t playerid, int32_t sumtype);
int32_t is_summonable_card() const;
int32_t is_spsummonable_card();
int32_t is_fusion_summonable_card(uint32_t summon_type);
int32_t is_spsummonable(effect* proc, material_info info = null_info);
int32_t is_summonable(effect* proc, uint8_t min_tribute, uint32_t zone = 0x1f, uint32_t releasable = 0xff00ff);
int32_t is_can_be_summoned(uint8_t playerid, uint8_t ingore_count, effect* peffect, uint8_t min_tribute, uint32_t zone = 0x1f);
int32_t is_summon_negatable(uint32_t sumtype, effect* reason_effect);
int32_t get_summon_tribute_count();
int32_t get_set_tribute_count();
int32_t is_can_be_flip_summoned(uint8_t playerid);
int32_t is_special_summonable(uint8_t playerid, uint32_t summon_type, material_info info = null_info);
int32_t is_can_be_special_summoned(effect* reason_effect, uint32_t sumtype, uint8_t sumpos, uint8_t sumplayer, uint8_t toplayer, uint8_t nocheck, uint8_t nolimit, uint32_t zone);
uint8_t get_spsummonable_position(effect* reason_effect, uint32_t sumtype, uint8_t sumpos, uint8_t sumplayer, uint8_t toplayer);
int32_t is_setable_mzone(uint8_t playerid, uint8_t ignore_count, effect* peffect, uint8_t min_tribute, uint32_t zone = 0x1f);
int32_t is_setable_szone(uint8_t playerid, uint8_t ignore_fd = 0);
int32_t is_affect_by_effect(effect* reason_effect);
int32_t is_can_be_disabled_by_effect(effect* reason_effect, bool is_monster_effect);
int32_t is_destructable();
int32_t is_destructable_by_battle(card* pcard);
effect* check_indestructable_by_effect(effect* reason_effect, uint8_t playerid);
int32_t is_destructable_by_effect(effect* reason_effect, uint8_t playerid);
int32_t is_removeable(uint8_t playerid, uint8_t pos, uint32_t reason);
int32_t is_removeable_as_cost(uint8_t playerid, uint8_t pos);
int32_t is_releasable_by_summon(uint8_t playerid, card* pcard);
int32_t is_releasable_by_nonsummon(uint8_t playerid, uint32_t reason);
int32_t is_releasable_by_effect(uint8_t playerid, effect* reason_effect);
int32_t is_capable_send_to_grave(uint8_t playerid);
int32_t is_capable_send_to_hand(uint8_t playerid);
int32_t is_capable_send_to_deck(uint8_t playerid, uint8_t send_activating = FALSE);
int32_t is_capable_send_to_extra(uint8_t playerid);
int32_t is_capable_cost_to_grave(uint8_t playerid);
int32_t is_capable_cost_to_hand(uint8_t playerid);
int32_t is_capable_cost_to_deck(uint8_t playerid);
int32_t is_capable_cost_to_extra(uint8_t playerid);
int32_t is_capable_attack();
int32_t is_capable_attack_announce(uint8_t playerid);
int32_t is_capable_change_position(uint8_t playerid);
int32_t is_capable_change_position_by_effect(uint8_t playerid);
int32_t is_capable_turn_set(uint8_t playerid);
int32_t is_capable_change_control();
int32_t is_control_can_be_changed(int32_t ignore_mzone, uint32_t zone);
int32_t is_capable_be_battle_target(card* pcard);
int32_t is_capable_be_effect_target(effect* reason_effect, uint8_t playerid);
int32_t is_capable_overlay(uint8_t playerid);
int32_t is_can_be_fusion_material(card* fcard, uint32_t summon_type);
int32_t is_can_be_synchro_material(card* scard, card* tuner = nullptr);
int32_t is_can_be_ritual_material(card* scard);
int32_t is_can_be_xyz_material(card* scard);
int32_t is_can_be_link_material(card* scard);
int32_t is_original_effect_property(int32_t filter);
int32_t is_effect_property(int32_t filter);
};
//Summon Type
#define SUMMON_TYPE_NORMAL 0x10000000
#define SUMMON_TYPE_ADVANCE 0x11000000
#define SUMMON_TYPE_DUAL 0x12000000
#define SUMMON_TYPE_FLIP 0x20000000
#define SUMMON_TYPE_SPECIAL 0x40000000
#define SUMMON_TYPE_FUSION 0x43000000
#define SUMMON_TYPE_RITUAL 0x45000000
#define SUMMON_TYPE_SYNCHRO 0x46000000
#define SUMMON_TYPE_XYZ 0x49000000
#define SUMMON_TYPE_PENDULUM 0x4a000000
#define SUMMON_TYPE_LINK 0x4c000000
//Summon Type in summon_info
#define SUMMON_TYPE_NORMAL 0x10000000U
#define SUMMON_TYPE_ADVANCE 0x11000000U
#define SUMMON_TYPE_FLIP 0x20000000U
#define SUMMON_TYPE_SPECIAL 0x40000000U
#define SUMMON_TYPE_FUSION 0x43000000U
#define SUMMON_TYPE_RITUAL 0x45000000U
#define SUMMON_TYPE_SYNCHRO 0x46000000U
#define SUMMON_TYPE_XYZ 0x49000000U
#define SUMMON_TYPE_PENDULUM 0x4a000000U
#define SUMMON_TYPE_LINK 0x4c000000U
//Gemini Summon
#define SUMMON_TYPE_DUAL 0x12000000U
//bitfield blocks
#define SUMMON_VALUE_MAIN_TYPE 0xf0000000U
#define SUMMON_VALUE_SUB_TYPE 0x0f000000U
#define SUMMON_VALUE_LOCATION 0x00ff0000U
#define SUMMON_VALUE_CUSTOM_TYPE 0x0000ffffU
constexpr uint32_t DEFAULT_SUMMON_TYPE = SUMMON_VALUE_MAIN_TYPE | SUMMON_VALUE_SUB_TYPE | SUMMON_VALUE_CUSTOM_TYPE;
#define SUMMON_VALUE_FUTURE_FUSION 0x18
//Counter
#define COUNTER_WITHOUT_PERMIT 0x1000
#define COUNTER_WITHOUT_PERMIT 0x1000U
//#define COUNTER_NEED_ENABLE 0x2000
//Assume
#define ASSUME_CODE 1
#define ASSUME_TYPE 2
#define ASSUME_LEVEL 3
......@@ -412,10 +440,17 @@ public:
#define ASSUME_ATTACK 7
#define ASSUME_DEFENSE 8
//double-name cards
#define CARD_MARINE_DOLPHIN 78734254
#define CARD_TWINKLE_MOSS 13857930
#define CARD_ARTWORK_VERSIONS_OFFSET 10
//Special Summon effect info
#define SUMMON_INFO_CODE 0x01
#define SUMMON_INFO_CODE2 0x02
#define SUMMON_INFO_TYPE 0x04
#define SUMMON_INFO_LEVEL 0x08
#define SUMMON_INFO_RANK 0x10
#define SUMMON_INFO_ATTRIBUTE 0x20
#define SUMMON_INFO_RACE 0x40
#define SUMMON_INFO_ATTACK 0x80
#define SUMMON_INFO_DEFENSE 0x100
#define SUMMON_INFO_REASON_EFFECT 0x200
#define SUMMON_INFO_REASON_PLAYER 0x400
#endif /* CARD_H_ */
card_data.h 0 → 100644
View file @ 287dd26c
#ifndef CARD_DATA_H_
#define CARD_DATA_H_
#include <cstring>
#include <unordered_map>
#include "common.h"
constexpr int CARD_ARTWORK_VERSIONS_OFFSET = 20;
constexpr int SIZE_SETCODE = 16;
constexpr uint32_t CARD_BLACK_LUSTER_SOLDIER2 = 5405695;
//double name
constexpr uint32_t CARD_MARINE_DOLPHIN = 78734254;
constexpr uint32_t CARD_TWINKLE_MOSS = 13857930;
constexpr uint32_t CARD_TIMAEUS = 1784686;
constexpr uint32_t CARD_CRITIAS = 11082056;
constexpr uint32_t CARD_HERMOS = 46232525;
const std::unordered_map<uint32_t, uint32_t> second_code = {
{CARD_MARINE_DOLPHIN, 17955766u},
{CARD_TWINKLE_MOSS, 17732278u},
{CARD_TIMAEUS, 10000050u},
{CARD_CRITIAS, 10000060u},
{CARD_HERMOS, 10000070u},
};
struct card_data {
uint32_t code{};
uint32_t alias{};
uint16_t setcode[SIZE_SETCODE]{};
uint32_t type{};
uint32_t level{};
uint32_t attribute{};
uint32_t race{};
int32_t attack{};
int32_t defense{};
uint32_t lscale{};
uint32_t rscale{};
uint32_t link_marker{};
void clear() {
std::memset(this, 0, sizeof(card_data));
}
bool is_setcode(uint32_t value) const {
const uint16_t settype = value & 0x0fff;
const uint16_t setsubtype = value & 0xf000;
for (auto& x : setcode) {
if ((x & 0x0fff) == settype && (x & setsubtype) == setsubtype)
return true;
if (!x)
return false;
}
return false;
}
bool is_alternative() const {
if (code == CARD_BLACK_LUSTER_SOLDIER2)
return false;
return alias && (alias < code + CARD_ARTWORK_VERSIONS_OFFSET) && (code < alias + CARD_ARTWORK_VERSIONS_OFFSET);
}
void set_setcode(uint64_t value) {
int ctr = 0;
while (value) {
if (value & 0xffff) {
setcode[ctr] = value & 0xffff;
++ctr;
}
value >>= 16;
}
if (ctr < SIZE_SETCODE)
std::memset(setcode + ctr, 0, (SIZE_SETCODE - ctr) * sizeof(uint16_t));
}
uint32_t get_original_code() const {
return is_alternative() ? alias : code;
}
};
#endif /* CARD_DATA_H_ */
common.h
View file @ 287dd26c
......@@ -9,16 +9,12 @@
#define COMMON_H_
#include <stdint.h>
typedef unsigned long long uint64;
typedef unsigned int uint32;
typedef unsigned short uint16;
typedef unsigned char uint8;
#include <assert.h>
typedef unsigned char byte;
typedef long long int64;
typedef int int32;
typedef short int16;
typedef signed char int8;
typedef int BOOL;
inline bool check_playerid(int32_t playerid) {
return playerid >= 0 && playerid <= 1;
}
#define MATCH_ALL(x,y) (((x)&(y))==(y))
#define MATCH_ANY(x,y) ((x)&(y))
......@@ -30,25 +26,35 @@ typedef int BOOL;
#define OPERATION_CANCELED -1
#define TRUE 1
#define FALSE 0
#ifndef NULL
#define NULL 0
#endif
struct card_sort {
bool operator()(void* const & c1, void* const & c2) const;
};
#define SIZE_MESSAGE_BUFFER 0x2000
#define SIZE_RETURN_VALUE 512
#define SIZE_AI_NAME 128
#define SIZE_HINT_MSG 1024
#define PROCESSOR_BUFFER_LEN 0x0fffffff
#define PROCESSOR_FLAG 0xf0000000
#define PROCESSOR_NONE 0
#define PROCESSOR_WAITING 0x10000000
#define PROCESSOR_END 0x20000000
#define MASTER_RULE3 3 //Master Rule 3 (2014)
#define NEW_MASTER_RULE 4 //New Master Rule (2017)
#define MASTER_RULE_2020 5 //Master Rule 2020
#define CURRENT_RULE 5
//Locations
#define LOCATION_DECK 0x01 //
#define LOCATION_HAND 0x02 //
#define LOCATION_MZONE 0x04 //
#define LOCATION_SZONE 0x08 //
#define LOCATION_GRAVE 0x10 //
#define LOCATION_REMOVED 0x20 //
#define LOCATION_EXTRA 0x40 //
#define LOCATION_OVERLAY 0x80 //
#define LOCATION_ONFIELD 0x0c //
#define LOCATION_FZONE 0x100 //
#define LOCATION_PZONE 0x200 //
#define LOCATION_DECK 0x01U
#define LOCATION_HAND 0x02U
#define LOCATION_MZONE 0x04U
#define LOCATION_SZONE 0x08U
#define LOCATION_GRAVE 0x10U
#define LOCATION_REMOVED 0x20U
#define LOCATION_EXTRA 0x40U
#define LOCATION_OVERLAY 0x80U
#define LOCATION_ONFIELD (LOCATION_MZONE | LOCATION_SZONE)
#define LOCATION_FZONE 0x100U
#define LOCATION_PZONE 0x200U
//For redirect
#define LOCATION_DECKBOT 0x10001 //Return to deck bottom
#define LOCATION_DECKSHF 0x20001 //Return to deck and shuffle
......@@ -69,6 +75,10 @@ struct card_sort {
//Flip effect flags
#define NO_FLIP_EFFECT 0x10000
//Move to field flags
#define RETURN_TEMP_REMOVE_TO_FIELD 1
#define RETURN_TRAP_MONSTER_TO_SZONE 2
//Types
#define TYPE_MONSTER 0x1 //
#define TYPE_SPELL 0x2 //
......@@ -96,7 +106,11 @@ struct card_sort {
#define TYPE_SPSUMMON 0x2000000 //
#define TYPE_LINK 0x4000000 //
#define TYPES_EXTRA_DECK (TYPE_FUSION | TYPE_SYNCHRO | TYPE_XYZ | TYPE_LINK)
//Attributes
#define ATTRIBUTES_COUNT 7
#define ATTRIBUTE_ALL 0x7f //
#define ATTRIBUTE_EARTH 0x01 //
#define ATTRIBUTE_WATER 0x02 //
#define ATTRIBUTE_FIRE 0x04 //
......@@ -106,6 +120,8 @@ struct card_sort {
#define ATTRIBUTE_DEVINE 0x40 //
//Races
#define RACES_COUNT 26
#define RACE_ALL 0x3ffffff
#define RACE_WARRIOR 0x1 //
#define RACE_SPELLCASTER 0x2 //
#define RACE_FAIRY 0x4 //
......@@ -131,6 +147,7 @@ struct card_sort {
#define RACE_CREATORGOD 0x400000 //
#define RACE_WYRM 0x800000 //
#define RACE_CYBERSE 0x1000000 //
#define RACE_ILLUSION 0x2000000 //
//Reason
#define REASON_DESTROY 0x1 //
......@@ -161,29 +178,33 @@ struct card_sort {
#define REASON_REVEAL 0x8000000 //
#define REASON_LINK 0x10000000 //
#define REASON_LOST_OVERLAY 0x20000000 //
#define REASON_MAINTENANCE 0x40000000 //
#define REASON_ACTION 0x80000000 //
#define REASONS_PROCEDURE (REASON_SYNCHRO | REASON_XYZ | REASON_LINK)
//Status
#define STATUS_DISABLED 0x0001 //
#define STATUS_TO_ENABLE 0x0002 //
#define STATUS_TO_DISABLE 0x0004 //
#define STATUS_PROC_COMPLETE 0x0008 //
#define STATUS_SET_TURN 0x0010 //
#define STATUS_NO_LEVEL 0x0020 //
#define STATUS_BATTLE_RESULT 0x0040 //
#define STATUS_SPSUMMON_STEP 0x0080 //
#define STATUS_FORM_CHANGED 0x0100 //
#define STATUS_SUMMONING 0x0200 //
#define STATUS_EFFECT_ENABLED 0x0400 //
#define STATUS_SUMMON_TURN 0x0800 //
#define STATUS_DESTROY_CONFIRMED 0x1000 //
#define STATUS_LEAVE_CONFIRMED 0x2000 //
#define STATUS_BATTLE_DESTROYED 0x4000 //
#define STATUS_COPYING_EFFECT 0x8000 //
#define STATUS_CHAINING 0x10000 //
#define STATUS_SUMMON_DISABLED 0x20000 //
#define STATUS_ACTIVATE_DISABLED 0x40000 //
#define STATUS_DISABLED 0x0001
#define STATUS_TO_ENABLE 0x0002
#define STATUS_TO_DISABLE 0x0004
#define STATUS_PROC_COMPLETE 0x0008
#define STATUS_SET_TURN 0x0010
#define STATUS_NO_LEVEL 0x0020
#define STATUS_BATTLE_RESULT 0x0040
#define STATUS_SPSUMMON_STEP 0x0080
#define STATUS_CANNOT_CHANGE_FORM 0x0100
#define STATUS_SUMMONING 0x0200
#define STATUS_EFFECT_ENABLED 0x0400
#define STATUS_SUMMON_TURN 0x0800
#define STATUS_DESTROY_CONFIRMED 0x1000
#define STATUS_LEAVE_CONFIRMED 0x2000
#define STATUS_BATTLE_DESTROYED 0x4000
#define STATUS_COPYING_EFFECT 0x8000
#define STATUS_CHAINING 0x10000
#define STATUS_SUMMON_DISABLED 0x20000
#define STATUS_ACTIVATE_DISABLED 0x40000
#define STATUS_EFFECT_REPLACED 0x80000
#define STATUS_FUTURE_FUSION 0x100000
#define STATUS_FLIP_SUMMONING 0x100000
#define STATUS_ATTACK_CANCELED 0x200000
#define STATUS_INITIALIZING 0x400000
#define STATUS_TO_HAND_WITHOUT_CONFIRM 0x800000
......@@ -194,6 +215,7 @@ struct card_sort {
#define STATUS_OPPO_BATTLE 0x10000000
#define STATUS_FLIP_SUMMON_TURN 0x20000000
#define STATUS_SPSUMMON_TURN 0x40000000
#define STATUS_FLIP_SUMMON_DISABLED 0x80000000
//Query list
#define QUERY_CODE 0x1
......@@ -233,12 +255,12 @@ struct card_sort {
//Messages
#define MSG_RETRY 1
#define MSG_HINT 2
#define MSG_WAITING 3
#define MSG_START 4
//#define MSG_WAITING 3
//#define MSG_START 4
#define MSG_WIN 5
#define MSG_UPDATE_DATA 6
#define MSG_UPDATE_CARD 7
#define MSG_REQUEST_DECK 8
//#define MSG_UPDATE_DATA 6
//#define MSG_UPDATE_CARD 7
//#define MSG_REQUEST_DECK 8
#define MSG_SELECT_BATTLECMD 10
#define MSG_SELECT_IDLECMD 11
#define MSG_SELECT_EFFECTYN 12
......@@ -249,7 +271,6 @@ struct card_sort {
#define MSG_SELECT_PLACE 18
#define MSG_SELECT_POSITION 19
#define MSG_SELECT_TRIBUTE 20
//#define MSG_SORT_CHAIN 21
#define MSG_SELECT_COUNTER 22
#define MSG_SELECT_SUM 23
#define MSG_SELECT_DISFIELD 24
......@@ -259,7 +280,7 @@ struct card_sort {
#define MSG_CONFIRM_CARDS 31
#define MSG_SHUFFLE_DECK 32
#define MSG_SHUFFLE_HAND 33
#define MSG_REFRESH_DECK 34
//#define MSG_REFRESH_DECK 34
#define MSG_SWAP_GRAVE_DECK 35
#define MSG_SHUFFLE_SET_CARD 36
#define MSG_REVERSE_DECK 37
......@@ -286,7 +307,7 @@ struct card_sort {
#define MSG_CHAIN_END 74
#define MSG_CHAIN_NEGATED 75
#define MSG_CHAIN_DISABLED 76
#define MSG_CARD_SELECTED 80
//#define MSG_CARD_SELECTED 80
#define MSG_RANDOM_SELECTED 81
#define MSG_BECOME_TARGET 83
#define MSG_DRAW 90
......@@ -294,7 +315,7 @@ struct card_sort {
#define MSG_RECOVER 92
#define MSG_EQUIP 93
#define MSG_LPUPDATE 94
#define MSG_UNEQUIP 95
//#define MSG_UNEQUIP 95
#define MSG_CARD_TARGET 96
#define MSG_CANCEL_TARGET 97
#define MSG_PAY_LPCOST 100
......@@ -306,9 +327,9 @@ struct card_sort {
#define MSG_DAMAGE_STEP_START 113
#define MSG_DAMAGE_STEP_END 114
#define MSG_MISSED_EFFECT 120
#define MSG_BE_CHAIN_TARGET 121
#define MSG_CREATE_RELATION 122
#define MSG_RELEASE_RELATION 123
//#define MSG_BE_CHAIN_TARGET 121
//#define MSG_CREATE_RELATION 122
//#define MSG_RELEASE_RELATION 123
#define MSG_TOSS_COIN 130
#define MSG_TOSS_DICE 131
#define MSG_ROCK_PAPER_SCISSORS 132
......@@ -319,9 +340,9 @@ struct card_sort {
#define MSG_ANNOUNCE_NUMBER 143
#define MSG_CARD_HINT 160
#define MSG_TAG_SWAP 161
#define MSG_RELOAD_FIELD 162 // Debug.ReloadFieldEnd()
#define MSG_AI_NAME 163
#define MSG_SHOW_HINT 164
#define MSG_RELOAD_FIELD 162 // Debug.ReloadFieldEnd() or query_field_info()
#define MSG_AI_NAME 163 // Debug.AIName()
#define MSG_SHOW_HINT 164 // Debug.ShowHint()
#define MSG_PLAYER_HINT 165
#define MSG_MATCH_KILL 170
#define MSG_CUSTOM_MSG 180
......@@ -388,12 +409,13 @@ struct card_sort {
//Options
#define DUEL_TEST_MODE 0x01
#define DUEL_ATTACK_FIRST_TURN 0x02
#define DUEL_OLD_REPLAY 0x04
//#define DUEL_OLD_REPLAY 0x04
#define DUEL_OBSOLETE_RULING 0x08
#define DUEL_PSEUDO_SHUFFLE 0x10
#define DUEL_TAG_MODE 0x20
#define DUEL_SIMPLE_AI 0x40
#define DUEL_RETURN_DECK_TOP 0x80
#define DUEL_REVEAL_DECK_SEQ 0x100
//Activity
#define ACTIVITY_SUMMON 1
......
duel.cpp
View file @ 287dd26c
......@@ -5,6 +5,7 @@
* Author: Argon
*/
#include <cstring>
#include "duel.h"
#include "interpreter.h"
#include "field.h"
......@@ -12,12 +13,16 @@
#include "effect.h"
#include "group.h"
#include "ocgapi.h"
#include "buffer.h"
duel::duel() {
lua = new interpreter(this);
game_field = new field(this);
game_field->temp_card = new_card(0);
clear_buffer();
game_field->temp_card = new_card(TEMP_CARD_ID);
message_buffer.reserve(SIZE_MESSAGE_BUFFER);
#ifdef _WIN32
_set_error_mode(_OUT_TO_MSGBOX);
#endif // _WIN32
}
duel::~duel() {
for(auto& pcard : cards)
......@@ -40,16 +45,17 @@ void duel::clear() {
cards.clear();
groups.clear();
effects.clear();
assumes.clear();
sgroups.clear();
uncopy.clear();
game_field = new field(this);
game_field->temp_card = new_card(0);
game_field->temp_card = new_card(TEMP_CARD_ID);
}
card* duel::new_card(uint32 code) {
card* duel::new_card(uint32_t code) {
card* pcard = new card(this);
cards.insert(pcard);
if(code)
if (code != TEMP_CARD_ID)
::read_card(code, &(pcard->data));
else
pcard->data.clear();
pcard->data.code = code;
lua->register_card(pcard);
return pcard;
......@@ -94,13 +100,15 @@ void duel::delete_effect(effect* peffect) {
effects.erase(peffect);
delete peffect;
}
int32 duel::read_buffer(byte* buf) {
std::memcpy(buf, buffer, bufferlen);
return bufferlen;
int32_t duel::read_buffer(byte* buf) {
auto size = buffer_size();
if (size)
std::memcpy(buf, message_buffer.data(), size);
return (int32_t)size;
}
void duel::release_script_group() {
for(auto& pgroup : sgroups) {
if(pgroup->is_readonly == 0) {
if(pgroup->is_readonly == GTYPE_DEFAULT) {
lua->unregister_group(pgroup);
groups.erase(pgroup);
delete pgroup;
......@@ -113,36 +121,29 @@ void duel::restore_assumes() {
pcard->assume_type = 0;
assumes.clear();
}
void duel::write_buffer32(uint32 value) {
std::memcpy(bufferp, &value, sizeof(value));
bufferp += 4;
bufferlen += 4;
void duel::write_buffer(const void* data, int size) {
vector_write_block(message_buffer, data, size);
}
void duel::write_buffer32(uint32_t value) {
vector_write<uint32_t>(message_buffer, value);
}
void duel::write_buffer16(uint16 value) {
std::memcpy(bufferp, &value, sizeof(value));
bufferp += 2;
bufferlen += 2;
void duel::write_buffer16(uint16_t value) {
vector_write<uint16_t>(message_buffer, value);
}
void duel::write_buffer8(uint8 value) {
std::memcpy(bufferp, &value, sizeof(value));
bufferp += 1;
bufferlen += 1;
void duel::write_buffer8(uint8_t value) {
vector_write<unsigned char>(message_buffer, value);
}
void duel::clear_buffer() {
bufferlen = 0;
bufferp = buffer;
message_buffer.clear();
}
void duel::set_responsei(uint32 resp) {
void duel::set_responsei(uint32_t resp) {
game_field->returns.ivalue[0] = resp;
}
void duel::set_responseb(byte* resp) {
std::memcpy(game_field->returns.bvalue, resp, 64);
std::memcpy(game_field->returns.bvalue, resp, SIZE_RETURN_VALUE);
}
int32 duel::get_next_integer(int32 l, int32 h) {
if (game_field->core.duel_options & DUEL_OLD_REPLAY) {
return random.get_random_integer_old(l, h);
}
else {
return random.get_random_integer(l, h);
}
int32_t duel::get_next_integer(int32_t l, int32_t h) {
if (rng_version == 1)
return random.get_random_integer_v1(l, h);
return random.get_random_integer_v2(l, h);
}
duel.h
View file @ 287dd26c
......@@ -9,9 +9,11 @@
#define DUEL_H_
#include "common.h"
#include "sort.h"
#include "mtrandom.h"
#include <set>
#include <unordered_set>
#include <vector>
class card;
class group;
......@@ -19,16 +21,17 @@ class effect;
class field;
class interpreter;
using card_set = std::set<card*, card_sort>;
class duel {
public:
using card_set = std::set<card*, card_sort>;
char strbuffer[256];
byte buffer[0x1000];
uint32 bufferlen;
byte* bufferp;
char strbuffer[256]{};
int32_t rng_version{ 2 };
interpreter* lua;
field* game_field;
mt19937 random;
mtrandom random;
std::vector<byte> message_buffer;
std::unordered_set<card*> cards;
std::unordered_set<card*> assumes;
std::unordered_set<group*> groups;
......@@ -40,7 +43,10 @@ public:
~duel();
void clear();
card* new_card(uint32 code);
uint32_t buffer_size() const {
return (uint32_t)message_buffer.size() & PROCESSOR_BUFFER_LEN;
}
card* new_card(uint32_t code);
group* new_group();
group* new_group(card* pcard);
group* new_group(const card_set& cset);
......@@ -50,14 +56,15 @@ public:
void delete_effect(effect* peffect);
void release_script_group();
void restore_assumes();
int32 read_buffer(byte* buf);
void write_buffer32(uint32 value);
void write_buffer16(uint16 value);
void write_buffer8(uint8 value);
int32_t read_buffer(byte* buf);
void write_buffer(const void* data, int size);
void write_buffer32(uint32_t value);
void write_buffer16(uint16_t value);
void write_buffer8(uint8_t value);
void clear_buffer();
void set_responsei(uint32 resp);
void set_responsei(uint32_t resp);
void set_responseb(byte* resp);
int32 get_next_integer(int32 l, int32 h);
int32_t get_next_integer(int32_t l, int32_t h);
private:
group* register_group(group* pgroup);
};
......
effect.cpp
View file @ 287dd26c
......@@ -12,80 +12,47 @@
#include "interpreter.h"
bool effect_sort_id(const effect* e1, const effect* e2) {
int32_t is_single1 = e1->is_initial_single();
int32_t is_single2 = e2->is_initial_single();
if (is_single1 != is_single2)
return is_single1 > is_single2;
return e1->id < e2->id;
}
// return: code is an event reserved for EFFECT_TYPE_CONTINUOUS or not
bool is_continuous_event(uint32 code) {
bool is_continuous_event(uint32_t code) {
if (code & EVENT_CUSTOM)
return false;
else if (code & 0xf0000)
else if (code & 0xf0000) // EVENT_ADD_COUNTER, EVENT_REMOVE_COUNTER
return false;
else if (code & 0xf000)
else if (code & 0xf000) // EVENT_PHASE_START must be continuous, but other EVENT_PHASE must not be
return !!(code & EVENT_PHASE_START);
else
return continuous_event.find(code) != continuous_event.end();
}
effect::effect(duel* pd) {
ref_handle = 0;
pduel = pd;
owner = 0;
handler = 0;
description = 0;
effect_owner = PLAYER_NONE;
card_type = 0;
active_type = 0;
active_location = 0;
active_sequence = 0;
active_handler = 0;
id = 0;
code = 0;
type = 0;
flag[0] = 0;
flag[1] = 0;
copy_id = 0;
range = 0;
s_range = 0;
o_range = 0;
count_limit = 0;
count_limit_max = 0;
reset_count = 0;
reset_flag = 0;
count_code = 0;
category = 0;
effect::effect(duel* pd)
: pduel(pd) {
label.reserve(4);
label_object = 0;
hint_timing[0] = 0;
hint_timing[1] = 0;
status = 0;
condition = 0;
cost = 0;
target = 0;
value = 0;
operation = 0;
cost_checked = FALSE;
}
int32 effect::is_disable_related() {
}
int32_t effect::is_disable_related() const {
if (code == EFFECT_IMMUNE_EFFECT || code == EFFECT_DISABLE || code == EFFECT_CANNOT_DISABLE || code == EFFECT_FORBIDDEN)
return TRUE;
return FALSE;
}
int32 effect::is_self_destroy_related() {
int32_t effect::is_self_destroy_related() const {
if(code == EFFECT_UNIQUE_CHECK || code == EFFECT_SELF_DESTROY || code == EFFECT_SELF_TOGRAVE)
return TRUE;
return FALSE;
}
int32 effect::is_can_be_forbidden() {
int32_t effect::is_can_be_forbidden() const {
if (is_flag(EFFECT_FLAG_CANNOT_DISABLE) && !is_flag(EFFECT_FLAG_CANNOT_NEGATE))
return FALSE;
if (code == EFFECT_CHANGE_CODE)
return FALSE;
return TRUE;
}
// check if a single/field/equip effect is available
// check properties: range, EFFECT_FLAG_OWNER_RELATE, STATUS_BATTLE_DESTROYED, STATUS_EFFECT_ENABLED, disabled/forbidden
// check fucntions: condition
int32 effect::is_available(int32 neglect_disabled) {
int32_t effect::is_available(int32_t neglect_disabled) {
if (type & EFFECT_TYPE_ACTIONS)
return FALSE;
if ((type & (EFFECT_TYPE_SINGLE | EFFECT_TYPE_XMATERIAL)) && !(type & EFFECT_TYPE_FIELD)) {
......@@ -136,7 +103,9 @@ int32 effect::is_available(int32 neglect_disabled) {
return FALSE;
if(!phandler->get_status(STATUS_EFFECT_ENABLED) && !is_flag(EFFECT_FLAG_IMMEDIATELY_APPLY))
return FALSE;
if((phandler->current.location & LOCATION_ONFIELD) && !phandler->is_position(POS_FACEUP))
if (phandler->current.is_location(LOCATION_ONFIELD) && !phandler->is_position(POS_FACEUP))
return FALSE;
if (phandler->current.is_stzone() && (phandler->data.type & (TYPE_SPELL | TYPE_TRAP)) && phandler->is_affected_by_effect(EFFECT_CHANGE_TYPE))
return FALSE;
if(is_flag(EFFECT_FLAG_OWNER_RELATE) && is_can_be_forbidden() && powner->is_status(STATUS_FORBIDDEN))
return FALSE;
......@@ -153,7 +122,7 @@ int32 effect::is_available(int32 neglect_disabled) {
if (!condition)
return TRUE;
pduel->lua->add_param(this, PARAM_TYPE_EFFECT);
int32 res = pduel->lua->check_condition(condition, 1);
int32_t res = pduel->lua->check_condition(condition, 1);
if(res) {
if(!(status & EFFECT_STATUS_AVAILABLE))
id = pduel->game_field->infos.field_id++;
......@@ -163,17 +132,16 @@ int32 effect::is_available(int32 neglect_disabled) {
return res;
}
// check if a count limit effect counter is available, which should be available even if the effect is disabled
int32 effect::limit_counter_is_available() {
int32_t effect::limit_counter_is_available() {
return is_available(TRUE);
}
// check if a effect is EFFECT_TYPE_SINGLE and is ready
// check: range, enabled, condition
int32 effect::is_single_ready() {
int32_t effect::is_single_ready() {
if(type & EFFECT_TYPE_ACTIONS)
return FALSE;
if((type & (EFFECT_TYPE_SINGLE | EFFECT_TYPE_XMATERIAL)) && !(type & EFFECT_TYPE_FIELD)) {
card* phandler = get_handler();
card* powner = get_owner();
if(phandler->current.controler == PLAYER_NONE)
return FALSE;
if(is_flag(EFFECT_FLAG_SINGLE_RANGE) && !in_range(phandler))
......@@ -188,21 +156,19 @@ int32 effect::is_single_ready() {
if(!condition)
return TRUE;
pduel->lua->add_param(this, PARAM_TYPE_EFFECT);
int32 res = pduel->lua->check_condition(condition, 1);
int32_t res = pduel->lua->check_condition(condition, 1);
return res;
}
// reset_count: count of effect reset
// count_limit: left count of activation
// count_limit_max: max count of activation
int32 effect::check_count_limit(uint8 playerid) {
int32_t effect::check_count_limit(uint8_t playerid) {
if(is_flag(EFFECT_FLAG_COUNT_LIMIT)) {
if(count_limit == 0)
return FALSE;
if(count_code) {
uint32 code = count_code & 0xfffffff;
uint32 count = count_limit_max;
if(code == 1) {
if(pduel->game_field->get_effect_code((count_code & 0xf0000000) | get_handler()->fieldid, PLAYER_NONE) >= count)
uint32_t limit_code = count_code & MAX_CARD_ID;
uint32_t limit_type = count_code & 0xf0000000U;
int32_t count = count_limit_max;
if(limit_code == EFFECT_COUNT_CODE_SINGLE) {
if(pduel->game_field->get_effect_code(limit_type | get_handler()->activate_count_id, PLAYER_NONE) >= count)
return FALSE;
} else {
if(pduel->game_field->get_effect_code(count_code, playerid) >= count)
......@@ -212,9 +178,69 @@ int32 effect::check_count_limit(uint8 playerid) {
}
return TRUE;
}
// check activate in hand/in set turn
int32_t effect::get_required_handorset_effects(effect_set* eset, uint8_t playerid, const tevent& e, int32_t neglect_loc) {
eset->clear();
if(!(type & EFFECT_TYPE_ACTIVATE))
return 1;
int32_t ecode = 0;
if (handler->current.location == LOCATION_HAND && !neglect_loc)
{
if(handler->data.type & TYPE_TRAP)
ecode = EFFECT_TRAP_ACT_IN_HAND;
else if((handler->data.type & TYPE_SPELL) && pduel->game_field->infos.turn_player != playerid) {
if(handler->data.type & TYPE_QUICKPLAY)
ecode = EFFECT_QP_ACT_IN_NTPHAND;
else
return FALSE;
}
}
else if (handler->current.location == LOCATION_SZONE)
{
if((handler->data.type & TYPE_TRAP) && handler->get_status(STATUS_SET_TURN))
ecode = EFFECT_TRAP_ACT_IN_SET_TURN;
if((handler->data.type & TYPE_SPELL) && (handler->data.type & TYPE_QUICKPLAY) && handler->get_status(STATUS_SET_TURN))
ecode = EFFECT_QP_ACT_IN_SET_TURN;
}
if (!ecode)
return 1;
int32_t available = 0;
effect_set tmp_eset;
handler->filter_effect(ecode, &tmp_eset);
if(!tmp_eset.size())
return available;
effect* oreason = pduel->game_field->core.reason_effect;
uint8_t op = pduel->game_field->core.reason_player;
pduel->game_field->core.reason_player = playerid;
pduel->game_field->save_lp_cost();
for(effect_set::size_type i = 0; i < tmp_eset.size(); ++i) {
auto peffect = tmp_eset[i];
if(peffect->check_count_limit(playerid)) {
pduel->game_field->core.reason_effect = peffect;
pduel->lua->add_param(peffect, PARAM_TYPE_EFFECT);
pduel->lua->add_param(playerid, PARAM_TYPE_INT);
pduel->lua->add_param(e.event_cards , PARAM_TYPE_GROUP);
pduel->lua->add_param(e.event_player, PARAM_TYPE_INT);
pduel->lua->add_param(e.event_value, PARAM_TYPE_INT);
pduel->lua->add_param(e.reason_effect , PARAM_TYPE_EFFECT);
pduel->lua->add_param(e.reason, PARAM_TYPE_INT);
pduel->lua->add_param(e.reason_player, PARAM_TYPE_INT);
pduel->lua->add_param(0, PARAM_TYPE_INT);
pduel->lua->add_param(this, PARAM_TYPE_EFFECT);
if(pduel->lua->check_condition(peffect->cost, 10)) {
available = 2;
eset->push_back(peffect);
}
}
}
pduel->game_field->core.reason_effect = oreason;
pduel->game_field->core.reason_player = op;
pduel->game_field->restore_lp_cost();
return available;
}
// check if an EFFECT_TYPE_ACTIONS effect can be activated
// for triggering effects, it checks EFFECT_FLAG_DAMAGE_STEP, EFFECT_FLAG_SET_AVAILABLE
int32 effect::is_activateable(uint8 playerid, const tevent& e, int32 neglect_cond, int32 neglect_cost, int32 neglect_target, int32 neglect_loc, int32 neglect_faceup) {
int32_t effect::is_activateable(uint8_t playerid, const tevent& e, int32_t neglect_cond, int32_t neglect_cost, int32_t neglect_target, int32_t neglect_loc, int32_t neglect_faceup) {
if(!(type & EFFECT_TYPE_ACTIONS))
return FALSE;
if(!check_count_limit(playerid))
......@@ -233,7 +259,7 @@ int32 effect::is_activateable(uint8 playerid, const tevent& e, int32 neglect_con
&& !pduel->game_field->get_cteffect(this, playerid, FALSE))
return FALSE;
}
uint32 zone = 0xff;
uint32_t zone = 0xff;
if(!(handler->data.type & (TYPE_FIELD | TYPE_PENDULUM)) && is_flag(EFFECT_FLAG_LIMIT_ZONE)) {
pduel->lua->add_param(playerid, PARAM_TYPE_INT);
pduel->lua->add_param(e.event_cards , PARAM_TYPE_GROUP);
......@@ -265,44 +291,16 @@ int32 effect::is_activateable(uint8 playerid, const tevent& e, int32 neglect_con
return FALSE;
}
// check activate in hand/in set turn
int32 ecode = 0;
if(handler->current.location == LOCATION_HAND && !neglect_loc) {
if(handler->data.type & TYPE_TRAP)
ecode = EFFECT_TRAP_ACT_IN_HAND;
else if((handler->data.type & TYPE_SPELL) && pduel->game_field->infos.turn_player != playerid) {
if(handler->data.type & TYPE_QUICKPLAY)
ecode = EFFECT_QP_ACT_IN_NTPHAND;
else
return FALSE;
}
} else if(handler->current.location == LOCATION_SZONE) {
if((handler->data.type & TYPE_TRAP) && handler->get_status(STATUS_SET_TURN))
ecode = EFFECT_TRAP_ACT_IN_SET_TURN;
if((handler->data.type & TYPE_SPELL) && (handler->data.type & TYPE_QUICKPLAY) && handler->get_status(STATUS_SET_TURN))
ecode = EFFECT_QP_ACT_IN_SET_TURN;
}
if(ecode) {
bool available = false;
effect_set eset;
handler->filter_effect(ecode, &eset);
for(int32 i = 0; i < eset.size(); ++i) {
if(eset[i]->check_count_limit(playerid)) {
available = true;
break;
}
}
if(!available)
if(!get_required_handorset_effects(&eset, playerid, e, neglect_loc))
return FALSE;
}
if(handler->is_status(STATUS_FORBIDDEN))
return FALSE;
if(handler->is_affected_by_effect(EFFECT_CANNOT_TRIGGER))
return FALSE;
} else if(!(type & EFFECT_TYPE_CONTINUOUS)) {
card* phandler = get_handler();
if(!(phandler->get_type() & TYPE_MONSTER) && (get_active_type() & TYPE_MONSTER))
return FALSE;
if((phandler->get_type() & TYPE_CONTINUOUS) && (phandler->get_type() & TYPE_EQUIP))
if(!(phandler->get_type() & TYPE_MONSTER) && (get_active_type(FALSE) & TYPE_MONSTER))
return FALSE;
if((type & EFFECT_TYPE_QUICK_O) && is_flag(EFFECT_FLAG_DELAY) && !in_range(phandler))
return FALSE;
......@@ -321,12 +319,14 @@ int32 effect::is_activateable(uint8 playerid, const tevent& e, int32 neglect_con
if(phandler->current.location == LOCATION_OVERLAY)
return FALSE;
if(phandler->current.location == LOCATION_DECK
|| pduel->game_field->core.duel_rule >= 5 && phandler->current.location == LOCATION_EXTRA && (phandler->current.position & POS_FACEDOWN)) {
|| pduel->game_field->core.duel_rule >= MASTER_RULE_2020 && phandler->current.location == LOCATION_EXTRA && (phandler->current.position & POS_FACEDOWN)) {
if((type & EFFECT_TYPE_SINGLE) && code != EVENT_TO_DECK)
return FALSE;
if((type & EFFECT_TYPE_FIELD) && !(range & (LOCATION_DECK | LOCATION_EXTRA)))
return FALSE;
}
if (phandler->current.is_stzone() && (phandler->data.type & (TYPE_SPELL|TYPE_TRAP)) && phandler->is_affected_by_effect(EFFECT_CHANGE_TYPE))
return FALSE;
if((type & EFFECT_TYPE_FIELD) && (phandler->current.controler != playerid) && !is_flag(EFFECT_FLAG_BOTH_SIDE | EFFECT_FLAG_EVENT_PLAYER))
return FALSE;
if(phandler->is_status(STATUS_FORBIDDEN))
......@@ -337,7 +337,8 @@ int32 effect::is_activateable(uint8 playerid, const tevent& e, int32 neglect_con
card* phandler = get_handler();
if((type & EFFECT_TYPE_FIELD) && phandler->is_status(STATUS_BATTLE_DESTROYED))
return FALSE;
if(((type & EFFECT_TYPE_FIELD) || ((type & EFFECT_TYPE_SINGLE) && is_flag(EFFECT_FLAG_SINGLE_RANGE))) && (phandler->current.location & LOCATION_ONFIELD)
if(((type & EFFECT_TYPE_FIELD) || ((type & EFFECT_TYPE_SINGLE) && is_flag(EFFECT_FLAG_SINGLE_RANGE)))
&& (phandler->current.location & LOCATION_ONFIELD)
&& (!phandler->is_position(POS_FACEUP) || !phandler->is_status(STATUS_EFFECT_ENABLED)))
return FALSE;
if((type & EFFECT_TYPE_SINGLE) && is_flag(EFFECT_FLAG_SINGLE_RANGE) && !in_range(phandler))
......@@ -357,10 +358,10 @@ int32 effect::is_activateable(uint8 playerid, const tevent& e, int32 neglect_con
}
pduel->game_field->save_lp_cost();
effect* oreason = pduel->game_field->core.reason_effect;
uint8 op = pduel->game_field->core.reason_player;
uint8_t op = pduel->game_field->core.reason_player;
pduel->game_field->core.reason_effect = this;
pduel->game_field->core.reason_player = playerid;
int32 result = TRUE;
int32_t result = TRUE;
if(!(type & EFFECT_TYPE_CONTINUOUS))
result = is_action_check(playerid);
if(result)
......@@ -371,10 +372,10 @@ int32 effect::is_activateable(uint8 playerid, const tevent& e, int32 neglect_con
return result;
}
// check functions: value of EFFECT_CANNOT_ACTIVATE, target, cost of EFFECT_ACTIVATE_COST
int32 effect::is_action_check(uint8 playerid) {
int32_t effect::is_action_check(uint8_t playerid) {
effect_set eset;
pduel->game_field->filter_player_effect(playerid, EFFECT_CANNOT_ACTIVATE, &eset);
for(int32 i = 0; i < eset.size(); ++i) {
for(effect_set::size_type i = 0; i < eset.size(); ++i) {
pduel->lua->add_param(this, PARAM_TYPE_EFFECT);
pduel->lua->add_param(playerid, PARAM_TYPE_INT);
if(eset[i]->check_value_condition(2))
......@@ -382,7 +383,7 @@ int32 effect::is_action_check(uint8 playerid) {
}
eset.clear();
pduel->game_field->filter_player_effect(playerid, EFFECT_ACTIVATE_COST, &eset);
for(int32 i = 0; i < eset.size(); ++i) {
for(effect_set::size_type i = 0; i < eset.size(); ++i) {
pduel->lua->add_param(eset[i], PARAM_TYPE_EFFECT);
pduel->lua->add_param(this, PARAM_TYPE_EFFECT);
pduel->lua->add_param(playerid, PARAM_TYPE_INT);
......@@ -397,7 +398,7 @@ int32 effect::is_action_check(uint8 playerid) {
return TRUE;
}
// check functions: condition, cost(chk=0), target(chk=0)
int32 effect::is_activate_ready(effect* reason_effect, uint8 playerid, const tevent& e, int32 neglect_cond, int32 neglect_cost, int32 neglect_target) {
int32_t effect::is_activate_ready(effect* reason_effect, uint8_t playerid, const tevent& e, int32_t neglect_cond, int32_t neglect_cost, int32_t neglect_target) {
if(!neglect_cond && condition) {
pduel->lua->add_param(reason_effect, PARAM_TYPE_EFFECT);
pduel->lua->add_param(playerid, PARAM_TYPE_INT);
......@@ -449,18 +450,18 @@ int32 effect::is_activate_ready(effect* reason_effect, uint8 playerid, const tev
reason_effect->cost_checked = FALSE;
return TRUE;
}
int32 effect::is_activate_ready(uint8 playerid, const tevent& e, int32 neglect_cond, int32 neglect_cost, int32 neglect_target) {
int32_t effect::is_activate_ready(uint8_t playerid, const tevent& e, int32_t neglect_cond, int32_t neglect_cost, int32_t neglect_target) {
return is_activate_ready(this, playerid, e, neglect_cond, neglect_cost, neglect_target);
}
// check functions: condition
int32 effect::is_condition_check(uint8 playerid, const tevent& e) {
int32_t effect::is_condition_check(uint8_t playerid, const tevent& e) {
card* phandler = get_handler();
if(!(type & EFFECT_TYPE_ACTIVATE) && (phandler->current.location & (LOCATION_ONFIELD | LOCATION_REMOVED)) && !phandler->is_position(POS_FACEUP))
return FALSE;
if(!condition)
return TRUE;
effect* oreason = pduel->game_field->core.reason_effect;
uint8 op = pduel->game_field->core.reason_player;
uint8_t op = pduel->game_field->core.reason_player;
pduel->game_field->core.reason_effect = this;
pduel->game_field->core.reason_player = playerid;
pduel->game_field->save_lp_cost();
......@@ -483,19 +484,19 @@ int32 effect::is_condition_check(uint8 playerid, const tevent& e) {
pduel->game_field->core.reason_player = op;
return TRUE;
}
int32 effect::is_activate_check(uint8 playerid, const tevent& e, int32 neglect_cond, int32 neglect_cost, int32 neglect_target) {
int32_t effect::is_activate_check(uint8_t playerid, const tevent& e, int32_t neglect_cond, int32_t neglect_cost, int32_t neglect_target) {
pduel->game_field->save_lp_cost();
effect* oreason = pduel->game_field->core.reason_effect;
uint8 op = pduel->game_field->core.reason_player;
uint8_t op = pduel->game_field->core.reason_player;
pduel->game_field->core.reason_effect = this;
pduel->game_field->core.reason_player = playerid;
int32 result = is_activate_ready(playerid, e, neglect_cond, neglect_cost, neglect_target);
int32_t result = is_activate_ready(playerid, e, neglect_cond, neglect_cost, neglect_target);
pduel->game_field->core.reason_effect = oreason;
pduel->game_field->core.reason_player = op;
pduel->game_field->restore_lp_cost();
return result;
}
int32 effect::is_target(card* pcard) {
int32_t effect::is_target(card* pcard) {
if(type & EFFECT_TYPE_ACTIONS)
return FALSE;
if(type & (EFFECT_TYPE_SINGLE | EFFECT_TYPE_EQUIP | EFFECT_TYPE_XMATERIAL) && !(type & EFFECT_TYPE_FIELD))
......@@ -507,7 +508,7 @@ int32 effect::is_target(card* pcard) {
&& !pcard->is_position(POS_FACEUP))
return FALSE;
if(!is_flag(EFFECT_FLAG_IGNORE_RANGE)) {
if(pcard->get_status(STATUS_SUMMONING | STATUS_SUMMON_DISABLED | STATUS_ACTIVATE_DISABLED | STATUS_SPSUMMON_STEP))
if(pcard->is_treated_as_not_on_field())
return FALSE;
if(is_flag(EFFECT_FLAG_SPSUM_PARAM))
return FALSE;
......@@ -531,7 +532,7 @@ int32 effect::is_target(card* pcard) {
}
return is_fit_target_function(pcard);
}
int32 effect::is_fit_target_function(card* pcard) {
int32_t effect::is_fit_target_function(card* pcard) {
if(target) {
pduel->lua->add_param(this, PARAM_TYPE_EFFECT);
pduel->lua->add_param(pcard, PARAM_TYPE_CARD);
......@@ -541,10 +542,10 @@ int32 effect::is_fit_target_function(card* pcard) {
}
return TRUE;
}
int32 effect::is_target_player(uint8 playerid) {
int32_t effect::is_target_player(uint8_t playerid) {
if(!is_flag(EFFECT_FLAG_PLAYER_TARGET))
return FALSE;
uint8 self = get_handler_player();
uint8_t self = get_handler_player();
if(is_flag(EFFECT_FLAG_ABSOLUTE_TARGET)) {
if(s_range && playerid == 0)
return TRUE;
......@@ -558,7 +559,7 @@ int32 effect::is_target_player(uint8 playerid) {
}
return FALSE;
}
int32 effect::is_player_effect_target(card* pcard) {
int32_t effect::is_player_effect_target(card* pcard) {
if(target) {
handler->pduel->lua->add_param(this, PARAM_TYPE_EFFECT);
handler->pduel->lua->add_param(pcard, PARAM_TYPE_CARD);
......@@ -568,9 +569,9 @@ int32 effect::is_player_effect_target(card* pcard) {
}
return TRUE;
}
int32 effect::is_immuned(card* pcard) {
int32_t effect::is_immuned(card* pcard) {
const effect_set_v& effects = pcard->immune_effect;
for (int32 i = 0; i < effects.size(); ++i) {
for (effect_set::size_type i = 0; i < effects.size(); ++i) {
effect* peffect = effects[i];
if(peffect->is_available() && peffect->value) {
pduel->lua->add_param(this, PARAM_TYPE_EFFECT);
......@@ -581,10 +582,10 @@ int32 effect::is_immuned(card* pcard) {
}
return FALSE;
}
int32 effect::is_chainable(uint8 tp) {
int32_t effect::is_chainable(uint8_t tp) {
if(!(type & EFFECT_TYPE_ACTIONS))
return FALSE;
int32 sp = get_speed();
int32_t sp = get_speed();
// Curse of Field is the exception
if((type & EFFECT_TYPE_ACTIVATE) && (sp <= 1) && !is_flag(EFFECT_FLAG2_COF))
return FALSE;
......@@ -612,12 +613,20 @@ int32 effect::is_chainable(uint8 tp) {
}
return TRUE;
}
int32 effect::is_hand_trigger() {
int32_t effect::is_hand_trigger() const {
return (range & LOCATION_HAND) && (type & EFFECT_TYPE_TRIGGER_O) && get_code_type() != CODE_PHASE;
}
int32_t effect::is_initial_single() const {
return (type & EFFECT_TYPE_SINGLE) && is_flag(EFFECT_FLAG_SINGLE_RANGE) && is_flag(EFFECT_FLAG_INITIAL);
}
int32_t effect::is_monster_effect() const {
if (range & (LOCATION_SZONE | LOCATION_FZONE | LOCATION_PZONE))
return FALSE;
return TRUE;
}
//return: this can be reset by reset_level or not
//RESET_DISABLE is valid only when owner == handler
int32 effect::reset(uint32 reset_level, uint32 reset_type) {
int32_t effect::reset(uint32_t reset_level, uint32_t reset_type) {
switch (reset_type) {
case RESET_EVENT: {
if(!(reset_flag & RESET_EVENT))
......@@ -636,11 +645,11 @@ int32 effect::reset(uint32 reset_level, uint32 reset_type) {
case RESET_PHASE: {
if(!(reset_flag & RESET_PHASE))
return FALSE;
uint8 pid = get_owner_player();
uint8 tp = handler->pduel->game_field->infos.turn_player;
uint8_t pid = get_owner_player();
uint8_t tp = handler->pduel->game_field->infos.turn_player;
if((((reset_flag & RESET_SELF_TURN) && pid == tp) || ((reset_flag & RESET_OPPO_TURN) && pid != tp))
&& (reset_level & 0x3ff & reset_flag))
reset_count--;
--reset_count;
if(reset_count == 0)
return TRUE;
return FALSE;
......@@ -657,7 +666,7 @@ int32 effect::reset(uint32 reset_level, uint32 reset_type) {
}
return FALSE;
}
void effect::dec_count(uint32 playerid) {
void effect::dec_count(uint8_t playerid) {
if(!is_flag(EFFECT_FLAG_COUNT_LIMIT))
return;
if(count_limit == 0)
......@@ -665,9 +674,10 @@ void effect::dec_count(uint32 playerid) {
if(count_code == 0 || is_flag(EFFECT_FLAG_NO_TURN_RESET))
count_limit -= 1;
if(count_code) {
uint32 code = count_code & 0xfffffff;
if(code == 1)
pduel->game_field->add_effect_code((count_code & 0xf0000000) | get_handler()->fieldid, PLAYER_NONE);
uint32_t limit_code = count_code & MAX_CARD_ID;
uint32_t limit_type = count_code & 0xf0000000;
if(limit_code == EFFECT_COUNT_CODE_SINGLE)
pduel->game_field->add_effect_code(limit_type | get_handler()->activate_count_id, PLAYER_NONE);
else
pduel->game_field->add_effect_code(count_code, playerid);
}
......@@ -677,81 +687,84 @@ void effect::recharge() {
count_limit = count_limit_max;
}
}
int32 effect::get_value(uint32 extraargs) {
int32_t effect::get_value(uint32_t extraargs) {
if(is_flag(EFFECT_FLAG_FUNC_VALUE)) {
pduel->lua->add_param(this, PARAM_TYPE_EFFECT, TRUE);
int32 res = pduel->lua->get_function_value(value, 1 + extraargs);
int32_t res = pduel->lua->get_function_value(value, 1 + extraargs);
return res;
} else {
pduel->lua->params.clear();
return (int32)value;
return value;
}
}
int32 effect::get_value(card* pcard, uint32 extraargs) {
int32_t effect::get_value(card* pcard, uint32_t extraargs) {
if(is_flag(EFFECT_FLAG_FUNC_VALUE)) {
pduel->lua->add_param(pcard, PARAM_TYPE_CARD, TRUE);
pduel->lua->add_param(this, PARAM_TYPE_EFFECT, TRUE);
int32 res = pduel->lua->get_function_value(value, 2 + extraargs);
int32_t res = pduel->lua->get_function_value(value, 2 + extraargs);
return res;
} else {
pduel->lua->params.clear();
return (int32)value;
return value;
}
}
int32 effect::get_value(effect* peffect, uint32 extraargs) {
int32_t effect::get_value(effect* peffect, uint32_t extraargs) {
if(is_flag(EFFECT_FLAG_FUNC_VALUE)) {
pduel->lua->add_param(peffect, PARAM_TYPE_EFFECT, TRUE);
pduel->lua->add_param(this, PARAM_TYPE_EFFECT, TRUE);
int32 res = pduel->lua->get_function_value(value, 2 + extraargs);
int32_t res = pduel->lua->get_function_value(value, 2 + extraargs);
return res;
} else {
pduel->lua->params.clear();
return (int32)value;
return value;
}
}
void effect::get_value(uint32 extraargs, std::vector<int32>* result) {
void effect::get_value(uint32_t extraargs, std::vector<lua_Integer>& result) {
if(is_flag(EFFECT_FLAG_FUNC_VALUE)) {
pduel->lua->add_param(this, PARAM_TYPE_EFFECT, TRUE);
pduel->lua->get_function_value(value, 1 + extraargs, result);
} else {
pduel->lua->params.clear();
result->push_back((int32)value);
result.push_back(value);
}
}
void effect::get_value(card* pcard, uint32 extraargs, std::vector<int32>* result) {
void effect::get_value(card* pcard, uint32_t extraargs, std::vector<lua_Integer>& result) {
if(is_flag(EFFECT_FLAG_FUNC_VALUE)) {
pduel->lua->add_param(pcard, PARAM_TYPE_CARD, TRUE);
pduel->lua->add_param(this, PARAM_TYPE_EFFECT, TRUE);
pduel->lua->get_function_value(value, 2 + extraargs, result);
} else {
pduel->lua->params.clear();
result->push_back((int32)value);
result.push_back(value);
}
}
void effect::get_value(effect* peffect, uint32 extraargs, std::vector<int32>* result) {
void effect::get_value(effect* peffect, uint32_t extraargs, std::vector<lua_Integer>& result) {
if(is_flag(EFFECT_FLAG_FUNC_VALUE)) {
pduel->lua->add_param(peffect, PARAM_TYPE_EFFECT, TRUE);
pduel->lua->add_param(this, PARAM_TYPE_EFFECT, TRUE);
pduel->lua->get_function_value(value, 2 + extraargs, result);
} else {
pduel->lua->params.clear();
result->push_back((int32)value);
result.push_back(value);
}
}
int32 effect::check_value_condition(uint32 extraargs) {
int32_t effect::get_integer_value() {
return is_flag(EFFECT_FLAG_FUNC_VALUE) ? 0 : value;
}
int32_t effect::check_value_condition(uint32_t extraargs) {
if(is_flag(EFFECT_FLAG_FUNC_VALUE)) {
pduel->lua->add_param(this, PARAM_TYPE_EFFECT, TRUE);
int32 res = pduel->lua->check_condition(value, 1 + extraargs);
int32_t res = pduel->lua->check_condition(value, 1 + extraargs);
return res;
} else {
pduel->lua->params.clear();
return (int32)value;
return value;
}
}
void* effect::get_label_object() {
return pduel->lua->get_ref_object(label_object);
}
int32 effect::get_speed() {
int32_t effect::get_speed() {
if(!(type & EFFECT_TYPE_ACTIONS))
return 0;
if(type & (EFFECT_TYPE_TRIGGER_O | EFFECT_TYPE_TRIGGER_F | EFFECT_TYPE_IGNITION))
......@@ -775,7 +788,7 @@ int32 effect::get_speed() {
}
effect* effect::clone() {
effect* ceffect = pduel->new_effect();
int32 ref = ceffect->ref_handle;
int32_t ref = ceffect->ref_handle;
*ceffect = *this;
ceffect->ref_handle = ref;
ceffect->handler = 0;
......@@ -798,7 +811,7 @@ card* effect::get_owner() const {
return handler->overlay_target;
return owner;
}
uint8 effect::get_owner_player() {
uint8_t effect::get_owner_player() const {
if(effect_owner != PLAYER_NONE)
return effect_owner;
return get_owner()->current.controler;
......@@ -810,17 +823,17 @@ card* effect::get_handler() const {
return handler->overlay_target;
return handler;
}
uint8 effect::get_handler_player() {
uint8_t effect::get_handler_player() const {
if(is_flag(EFFECT_FLAG_FIELD_ONLY))
return effect_owner;
return get_handler()->current.controler;
}
int32 effect::in_range(card* pcard) {
int32_t effect::in_range(card* pcard) const {
if(type & EFFECT_TYPE_XMATERIAL)
return handler->overlay_target ? TRUE : FALSE;
return pcard->current.is_location(range);
}
int32 effect::in_range(const chain& ch) {
int32_t effect::in_range(const chain& ch) const {
if(type & EFFECT_TYPE_XMATERIAL)
return handler->overlay_target ? TRUE : FALSE;
return range & ch.triggering_location;
......@@ -836,9 +849,9 @@ void effect::set_active_type() {
if(active_type & TYPE_TRAPMONSTER)
active_type &= ~TYPE_TRAP;
}
uint32 effect::get_active_type() {
if(type & 0x7f0) {
if(active_type)
uint32_t effect::get_active_type(uint8_t uselast) {
if(type & EFFECT_TYPES_CHAIN_LINK) {
if(active_type && uselast)
return active_type;
else if((type & EFFECT_TYPE_ACTIVATE) && (get_handler()->data.type & TYPE_PENDULUM))
return TYPE_PENDULUM + TYPE_SPELL;
......@@ -847,9 +860,9 @@ uint32 effect::get_active_type() {
} else
return owner->get_type();
}
int32 effect::get_code_type() {
code_type effect::get_code_type() const {
// start from the highest bit
if (code & EVENT_CUSTOM)
if (code & 0xf0000000)
return CODE_CUSTOM;
else if (code & 0xf0000)
return CODE_COUNTER;
......
effect.h
View file @ 287dd26c
......@@ -11,110 +11,116 @@
#include "common.h"
#include "field.h"
#include "effectset.h"
#include <stdlib.h>
#include <vector>
#include <map>
class card;
class duel;
class group;
class effect;
struct tevent;
struct effect_set;
struct effect_set_v;
enum effect_flag : uint32;
enum effect_flag2 : uint32;
enum effect_flag : uint64_t;
enum effect_flag2 : uint64_t;
enum effect_category :uint64_t;
enum code_type : int32_t;
bool is_continuous_event(uint32_t code);
class effect {
public:
int32 ref_handle;
duel* pduel;
card* owner;
card* handler;
uint8 effect_owner;
uint32 description;
uint32 code;
uint32 flag[2];
uint32 id;
uint16 type;
uint16 copy_id;
uint16 range;
uint16 s_range;
uint16 o_range;
uint8 count_limit;
uint8 count_limit_max;
uint16 reset_count;
uint32 reset_flag;
uint32 count_code;
uint32 category;
uint32 hint_timing[2];
uint32 card_type;
uint32 active_type;
uint16 active_location;
uint16 active_sequence;
card* active_handler;
uint16 status;
std::vector<uint32> label;
int32 label_object;
int32 condition;
int32 cost;
int32 target;
int32 value;
int32 operation;
uint8 cost_checked;
int32_t ref_handle{ 0 };
duel* pduel{ nullptr };
card* owner{ nullptr };
card* handler{ nullptr };
uint8_t effect_owner{ PLAYER_NONE };
uint32_t description{ 0 };
uint32_t code{ 0 };
uint32_t id{ 0 };
uint32_t type{ 0 };
uint16_t copy_id{ 0 };
uint16_t range{ 0 };
uint16_t s_range{ 0 };
uint16_t o_range{ 0 };
uint8_t count_limit{ 0 }; //left count of activation
uint8_t count_limit_max{ 0 }; //max count of activation
uint16_t status{ 0 };
int32_t reset_count{ 0 };
uint32_t reset_flag{ 0 };
uint32_t count_code{ 0 };
uint64_t category{ 0 };
uint64_t flag[2]{};
uint32_t hint_timing[2]{};
uint32_t card_type{ 0 };
uint32_t active_type{ 0 };
uint16_t active_location{ 0 };
uint16_t active_sequence{ 0 };
card* active_handler{ nullptr };
std::vector<lua_Integer> label;
int32_t label_object{ 0 };
int32_t condition{ 0 };
int32_t cost{ 0 };
int32_t target{ 0 };
int32_t value{ 0 };
int32_t operation{ 0 };
uint8_t cost_checked{ FALSE };
effect_set required_handorset_effects;
LuaParamType object_type{ PARAM_TYPE_INT };
explicit effect(duel* pd);
~effect() = default;
int32 is_disable_related();
int32 is_self_destroy_related();
int32 is_can_be_forbidden();
int32 is_available(int32 neglect_disabled = FALSE);
int32 limit_counter_is_available();
int32 is_single_ready();
int32 check_count_limit(uint8 playerid);
int32 is_activateable(uint8 playerid, const tevent& e, int32 neglect_cond = FALSE, int32 neglect_cost = FALSE, int32 neglect_target = FALSE, int32 neglect_loc = FALSE, int32 neglect_faceup = FALSE);
int32 is_action_check(uint8 playerid);
int32 is_activate_ready(effect* reason_effect, uint8 playerid, const tevent& e, int32 neglect_cond = FALSE, int32 neglect_cost = FALSE, int32 neglect_target = FALSE);
int32 is_activate_ready(uint8 playerid, const tevent& e, int32 neglect_cond = FALSE, int32 neglect_cost = FALSE, int32 neglect_target = FALSE);
int32 is_condition_check(uint8 playerid, const tevent& e);
int32 is_activate_check(uint8 playerid, const tevent& e, int32 neglect_cond = FALSE, int32 neglect_cost = FALSE, int32 neglect_target = FALSE);
int32 is_target(card* pcard);
int32 is_fit_target_function(card* pcard);
int32 is_target_player(uint8 playerid);
int32 is_player_effect_target(card* pcard);
int32 is_immuned(card* pcard);
int32 is_chainable(uint8 tp);
int32 is_hand_trigger();
int32 reset(uint32 reset_level, uint32 reset_type);
void dec_count(uint32 playerid = 2);
int32_t is_disable_related() const;
int32_t is_self_destroy_related() const;
int32_t is_can_be_forbidden() const;
int32_t is_available(int32_t neglect_disabled = FALSE);
int32_t limit_counter_is_available();
int32_t is_single_ready();
int32_t check_count_limit(uint8_t playerid);
int32_t get_required_handorset_effects(effect_set* eset, uint8_t playerid, const tevent& e, int32_t neglect_loc = FALSE);
int32_t is_activateable(uint8_t playerid, const tevent &e, int32_t neglect_cond = FALSE, int32_t neglect_cost = FALSE, int32_t neglect_target = FALSE, int32_t neglect_loc = FALSE, int32_t neglect_faceup = FALSE);
int32_t is_action_check(uint8_t playerid);
int32_t is_activate_ready(effect* reason_effect, uint8_t playerid, const tevent& e, int32_t neglect_cond = FALSE, int32_t neglect_cost = FALSE, int32_t neglect_target = FALSE);
int32_t is_activate_ready(uint8_t playerid, const tevent& e, int32_t neglect_cond = FALSE, int32_t neglect_cost = FALSE, int32_t neglect_target = FALSE);
int32_t is_condition_check(uint8_t playerid, const tevent& e);
int32_t is_activate_check(uint8_t playerid, const tevent& e, int32_t neglect_cond = FALSE, int32_t neglect_cost = FALSE, int32_t neglect_target = FALSE);
int32_t is_target(card* pcard);
int32_t is_fit_target_function(card* pcard);
int32_t is_target_player(uint8_t playerid);
int32_t is_player_effect_target(card* pcard);
int32_t is_immuned(card* pcard);
int32_t is_chainable(uint8_t tp);
int32_t is_hand_trigger() const;
int32_t is_initial_single() const;
int32_t is_monster_effect() const;
int32_t reset(uint32_t reset_level, uint32_t reset_type);
void dec_count(uint8_t playerid = PLAYER_NONE);
void recharge();
int32 get_value(uint32 extraargs = 0);
int32 get_value(card* pcard, uint32 extraargs = 0);
int32 get_value(effect* peffect, uint32 extraargs = 0);
void get_value(uint32 extraargs, std::vector<int32>* result);
void get_value(card* pcard, uint32 extraargs, std::vector<int32>* result);
void get_value(effect* peffect, uint32 extraargs, std::vector<int32>* result);
int32 check_value_condition(uint32 extraargs = 0);
int32_t get_value(uint32_t extraargs = 0);
int32_t get_value(card* pcard, uint32_t extraargs = 0);
int32_t get_value(effect* peffect, uint32_t extraargs = 0);
void get_value(uint32_t extraargs, std::vector<lua_Integer>& result);
void get_value(card* pcard, uint32_t extraargs, std::vector<lua_Integer>& result);
void get_value(effect* peffect, uint32_t extraargs, std::vector<lua_Integer>& result);
int32_t get_integer_value();
int32_t check_value_condition(uint32_t extraargs = 0);
void* get_label_object();
int32 get_speed();
int32_t get_speed();
effect* clone();
card* get_owner() const;
uint8 get_owner_player();
uint8_t get_owner_player() const;
card* get_handler() const;
uint8 get_handler_player();
int32 in_range(card* pcard);
int32 in_range(const chain& ch);
uint8_t get_handler_player() const;
int32_t in_range(card* pcard) const;
int32_t in_range(const chain& ch) const;
void set_activate_location();
void set_active_type();
uint32 get_active_type();
int32 get_code_type();
uint32_t get_active_type(uint8_t uselast = TRUE);
code_type get_code_type() const;
bool is_flag(effect_flag flag) const {
return !!(this->flag[0] & flag);
bool is_flag(effect_flag x) const {
return !!(flag[0] & x);
}
bool is_flag(effect_flag2 flag) const {
return !!(this->flag[1] & flag);
bool is_flag(effect_flag2 x) const {
return !!(flag[1] & x);
}
};
......@@ -123,8 +129,10 @@ public:
//#define EFFECT_STATUS_ACTIVATED 0x0002
#define EFFECT_STATUS_SPSELF 0x0004
#define EFFECT_COUNT_CODE_OATH 0x10000000
#define EFFECT_COUNT_CODE_DUEL 0x20000000
#define EFFECT_COUNT_CODE_OATH 0x10000000U
#define EFFECT_COUNT_CODE_DUEL 0x20000000U
#define EFFECT_COUNT_CODE_CHAIN 0x40000000U
#define EFFECT_COUNT_CODE_SINGLE 0x1U
//========== Reset ==========
#define RESET_SELF_TURN 0x10000000
......@@ -149,6 +157,8 @@ public:
#define RESET_OVERLAY 0x04000000
#define RESET_MSCHANGE 0x08000000
constexpr uint32_t RESETS_STANDARD = RESET_TOFIELD | RESET_LEAVE | RESET_TODECK | RESET_TOHAND | RESET_TEMP_REMOVE | RESET_REMOVE | RESET_TOGRAVE | RESET_TURN_SET;
//========== Types ==========
#define EFFECT_TYPE_SINGLE 0x0001 //
#define EFFECT_TYPE_FIELD 0x0002 //
......@@ -166,10 +176,11 @@ public:
#define EFFECT_TYPE_GRANT 0x2000 //
#define EFFECT_TYPE_TARGET 0x4000 //
#define EFFECT_TYPES_TRIGGER_LIKE (EFFECT_TYPE_ACTIVATE | EFFECT_TYPE_TRIGGER_O | EFFECT_TYPE_TRIGGER_F | EFFECT_TYPE_QUICK_O | EFFECT_TYPE_QUICK_F)
constexpr uint32_t EFFECT_TYPES_TRIGGER_LIKE = EFFECT_TYPE_ACTIVATE | EFFECT_TYPE_TRIGGER_O | EFFECT_TYPE_TRIGGER_F | EFFECT_TYPE_QUICK_O | EFFECT_TYPE_QUICK_F;
constexpr uint32_t EFFECT_TYPES_CHAIN_LINK = EFFECT_TYPES_TRIGGER_LIKE | EFFECT_TYPE_FLIP | EFFECT_TYPE_IGNITION;
//========== Flags ==========
enum effect_flag : uint32 {
enum effect_flag : uint64_t {
EFFECT_FLAG_INITIAL = 0x0001,
EFFECT_FLAG_FUNC_VALUE = 0x0002,
EFFECT_FLAG_COUNT_LIMIT = 0x0004,
......@@ -183,7 +194,7 @@ enum effect_flag : uint32 {
EFFECT_FLAG_CANNOT_DISABLE = 0x0400,
EFFECT_FLAG_PLAYER_TARGET = 0x0800,
EFFECT_FLAG_BOTH_SIDE = 0x1000,
EFFECT_FLAG_COPY_INHERIT = 0x2000,
EFFECT_FLAG_COPY = 0x2000,
EFFECT_FLAG_DAMAGE_STEP = 0x4000,
EFFECT_FLAG_DAMAGE_CAL = 0x8000,
EFFECT_FLAG_DELAY = 0x10000,
......@@ -199,20 +210,66 @@ enum effect_flag : uint32 {
EFFECT_FLAG_CLIENT_HINT = 0x4000000,
EFFECT_FLAG_CONTINUOUS_TARGET = 0x8000000,
EFFECT_FLAG_LIMIT_ZONE = 0x10000000,
// EFFECT_FLAG_COF = 0x20000000,
EFFECT_FLAG_ACTIVATE_CONDITION = 0x20000000,
// EFFECT_FLAG_CVAL_CHECK = 0x40000000,
EFFECT_FLAG_IMMEDIATELY_APPLY = 0x80000000,
EFFECT_FLAG_COIN = 0x100000000,
EFFECT_FLAG_DICE = 0x200000000,
EFFECT_FLAG_FUSION_SUMMON = 0x400000000,
};
enum effect_flag2 : uint32 {
// EFFECT_FLAG2_MILLENNIUM_RESTRICT = 0x0001,
enum effect_flag2 : uint64_t {
EFFECT_FLAG2_REPEAT_UPDATE = 0x0001,
EFFECT_FLAG2_COF = 0x0002,
EFFECT_FLAG2_WICKED = 0x0004,
EFFECT_FLAG2_OPTION = 0x0008,
};
inline effect_flag operator|(effect_flag flag1, effect_flag flag2)
{
return static_cast<effect_flag>(static_cast<uint32>(flag1) | static_cast<uint32>(flag2));
constexpr effect_flag operator|(effect_flag flag1, effect_flag flag2) {
return static_cast<effect_flag>(static_cast<uint64_t>(flag1) | static_cast<uint64_t>(flag2));
}
constexpr uint64_t INTERNAL_FLAGS = EFFECT_FLAG_INITIAL | EFFECT_FLAG_COPY | EFFECT_FLAG_FUNC_VALUE | EFFECT_FLAG_COUNT_LIMIT | EFFECT_FLAG_FIELD_ONLY | EFFECT_FLAG_ABSOLUTE_TARGET;
//Category
enum effect_category : uint64_t {
CATEGORY_DESTROY = 0x1,
CATEGORY_RELEASE = 0x2,
CATEGORY_REMOVE = 0x4,
CATEGORY_TOHAND = 0x8,
CATEGORY_TODECK = 0x10,
CATEGORY_TOGRAVE = 0x20,
CATEGORY_DECKDES = 0x40,
CATEGORY_HANDES = 0x80,
CATEGORY_SUMMON = 0x100,
CATEGORY_SPECIAL_SUMMON = 0x200,
CATEGORY_TOKEN = 0x400,
CATEGORY_GRAVE_ACTION = 0x800,
CATEGORY_POSITION = 0x1000,
CATEGORY_CONTROL = 0x2000,
CATEGORY_DISABLE = 0x4000,
CATEGORY_DISABLE_SUMMON = 0x8000,
CATEGORY_DRAW = 0x10000,
CATEGORY_SEARCH = 0x20000,
CATEGORY_EQUIP = 0x40000,
CATEGORY_DAMAGE = 0x80000,
CATEGORY_RECOVER = 0x100000,
CATEGORY_ATKCHANGE = 0x200000,
CATEGORY_DEFCHANGE = 0x400000,
CATEGORY_COUNTER = 0x800000,
CATEGORY_COIN = 0x1000000,
CATEGORY_DICE = 0x2000000,
CATEGORY_LEAVE_GRAVE = 0x4000000,
CATEGORY_GRAVE_SPSUMMON = 0x8000000,
CATEGORY_NEGATE = 0x10000000,
CATEGORY_ANNOUNCE = 0x20000000,
CATEGORY_FUSION_SUMMON = 0x40000000,
CATEGORY_TOEXTRA = 0x80000000,
};
const std::map<uint64_t, uint64_t> category_checklist{
{CATEGORY_COIN, EFFECT_FLAG_COIN},
{CATEGORY_DICE, EFFECT_FLAG_DICE},
{CATEGORY_FUSION_SUMMON, EFFECT_FLAG_FUSION_SUMMON},
};
//========== Codes ==========
#define EFFECT_IMMUNE_EFFECT 1 //
#define EFFECT_DISABLE 2 //
......@@ -383,7 +440,7 @@ inline effect_flag operator|(effect_flag flag1, effect_flag flag2)
#define EFFECT_TOSS_DICE_REPLACE 221
#define EFFECT_FUSION_MATERIAL 230
#define EFFECT_CHAIN_MATERIAL 231
#define EFFECT_SYNCHRO_MATERIAL 232
#define EFFECT_EXTRA_SYNCHRO_MATERIAL 232
#define EFFECT_XYZ_MATERIAL 233
#define EFFECT_FUSION_SUBSTITUTE 234
#define EFFECT_CANNOT_BE_FUSION_MATERIAL 235
......@@ -467,6 +524,12 @@ inline effect_flag operator|(effect_flag flag1, effect_flag flag2)
#define EFFECT_CHANGE_GRAVE_RACE 366
#define EFFECT_ACTIVATION_COUNT_LIMIT 367
#define EFFECT_LIMIT_SPECIAL_SUMMON_POSITION 368
#define EFFECT_TUNER 369
#define EFFECT_KAISER_COLOSSEUM 370
#define EFFECT_REPLACE_DAMAGE 371
#define EFFECT_XYZ_MIN_COUNT 372
#define EFFECT_SYNCHRO_LEVEL_EX 373
#define EFFECT_RITUAL_LEVEL_EX 374
//#define EVENT_STARTUP 1000
#define EVENT_FLIP 1001
......@@ -493,6 +556,7 @@ inline effect_flag operator|(effect_flag flag1, effect_flag flag2)
#define EVENT_DESTROYED 1029
#define EVENT_MOVE 1030
#define EVENT_LEAVE_GRAVE 1031
#define EVENT_LEAVE_DECK 1032
#define EVENT_ADJUST 1040
#define EVENT_BREAK_EFFECT 1050
#define EVENT_SUMMON_SUCCESS 1100
......@@ -512,6 +576,7 @@ inline effect_flag operator|(effect_flag flag1, effect_flag flag2)
#define EVENT_SUMMON_NEGATED 1114
#define EVENT_FLIP_SUMMON_NEGATED 1115
#define EVENT_SPSUMMON_NEGATED 1116
#define EVENT_SPSUMMON_SUCCESS_G_P 1117
#define EVENT_CONTROL_CHANGED 1120
#define EVENT_EQUIP 1121
#define EVENT_ATTACK_ANNOUNCE 1130
......@@ -542,16 +607,36 @@ inline effect_flag operator|(effect_flag flag1, effect_flag flag2)
#define EVENT_REMOVE_COUNTER 0x20000
#define EVENT_CUSTOM 0x10000000
#define DOUBLE_DAMAGE 0x80000000
#define HALF_DAMAGE 0x80000001
constexpr int32_t DOUBLE_DAMAGE = INT32_MIN;
constexpr int32_t HALF_DAMAGE = INT32_MIN + 1;
// The type of event in code
#define CODE_CUSTOM 1 // header + id (28 bits)
#define CODE_COUNTER 2 // header + counter_id (16 bits)
#define CODE_PHASE 3 // header + phase_id (12 bits)
#define CODE_VALUE 4 // numeric value, max = 4095
constexpr uint32_t MAX_PARAMETER = 0xffffU;
constexpr uint32_t MAX_XYZ_LEVEL = 0x0fffU;
const std::unordered_set<uint32> continuous_event({ EVENT_ADJUST, EVENT_BREAK_EFFECT, EVENT_TURN_END });
bool is_continuous_event(uint32 code);
// flag effect
#define EFFECT_FLAG_EFFECT 0x20000000U
#define MAX_CARD_ID 0x0fffffffU
// The type of effect code
enum code_type : int32_t {
CODE_CUSTOM = 1, // header + id (28 bits)
CODE_COUNTER, // header + counter_id (16 bits)
CODE_PHASE, // header + phase_id (12 bits)
CODE_VALUE, // numeric value, max = 4095
};
const std::unordered_set<uint32_t> continuous_event{
EVENT_ADJUST,
EVENT_BREAK_EFFECT,
EVENT_TURN_END,
EVENT_PRE_BATTLE_DAMAGE,
EVENT_SPSUMMON_SUCCESS_G_P,
};
const std::unordered_set<uint32_t> affect_summoning_effect{
EFFECT_CANNOT_DISABLE_SUMMON,
EFFECT_CANNOT_DISABLE_SPSUMMON,
EVENT_BE_PRE_MATERIAL,
};
#endif /* EFFECT_H_ */
effectset.h
View file @ 287dd26c
......@@ -8,8 +8,6 @@
#ifndef EFFECTSET_H_
#define EFFECTSET_H_
#include <stdlib.h>
#include <array>
#include <vector>
#include <algorithm>
......@@ -17,100 +15,7 @@ class effect;
bool effect_sort_id(const effect* e1, const effect* e2);
struct effect_set {
effect_set()
: count(0), container{ nullptr } {}
void add_item(effect* peffect) {
if(count >= 64) return;
container[count++] = peffect;
}
void remove_item(int index) {
if(index >= count)
return;
if(index == count - 1) {
count--;
return;
}
for(int i = index; i < count - 1; ++i)
container[i] = container[i + 1];
count--;
}
void clear() {
count = 0;
}
int size() const {
return count;
}
void sort() {
if(count < 2)
return;
std::sort(container.begin(), container.begin() + count, effect_sort_id);
}
effect* const& get_last() const {
return container[count - 1];
}
effect*& get_last() {
return container[count - 1];
}
effect* const& operator[] (int index) const {
return container[index];
}
effect*& operator[] (int index) {
return container[index];
}
effect* const& at(int index) const {
return container[index];
}
effect*& at(int index) {
return container[index];
}
private:
std::array<effect*, 64> container;
int count;
};
struct effect_set_v {
effect_set_v() {}
void add_item(effect* peffect) {
container.push_back(peffect);
}
void remove_item(int index) {
if(index >= (int)container.size())
return;
container.erase(container.begin() + index);
}
void clear() {
container.clear();
}
int size() const {
return (int)container.size();
}
void sort() {
int count = (int)container.size();
if(count < 2)
return;
std::sort(container.begin(), container.begin() + count, effect_sort_id);
}
effect* const& get_last() const {
return container.back();
}
effect*& get_last() {
return container.back();
}
effect* const& operator[] (int index) const {
return container[index];
}
effect*& operator[] (int index) {
return container[index];
}
effect* const& at(int index) const {
return container[index];
}
effect*& at(int index) {
return container[index];
}
private:
std::vector<effect*> container;
};
using effect_set = std::vector<effect*>;
using effect_set_v = effect_set;
#endif //EFFECTSET_H_
field.cpp
View file @ 287dd26c
This source diff could not be displayed because it is too large. You can view the blob instead.
field.h
View file @ 287dd26c
......@@ -11,82 +11,81 @@
#include "common.h"
#include "card.h"
#include "effectset.h"
#include "interpreter.h"
#include <vector>
#include <set>
#include <map>
#include <list>
#include <array>
#include <functional>
#include <unordered_map>
#include <unordered_set>
#define MAX_COIN_COUNT 20
//summon action type
#define SUMMON_IN_IDLE 0
#define SUMMON_IN_CHAIN 1
class card;
struct card_data;
class duel;
class group;
class effect;
using effect_vector = std::vector<effect*>;
struct tevent {
card* trigger_card;
group* event_cards;
effect* reason_effect;
uint32 event_code;
uint32 event_value;
uint32 reason;
uint8 event_player;
uint8 reason_player;
tevent()
: trigger_card(nullptr), event_cards(nullptr), reason_effect(nullptr), event_code(0), event_value(0), reason(0), event_player(PLAYER_NONE), reason_player(PLAYER_NONE) {}
card* trigger_card{ nullptr };
group* event_cards{ nullptr };
effect* reason_effect{ nullptr };
uint32_t event_code{ 0 };
uint32_t event_value{ 0 };
uint32_t reason{ 0 };
uint8_t event_player{ PLAYER_NONE };
uint8_t reason_player{ PLAYER_NONE };
bool operator< (const tevent& v) const;
};
struct optarget {
group* op_cards;
uint8 op_count;
uint8 op_player;
int32 op_param;
optarget()
: op_cards(nullptr), op_count(0), op_player(PLAYER_NONE), op_param(0) {}
group* op_cards{ nullptr };
uint8_t op_count{ 0 };
uint8_t op_player{ PLAYER_NONE };
int32_t op_param{ 0 };
};
struct chain {
using opmap = std::unordered_map<uint32, optarget>;
uint16 chain_id;
uint8 chain_count;
uint8 triggering_player;
uint8 triggering_controler;
uint16 triggering_location;
uint8 triggering_sequence;
uint8 triggering_position;
using opmap = std::unordered_map<uint32_t, optarget>;
uint16_t chain_id{ 0 };
uint8_t chain_count{ 0 };
uint8_t triggering_player{ PLAYER_NONE };
uint8_t triggering_controler{ PLAYER_NONE };
uint16_t triggering_location{ 0 };
uint8_t triggering_sequence{ 0 };
uint8_t triggering_position{ 0 };
card_state triggering_state;
effect* triggering_effect;
group* target_cards;
int32 replace_op;
uint8 target_player;
int32 target_param;
effect* disable_reason;
uint8 disable_player;
effect* triggering_effect{ nullptr };
group* target_cards{ nullptr };
int32_t replace_op{ 0 };
uint8_t target_player{ PLAYER_NONE };
int32_t target_param{ 0 };
effect* disable_reason{ nullptr };
uint8_t disable_player{ PLAYER_NONE };
tevent evt;
opmap opinfos;
uint32 flag;
uint32_t flag{ 0 };
effect_set required_handorset_effects;
chain()
: chain_id(0), chain_count(0), triggering_player(PLAYER_NONE), triggering_controler(PLAYER_NONE), triggering_location(0), triggering_sequence(0), triggering_position(0),
triggering_state(), triggering_effect(nullptr), target_cards(nullptr), replace_op(0), target_player(PLAYER_NONE), target_param(0), disable_reason(nullptr), disable_player(PLAYER_NONE),
evt(), flag(0) {}
static bool chain_operation_sort(const chain& c1, const chain& c2);
void set_triggering_state(card* pcard);
};
struct player_info {
using card_vector = std::vector<card*>;
int32 lp;
int32 start_count;
int32 draw_count;
uint32 used_location;
uint32 disabled_location;
uint32 extra_p_count;
uint32 tag_extra_p_count;
int32_t lp{ 8000 };
int32_t start_count{ 5 };
int32_t draw_count{ 1 };
uint32_t used_location{ 0 };
uint32_t disabled_location{ 0 };
uint32_t extra_p_count{ 0 };
uint32_t tag_extra_p_count{ 0 };
int32_t szone_size{ 6 };
card_vector list_mzone;
card_vector list_szone;
card_vector list_main;
......@@ -97,15 +96,9 @@ struct player_info {
card_vector tag_list_main;
card_vector tag_list_hand;
card_vector tag_list_extra;
player_info()
: lp(0), start_count(0), draw_count(0), used_location(0), disabled_location(0), extra_p_count(0), tag_extra_p_count(0) {}
};
struct field_effect {
using effect_container = std::multimap<uint32, effect*>;
using effect_indexer = std::unordered_map<effect*, effect_container::iterator>;
using oath_effects = std::unordered_map<effect*, effect*>;
using effect_collection = std::unordered_set<effect*>;
using gain_effects = std::unordered_map<card*, effect*>;
using grant_effect_container = std::unordered_map<effect*, gain_effects>;
......@@ -130,70 +123,70 @@ struct field_effect {
grant_effect_container grant_effect;
};
struct field_info {
int32 field_id;
int16 copy_id;
int16 turn_id;
int16 turn_id_by_player[2];
int16 card_id;
uint16 phase;
uint8 turn_player;
uint8 priorities[2];
uint8 can_shuffle;
field_info()
: field_id(0), copy_id(0), turn_id(0), turn_id_by_player{ 0 }, card_id(0), phase(0), turn_player(0), priorities{ 0 }, can_shuffle(TRUE) {}
uint64_t card_id{ 1 };
int32_t field_id{ 1 };
uint16_t copy_id{ 1 };
uint16_t turn_id{};
uint16_t turn_id_by_player[2]{};
uint16_t phase{};
uint8_t turn_player{};
uint8_t priorities[2]{};
uint8_t can_shuffle{ TRUE };
};
struct lpcost {
int32 count;
int32 amount;
int32 lpstack[8];
lpcost()
: count(0), amount(0), lpstack{ 0 } {}
int32_t count{};
int32_t amount{};
int32_t lpstack[8]{};
};
struct processor_unit {
uint16 type;
uint16 step;
effect* peffect;
group* ptarget;
int32 arg1;
int32 arg2;
int32 arg3;
int32 arg4;
void* ptr1;
void* ptr2;
processor_unit()
: type(0), step(0), peffect(nullptr), ptarget(nullptr), arg1(0), arg2(0), arg3(0), arg4(0), ptr1(nullptr), ptr2(nullptr) {}
uint16_t type{ 0 };
uint16_t step{ 0 };
effect* peffect{ nullptr };
group* ptarget{ nullptr };
uint32_t arg1{ 0 };
uint32_t arg2{ 0 };
uint32_t arg3{ 0 };
uint32_t arg4{ 0 };
int32_t value1{ 0 };
int32_t value2{ 0 };
int32_t value3{ 0 };
int32_t value4{ 0 };
void* ptr1{ nullptr };
void* ptr2{ nullptr };
void* ptr3{ nullptr };
void* ptr4{ nullptr };
};
constexpr int SIZE_SVALUE = SIZE_RETURN_VALUE / 2;
constexpr int SIZE_IVALUE = SIZE_RETURN_VALUE / 4;
constexpr int SIZE_LVALUE = SIZE_RETURN_VALUE / 8;
union return_value {
int8 bvalue[64];
int16 svalue[32];
int32 ivalue[16];
int64 lvalue[8];
uint8_t bvalue[SIZE_RETURN_VALUE];
uint16_t svalue[SIZE_SVALUE];
int32_t ivalue[SIZE_IVALUE];
int64_t lvalue[SIZE_LVALUE];
};
using option_vector = std::vector<uint32_t>;
using card_list = std::list<card*>;
using event_list = std::list<tevent>;
using chain_list = std::list<chain>;
using instant_f_list = std::map<effect*, chain>;
using chain_array = std::vector<chain>;
using processor_list = std::list<processor_unit>;
using delayed_effect_collection = std::set<std::pair<effect*, tevent>>;
using activity_map = std::unordered_map<int32_t, std::pair<int32_t, uint32_t>>; // (counter_id, (counter_filter, count[1]|count[0]))
struct processor {
using effect_vector = std::vector<effect*>;
using card_vector = std::vector<card*>;
using option_vector = std::vector<uint32>;
using card_list = std::list<card*>;
using event_list = std::list<tevent>;
using chain_list = std::list<chain>;
using instant_f_list = std::map<effect*, chain>;
using chain_array = std::vector<chain>;
using processor_list = std::list<processor_unit>;
using card_set = std::set<card*, card_sort>;
using delayed_effect_collection = std::set<std::pair<effect*, tevent>>;
struct chain_limit_t {
chain_limit_t(int32 f, int32 p): function(f), player(p) {}
int32 function;
int32 player;
chain_limit_t(int32_t f, int32_t p): function(f), player(p) {}
int32_t function{ 0 };
int32_t player{ PLAYER_NONE };
};
using chain_limit_list = std::vector<chain_limit_t>;
processor_list units;
processor_list subunits;
processor_unit reserved;
processor_unit damage_step_reserved;
processor_unit summon_reserved;
card_vector select_cards;
card_vector unselect_cards;
card_vector summonable_cards;
......@@ -252,6 +245,7 @@ struct processor {
card_set operated_set;
card_set discarded_set;
card_set destroy_canceled;
card_set indestructable_count_set;
card_set delayed_enable_set;
card_set set_group_pre_set;
card_set set_group_set;
......@@ -259,393 +253,394 @@ struct processor {
effect_set_v extra_mzone_effects;
effect_set_v extra_szone_effects;
std::set<effect*> reseted_effects;
std::unordered_map<card*, uint32> readjust_map;
std::unordered_map<card*, uint32_t> readjust_map;
std::unordered_set<card*> unique_cards[2];
std::unordered_map<uint32, uint32> effect_count_code;
std::unordered_map<uint32, uint32> effect_count_code_duel;
std::unordered_map<uint32, uint32> spsummon_once_map[2];
std::multimap<int32, card*, std::greater<int32>> xmaterial_lst;
int32 temp_var[4];
uint32 global_flag;
uint16 pre_field[2];
std::set<uint16> opp_mzone;
std::unordered_map<uint32_t, int32_t> effect_count_code[3];
std::unordered_map<uint32_t, int32_t> effect_count_code_duel[3];
std::unordered_map<uint32_t, int32_t> effect_count_code_chain[3];
std::unordered_map<uint32_t, uint32_t> spsummon_once_map[2];
std::multimap<int32_t, card*, std::greater<int32_t>> xmaterial_lst;
int32_t temp_var[4]{};
uint32_t global_flag{ 0 };
uint16_t pre_field[2]{};
std::set<uint16_t> opp_mzone;
chain_limit_list chain_limit;
chain_limit_list chain_limit_p;
uint8 chain_solving;
uint8 conti_solving;
uint8 win_player;
uint8 win_reason;
uint8 re_adjust;
effect* reason_effect;
uint8 reason_player;
card* summoning_card;
uint8 summon_depth;
uint8 summon_cancelable;
card* attacker;
card* attack_target;
uint32 limit_extra_summon_zone;
uint32 limit_extra_summon_releasable;
card* limit_tuner;
group* limit_syn;
int32 limit_syn_minc;
int32 limit_syn_maxc;
group* limit_xyz;
int32 limit_xyz_minc;
int32 limit_xyz_maxc;
group* limit_link;
card* limit_link_card;
int32 limit_link_minc;
int32 limit_link_maxc;
uint8 not_material;
uint8 attack_cancelable;
uint8 attack_rollback;
uint8 effect_damage_step;
int32 battle_damage[2];
int32 summon_count[2];
uint8 extra_summon[2];
int32 spe_effect[2];
int32 duel_options;
int32 duel_rule; //current rule: 5, Master Rule 2020
uint32 copy_reset;
uint8 copy_reset_count;
uint32 last_control_changed_id;
uint32 set_group_used_zones;
uint8 set_group_seq[7];
uint8 dice_result[5];
uint8 coin_result[5];
uint8 to_bp;
uint8 to_m2;
uint8 to_ep;
uint8 skip_m2;
uint8 chain_attack;
uint32 chain_attacker_id;
card* chain_attack_target;
uint8 attack_player;
uint8 selfdes_disabled;
uint8 overdraw[2];
int32 check_level;
uint8 shuffle_check_disabled;
uint8 shuffle_hand_check[2];
uint8 shuffle_deck_check[2];
uint8 deck_reversed;
uint8 remove_brainwashing;
uint8 flip_delayed;
uint8 damage_calculated;
uint8 hand_adjusted;
uint8 summon_state_count[2];
uint8 normalsummon_state_count[2];
uint8 flipsummon_state_count[2];
uint8 spsummon_state_count[2];
uint8 attack_state_count[2];
uint8 battle_phase_count[2];
uint8 battled_count[2];
uint8 phase_action;
uint32 hint_timing[2];
uint8 current_player;
uint8 conti_player;
std::unordered_map<uint32, std::pair<uint32, uint32>> summon_counter;
std::unordered_map<uint32, std::pair<uint32, uint32>> normalsummon_counter;
std::unordered_map<uint32, std::pair<uint32, uint32>> spsummon_counter;
std::unordered_map<uint32, std::pair<uint32, uint32>> flipsummon_counter;
std::unordered_map<uint32, std::pair<uint32, uint32>> attack_counter;
std::unordered_map<uint32, std::pair<uint32, uint32>> chain_counter;
uint8_t chain_solving{ FALSE };
uint8_t conti_solving{ FALSE };
uint8_t win_player{ 5 };
uint8_t win_reason{ 0 };
uint8_t re_adjust{ FALSE };
effect* reason_effect{ nullptr };
uint8_t reason_player{ PLAYER_NONE };
card* summoning_card{ nullptr };
uint8_t summon_depth{ 0 };
uint8_t summon_cancelable{ FALSE };
card* attacker{ nullptr };
card* attack_target{ nullptr };
uint8_t attacker_player{ PLAYER_NONE };
uint8_t attack_target_player{ PLAYER_NONE };
uint32_t limit_extra_summon_zone{ 0 };
uint32_t limit_extra_summon_releasable{ 0 };
card* limit_tuner{ nullptr };
group* limit_syn{ nullptr };
int32_t limit_syn_minc{ 0 };
int32_t limit_syn_maxc{ 0 };
group* limit_xyz{ nullptr };
int32_t limit_xyz_minc{ 0 };
int32_t limit_xyz_maxc{ 0 };
group* limit_link{ nullptr };
card* limit_link_card{ nullptr };
int32_t limit_link_minc{ 0 };
int32_t limit_link_maxc{ 0 };
uint8_t not_material{ FALSE };
uint8_t attack_cancelable{ FALSE };
uint8_t attack_rollback{ FALSE };
uint8_t effect_damage_step{ 0 };
int32_t battle_damage[2]{};
int32_t summon_count[2]{};
uint8_t extra_summon[2]{};
int32_t spe_effect[2]{};
int32_t last_select_hint[2]{ 0 };
uint32_t duel_options{ 0 };
int32_t duel_rule{ CURRENT_RULE };
uint32_t copy_reset{ 0 };
int32_t copy_reset_count{ 0 };
uint32_t last_control_changed_id{ 0 };
uint32_t set_group_used_zones{ 0 };
uint8_t set_group_seq[7]{};
uint8_t dice_result[5]{};
uint8_t coin_result[MAX_COIN_COUNT]{};
int32_t coin_count{ 0 };
bool is_target_ready{ false };
bool is_gemini_summoning{ false };
bool is_summon_negated{ false };
uint8_t to_bp{ FALSE };
uint8_t to_m2{ FALSE };
uint8_t to_ep{ FALSE };
uint8_t skip_m2{ FALSE };
uint8_t chain_attack{ FALSE };
uint32_t chain_attacker_id{ 0 };
card* chain_attack_target{ nullptr };
uint8_t attack_player{ PLAYER_NONE };
uint8_t selfdes_disabled{ FALSE };
uint8_t overdraw[2]{};
int32_t check_level{ 0 };
uint8_t shuffle_check_disabled{ FALSE };
uint8_t shuffle_hand_check[2]{};
uint8_t shuffle_deck_check[2]{};
uint8_t deck_reversed{ FALSE };
uint8_t remove_brainwashing{ FALSE };
uint8_t flip_delayed{ FALSE };
uint8_t damage_calculated{ FALSE };
uint8_t hand_adjusted{ FALSE };
uint8_t summon_state_count[2]{};
uint8_t normalsummon_state_count[2]{};
uint8_t flipsummon_state_count[2]{};
uint8_t spsummon_state_count[2]{};
uint8_t attack_state_count[2]{};
uint8_t battle_phase_count[2]{};
uint8_t battled_count[2]{};
uint8_t phase_action{ FALSE };
uint32_t hint_timing[2]{};
uint8_t current_player{ PLAYER_NONE };
uint8_t conti_player{ PLAYER_NONE };
uint8_t select_deck_sequence_revealed{ FALSE };
uint8_t selecting_player{ 0 };
activity_map summon_counter;
activity_map normalsummon_counter;
activity_map spsummon_counter;
activity_map flipsummon_counter;
activity_map attack_counter;
activity_map chain_counter;
processor_list recover_damage_reserve;
effect_vector dec_count_reserve;
processor()
: temp_var{ 0 }, global_flag(0), pre_field{ 0 }, chain_solving(FALSE), conti_solving(FALSE), win_player(5), win_reason(0), re_adjust(FALSE), reason_effect(nullptr), reason_player(PLAYER_NONE),
summoning_card(nullptr), summon_depth(0), summon_cancelable(FALSE), attacker(nullptr), attack_target(nullptr), limit_extra_summon_zone(0), limit_extra_summon_releasable(0),
limit_tuner(nullptr), limit_syn(nullptr), limit_syn_minc(0), limit_syn_maxc(0), limit_xyz(nullptr), limit_xyz_minc(0), limit_xyz_maxc(0), limit_link(nullptr), limit_link_card(nullptr),
limit_link_minc(0), limit_link_maxc(0), not_material(FALSE), attack_cancelable(FALSE), attack_rollback(FALSE), effect_damage_step(0), battle_damage{ 0 }, summon_count{ 0 }, extra_summon{ FALSE },
spe_effect{ 0 }, duel_options(0), duel_rule(0), copy_reset(0), copy_reset_count(0), last_control_changed_id(0), set_group_used_zones(0), set_group_seq{ 0 }, dice_result{ 0 }, coin_result{ 0 },
to_bp(FALSE), to_m2(FALSE), to_ep(FALSE), skip_m2(FALSE), chain_attack(FALSE), chain_attacker_id(0), chain_attack_target(nullptr), attack_player(PLAYER_NONE), selfdes_disabled(FALSE),
overdraw{ FALSE }, check_level(0), shuffle_check_disabled(FALSE), shuffle_hand_check{ FALSE }, shuffle_deck_check{ FALSE }, deck_reversed(FALSE), remove_brainwashing(FALSE), flip_delayed(FALSE),
damage_calculated(FALSE), hand_adjusted(FALSE), summon_state_count{ 0 }, normalsummon_state_count{ 0 }, flipsummon_state_count{ 0 }, spsummon_state_count{ 0 }, attack_state_count{ 0 },
battle_phase_count{ 0 }, battled_count{ 0 }, phase_action(FALSE), hint_timing{ 0 }, current_player(PLAYER_NONE), conti_player(PLAYER_NONE) {}
};
class field {
public:
using effect_container = std::multimap<uint32, effect*>;
using card_set = std::set<card*, card_sort>;
using effect_vector = std::vector<effect*>;
using card_vector = std::vector<card*>;
using card_list = std::list<card*>;
using event_list = std::list<tevent>;
using chain_list = std::list<chain>;
using instant_f_list = std::map<effect*, chain>;
using chain_array = std::vector<chain>;
using processor_list = std::list<processor_unit>;
duel* pduel;
duel* pduel{};
player_info player[2];
card* temp_card;
card* temp_card{};
field_info infos;
//lpcost cost[2];
field_effect effects;
processor core;
return_value returns;
return_value returns{};
tevent nil_event;
static int32 field_used_count[32];
explicit field(duel* pduel);
static int32_t field_used_count[32];
explicit field(duel* pd);
~field() = default;
void reload_field_info();
void add_card(uint8 playerid, card* pcard, uint8 location, uint8 sequence, uint8 pzone = FALSE);
void add_card(uint8_t playerid, card* pcard, uint8_t location, uint8_t sequence, uint8_t pzone = FALSE);
void remove_card(card* pcard);
void move_card(uint8 playerid, card* pcard, uint8 location, uint8 sequence, uint8 pzone = FALSE);
void swap_card(card* pcard1, card* pcard2, uint8 new_sequence1, uint8 new_sequence2);
void move_card(uint8_t playerid, card* pcard, uint8_t location, uint8_t sequence, uint8_t pzone = FALSE);
void swap_card(card* pcard1, card* pcard2, uint8_t new_sequence1, uint8_t new_sequence2);
void swap_card(card* pcard1, card* pcard2);
void set_control(card* pcard, uint8 playerid, uint16 reset_phase, uint8 reset_count);
card* get_field_card(uint32 playerid, uint32 location, uint32 sequence);
int32 is_location_useable(uint32 playerid, uint32 location, uint32 sequence);
int32 get_useable_count(card* pcard, uint8 playerid, uint8 location, uint8 uplayer, uint32 reason, uint32 zone = 0xff, uint32* list = 0);
int32 get_useable_count_fromex(card* pcard, uint8 playerid, uint8 uplayer, uint32 zone = 0xff, uint32* list = 0);
int32 get_spsummonable_count(card* pcard, uint8 playerid, uint32 zone = 0xff, uint32* list = 0);
int32 get_spsummonable_count_fromex(card* pcard, uint8 playerid, uint8 uplayer, uint32 zone = 0xff, uint32* list = 0);
int32 get_useable_count_other(card* pcard, uint8 playerid, uint8 location, uint8 uplayer, uint32 reason, uint32 zone = 0xff, uint32* list = 0);
int32 get_tofield_count(card* pcard, uint8 playerid, uint8 location, uint32 uplayer, uint32 reason, uint32 zone = 0xff, uint32* list = 0);
int32 get_useable_count_fromex_rule4(card* pcard, uint8 playerid, uint8 uplayer, uint32 zone = 0xff, uint32* list = 0);
int32 get_spsummonable_count_fromex_rule4(card* pcard, uint8 playerid, uint8 uplayer, uint32 zone = 0xff, uint32* list = 0);
int32 get_mzone_limit(uint8 playerid, uint8 uplayer, uint32 reason);
int32 get_szone_limit(uint8 playerid, uint8 uplayer, uint32 reason);
uint32 get_linked_zone(int32 playerid);
uint32 get_rule_zone_fromex(int32 playerid, card* pcard);
void filter_must_use_mzone(uint8 playerid, uint8 uplayer, uint32 reason, card* pcard, uint32* flag);
void get_linked_cards(uint8 self, uint8 s, uint8 o, card_set* cset);
int32 check_extra_link(int32 playerid);
int32 check_extra_link(int32 playerid, card* pcard, int32 sequence);
void get_cards_in_zone(card_set* cset, uint32 zone, int32 playerid, int32 location);
void shuffle(uint8 playerid, uint8 location);
void reset_sequence(uint8 playerid, uint8 location);
void swap_deck_and_grave(uint8 playerid);
void reverse_deck(uint8 playerid);
void tag_swap(uint8 playerid);
void add_effect(effect* peffect, uint8 owner_player = 2);
void set_control(card* pcard, uint8_t playerid, uint16_t reset_phase, uint8_t reset_count);
int32_t get_pzone_sequence(uint8_t pseq) const;
card* get_field_card(uint8_t playerid, uint32_t general_location, uint8_t sequence) const;
int32_t is_location_useable(uint8_t playerid, uint32_t general_location, uint8_t sequence) const;
int32_t get_useable_count(card* pcard, uint8_t playerid, uint8_t location, uint8_t uplayer, uint32_t reason, uint32_t zone = 0xff, uint32_t* list = nullptr);
int32_t get_useable_count_fromex(card* pcard, uint8_t playerid, uint8_t uplayer, uint32_t zone = 0xff, uint32_t* list = nullptr);
int32_t get_spsummonable_count(card* pcard, uint8_t playerid, uint32_t zone = 0xff, uint32_t* list = nullptr);
int32_t get_spsummonable_count_fromex(card* pcard, uint8_t playerid, uint8_t uplayer, uint32_t zone = 0xff, uint32_t* list = nullptr);
int32_t get_useable_count_other(card* pcard, uint8_t playerid, uint8_t location, uint8_t uplayer, uint32_t reason, uint32_t zone = 0xff, uint32_t* list = nullptr);
int32_t get_tofield_count(card* pcard, uint8_t playerid, uint8_t location, uint32_t uplayer, uint32_t reason, uint32_t zone = 0xff, uint32_t* list = nullptr);
int32_t get_useable_count_fromex_rule4(card* pcard, uint8_t playerid, uint8_t uplayer, uint32_t zone = 0xff, uint32_t* list = nullptr);
int32_t get_spsummonable_count_fromex_rule4(card* pcard, uint8_t playerid, uint8_t uplayer, uint32_t zone = 0xff, uint32_t* list = nullptr);
int32_t get_mzone_limit(uint8_t playerid, uint8_t uplayer, uint32_t reason);
int32_t get_szone_limit(uint8_t playerid, uint8_t uplayer, uint32_t reason);
uint32_t get_linked_zone(int32_t playerid);
uint32_t get_rule_zone_fromex(int32_t playerid, card* pcard);
void filter_must_use_mzone(uint8_t playerid, uint8_t uplayer, uint32_t reason, card* pcard, uint32_t* flag);
void get_linked_cards(uint8_t self, uint8_t s, uint8_t o, card_set* cset);
int32_t check_extra_link(int32_t playerid);
int32_t check_extra_link(int32_t playerid, card* pcard, int32_t sequence);
void get_cards_in_zone(card_set* cset, uint32_t zone, int32_t playerid, int32_t location);
void shuffle(uint8_t playerid, uint8_t location);
void reset_sequence(uint8_t playerid, uint8_t location);
void swap_deck_and_grave(uint8_t playerid);
void reverse_deck(uint8_t playerid);
void refresh_player_info(uint8_t playerid);
void tag_swap(uint8_t playerid);
void add_effect(effect* peffect, uint8_t owner_player = PLAYER_NONE);
void remove_effect(effect* peffect);
void remove_oath_effect(effect* reason_effect);
void release_oath_relation(effect* reason_effect);
void reset_phase(uint32 phase);
void reset_phase(uint32_t phase);
void reset_chain();
void add_effect_code(uint32 code, uint32 playerid);
uint32 get_effect_code(uint32 code, uint32 playerid);
void dec_effect_code(uint32 code, uint32 playerid);
void add_effect_code(uint32_t code, int32_t playerid);
int32_t get_effect_code(uint32_t code, int32_t playerid);
void dec_effect_code(uint32_t code, int32_t playerid);
void filter_field_effect(uint32 code, effect_set* eset, uint8 sort = TRUE);
void filter_field_effect(uint32_t code, effect_set* eset, uint8_t sort = TRUE);
void filter_affected_cards(effect* peffect, card_set* cset);
void filter_inrange_cards(effect* peffect, card_set* cset);
void filter_player_effect(uint8 playerid, uint32 code, effect_set* eset, uint8 sort = TRUE);
int32 filter_matching_card(int32 findex, uint8 self, uint32 location1, uint32 location2, group* pgroup, card* pexception, group* pexgroup, uint32 extraargs, card** pret = 0, int32 fcount = 0, int32 is_target = FALSE);
int32 filter_field_card(uint8 self, uint32 location, uint32 location2, group* pgroup);
effect* is_player_affected_by_effect(uint8 playerid, uint32 code);
int32 get_release_list(uint8 playerid, card_set* release_list, card_set* ex_list, card_set* ex_list_oneof, int32 use_con, int32 use_hand, int32 fun, int32 exarg, card* exc, group* exg);
int32 check_release_list(uint8 playerid, int32 count, int32 use_con, int32 use_hand, int32 fun, int32 exarg, card* exc, group* exg);
int32 get_summon_release_list(card* target, card_set* release_list, card_set* ex_list, card_set* ex_list_oneof, group* mg = NULL, uint32 ex = 0, uint32 releasable = 0xff00ff, uint32 pos = 0x1);
int32 get_summon_count_limit(uint8 playerid);
int32 get_draw_count(uint8 playerid);
void get_ritual_material(uint8 playerid, effect* peffect, card_set* material, uint8 no_level = FALSE);
void get_fusion_material(uint8 playerid, card_set* material_all, card_set* material_base, uint32 location);
void ritual_release(card_set* material);
void get_xyz_material(card* scard, int32 findex, uint32 lv, int32 maxc, group* mg);
void get_overlay_group(uint8 self, uint8 s, uint8 o, card_set* pset);
int32 get_overlay_count(uint8 self, uint8 s, uint8 o);
void filter_player_effect(uint8_t playerid, uint32_t code, effect_set* eset, uint8_t sort = TRUE);
int32_t filter_matching_card(lua_State* L, int32_t findex, uint8_t self, uint32_t location1, uint32_t location2, group* pgroup, card* pexception, group* pexgroup, uint32_t extraargs, card** pret = nullptr, int32_t fcount = 0, int32_t is_target = FALSE);
int32_t filter_field_card(uint8_t self, uint32_t location, uint32_t location2, group* pgroup);
effect* is_player_affected_by_effect(uint8_t playerid, uint32_t code);
int32_t get_release_list(lua_State* L, uint8_t playerid, card_set* release_list, card_set* ex_list, card_set* ex_list_oneof, int32_t use_con, int32_t use_hand, int32_t fun, int32_t exarg, card* exc, group* exg, uint32_t reason);
int32_t check_release_list(lua_State* L, uint8_t playerid, int32_t count, int32_t use_con, int32_t use_hand, int32_t fun, int32_t exarg, card* exc, group* exg, uint32_t reason);
int32_t get_summon_release_list(card* target, card_set* release_list, card_set* ex_list, card_set* ex_list_oneof, group* mg = nullptr, uint32_t ex = 0, uint32_t releasable = 0xff00ff, uint32_t pos = 0x1);
int32_t get_summon_count_limit(uint8_t playerid);
int32_t get_draw_count(uint8_t playerid);
void get_ritual_material(uint8_t playerid, effect* peffect, card_set* material, uint8_t no_level = FALSE);
void get_fusion_material(uint8_t playerid, card_set* material_all, card_set* material_base, uint32_t location);
void ritual_release(const card_set& material);
void get_xyz_material(lua_State* L, card* scard, int32_t findex, uint32_t lv, int32_t maxc, group* mg);
void get_overlay_group(uint8_t self, uint8_t s, uint8_t o, card_set* pset);
int32_t get_overlay_count(uint8_t self, uint8_t s, uint8_t o);
void update_disable_check_list(effect* peffect);
void add_to_disable_check_list(card* pcard);
void adjust_disable_check_list();
void adjust_self_destroy_set();
void erase_grant_effect(effect* peffect);
int32 adjust_grant_effect();
int32_t adjust_grant_effect();
void add_unique_card(card* pcard);
void remove_unique_card(card* pcard);
effect* check_unique_onfield(card* pcard, uint8 controler, uint8 location, card* icard = 0);
int32 check_spsummon_once(card* pcard, uint8 playerid);
void check_card_counter(card* pcard, int32 counter_type, int32 playerid);
void check_card_counter(group* pgroup, int32 counter_type, int32 playerid);
void check_chain_counter(effect* peffect, int32 playerid, int32 chainid, bool cancel = false);
void set_spsummon_counter(uint8 playerid);
int32 check_spsummon_counter(uint8 playerid, uint8 ct = 1);
int32 check_lp_cost(uint8 playerid, uint32 cost, uint32 must_pay);
effect* check_unique_onfield(card* pcard, uint8_t controler, uint8_t location, card* icard = nullptr);
int32_t check_spsummon_once(card* pcard, uint8_t playerid);
void check_card_counter(card* pcard, int32_t counter_type, int32_t playerid);
void check_card_counter(group* pgroup, int32_t counter_type, int32_t playerid);
void check_chain_counter(effect* peffect, int32_t playerid, int32_t chainid, bool cancel = false);
void set_spsummon_counter(uint8_t playerid);
int32_t check_spsummon_counter(uint8_t playerid, uint8_t ct = 1);
bool is_select_hide_deck_sequence(uint8_t playerid);
int32_t check_lp_cost(uint8_t playerid, int32_t cost, uint32_t must_pay);
void save_lp_cost() {}
void restore_lp_cost() {}
int32 pay_lp_cost(uint32 step, uint8 playerid, uint32 cost, uint32 must_pay);
int32_t pay_lp_cost(uint32_t step, uint8_t playerid, uint32_t cost, uint32_t must_pay);
uint32 get_field_counter(uint8 self, uint8 s, uint8 o, uint16 countertype);
int32 effect_replace_check(uint32 code, const tevent& e);
int32 get_attack_target(card* pcard, card_vector* v, uint8 chain_attack = FALSE, bool select_target = true);
uint32_t get_field_counter(uint8_t self, uint8_t s, uint8_t o, uint16_t countertype);
int32_t effect_replace_check(uint32_t code, const tevent& e);
int32_t get_attack_target(card* pcard, card_vector* v, uint8_t chain_attack = FALSE, bool select_target = true);
bool confirm_attack_target();
void attack_all_target_check();
int32 check_synchro_material(card* pcard, int32 findex1, int32 findex2, int32 min, int32 max, card* smat, group* mg);
int32 check_tuner_material(card* pcard, card* tuner, int32 findex1, int32 findex2, int32 min, int32 max, card* smat, group* mg);
int32 check_other_synchro_material(const card_vector& nsyn, int32 lv, int32 min, int32 max, int32 mcount);
int32 check_tribute(card* pcard, int32 min, int32 max, group* mg, uint8 toplayer, uint32 zone = 0x1f, uint32 releasable = 0xff00ff, uint32 pos = 0x1);
static int32 check_with_sum_limit(const card_vector& mats, int32 acc, int32 index, int32 count, int32 min, int32 max, int32 opmin);
static int32 check_with_sum_limit_m(const card_vector& mats, int32 acc, int32 index, int32 min, int32 max, int32 opmin, int32 must_count);
static int32 check_with_sum_greater_limit(const card_vector& mats, int32 acc, int32 index, int32 opmin);
static int32 check_with_sum_greater_limit_m(const card_vector& mats, int32 acc, int32 index, int32 opmin, int32 must_count);
int32 check_xyz_material(card* pcard, int32 findex, int32 lv, int32 min, int32 max, group* mg);
int32 is_player_can_draw(uint8 playerid);
int32 is_player_can_discard_deck(uint8 playerid, int32 count);
int32 is_player_can_discard_deck_as_cost(uint8 playerid, int32 count);
int32 is_player_can_discard_hand(uint8 playerid, card* pcard, effect* reason_effect, uint32 reason);
int32 is_player_can_action(uint8 playerid, uint32 actionlimit);
int32 is_player_can_summon(uint32 sumtype, uint8 playerid, card* pcard, uint8 toplayer);
int32 is_player_can_mset(uint32 sumtype, uint8 playerid, card* pcard, uint8 toplayer);
int32 is_player_can_sset(uint8 playerid, card* pcard);
int32 is_player_can_spsummon(uint8 playerid);
int32 is_player_can_spsummon(effect* reason_effect, uint32 sumtype, uint8 sumpos, uint8 playerid, uint8 toplayer, card* pcard);
int32 is_player_can_flipsummon(uint8 playerid, card* pcard);
int32 is_player_can_spsummon_monster(uint8 playerid, uint8 toplayer, uint8 sumpos, uint32 sumtype, card_data* pdata);
int32 is_player_can_spsummon_count(uint8 playerid, uint32 count);
int32 is_player_can_release(uint8 playerid, card* pcard);
int32 is_player_can_place_counter(uint8 playerid, card* pcard, uint16 countertype, uint16 count);
int32 is_player_can_remove_counter(uint8 playerid, card* pcard, uint8 s, uint8 o, uint16 countertype, uint16 count, uint32 reason);
int32 is_player_can_remove_overlay_card(uint8 playerid, card* pcard, uint8 s, uint8 o, uint16 count, uint32 reason);
int32 is_player_can_send_to_grave(uint8 playerid, card* pcard);
int32 is_player_can_send_to_hand(uint8 playerid, card* pcard);
int32 is_player_can_send_to_deck(uint8 playerid, card* pcard);
int32 is_player_can_remove(uint8 playerid, card* pcard, uint32 reason);
int32 is_chain_negatable(uint8 chaincount);
int32 is_chain_disablable(uint8 chaincount);
int32 is_chain_disabled(uint8 chaincount);
int32 check_chain_target(uint8 chaincount, card* pcard);
chain* get_chain(uint32 chaincount);
int32 get_cteffect(effect* peffect, int32 playerid, int32 store);
int32 get_cteffect_evt(effect* feffect, int32 playerid, const tevent& e, int32 store);
int32 check_cteffect_hint(effect* peffect, uint8 playerid);
int32 check_nonpublic_trigger(chain& ch);
int32 check_trigger_effect(const chain& ch) const;
int32 check_spself_from_hand_trigger(const chain& ch) const;
int32 is_able_to_enter_bp();
void add_process(uint16 type, uint16 step, effect* peffect, group* target, int32 arg1, int32 arg2, int32 arg3 = 0, int32 arg4 = 0, void* ptr1 = nullptr, void* ptr2 = nullptr);
int32 process();
int32 execute_cost(uint16 step, effect* peffect, uint8 triggering_player);
int32 execute_operation(uint16 step, effect* peffect, uint8 triggering_player);
int32 execute_target(uint16 step, effect* peffect, uint8 triggering_player);
void raise_event(card* event_card, uint32 event_code, effect* reason_effect, uint32 reason, uint8 reason_player, uint8 event_player, uint32 event_value);
void raise_event(card_set* event_cards, uint32 event_code, effect* reason_effect, uint32 reason, uint8 reason_player, uint8 event_player, uint32 event_value);
void raise_single_event(card* trigger_card, card_set* event_cards, uint32 event_code, effect* reason_effect, uint32 reason, uint8 reason_player, uint8 event_player, uint32 event_value);
int32 check_event(uint32 code, tevent* pe = 0);
int32 check_event_c(effect* peffect, uint8 playerid, int32 neglect_con, int32 neglect_cost, int32 copy_info, tevent* pe = 0);
int32 check_hint_timing(effect* peffect);
int32 process_phase_event(int16 step, int32 phase_event);
int32 process_point_event(int16 step, int32 skip_trigger, int32 skip_freechain, int32 skip_new);
int32 process_quick_effect(int16 step, int32 skip_freechain, uint8 priority);
int32 process_instant_event();
int32 process_single_event();
int32 process_single_event(effect* peffect, const tevent& e, chain_list& tp, chain_list& ntp);
int32 process_idle_command(uint16 step);
int32 process_battle_command(uint16 step);
int32 process_damage_step(uint16 step, uint32 new_attack);
void calculate_battle_damage(effect** pdamchange, card** preason_card, uint8* battle_destroyed);
int32 process_turn(uint16 step, uint8 turn_player);
int32 add_chain(uint16 step);
void solve_continuous(uint8 playerid, effect* peffect, const tevent& e);
int32 solve_continuous(uint16 step);
int32 solve_chain(uint16 step, uint32 chainend_arg1, uint32 chainend_arg2);
int32 break_effect();
int32_t get_must_material_list(uint8_t playerid, uint32_t limit, card_set* must_list);
int32_t check_must_material(group* mg, uint8_t playerid, uint32_t limit);
void get_synchro_material(uint8_t playerid, card_set* material, effect* tuner_limit = nullptr);
//check material
int32_t check_synchro_material(lua_State* L, card* pcard, int32_t findex1, int32_t findex2, int32_t min, int32_t max, card* smat, group* mg);
int32_t check_tuner_material(lua_State* L, card* pcard, card* tuner, int32_t findex1, int32_t findex2, int32_t min, int32_t max, card* smat, group* mg);
int32_t check_other_synchro_material(const card_vector& nsyn, int32_t lv, int32_t min, int32_t max, int32_t mcount);
int32_t check_tribute(card* pcard, int32_t min, int32_t max, group* mg, uint8_t toplayer, uint32_t zone = 0x1f, uint32_t releasable = 0xff00ff, uint32_t pos = 0x1);
static int32_t check_with_sum_limit(const card_vector& mats, int32_t acc, int32_t index, int32_t count, int32_t min, int32_t max, int32_t opmin);
static int32_t check_with_sum_limit_m(const card_vector& mats, int32_t acc, int32_t index, int32_t min, int32_t max, int32_t opmin, int32_t must_count);
static int32_t check_with_sum_greater_limit(const card_vector& mats, int32_t acc, int32_t index, int32_t opmin);
static int32_t check_with_sum_greater_limit_m(const card_vector& mats, int32_t acc, int32_t index, int32_t opmin, int32_t must_count);
int32_t check_xyz_material(lua_State* L, card* pcard, int32_t findex, int32_t lv, int32_t min, int32_t max, group* mg);
int32_t is_player_can_draw(uint8_t playerid);
int32_t is_player_can_discard_deck(uint8_t playerid, int32_t count);
int32_t is_player_can_discard_deck_as_cost(uint8_t playerid, int32_t count);
int32_t is_player_can_discard_hand(uint8_t playerid, card* pcard, effect* reason_effect, uint32_t reason);
int32_t is_player_can_action(uint8_t playerid, uint32_t actionlimit);
int32_t is_player_can_summon(uint32_t sumtype, uint8_t playerid, card* pcard, uint8_t toplayer);
int32_t is_player_can_mset(uint32_t sumtype, uint8_t playerid, card* pcard, uint8_t toplayer);
int32_t is_player_can_sset(uint8_t playerid, card* pcard);
int32_t is_player_can_spsummon(uint8_t playerid);
int32_t is_player_can_spsummon(effect* reason_effect, uint32_t sumtype, uint8_t sumpos, uint8_t playerid, uint8_t toplayer, card* pcard);
int32_t is_player_can_flipsummon(uint8_t playerid, card* pcard);
int32_t is_player_can_spsummon_monster(uint8_t playerid, uint8_t toplayer, uint8_t sumpos, uint32_t sumtype, card_data* pdata);
int32_t is_player_can_spsummon_count(uint8_t playerid, uint32_t count);
int32_t is_player_can_release(uint8_t playerid, card* pcard, uint32_t reason);
int32_t is_player_can_place_counter(uint8_t playerid, card* pcard, uint16_t countertype, uint16_t count);
int32_t is_player_can_remove_counter(uint8_t playerid, card* pcard, uint8_t s, uint8_t o, uint16_t countertype, uint16_t count, uint32_t reason);
int32_t is_player_can_remove_overlay_card(uint8_t playerid, card* pcard, uint8_t s, uint8_t o, uint16_t count, uint32_t reason);
int32_t is_player_can_send_to_grave(uint8_t playerid, card* pcard);
int32_t is_player_can_send_to_hand(uint8_t playerid, card* pcard);
int32_t is_player_can_send_to_deck(uint8_t playerid, card* pcard);
int32_t is_player_can_remove(uint8_t playerid, card* pcard, uint32_t reason);
int32_t is_chain_negatable(uint8_t chaincount);
int32_t is_chain_disablable(uint8_t chaincount);
int32_t is_chain_disabled(uint8_t chaincount);
int32_t check_chain_target(uint8_t chaincount, card* pcard);
chain* get_chain(uint32_t chaincount);
int32_t get_cteffect(effect* peffect, int32_t playerid, int32_t store);
int32_t get_cteffect_evt(effect* feffect, int32_t playerid, const tevent& e, int32_t store);
int32_t check_cteffect_hint(effect* peffect, uint8_t playerid);
int32_t check_nonpublic_trigger(chain& ch);
int32_t check_trigger_effect(const chain& ch) const;
int32_t check_spself_from_hand_trigger(const chain& ch) const;
int32_t is_able_to_enter_bp();
void add_process(uint16_t type, uint16_t step, effect* peffect, group* target, int32_t arg1, int32_t arg2, int32_t arg3 = 0, int32_t arg4 = 0, void* ptr1 = nullptr, void* ptr2 = nullptr);
uint32_t process();
int32_t execute_cost(uint16_t step, effect* peffect, uint8_t triggering_player);
int32_t execute_operation(uint16_t step, effect* peffect, uint8_t triggering_player);
int32_t execute_target(uint16_t step, effect* peffect, uint8_t triggering_player);
void raise_event(card* event_card, uint32_t event_code, effect* reason_effect, uint32_t reason, uint8_t reason_player, uint8_t event_player, uint32_t event_value);
void raise_event(const card_set& event_cards, uint32_t event_code, effect* reason_effect, uint32_t reason, uint8_t reason_player, uint8_t event_player, uint32_t event_value);
void raise_single_event(card* trigger_card, card_set* event_cards, uint32_t event_code, effect* reason_effect, uint32_t reason, uint8_t reason_player, uint8_t event_player, uint32_t event_value);
int32_t check_event(uint32_t code, tevent* pe = nullptr);
int32_t check_event_c(effect* peffect, uint8_t playerid, int32_t neglect_con, int32_t neglect_cost, int32_t copy_info, tevent* pe = nullptr);
int32_t check_hint_timing(effect* peffect);
int32_t process_phase_event(int16_t step, int32_t phase_event);
int32_t process_point_event(int16_t step, int32_t skip_trigger, int32_t skip_freechain, int32_t skip_new);
int32_t process_quick_effect(int16_t step, int32_t skip_freechain, uint8_t priority);
int32_t process_instant_event();
int32_t process_single_event();
int32_t process_single_event(effect* peffect, const tevent& e, chain_list& tp, chain_list& ntp);
int32_t process_idle_command(uint16_t step);
int32_t process_battle_command(uint16_t step);
int32_t process_damage_step(uint16_t step, uint32_t new_attack);
void calculate_battle_damage(effect** pdamchange, card** preason_card, uint8_t* battle_destroyed);
int32_t process_turn(uint16_t step, uint8_t turn_player);
int32_t add_chain(uint16_t step);
void solve_continuous(uint8_t playerid, effect* peffect, const tevent& e);
int32_t solve_continuous(uint16_t step);
int32_t solve_chain(uint16_t step, uint32_t chainend_arg1, uint32_t chainend_arg2);
int32_t break_effect();
void adjust_instant();
void adjust_all();
void refresh_location_info_instant();
int32 refresh_location_info(uint16 step);
int32 adjust_step(uint16 step);
int32_t refresh_location_info(uint16_t step);
int32_t adjust_step(uint16_t step);
//operations
int32 negate_chain(uint8 chaincount);
int32 disable_chain(uint8 chaincount, uint8 forced);
void change_chain_effect(uint8 chaincount, int32 replace_op);
void change_target(uint8 chaincount, group* targets);
void change_target_player(uint8 chaincount, uint8 playerid);
void change_target_param(uint8 chaincount, int32 param);
void remove_counter(uint32 reason, card* pcard, uint32 rplayer, uint32 s, uint32 o, uint32 countertype, uint32 count);
void remove_overlay_card(uint32 reason, card* pcard, uint32 rplayer, uint32 s, uint32 o, uint16 min, uint16 max);
void get_control(card_set* targets, effect* reason_effect, uint32 reason_player, uint32 playerid, uint32 reset_phase, uint32 reset_count, uint32 zone);
void get_control(card* target, effect* reason_effect, uint32 reason_player, uint32 playerid, uint32 reset_phase, uint32 reset_count, uint32 zone);
void swap_control(effect* reason_effect, uint32 reason_player, card_set* targets1, card_set* targets2, uint32 reset_phase, uint32 reset_count);
void swap_control(effect* reason_effect, uint32 reason_player, card* pcard1, card* pcard2, uint32 reset_phase, uint32 reset_count);
void equip(uint32 equip_player, card* equip_card, card* target, uint32 up, uint32 is_step);
void draw(effect* reason_effect, uint32 reason, uint32 reason_player, uint32 playerid, uint32 count);
void damage(effect* reason_effect, uint32 reason, uint32 reason_player, card* reason_card, uint32 playerid, uint32 amount, uint32 is_step = FALSE);
void recover(effect* reason_effect, uint32 reason, uint32 reason_player, uint32 playerid, uint32 amount, uint32 is_step = FALSE);
void summon(uint32 sumplayer, card* target, effect* proc, uint32 ignore_count, uint32 min_tribute, uint32 zone = 0x1f);
void mset(uint32 setplayer, card* target, effect* proc, uint32 ignore_count, uint32 min_tribute, uint32 zone = 0x1f);
void special_summon_rule(uint32 sumplayer, card* target, uint32 summon_type);
void special_summon(card_set* target, uint32 sumtype, uint32 sumplayer, uint32 playerid, uint32 nocheck, uint32 nolimit, uint32 positions, uint32 zone);
void special_summon_step(card* target, uint32 sumtype, uint32 sumplayer, uint32 playerid, uint32 nocheck, uint32 nolimit, uint32 positions, uint32 zone);
void special_summon_complete(effect* reason_effect, uint8 reason_player);
void destroy(card_set* targets, effect* reason_effect, uint32 reason, uint32 reason_player, uint32 playerid = 2, uint32 destination = 0, uint32 sequence = 0);
void destroy(card* target, effect* reason_effect, uint32 reason, uint32 reason_player, uint32 playerid = 2, uint32 destination = 0, uint32 sequence = 0);
void release(card_set* targets, effect* reason_effect, uint32 reason, uint32 reason_player);
void release(card* target, effect* reason_effect, uint32 reason, uint32 reason_player);
void send_to(card_set* targets, effect* reason_effect, uint32 reason, uint32 reason_player, uint32 playerid, uint32 destination, uint32 sequence, uint32 position);
void send_to(card* target, effect* reason_effect, uint32 reason, uint32 reason_player, uint32 playerid, uint32 destination, uint32 sequence, uint32 position);
void move_to_field(card* target, uint32 move_player, uint32 playerid, uint32 destination, uint32 positions, uint32 enable = FALSE, uint32 ret = 0, uint32 pzone = FALSE, uint32 zone = 0xff);
void change_position(card_set* targets, effect* reason_effect, uint32 reason_player, uint32 au, uint32 ad, uint32 du, uint32 dd, uint32 flag, uint32 enable = FALSE);
void change_position(card* target, effect* reason_effect, uint32 reason_player, uint32 npos, uint32 flag, uint32 enable = FALSE);
void operation_replace(int32 type, int32 step, group* targets);
void select_tribute_cards(card* target, uint8 playerid, uint8 cancelable, int32 min, int32 max, uint8 toplayer, uint32 zone);
int32 remove_counter(uint16 step, uint32 reason, card* pcard, uint8 rplayer, uint8 s, uint8 o, uint16 countertype, uint16 count);
int32 remove_overlay_card(uint16 step, uint32 reason, card* pcard, uint8 rplayer, uint8 s, uint8 o, uint16 min, uint16 max);
int32 get_control(uint16 step, effect* reason_effect, uint8 reason_player, group* targets, uint8 playerid, uint16 reset_phase, uint8 reset_count, uint32 zone);
int32 swap_control(uint16 step, effect* reason_effect, uint8 reason_player, group* targets1, group* targets2, uint16 reset_phase, uint8 reset_count);
int32 self_destroy(uint16 step, card* ucard, int32 p);
int32 trap_monster_adjust(uint16 step);
int32 equip(uint16 step, uint8 equip_player, card* equip_card, card* target, uint32 up, uint32 is_step);
int32 draw(uint16 step, effect* reason_effect, uint32 reason, uint8 reason_player, uint8 playerid, uint32 count);
int32 damage(uint16 step, effect* reason_effect, uint32 reason, uint8 reason_player, card* reason_card, uint8 playerid, uint32 amount, uint32 is_step);
int32 recover(uint16 step, effect* reason_effect, uint32 reason, uint8 reason_player, uint8 playerid, uint32 amount, uint32 is_step);
int32 summon(uint16 step, uint8 sumplayer, card* target, effect* proc, uint8 ignore_count, uint8 min_tribute, uint32 zone);
int32 flip_summon(uint16 step, uint8 sumplayer, card* target);
int32 mset(uint16 step, uint8 setplayer, card* ptarget, effect* proc, uint8 ignore_count, uint8 min_tribute, uint32 zone);
int32 sset(uint16 step, uint8 setplayer, uint8 toplayer, card* ptarget, effect* reason_effect);
int32 sset_g(uint16 step, uint8 setplayer, uint8 toplayer, group* ptarget, uint8 confirm, effect* reason_effect);
int32 special_summon_rule(uint16 step, uint8 sumplayer, card* target, uint32 summon_type);
int32 special_summon_step(uint16 step, group* targets, card* target, uint32 zone);
int32 special_summon(uint16 step, effect* reason_effect, uint8 reason_player, group* targets, uint32 zone);
int32 destroy_replace(uint16 step, group* targets, card* target, uint8 battle);
int32 destroy(uint16 step, group* targets, effect* reason_effect, uint32 reason, uint8 reason_player);
int32 release_replace(uint16 step, group* targets, card* target);
int32 release(uint16 step, group* targets, effect* reason_effect, uint32 reason, uint8 reason_player);
int32 send_replace(uint16 step, group* targets, card* target);
int32 send_to(uint16 step, group* targets, effect* reason_effect, uint32 reason, uint8 reason_player);
int32 discard_deck(uint16 step, uint8 playerid, uint8 count, uint32 reason);
int32 move_to_field(uint16 step, card* target, uint32 enable, uint32 ret, uint32 pzone, uint32 zone);
int32 change_position(uint16 step, group* targets, effect* reason_effect, uint8 reason_player, uint32 enable);
int32 operation_replace(uint16 step, effect* replace_effect, group* targets, card* target, int32 is_destroy);
int32 activate_effect(uint16 step, effect* peffect);
int32 select_synchro_material(int16 step, uint8 playerid, card* pcard, int32 min, int32 max, card* smat, group* mg);
int32 select_xyz_material(int16 step, uint8 playerid, uint32 lv, card* pcard, int32 min, int32 max);
int32 select_release_cards(int16 step, uint8 playerid, uint8 cancelable, int32 min, int32 max);
int32 select_tribute_cards(int16 step, card* target, uint8 playerid, uint8 cancelable, int32 min, int32 max, uint8 toplayer, uint32 zone);
int32 toss_coin(uint16 step, effect* reason_effect, uint8 reason_player, uint8 playerid, uint8 count);
int32 toss_dice(uint16 step, effect* reason_effect, uint8 reason_player, uint8 playerid, uint8 count1, uint8 count2);
int32 rock_paper_scissors(uint16 step, uint8 repeat);
int32 select_battle_command(uint16 step, uint8 playerid);
int32 select_idle_command(uint16 step, uint8 playerid);
int32 select_effect_yes_no(uint16 step, uint8 playerid, uint32 description, card* pcard);
int32 select_yes_no(uint16 step, uint8 playerid, uint32 description);
int32 select_option(uint16 step, uint8 playerid);
int32 select_card(uint16 step, uint8 playerid, uint8 cancelable, uint8 min, uint8 max);
int32 select_unselect_card(uint16 step, uint8 playerid, uint8 cancelable, uint8 min, uint8 max, uint8 finishable);
int32 select_chain(uint16 step, uint8 playerid, uint8 spe_count, uint8 forced);
int32 select_place(uint16 step, uint8 playerid, uint32 flag, uint8 count);
int32 select_position(uint16 step, uint8 playerid, uint32 code, uint8 positions);
int32 select_tribute(uint16 step, uint8 playerid, uint8 cancelable, uint8 min, uint8 max);
int32 select_counter(uint16 step, uint8 playerid, uint16 countertype, uint16 count, uint8 s, uint8 o);
int32 select_with_sum_limit(int16 step, uint8 playerid, int32 acc, int32 min, int32 max);
int32 sort_card(int16 step, uint8 playerid);
int32 announce_race(int16 step, uint8 playerid, int32 count, int32 available);
int32 announce_attribute(int16 step, uint8 playerid, int32 count, int32 available);
int32 announce_card(int16 step, uint8 playerid);
int32 announce_number(int16 step, uint8 playerid);
int32_t negate_chain(uint8_t chaincount);
int32_t disable_chain(uint8_t chaincount, uint8_t forced);
void change_chain_effect(uint8_t chaincount, int32_t replace_op);
void change_target(uint8_t chaincount, group* targets);
void change_target_player(uint8_t chaincount, uint8_t playerid);
void change_target_param(uint8_t chaincount, int32_t param);
void remove_counter(uint32_t reason, card* pcard, uint32_t rplayer, uint32_t s, uint32_t o, uint32_t countertype, uint32_t count);
void remove_overlay_card(uint32_t reason, card* pcard, uint32_t rplayer, uint32_t s, uint32_t o, uint16_t min, uint16_t max);
void get_control(const card_set& targets, effect* reason_effect, uint32_t reason_player, uint32_t playerid, uint32_t reset_phase, uint32_t reset_count, uint32_t zone);
void get_control(card* target, effect* reason_effect, uint32_t reason_player, uint32_t playerid, uint32_t reset_phase, uint32_t reset_count, uint32_t zone);
void swap_control(effect* reason_effect, uint32_t reason_player, const card_set& targets1, const card_set& targets2, uint32_t reset_phase, uint32_t reset_count);
void swap_control(effect* reason_effect, uint32_t reason_player, card* pcard1, card* pcard2, uint32_t reset_phase, uint32_t reset_count);
void equip(uint32_t equip_player, card* equip_card, card* target, uint32_t up, uint32_t is_step);
void draw(effect* reason_effect, uint32_t reason, uint32_t reason_player, uint32_t playerid, int32_t count);
void damage(effect* reason_effect, uint32_t reason, uint32_t reason_player, card* reason_card, uint32_t playerid, int32_t amount, uint32_t is_step = FALSE);
void recover(effect* reason_effect, uint32_t reason, uint32_t reason_player, uint32_t playerid, int32_t amount, uint32_t is_step = FALSE);
void summon(uint32_t sumplayer, card* target, effect* proc, uint32_t ignore_count, uint32_t min_tribute, uint32_t zone = 0x1f, uint32_t action_type = SUMMON_IN_IDLE);
void mset(uint32_t setplayer, card* target, effect* proc, uint32_t ignore_count, uint32_t min_tribute, uint32_t zone = 0x1f, uint32_t action_type = SUMMON_IN_IDLE);
void special_summon_rule(uint32_t sumplayer, card* target, uint32_t summon_type, uint32_t action_type = SUMMON_IN_IDLE);
void special_summon(const card_set& target, uint32_t sumtype, uint32_t sumplayer, uint32_t playerid, uint32_t nocheck, uint32_t nolimit, uint32_t positions, uint32_t zone);
void special_summon_step(card* target, uint32_t sumtype, uint32_t sumplayer, uint32_t playerid, uint32_t nocheck, uint32_t nolimit, uint32_t positions, uint32_t zone);
void special_summon_complete(effect* reason_effect, uint8_t reason_player);
void destroy(card_set& targets, effect* reason_effect, uint32_t reason, uint32_t reason_player, uint32_t playerid = 2, uint32_t destination = 0, uint32_t sequence = 0);
void destroy(card* target, effect* reason_effect, uint32_t reason, uint32_t reason_player, uint32_t playerid = 2, uint32_t destination = 0, uint32_t sequence = 0);
void release(const card_set& targets, effect* reason_effect, uint32_t reason, uint32_t reason_player);
void release(card* target, effect* reason_effect, uint32_t reason, uint32_t reason_player);
void send_to(const card_set& targets, effect* reason_effect, uint32_t reason, uint32_t reason_player, uint32_t playerid, uint32_t destination, uint32_t sequence, uint32_t position, uint8_t send_activating = FALSE);
void send_to(card* target, effect* reason_effect, uint32_t reason, uint32_t reason_player, uint32_t playerid, uint32_t destination, uint32_t sequence, uint32_t position, uint8_t send_activating = FALSE);
void move_to_field(card* target, uint32_t move_player, uint32_t playerid, uint32_t destination, uint32_t positions, uint32_t enable = FALSE, uint32_t ret = 0, uint32_t pzone = FALSE, uint32_t zone = 0xff);
void change_position(const card_set& targets, effect* reason_effect, uint32_t reason_player, uint32_t au, uint32_t ad, uint32_t du, uint32_t dd, uint32_t flag, uint32_t enable = FALSE);
void change_position(card* target, effect* reason_effect, uint32_t reason_player, uint32_t npos, uint32_t flag, uint32_t enable = FALSE);
void operation_replace(int32_t type, int32_t step, group* targets);
void select_tribute_cards(card* target, uint8_t playerid, uint8_t cancelable, int32_t min, int32_t max, uint8_t toplayer, uint32_t zone);
// summon
int32_t summon(uint16_t step, uint8_t sumplayer, card* target, effect* proc, uint8_t ignore_count, uint8_t min_tribute, uint32_t zone, uint32_t action_type);
int32_t mset(uint16_t step, uint8_t setplayer, card* ptarget, effect* proc, uint8_t ignore_count, uint8_t min_tribute, uint32_t zone, uint32_t action_type);
int32_t flip_summon(uint16_t step, uint8_t sumplayer, card* target, uint32_t action_type);
int32_t special_summon_rule(uint16_t step, uint8_t sumplayer, card* target, uint32_t summon_type, uint32_t action_type);
int32_t remove_counter(uint16_t step, uint32_t reason, card* pcard, uint8_t rplayer, uint8_t s, uint8_t o, uint16_t countertype, uint16_t count);
int32_t remove_overlay_card(uint16_t step, uint32_t reason, card* pcard, uint8_t rplayer, uint8_t s, uint8_t o, uint16_t min, uint16_t max);
int32_t get_control(uint16_t step, effect* reason_effect, uint8_t reason_player, group* targets, uint8_t playerid, uint16_t reset_phase, uint8_t reset_count, uint32_t zone);
int32_t swap_control(uint16_t step, effect* reason_effect, uint8_t reason_player, group* targets1, group* targets2, uint16_t reset_phase, uint8_t reset_count);
int32_t self_destroy(uint16_t step, card* ucard, int32_t p);
int32_t trap_monster_adjust(uint16_t step);
int32_t equip(uint16_t step, uint8_t equip_player, card* equip_card, card* target, uint32_t up, uint32_t is_step);
int32_t draw(uint16_t step, effect* reason_effect, uint32_t reason, uint8_t reason_player, uint8_t playerid, int32_t count);
int32_t damage(uint16_t step, effect* reason_effect, uint32_t reason, uint8_t reason_player, card* reason_card, uint8_t playerid, int32_t amount, uint32_t is_step);
int32_t recover(uint16_t step, effect* reason_effect, uint32_t reason, uint8_t reason_player, uint8_t playerid, int32_t amount, uint32_t is_step);
int32_t sset(uint16_t step, uint8_t setplayer, uint8_t toplayer, card* ptarget, effect* reason_effect);
int32_t sset_g(uint16_t step, uint8_t setplayer, uint8_t toplayer, group* ptarget, uint8_t confirm, effect* reason_effect);
int32_t special_summon_step(uint16_t step, group* targets, card* target, uint32_t zone);
int32_t special_summon(uint16_t step, effect* reason_effect, uint8_t reason_player, group* targets, uint32_t zone);
int32_t destroy_replace(uint16_t step, group* targets, card* target, uint8_t battle);
int32_t destroy(uint16_t step, group* targets, effect* reason_effect, uint32_t reason, uint8_t reason_player);
int32_t release_replace(uint16_t step, group* targets, card* target);
int32_t release(uint16_t step, group* targets, effect* reason_effect, uint32_t reason, uint8_t reason_player);
int32_t send_replace(uint16_t step, group* targets, card* target);
int32_t send_to(uint16_t step, group* targets, effect* reason_effect, uint32_t reason, uint8_t reason_player, uint8_t send_activating);
int32_t discard_deck(uint16_t step, uint8_t playerid, uint8_t count, uint32_t reason);
int32_t move_to_field(uint16_t step, card* target, uint32_t enable, uint32_t ret, uint32_t pzone, uint32_t zone);
int32_t change_position(uint16_t step, group* targets, effect* reason_effect, uint8_t reason_player, uint32_t enable);
int32_t operation_replace(uint16_t step, effect* replace_effect, group* targets, card* target, int32_t is_destroy);
int32_t activate_effect(uint16_t step, effect* peffect);
int32_t select_synchro_material(int16_t step, uint8_t playerid, card* pcard, int32_t min, int32_t max, card* smat, group* mg, int32_t filter1, int32_t filter2);
int32_t select_xyz_material(int16_t step, uint8_t playerid, uint32_t lv, card* pcard, int32_t min, int32_t max);
int32_t select_release_cards(int16_t step, uint8_t playerid, uint8_t cancelable, int32_t min, int32_t max);
int32_t select_tribute_cards(int16_t step, card* target, uint8_t playerid, uint8_t cancelable, int32_t min, int32_t max, uint8_t toplayer, uint32_t zone);
int32_t toss_coin(uint16_t step, effect* reason_effect, uint8_t reason_player, uint8_t playerid, int32_t count);
int32_t toss_dice(uint16_t step, effect* reason_effect, uint8_t reason_player, uint8_t playerid, uint8_t count1, uint8_t count2);
int32_t rock_paper_scissors(uint16_t step, uint8_t repeat);
bool check_response(size_t vector_size, int32_t min_len, int32_t max_len) const;
int32_t select_battle_command(uint16_t step, uint8_t playerid);
int32_t select_idle_command(uint16_t step, uint8_t playerid);
int32_t select_effect_yes_no(uint16_t step, uint8_t playerid, uint32_t description, card* pcard);
int32_t select_yes_no(uint16_t step, uint8_t playerid, uint32_t description);
int32_t select_option(uint16_t step, uint8_t playerid);
int32_t select_card(uint16_t step, uint8_t playerid, uint8_t cancelable, uint8_t min, uint8_t max);
int32_t select_unselect_card(uint16_t step, uint8_t playerid, uint8_t cancelable, uint8_t min, uint8_t max, uint8_t finishable);
int32_t select_chain(uint16_t step, uint8_t playerid, uint8_t spe_count, uint8_t forced);
int32_t select_place(uint16_t step, uint8_t playerid, uint32_t flag, uint8_t count);
int32_t select_position(uint16_t step, uint8_t playerid, uint32_t code, uint8_t positions);
int32_t select_tribute(uint16_t step, uint8_t playerid, uint8_t cancelable, uint8_t min, uint8_t max);
int32_t select_counter(uint16_t step, uint8_t playerid, uint16_t countertype, uint16_t count, uint8_t s, uint8_t o);
int32_t select_with_sum_limit(int16_t step, uint8_t playerid, int32_t acc, int32_t min, int32_t max);
int32_t sort_card(int16_t step, uint8_t playerid);
int32_t announce_race(int16_t step, uint8_t playerid, int32_t count, int32_t available);
int32_t announce_attribute(int16_t step, uint8_t playerid, int32_t count, int32_t available);
int32_t announce_card(int16_t step, uint8_t playerid);
int32_t announce_number(int16_t step, uint8_t playerid);
};
//Location Use Reason
......@@ -718,7 +713,7 @@ public:
#define GLOBALFLAG_SCRAP_CHIMERA 0x4
//#define GLOBALFLAG_DELAYED_QUICKEFFECT 0x8
#define GLOBALFLAG_DETACH_EVENT 0x10
#define GLOBALFLAG_MUST_BE_SMATERIAL 0x20
//#define GLOBALFLAG_MUST_BE_SMATERIAL 0x20
#define GLOBALFLAG_SPSUMMON_COUNT 0x40
#define GLOBALFLAG_XMAT_COUNT_LIMIT 0x80
#define GLOBALFLAG_SELF_TOGRAVE 0x100
......@@ -726,9 +721,6 @@ public:
#define GLOBALFLAG_TUNE_MAGICIAN 0x400
#define GLOBALFLAG_ACTIVATION_COUNT 0x800
//
#define PROCESSOR_NONE 0
#define PROCESSOR_WAITING 0x10000
#define PROCESSOR_END 0x20000
#define PROCESSOR_ADJUST 1
#define PROCESSOR_HINT 2
......
group.cpp
View file @ 287dd26c
......@@ -10,21 +10,15 @@
#include "duel.h"
group::group(duel* pd) {
ref_handle = 0;
pduel = pd;
is_readonly = FALSE;
it = container.begin();
}
group::group(duel* pd, card* pcard) {
container.insert(pcard);
ref_handle = 0;
pduel = pd;
is_readonly = FALSE;
it = container.begin();
}
group::group(duel* pd, const card_set& cset): container(cset) {
ref_handle = 0;
pduel = pd;
is_readonly = FALSE;
it = container.begin();
}
group.h
View file @ 287dd26c
......@@ -9,22 +9,29 @@
#define GROUP_H_
#include "common.h"
#include "sort.h"
#include <set>
#include <list>
class card;
class duel;
class group {
using card_set = std::set<card*, card_sort>;
constexpr uint32_t GTYPE_DEFAULT = 0;
constexpr uint32_t GTYPE_READ_ONLY = 1;
constexpr uint32_t GTYPE_KEEP_ALIVE = 2;
class alignas(8) group {
public:
using card_set = std::set<card*, card_sort>;
int32 ref_handle;
int32_t ref_handle{ 0 };
uint32_t is_readonly{ GTYPE_DEFAULT };
duel* pduel;
card_set container;
card_set::iterator it;
uint32 is_readonly;
bool is_iterator_dirty{ true };
inline bool has_card(card* c) {
bool has_card(card* c) {
return container.find(c) != container.end();
}
......
interpreter.cpp
View file @ 287dd26c
......@@ -5,6 +5,7 @@
* Author: Argon
*/
#include <cstring>
#include "duel.h"
#include "group.h"
#include "card.h"
......@@ -17,33 +18,29 @@ interpreter::interpreter(duel* pd): coroutines(256) {
lua_state = luaL_newstate();
current_state = lua_state;
pduel = pd;
memcpy(lua_getextraspace(lua_state), &pd, LUA_EXTRASPACE); //set_duel_info
std::memcpy(lua_getextraspace(lua_state), &pd, LUA_EXTRASPACE); //set_duel_info
no_action = 0;
call_depth = 0;
//Initial
luaL_openlibs(lua_state);
lua_pushnil(lua_state);
lua_setglobal(lua_state, "io");
lua_pushnil(lua_state);
lua_setglobal(lua_state, "os");
lua_pushnil(lua_state);
lua_setglobal(lua_state, "package");
lua_pushnil(lua_state);
lua_setglobal(lua_state, "debug");
lua_pushnil(lua_state);
lua_setglobal(lua_state, "coroutine");
luaL_getsubtable(lua_state, LUA_REGISTRYINDEX, "_LOADED");
lua_pushnil(lua_state);
lua_setfield(lua_state, -2, "io");
lua_pushnil(lua_state);
lua_setfield(lua_state, -2, "os");
lua_pushnil(lua_state);
lua_setfield(lua_state, -2, "package");
lua_pushnil(lua_state);
lua_setfield(lua_state, -2, "debug");
lua_pushnil(lua_state);
lua_setfield(lua_state, -2, "coroutine");
luaL_requiref(lua_state, "base", luaopen_base, 0);
lua_pop(lua_state, 1);
luaL_requiref(lua_state, "string", luaopen_string, 1);
lua_pop(lua_state, 1);
luaL_requiref(lua_state, "utf8", luaopen_utf8, 1);
lua_pop(lua_state, 1);
luaL_requiref(lua_state, "table", luaopen_table, 1);
lua_pop(lua_state, 1);
luaL_requiref(lua_state, "math", luaopen_math, 1);
lua_pop(lua_state, 1);
auto nil_out = [&](const char* name) {
lua_pushnil(lua_state);
lua_setglobal(lua_state, name);
};
nil_out("collectgarbage");
#ifndef ENABLE_UNSAFE_LIBRARIES
nil_out("dofile");
nil_out("loadfile");
#endif // ENABLE_UNSAFE_LIBRARIES
//open all libs
scriptlib::open_cardlib(lua_state);
scriptlib::open_effectlib(lua_state);
......@@ -53,42 +50,41 @@ interpreter::interpreter(duel* pd): coroutines(256) {
//extra scripts
load_script("./script/constant.lua");
load_script("./script/utility.lua");
load_script("./script/procedure.lua");
}
interpreter::~interpreter() {
lua_close(lua_state);
}
int32 interpreter::register_card(card *pcard) {
void interpreter::register_card(card *pcard) {
if (!pcard)
return;
//create a card in by userdata
luaL_checkstack(lua_state, 1, NULL);
luaL_checkstack(current_state, 1, NULL);
card ** ppcard = (card**) lua_newuserdata(lua_state, sizeof(card*));
luaL_checkstack(lua_state, 1, nullptr);
card ** ppcard = (card**) lua_newuserdata(lua_state, sizeof(card*)); //+1 userdata
*ppcard = pcard;
pcard->ref_handle = luaL_ref(lua_state, LUA_REGISTRYINDEX);
pcard->ref_handle = luaL_ref(lua_state, LUA_REGISTRYINDEX); //-1
//some userdata may be created in script like token so use current_state
lua_rawgeti(current_state, LUA_REGISTRYINDEX, pcard->ref_handle);
//load script
if(pcard->data.alias && (pcard->data.alias < pcard->data.code + CARD_ARTWORK_VERSIONS_OFFSET) && (pcard->data.code < pcard->data.alias + CARD_ARTWORK_VERSIONS_OFFSET))
load_card_script(pcard->data.alias);
else
load_card_script(pcard->data.code);
luaL_checkstack(current_state, 1, nullptr);
lua_rawgeti(current_state, LUA_REGISTRYINDEX, pcard->ref_handle); //+1 userdata
load_card_script(pcard->data.get_original_code());
//stack: table cxxx, userdata
//set metatable of pointer to base script
lua_setmetatable(current_state, -2);
lua_pop(current_state, 1);
lua_setmetatable(current_state, -2); //-1
lua_pop(current_state, 1); //-1
//Initial
if(pcard->data.code && (!(pcard->data.type & TYPE_NORMAL) || (pcard->data.type & TYPE_PENDULUM))) {
if(is_load_script(pcard->data)) {
pcard->set_status(STATUS_INITIALIZING, TRUE);
add_param(pcard, PARAM_TYPE_CARD);
call_card_function(pcard, "initial_effect", 1, 0);
pcard->set_status(STATUS_INITIALIZING, FALSE);
}
pcard->cardid = pduel->game_field->infos.card_id++;
return OPERATION_SUCCESS;
}
void interpreter::register_effect(effect *peffect) {
if (!peffect)
return;
//create a effect in by userdata
luaL_checkstack(lua_state, 3, NULL);
//create a effect in userdata
luaL_checkstack(lua_state, 3, nullptr);
effect ** ppeffect = (effect**) lua_newuserdata(lua_state, sizeof(effect*));
*ppeffect = peffect;
peffect->ref_handle = luaL_ref(lua_state, LUA_REGISTRYINDEX);
......@@ -118,7 +114,7 @@ void interpreter::register_group(group *pgroup) {
if (!pgroup)
return;
//create a group in by userdata
luaL_checkstack(lua_state, 3, NULL);
luaL_checkstack(lua_state, 3, nullptr);
group ** ppgroup = (group**) lua_newuserdata(lua_state, sizeof(group*));
*ppgroup = pgroup;
pgroup->ref_handle = luaL_ref(lua_state, LUA_REGISTRYINDEX);
......@@ -134,120 +130,128 @@ void interpreter::unregister_group(group *pgroup) {
luaL_unref(lua_state, LUA_REGISTRYINDEX, pgroup->ref_handle);
pgroup->ref_handle = 0;
}
int32 interpreter::load_script(const char* script_name) {
int32 len = 0;
byte* buffer = read_script(script_name, &len);
int32_t interpreter::load_script(const char* script_name) {
int len = 0;
byte* buffer = ::read_script(script_name, &len);
if (!buffer)
return OPERATION_FAIL;
no_action++;
int32 error = luaL_loadbuffer(current_state, (char*)buffer, len, script_name) || lua_pcall(current_state, 0, 0, 0);
++no_action;
luaL_checkstack(current_state, 2, nullptr);
int32_t error = luaL_loadbuffer(current_state, (const char*)buffer, len, script_name) || lua_pcall(current_state, 0, 0, 0);
if (error) {
sprintf(pduel->strbuffer, "%s", lua_tostring(current_state, -1));
interpreter::sprintf(pduel->strbuffer, "%s", lua_tostring(current_state, -1));
handle_message(pduel, 1);
lua_pop(current_state, 1);
no_action--;
--no_action;
return OPERATION_FAIL;
}
no_action--;
--no_action;
return OPERATION_SUCCESS;
}
int32 interpreter::load_card_script(uint32 code) {
//push table cxxx onto the stack of current_state
int32_t interpreter::load_card_script(uint32_t code) {
char class_name[20];
sprintf(class_name, "c%d", code);
luaL_checkstack(current_state, 1, NULL);
lua_getglobal(current_state, class_name);
//if script is not loaded, create and load it
interpreter::sprintf(class_name, "c%d", code);
luaL_checkstack(current_state, 1, nullptr);
lua_getglobal(current_state, class_name); //+1 table cxxx
if (lua_isnil(current_state, -1)) {
luaL_checkstack(current_state, 5, NULL);
lua_pop(current_state, 1);
luaL_checkstack(current_state, 5, nullptr);
lua_pop(current_state, 1); //-1
//create a table & set metatable
lua_createtable(current_state, 0, 0);
lua_setglobal(current_state, class_name);
lua_getglobal(current_state, class_name);
lua_getglobal(current_state, "Card");
lua_setmetatable(current_state, -2);
lua_pushstring(current_state, "__index");
lua_pushvalue(current_state, -2);
lua_rawset(current_state, -3);
lua_getglobal(current_state, class_name);
lua_setglobal(current_state, "self_table");
lua_pushinteger(current_state, code);
lua_setglobal(current_state, "self_code");
lua_createtable(current_state, 0, 0); //+1, {}
lua_setglobal(current_state, class_name); //-1
lua_getglobal(current_state, class_name); //+1 table cxxx
lua_getglobal(current_state, "Card"); //+1 Card, table cxxx
lua_setmetatable(current_state, -2); //-1 table cxxx
lua_pushstring(current_state, "__index"); //+1 "__index", table cxxx
lua_pushvalue(current_state, -2); //+1 table cxxx, "__index", table cxxx
lua_rawset(current_state, -3); //-2 table cxxx
card_data cdata;
int32_t res = OPERATION_SUCCESS;
::read_card(code, &cdata);
if (is_load_script(cdata)) {
lua_getglobal(current_state, class_name); //+1
lua_setglobal(current_state, "self_table"); //-1
lua_pushinteger(current_state, code); //+1
lua_setglobal(current_state, "self_code"); //-1
char script_name[64];
sprintf(script_name, "./script/c%d.lua", code);
int32 res = load_script(script_name);
lua_pushnil(current_state);
lua_setglobal(current_state, "self_table");
lua_pushnil(current_state);
lua_setglobal(current_state, "self_code");
interpreter::sprintf(script_name, "./script/c%d.lua", code);
res = load_script(script_name);
lua_pushnil(current_state); //+1
lua_setglobal(current_state, "self_table"); //-1
lua_pushnil(current_state); //+1
lua_setglobal(current_state, "self_code"); //-1 table cxxx {__index: cxxx }
}
if(!res) {
return OPERATION_FAIL;
}
}
return OPERATION_SUCCESS;
}
void interpreter::add_param(void *param, int32 type, bool front) {
void interpreter::add_param(void* param, LuaParamType type, bool front) {
lua_param p;
p.ptr = param;
if(front)
params.emplace_front(param, type);
params.emplace_front(p, type);
else
params.emplace_back(param, type);
params.emplace_back(p, type);
}
void interpreter::add_param(int32 param, int32 type, bool front) {
void interpreter::add_param(int32_t param, LuaParamType type, bool front) {
lua_param p;
p.integer = param;
if(front)
params.emplace_front((void*)(intptr_t)param, type);
params.emplace_front(p, type);
else
params.emplace_back((void*)(intptr_t)param, type);
params.emplace_back(p, type);
}
void interpreter::push_param(lua_State* L, bool is_coroutine) {
int32 pushed = 0;
int32_t pushed = 0;
for (const auto& it : params) {
luaL_checkstack(L, 1, NULL);
uint32 type = it.second;
luaL_checkstack(L, 1, nullptr);
auto type = it.second;
switch(type) {
case PARAM_TYPE_INT:
lua_pushinteger(L, (lua_Integer)it.first);
lua_pushinteger(L, it.first.integer);
break;
case PARAM_TYPE_STRING:
lua_pushstring(L, (const char *)it.first);
lua_pushstring(L, (const char*)it.first.ptr);
break;
case PARAM_TYPE_BOOLEAN:
lua_pushboolean(L, (int32)(intptr_t)it.first);
lua_pushboolean(L, it.first.integer);
break;
case PARAM_TYPE_CARD: {
if (it.first)
lua_rawgeti(L, LUA_REGISTRYINDEX, ((card*)it.first)->ref_handle);
if (it.first.ptr)
lua_rawgeti(L, LUA_REGISTRYINDEX, ((card*)it.first.ptr)->ref_handle);
else
lua_pushnil(L);
break;
}
case PARAM_TYPE_EFFECT: {
if (it.first)
lua_rawgeti(L, LUA_REGISTRYINDEX, ((effect*)it.first)->ref_handle);
if (it.first.ptr)
lua_rawgeti(L, LUA_REGISTRYINDEX, ((effect*)it.first.ptr)->ref_handle);
else
lua_pushnil(L);
break;
}
case PARAM_TYPE_GROUP: {
if (it.first)
lua_rawgeti(L, LUA_REGISTRYINDEX, ((group*)it.first)->ref_handle);
if (it.first.ptr)
lua_rawgeti(L, LUA_REGISTRYINDEX, ((group*)it.first.ptr)->ref_handle);
else
lua_pushnil(L);
break;
}
case PARAM_TYPE_FUNCTION: {
function2value(L, (int32)(intptr_t)it.first);
function2value(L, it.first.integer);
break;
}
case PARAM_TYPE_INDEX: {
int32 index = (int32)(intptr_t)it.first;
int32_t index = it.first.integer;
if(index > 0)
lua_pushvalue(L, index);
else if(is_coroutine) {
//copy value from current_state to new stack
lua_pushvalue(current_state, index);
int32 ref = luaL_ref(current_state, LUA_REGISTRYINDEX);
lua_rawgeti(L, LUA_REGISTRYINDEX, ref);
luaL_unref(current_state, LUA_REGISTRYINDEX, ref);
lua_xmove(current_state, L, 1);
} else {
//the calling function is pushed before the params, so the actual index is: index - pushed -1
lua_pushvalue(L, index - pushed - 1);
......@@ -255,300 +259,300 @@ void interpreter::push_param(lua_State* L, bool is_coroutine) {
break;
}
}
pushed++;
++pushed;
}
params.clear();
}
int32 interpreter::call_function(int32 f, uint32 param_count, int32 ret_count) {
int32_t interpreter::call_function(int32_t f, uint32_t param_count, int32_t ret_count) {
if (!f) {
sprintf(pduel->strbuffer, "\"CallFunction\": attempt to call a null function.");
interpreter::sprintf(pduel->strbuffer, "%s", "\"CallFunction\": attempt to call a null function.");
handle_message(pduel, 1);
params.clear();
return OPERATION_FAIL;
}
if (param_count != params.size()) {
sprintf(pduel->strbuffer, "\"CallFunction\": incorrect parameter count (%d expected, %zu pushed)", param_count, params.size());
interpreter::sprintf(pduel->strbuffer, "\"CallFunction\": incorrect parameter count (%d expected, %zu pushed)", param_count, params.size());
handle_message(pduel, 1);
params.clear();
return OPERATION_FAIL;
}
function2value(current_state, f);
if (!lua_isfunction(current_state, -1)) {
sprintf(pduel->strbuffer, "\"CallFunction\": attempt to call an error function");
interpreter::sprintf(pduel->strbuffer, "%s", "\"CallFunction\": attempt to call an error function");
handle_message(pduel, 1);
lua_pop(current_state, 1);
params.clear();
return OPERATION_FAIL;
}
no_action++;
call_depth++;
++no_action;
++call_depth;
push_param(current_state);
if (lua_pcall(current_state, param_count, ret_count, 0)) {
sprintf(pduel->strbuffer, "%s", lua_tostring(current_state, -1));
interpreter::sprintf(pduel->strbuffer, "%s", lua_tostring(current_state, -1));
handle_message(pduel, 1);
lua_pop(current_state, 1);
no_action--;
call_depth--;
--no_action;
--call_depth;
if(call_depth == 0) {
pduel->release_script_group();
pduel->restore_assumes();
}
return OPERATION_FAIL;
}
no_action--;
call_depth--;
--no_action;
--call_depth;
if(call_depth == 0) {
pduel->release_script_group();
pduel->restore_assumes();
}
return OPERATION_SUCCESS;
}
int32 interpreter::call_card_function(card* pcard, const char* f, uint32 param_count, int32 ret_count) {
int32_t interpreter::call_card_function(card* pcard, const char* f, uint32_t param_count, int32_t ret_count) {
if (param_count != params.size()) {
sprintf(pduel->strbuffer, "\"CallCardFunction\"(c%d.%s): incorrect parameter count", pcard->data.code, f);
interpreter::sprintf(pduel->strbuffer, "\"CallCardFunction\"(c%d.%s): incorrect parameter count", pcard->data.get_original_code(), f);
handle_message(pduel, 1);
params.clear();
return OPERATION_FAIL;
}
card2value(current_state, pcard);
luaL_checkstack(current_state, 1, NULL);
luaL_checkstack(current_state, 1, nullptr);
lua_getfield(current_state, -1, f);
if (!lua_isfunction(current_state, -1)) {
sprintf(pduel->strbuffer, "\"CallCardFunction\"(c%d.%s): attempt to call an error function", pcard->data.code, f);
interpreter::sprintf(pduel->strbuffer, "\"CallCardFunction\"(c%d.%s): attempt to call an error function", pcard->data.get_original_code(), f);
handle_message(pduel, 1);
lua_pop(current_state, 2);
params.clear();
return OPERATION_FAIL;
}
no_action++;
call_depth++;
++no_action;
++call_depth;
lua_remove(current_state, -2);
push_param(current_state);
if (lua_pcall(current_state, param_count, ret_count, 0)) {
sprintf(pduel->strbuffer, "%s", lua_tostring(current_state, -1));
interpreter::sprintf(pduel->strbuffer, "%s", lua_tostring(current_state, -1));
handle_message(pduel, 1);
lua_pop(current_state, 1);
no_action--;
call_depth--;
--no_action;
--call_depth;
if(call_depth == 0) {
pduel->release_script_group();
pduel->restore_assumes();
}
return OPERATION_FAIL;
}
no_action--;
call_depth--;
--no_action;
--call_depth;
if(call_depth == 0) {
pduel->release_script_group();
pduel->restore_assumes();
}
return OPERATION_SUCCESS;
}
int32 interpreter::call_code_function(uint32 code, const char* f, uint32 param_count, int32 ret_count) {
int32_t interpreter::call_code_function(uint32_t code, const char* f, uint32_t param_count, int32_t ret_count) {
if (param_count != params.size()) {
sprintf(pduel->strbuffer, "\"CallCodeFunction\": incorrect parameter count");
interpreter::sprintf(pduel->strbuffer, "%s", "\"CallCodeFunction\": incorrect parameter count");
handle_message(pduel, 1);
params.clear();
return OPERATION_FAIL;
}
load_card_script(code);
luaL_checkstack(current_state, 1, NULL);
luaL_checkstack(current_state, 1, nullptr);
lua_getfield(current_state, -1, f);
if (!lua_isfunction(current_state, -1)) {
sprintf(pduel->strbuffer, "\"CallCodeFunction\": attempt to call an error function");
interpreter::sprintf(pduel->strbuffer, "%s", "\"CallCodeFunction\": attempt to call an error function");
handle_message(pduel, 1);
lua_pop(current_state, 2);
params.clear();
return OPERATION_FAIL;
}
lua_remove(current_state, -2);
no_action++;
call_depth++;
++no_action;
++call_depth;
push_param(current_state);
if (lua_pcall(current_state, param_count, ret_count, 0)) {
sprintf(pduel->strbuffer, "%s", lua_tostring(current_state, -1));
interpreter::sprintf(pduel->strbuffer, "%s", lua_tostring(current_state, -1));
handle_message(pduel, 1);
lua_pop(current_state, 1);
no_action--;
call_depth--;
--no_action;
--call_depth;
if(call_depth == 0) {
pduel->release_script_group();
pduel->restore_assumes();
}
return OPERATION_FAIL;
}
no_action--;
call_depth--;
--no_action;
--call_depth;
if(call_depth == 0) {
pduel->release_script_group();
pduel->restore_assumes();
}
return OPERATION_SUCCESS;
}
int32 interpreter::check_condition(int32 f, uint32 param_count) {
int32_t interpreter::check_condition(int32_t f, uint32_t param_count) {
if(!f) {
params.clear();
return TRUE;
}
no_action++;
call_depth++;
++no_action;
++call_depth;
if (call_function(f, param_count, 1)) {
int32 result = lua_toboolean(current_state, -1);
int32_t result = lua_toboolean(current_state, -1);
lua_pop(current_state, 1);
no_action--;
call_depth--;
--no_action;
--call_depth;
if(call_depth == 0) {
pduel->release_script_group();
pduel->restore_assumes();
}
return result;
}
no_action--;
call_depth--;
--no_action;
--call_depth;
if(call_depth == 0) {
pduel->release_script_group();
pduel->restore_assumes();
}
return OPERATION_FAIL;
}
int32 interpreter::check_matching(card* pcard, int32 findex, int32 extraargs) {
if(!findex || lua_isnil(current_state, findex))
int32_t interpreter::check_filter(lua_State* L, card* pcard, int32_t findex, int32_t extraargs) {
if (!findex || lua_isnil(L, findex))
return TRUE;
no_action++;
call_depth++;
luaL_checkstack(current_state, 1 + extraargs, NULL);
lua_pushvalue(current_state, findex);
interpreter::card2value(current_state, pcard);
for(int32 i = 0; i < extraargs; ++i)
lua_pushvalue(current_state, (int32)(-extraargs - 2));
if (lua_pcall(current_state, 1 + extraargs, 1, 0)) {
sprintf(pduel->strbuffer, "%s", lua_tostring(current_state, -1));
++no_action;
++call_depth;
luaL_checkstack(L, 1 + extraargs, nullptr);
lua_pushvalue(L, findex);
card2value(L, pcard);
for (int32_t i = 0; i < extraargs; ++i)
lua_pushvalue(L, (int32_t)(-extraargs - 2));
if (lua_pcall(L, 1 + extraargs, 1, 0)) {
interpreter::sprintf(pduel->strbuffer, "%s", lua_tostring(L, -1));
handle_message(pduel, 1);
lua_pop(current_state, 1);
no_action--;
call_depth--;
if(call_depth == 0) {
lua_pop(L, 1);
--no_action;
--call_depth;
if (call_depth == 0) {
pduel->release_script_group();
pduel->restore_assumes();
}
return OPERATION_FAIL;
}
int32 result = lua_toboolean(current_state, -1);
lua_pop(current_state, 1);
no_action--;
call_depth--;
if(call_depth == 0) {
int32_t result = lua_toboolean(L, -1);
lua_pop(L, 1);
--no_action;
--call_depth;
if (call_depth == 0) {
pduel->release_script_group();
pduel->restore_assumes();
}
return result;
}
int32 interpreter::get_operation_value(card* pcard, int32 findex, int32 extraargs) {
int32_t interpreter::get_operation_value(card* pcard, int32_t findex, int32_t extraargs) {
if(!findex || lua_isnil(current_state, findex))
return 0;
no_action++;
call_depth++;
luaL_checkstack(current_state, 1 + extraargs, NULL);
++no_action;
++call_depth;
luaL_checkstack(current_state, 1 + extraargs, nullptr);
lua_pushvalue(current_state, findex);
interpreter::card2value(current_state, pcard);
for(int32 i = 0; i < extraargs; ++i)
lua_pushvalue(current_state, (int32)(-extraargs - 2));
for(int32_t i = 0; i < extraargs; ++i)
lua_pushvalue(current_state, (int32_t)(-extraargs - 2));
if (lua_pcall(current_state, 1 + extraargs, 1, 0)) {
sprintf(pduel->strbuffer, "%s", lua_tostring(current_state, -1));
interpreter::sprintf(pduel->strbuffer, "%s", lua_tostring(current_state, -1));
handle_message(pduel, 1);
lua_pop(current_state, 1);
no_action--;
call_depth--;
--no_action;
--call_depth;
if(call_depth == 0) {
pduel->release_script_group();
pduel->restore_assumes();
}
return OPERATION_FAIL;
}
int32 result = lua_isinteger(current_state, -1) ? (int32)lua_tointeger(current_state, -1) : (int32)lua_tonumber(current_state, -1);
int32_t result = lua_isinteger(current_state, -1) ? (int32_t)lua_tointeger(current_state, -1) : (int32_t)lua_tonumber(current_state, -1);
lua_pop(current_state, 1);
no_action--;
call_depth--;
--no_action;
--call_depth;
if(call_depth == 0) {
pduel->release_script_group();
pduel->restore_assumes();
}
return result;
}
int32 interpreter::get_function_value(int32 f, uint32 param_count) {
int32_t interpreter::get_function_value(int32_t f, uint32_t param_count) {
if(!f) {
params.clear();
return 0;
}
no_action++;
call_depth++;
++no_action;
++call_depth;
if (call_function(f, param_count, 1)) {
int32 result = 0;
int32_t result = 0;
if(lua_isboolean(current_state, -1))
result = lua_toboolean(current_state, -1);
else if(lua_isinteger(current_state, -1))
result = (int32)lua_tointeger(current_state, -1);
result = (int32_t)lua_tointeger(current_state, -1);
else
result = (int32)lua_tonumber(current_state, -1);
result = (int32_t)lua_tonumber(current_state, -1);
lua_pop(current_state, 1);
no_action--;
call_depth--;
--no_action;
--call_depth;
if(call_depth == 0) {
pduel->release_script_group();
pduel->restore_assumes();
}
return result;
}
no_action--;
call_depth--;
--no_action;
--call_depth;
if(call_depth == 0) {
pduel->release_script_group();
pduel->restore_assumes();
}
return OPERATION_FAIL;
}
int32 interpreter::get_function_value(int32 f, uint32 param_count, std::vector<int32>* result) {
int32 is_success = OPERATION_FAIL;
int32_t interpreter::get_function_value(int32_t f, uint32_t param_count, std::vector<lua_Integer>& result) {
int32_t is_success = OPERATION_FAIL;
if(!f) {
params.clear();
return is_success;
}
int32 stack_top = lua_gettop(current_state);
no_action++;
call_depth++;
int32_t stack_top = lua_gettop(current_state);
++no_action;
++call_depth;
if (call_function(f, param_count, LUA_MULTRET)) {
int32 stack_newtop = lua_gettop(current_state);
for (int32 index = stack_top + 1; index <= stack_newtop; ++index) {
int32 return_value = 0;
int32_t stack_newtop = lua_gettop(current_state);
for (int32_t index = stack_top + 1; index <= stack_newtop; ++index) {
lua_Integer return_value = 0;
if(lua_isboolean(current_state, index))
return_value = lua_toboolean(current_state, index);
else if(lua_isinteger(current_state, index))
return_value = (int32)lua_tointeger(current_state, index);
return_value = lua_tointeger(current_state, index);
else
return_value = (int32)lua_tonumber(current_state, index);
result->push_back(return_value);
return_value = static_cast<lua_Integer>(lua_tonumber(current_state, index));
result.push_back(return_value);
}
lua_settop(current_state, stack_top);
is_success = OPERATION_SUCCESS;
}
no_action--;
call_depth--;
--no_action;
--call_depth;
if(call_depth == 0) {
pduel->release_script_group();
pduel->restore_assumes();
}
return is_success;
}
int32 interpreter::call_coroutine(int32 f, uint32 param_count, uint32 * yield_value, uint16 step) {
int32_t interpreter::call_coroutine(int32_t f, uint32_t param_count, int32_t* yield_value, uint16_t step) {
*yield_value = 0;
if (!f) {
sprintf(pduel->strbuffer, "\"CallCoroutine\": attempt to call a null function");
interpreter::sprintf(pduel->strbuffer, "%s", "\"CallCoroutine\": attempt to call a null function");
handle_message(pduel, 1);
params.clear();
return OPERATION_FAIL;
}
if (param_count != params.size()) {
sprintf(pduel->strbuffer, "\"CallCoroutine\": incorrect parameter count");
interpreter::sprintf(pduel->strbuffer, "%s", "\"CallCoroutine\": incorrect parameter count");
handle_message(pduel, 1);
params.clear();
return OPERATION_FAIL;
......@@ -557,124 +561,130 @@ int32 interpreter::call_coroutine(int32 f, uint32 param_count, uint32 * yield_va
lua_State* rthread;
if (it == coroutines.end()) {
rthread = lua_newthread(lua_state);
const auto threadref = luaL_ref(lua_state, LUA_REGISTRYINDEX);
function2value(rthread, f);
if(!lua_isfunction(rthread, -1)) {
sprintf(pduel->strbuffer, "\"CallCoroutine\": attempt to call an error function");
luaL_unref(lua_state, LUA_REGISTRYINDEX, threadref);
interpreter::sprintf(pduel->strbuffer, "%s", "\"CallCoroutine\": attempt to call an error function");
handle_message(pduel, 1);
params.clear();
return OPERATION_FAIL;
}
call_depth++;
coroutines.emplace(f, rthread);
++call_depth;
auto ret = coroutines.emplace(f, coroutine_map::mapped_type(rthread, threadref));
it = ret.first;
} else {
rthread = it->second;
if(step == 0) {
sprintf(pduel->strbuffer, "recursive event trigger detected.");
auto threadref = it->second.second;
coroutines.erase(it);
luaL_unref(lua_state, LUA_REGISTRYINDEX, threadref);
interpreter::sprintf(pduel->strbuffer, "%s", "recursive event trigger detected");
handle_message(pduel, 1);
params.clear();
call_depth--;
--call_depth;
if(call_depth == 0) {
pduel->release_script_group();
pduel->restore_assumes();
}
return OPERATION_FAIL;
}
rthread = it->second.first;
}
push_param(rthread, true);
lua_State* prev_state = current_state;
int32_t result = 0, nresults = 0;
{
auto prev_state = current_state;
current_state = rthread;
#if (LUA_VERSION_NUM >= 504)
int32 nresults;
int32 result = lua_resume(rthread, prev_state, param_count, &nresults);
result = lua_resume(rthread, prev_state, param_count, &nresults);
#else
int32 result = lua_resume(rthread, 0, param_count);
int32 nresults = lua_gettop(rthread);
result = lua_resume(rthread, prev_state, param_count);
nresults = lua_gettop(rthread);
#endif
if (result == 0) {
coroutines.erase(f);
if(yield_value) {
if(nresults == 0)
*yield_value = 0;
else if(lua_isboolean(rthread, -1))
*yield_value = lua_toboolean(rthread, -1);
else
*yield_value = (uint32)lua_tointeger(rthread, -1);
current_state = prev_state;
}
current_state = lua_state;
call_depth--;
if(call_depth == 0) {
pduel->release_script_group();
pduel->restore_assumes();
}
return COROUTINE_FINISH;
} else if (result == LUA_YIELD) {
if (result == LUA_YIELD)
return COROUTINE_YIELD;
} else {
coroutines.erase(f);
sprintf(pduel->strbuffer, "%s", lua_tostring(rthread, -1));
if (result != LUA_OK) {
interpreter::sprintf(pduel->strbuffer, "%s", lua_tostring(rthread, -1));
handle_message(pduel, 1);
lua_pop(rthread, 1);
current_state = lua_state;
call_depth--;
if(call_depth == 0) {
}
else if (yield_value) {
if (nresults == 0)
*yield_value = 0;
else if (lua_isboolean(rthread, -1))
*yield_value = lua_toboolean(rthread, -1);
else
*yield_value = (int32_t)lua_tointeger(rthread, -1);
}
auto threadref = it->second.second;
coroutines.erase(it);
luaL_unref(lua_state, LUA_REGISTRYINDEX, threadref);
--call_depth;
if (call_depth == 0) {
pduel->release_script_group();
pduel->restore_assumes();
}
return COROUTINE_ERROR;
}
return (result == LUA_OK) ? COROUTINE_FINISH : COROUTINE_ERROR;
}
int32 interpreter::clone_function_ref(int32 func_ref) {
luaL_checkstack(current_state, 1, NULL);
int32_t interpreter::clone_function_ref(int32_t func_ref) {
luaL_checkstack(current_state, 1, nullptr);
lua_rawgeti(current_state, LUA_REGISTRYINDEX, func_ref);
int32 ref = luaL_ref(current_state, LUA_REGISTRYINDEX);
int32_t ref = luaL_ref(current_state, LUA_REGISTRYINDEX);
return ref;
}
void* interpreter::get_ref_object(int32 ref_handler) {
void* interpreter::get_ref_object(int32_t ref_handler) {
if(ref_handler == 0)
return nullptr;
luaL_checkstack(current_state, 1, NULL);
luaL_checkstack(current_state, 1, nullptr);
lua_rawgeti(current_state, LUA_REGISTRYINDEX, ref_handler);
void* p = *(void**)lua_touserdata(current_state, -1);
lua_pop(current_state, 1);
return p;
}
//Convert a pointer to a lua value, +1 -0
//push the object onto the stack of L, +1
void interpreter::card2value(lua_State* L, card* pcard) {
luaL_checkstack(L, 1, NULL);
luaL_checkstack(L, 1, nullptr);
if (!pcard || pcard->ref_handle == 0)
lua_pushnil(L);
else
lua_rawgeti(L, LUA_REGISTRYINDEX, pcard->ref_handle);
}
void interpreter::group2value(lua_State* L, group* pgroup) {
luaL_checkstack(L, 1, NULL);
luaL_checkstack(L, 1, nullptr);
if (!pgroup || pgroup->ref_handle == 0)
lua_pushnil(L);
else
lua_rawgeti(L, LUA_REGISTRYINDEX, pgroup->ref_handle);
}
void interpreter::effect2value(lua_State* L, effect* peffect) {
luaL_checkstack(L, 1, NULL);
luaL_checkstack(L, 1, nullptr);
if (!peffect || peffect->ref_handle == 0)
lua_pushnil(L);
else
lua_rawgeti(L, LUA_REGISTRYINDEX, peffect->ref_handle);
}
void interpreter::function2value(lua_State* L, int32 func_ref) {
luaL_checkstack(L, 1, NULL);
void interpreter::function2value(lua_State* L, int32_t func_ref) {
luaL_checkstack(L, 1, nullptr);
if (!func_ref)
lua_pushnil(L);
else
lua_rawgeti(L, LUA_REGISTRYINDEX, func_ref);
}
int32 interpreter::get_function_handle(lua_State* L, int32 index) {
luaL_checkstack(L, 1, NULL);
int32_t interpreter::get_function_handle(lua_State* L, int32_t index) {
luaL_checkstack(L, 1, nullptr);
lua_pushvalue(L, index);
int32 ref = luaL_ref(L, LUA_REGISTRYINDEX);
int32_t ref = luaL_ref(L, LUA_REGISTRYINDEX);
return ref;
}
duel* interpreter::get_duel_info(lua_State * L) {
duel* interpreter::get_duel_info(lua_State* L) {
duel* pduel;
memcpy(&pduel, lua_getextraspace(L), LUA_EXTRASPACE);
std::memcpy(&pduel, lua_getextraspace(L), LUA_EXTRASPACE);
return pduel;
}
bool interpreter::is_load_script(const card_data& data) {
if(data.code == TEMP_CARD_ID)
return false;
return !(data.type & TYPE_NORMAL) || (data.type & TYPE_PENDULUM);
}
interpreter.h
View file @ 287dd26c
......@@ -8,25 +8,40 @@
#ifndef INTERPRETER_H_
#define INTERPRETER_H_
#include "lua.h"
#include "lauxlib.h"
#include "lualib.h"
#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>
#include "common.h"
#include <unordered_map>
#include <list>
#include <vector>
#include <cstdio>
#include <cstring>
class card;
struct card_data;
class effect;
class group;
class duel;
enum LuaParamType : int32_t {
PARAM_TYPE_INT = 0x01,
PARAM_TYPE_STRING = 0x02,
PARAM_TYPE_CARD = 0x04,
PARAM_TYPE_GROUP = 0x08,
PARAM_TYPE_EFFECT = 0x10,
PARAM_TYPE_FUNCTION = 0x20,
PARAM_TYPE_BOOLEAN = 0x40,
PARAM_TYPE_INDEX = 0x80,
};
class interpreter {
public:
using coroutine_map = std::unordered_map<int32, lua_State*>;
using param_list = std::list<std::pair<void*, uint32>>;
union lua_param {
void* ptr;
int32_t integer;
};
using coroutine_map = std::unordered_map<int32_t, std::pair<lua_State*, int32_t>>;
using param_list = std::list<std::pair<lua_param, LuaParamType>>;
duel* pduel;
char msgbuf[64];
......@@ -35,41 +50,42 @@ public:
param_list params;
param_list resumes;
coroutine_map coroutines;
int32 no_action;
int32 call_depth;
int32_t no_action;
int32_t call_depth;
explicit interpreter(duel* pd);
~interpreter();
int32 register_card(card* pcard);
void register_card(card* pcard);
void register_effect(effect* peffect);
void unregister_effect(effect* peffect);
void register_group(group* pgroup);
void unregister_group(group* pgroup);
int32 load_script(const char* script_name);
int32 load_card_script(uint32 code);
void add_param(void* param, int32 type, bool front = false);
void add_param(int32 param, int32 type, bool front = false);
int32_t load_script(const char* script_name);
int32_t load_card_script(uint32_t code);
void add_param(void* param, LuaParamType type, bool front = false);
void add_param(int32_t param, LuaParamType type, bool front = false);
void push_param(lua_State* L, bool is_coroutine = false);
int32 call_function(int32 f, uint32 param_count, int32 ret_count);
int32 call_card_function(card* pcard, const char* f, uint32 param_count, int32 ret_count);
int32 call_code_function(uint32 code, const char* f, uint32 param_count, int32 ret_count);
int32 check_condition(int32 f, uint32 param_count);
int32 check_matching(card* pcard, int32 findex, int32 extraargs);
int32 get_operation_value(card* pcard, int32 findex, int32 extraargs);
int32 get_function_value(int32 f, uint32 param_count);
int32 get_function_value(int32 f, uint32 param_count, std::vector<int32>* result);
int32 call_coroutine(int32 f, uint32 param_count, uint32* yield_value, uint16 step);
int32 clone_function_ref(int32 func_ref);
void* get_ref_object(int32 ref_handler);
int32_t call_function(int32_t f, uint32_t param_count, int32_t ret_count);
int32_t call_card_function(card* pcard, const char* f, uint32_t param_count, int32_t ret_count);
int32_t call_code_function(uint32_t code, const char* f, uint32_t param_count, int32_t ret_count);
int32_t check_condition(int32_t f, uint32_t param_count);
int32_t check_filter(lua_State* L, card* pcard, int32_t findex, int32_t extraargs);
int32_t get_operation_value(card* pcard, int32_t findex, int32_t extraargs);
int32_t get_function_value(int32_t f, uint32_t param_count);
int32_t get_function_value(int32_t f, uint32_t param_count, std::vector<lua_Integer>& result);
int32_t call_coroutine(int32_t f, uint32_t param_count, int32_t* yield_value, uint16_t step);
int32_t clone_function_ref(int32_t func_ref);
void* get_ref_object(int32_t ref_handler);
static void card2value(lua_State* L, card* pcard);
static void group2value(lua_State* L, group* pgroup);
static void effect2value(lua_State* L, effect* peffect);
static void function2value(lua_State* L, int32 pointer);
static int32 get_function_handle(lua_State* L, int32 index);
static void function2value(lua_State* L, int32_t func_ref);
static int32_t get_function_handle(lua_State* L, int32_t index);
static duel* get_duel_info(lua_State* L);
static bool is_load_script(const card_data& data);
template <size_t N, typename... TR>
static int sprintf(char (&buffer)[N], const char* format, TR... args) {
......@@ -77,15 +93,6 @@ public:
}
};
#define PARAM_TYPE_INT 0x01
#define PARAM_TYPE_STRING 0x02
#define PARAM_TYPE_CARD 0x04
#define PARAM_TYPE_GROUP 0x08
#define PARAM_TYPE_EFFECT 0x10
#define PARAM_TYPE_FUNCTION 0x20
#define PARAM_TYPE_BOOLEAN 0x40
#define PARAM_TYPE_INDEX 0x80
#define COROUTINE_FINISH 1
#define COROUTINE_YIELD 2
#define COROUTINE_ERROR 3
......
libcard.cpp
View file @ 287dd26c
This source diff could not be displayed because it is too large. You can view the blob instead.
libdebug.cpp
View file @ 287dd26c
......@@ -5,7 +5,7 @@
* Author: Argon
*/
#include <string.h>
#include <cstring>
#include "scriptlib.h"
#include "duel.h"
#include "field.h"
......@@ -13,7 +13,8 @@
#include "effect.h"
#include "ocgapi.h"
int32 scriptlib::debug_message(lua_State *L) {
int32_t scriptlib::debug_message(lua_State *L) {
check_param_count(L, 1);
duel* pduel = interpreter::get_duel_info(L);
lua_getglobal(L, "tostring");
lua_pushvalue(L, -2);
......@@ -22,19 +23,19 @@ int32 scriptlib::debug_message(lua_State *L) {
handle_message(pduel, 2);
return 0;
}
int32 scriptlib::debug_add_card(lua_State *L) {
int32_t scriptlib::debug_add_card(lua_State *L) {
check_param_count(L, 6);
duel* pduel = interpreter::get_duel_info(L);
int32 code = (int32)lua_tointeger(L, 1);
int32 owner = (int32)lua_tointeger(L, 2);
int32 playerid = (int32)lua_tointeger(L, 3);
int32 location = (int32)lua_tointeger(L, 4);
int32 sequence = (int32)lua_tointeger(L, 5);
int32 position = (int32)lua_tointeger(L, 6);
int32 proc = lua_toboolean(L, 7);
if(owner != 0 && owner != 1)
int32_t code = (int32_t)lua_tointeger(L, 1);
int32_t owner = (int32_t)lua_tointeger(L, 2);
int32_t playerid = (int32_t)lua_tointeger(L, 3);
int32_t location = (int32_t)lua_tointeger(L, 4);
int32_t sequence = (int32_t)lua_tointeger(L, 5);
int32_t position = (int32_t)lua_tointeger(L, 6);
int32_t proc = lua_toboolean(L, 7);
if (!check_playerid(owner))
return 0;
if(playerid != 0 && playerid != 1)
if (!check_playerid(playerid))
return 0;
if(pduel->game_field->is_location_useable(playerid, location, sequence)) {
card* pcard = pduel->new_card(code);
......@@ -43,7 +44,7 @@ int32 scriptlib::debug_add_card(lua_State *L) {
position = POS_FACEDOWN_DEFENSE;
pcard->sendto_param.position = position;
if(location == LOCATION_PZONE) {
int32 seq = pduel->game_field->core.duel_rule >= 4 ? sequence * 4 : sequence + 6;
int32_t seq = pduel->game_field->get_pzone_sequence(sequence);
pduel->game_field->add_card(playerid, pcard, LOCATION_SZONE, seq, TRUE);
} else {
pduel->game_field->add_card(playerid, pcard, location, sequence);
......@@ -58,9 +59,11 @@ int32 scriptlib::debug_add_card(lua_State *L) {
interpreter::card2value(L, pcard);
return 1;
} else if(location == LOCATION_MZONE) {
card* fcard = pduel->game_field->get_field_card(playerid, location, sequence);
if (!fcard || !(fcard->data.type & TYPE_XYZ))
return 0;
card* pcard = pduel->new_card(code);
pcard->owner = owner;
card* fcard = pduel->game_field->get_field_card(playerid, location, sequence);
fcard->xyz_add(pcard);
if(proc)
pcard->set_status(STATUS_PROC_COMPLETE, TRUE);
......@@ -69,13 +72,13 @@ int32 scriptlib::debug_add_card(lua_State *L) {
}
return 0;
}
int32 scriptlib::debug_set_player_info(lua_State *L) {
int32_t scriptlib::debug_set_player_info(lua_State *L) {
check_param_count(L, 4);
duel* pduel = interpreter::get_duel_info(L);
uint32 playerid = (uint32)lua_tointeger(L, 1);
uint32 lp = (uint32)lua_tointeger(L, 2);
uint32 startcount = (uint32)lua_tointeger(L, 3);
uint32 drawcount = (uint32)lua_tointeger(L, 4);
int32_t playerid = (int32_t)lua_tointeger(L, 1);
int32_t lp = (int32_t)lua_tointeger(L, 2);
int32_t startcount = (int32_t)lua_tointeger(L, 3);
int32_t drawcount = (int32_t)lua_tointeger(L, 4);
if(playerid != 0 && playerid != 1)
return 0;
pduel->game_field->player[playerid].lp = lp;
......@@ -83,18 +86,18 @@ int32 scriptlib::debug_set_player_info(lua_State *L) {
pduel->game_field->player[playerid].draw_count = drawcount;
return 0;
}
int32 scriptlib::debug_pre_summon(lua_State *L) {
int32_t scriptlib::debug_pre_summon(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_CARD, 1);
card* pcard = *(card**) lua_touserdata(L, 1);
uint32 summon_type = (uint32)lua_tointeger(L, 2);
uint8 summon_location = 0;
uint32_t summon_type = (uint32_t)lua_tointeger(L, 2);
uint8_t summon_location = 0;
if(lua_gettop(L) > 2)
summon_location = (uint8)lua_tointeger(L, 3);
summon_location = (uint8_t)lua_tointeger(L, 3);
pcard->summon_info = summon_type | (summon_location << 16);
return 0;
}
int32 scriptlib::debug_pre_equip(lua_State *L) {
int32_t scriptlib::debug_pre_equip(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_CARD, 1);
check_param(L, PARAM_TYPE_CARD, 2);
......@@ -112,7 +115,7 @@ int32 scriptlib::debug_pre_equip(lua_State *L) {
}
return 1;
}
int32 scriptlib::debug_pre_set_target(lua_State *L) {
int32_t scriptlib::debug_pre_set_target(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_CARD, 1);
check_param(L, PARAM_TYPE_CARD, 2);
......@@ -121,30 +124,23 @@ int32 scriptlib::debug_pre_set_target(lua_State *L) {
t_card->add_card_target(target);
return 0;
}
int32 scriptlib::debug_pre_add_counter(lua_State *L) {
int32_t scriptlib::debug_pre_add_counter(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_CARD, 1);
card* pcard = *(card**) lua_touserdata(L, 1);
uint32 countertype = (uint32)lua_tointeger(L, 2);
uint32 count = (uint32)lua_tointeger(L, 3);
uint16 cttype = countertype;
auto pr = pcard->counters.emplace(cttype, card::counter_map::mapped_type());
uint32_t countertype = (uint32_t)lua_tointeger(L, 2);
uint16_t count = (uint16_t)lua_tointeger(L, 3);
uint16_t cttype = countertype;
auto pr = pcard->counters.emplace(cttype, 0);
auto cmit = pr.first;
if(pr.second) {
cmit->second[0] = 0;
cmit->second[1] = 0;
}
if(countertype & COUNTER_WITHOUT_PERMIT)
cmit->second[0] += count;
else
cmit->second[1] += count;
cmit->second += count;
return 0;
}
int32 scriptlib::debug_reload_field_begin(lua_State *L) {
int32_t scriptlib::debug_reload_field_begin(lua_State *L) {
check_param_count(L, 1);
duel* pduel = interpreter::get_duel_info(L);
uint32 flag = (uint32)lua_tointeger(L, 1);
int32 rule = (int32)lua_tointeger(L, 2);
uint32_t flag = (uint32_t)lua_tointeger(L, 1);
int32_t rule = (int32_t)lua_tointeger(L, 2);
pduel->clear();
pduel->game_field->core.duel_options |= flag;
if (rule)
......@@ -152,10 +148,10 @@ int32 scriptlib::debug_reload_field_begin(lua_State *L) {
else if (flag & DUEL_OBSOLETE_RULING)
pduel->game_field->core.duel_rule = 1;
else
pduel->game_field->core.duel_rule = 5;
pduel->game_field->core.duel_rule = CURRENT_RULE;
return 0;
}
int32 scriptlib::debug_reload_field_end(lua_State *L) {
int32_t scriptlib::debug_reload_field_end(lua_State *L) {
duel* pduel = interpreter::get_duel_info(L);
pduel->game_field->core.shuffle_hand_check[0] = FALSE;
pduel->game_field->core.shuffle_hand_check[1] = FALSE;
......@@ -164,35 +160,31 @@ int32 scriptlib::debug_reload_field_end(lua_State *L) {
pduel->game_field->reload_field_info();
return 0;
}
int32 scriptlib::debug_set_ai_name(lua_State *L) {
int32_t scriptlib::debug_set_ai_name(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_STRING, 1);
duel* pduel = interpreter::get_duel_info(L);
pduel->write_buffer8(MSG_AI_NAME);
const char* pstr = lua_tostring(L, 1);
int len = (int)strlen(pstr);
if(len > 100)
len = 100;
int len = (int)std::strlen(pstr);
if(len > SIZE_AI_NAME -1)
len = SIZE_AI_NAME - 1;
pduel->write_buffer16(len);
memcpy(pduel->bufferp, pstr, len);
pduel->bufferp += len;
pduel->bufferlen += len;
pduel->write_buffer(pstr, len);
pduel->write_buffer8(0);
return 0;
}
int32 scriptlib::debug_show_hint(lua_State *L) {
int32_t scriptlib::debug_show_hint(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_STRING, 1);
duel* pduel = interpreter::get_duel_info(L);
pduel->write_buffer8(MSG_SHOW_HINT);
const char* pstr = lua_tostring(L, 1);
int len = (int)strlen(pstr);
if(len > 1024)
len = 1024;
int len = (int)std::strlen(pstr);
if (len > SIZE_HINT_MSG - 1)
len = SIZE_HINT_MSG - 1;
pduel->write_buffer16(len);
memcpy(pduel->bufferp, pstr, len);
pduel->bufferp += len;
pduel->bufferlen += len;
pduel->write_buffer(pstr, len);
pduel->write_buffer8(0);
return 0;
}
......@@ -209,7 +201,7 @@ static const struct luaL_Reg debuglib[] = {
{ "ReloadFieldEnd", scriptlib::debug_reload_field_end },
{ "SetAIName", scriptlib::debug_set_ai_name },
{ "ShowHint", scriptlib::debug_show_hint },
{ NULL, NULL }
{ nullptr, nullptr }
};
void scriptlib::open_debuglib(lua_State *L) {
luaL_newlib(L, debuglib);
......
libduel.cpp
View file @ 287dd26c
This source diff could not be displayed because it is too large. You can view the blob instead.
libeffect.cpp
View file @ 287dd26c
......@@ -12,7 +12,62 @@
#include "effect.h"
#include "group.h"
int32 scriptlib::effect_new(lua_State *L) {
int32_t scriptlib::get_effect_property(lua_State* L, effect_member type) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**)lua_touserdata(L, 1);
lua_Integer value{};
if (peffect) {
switch (type) {
case MEMBER_CATEGORY:
value = peffect->category;
break;
case MEMBER_CODE:
value = peffect->code;
break;
case MEMBER_DESCRIPTION:
value = peffect->description;
break;
case MEMBER_ID:
value = peffect->id;
break;
case MEMBER_RANGE:
value = peffect->range;
break;
case MEMBER_TYPE:
value = peffect->type;
break;
}
}
lua_pushinteger(L, value);
return 1;
}
int32_t scriptlib::is_effect_has_property(lua_State* L, effect_member type) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**)lua_touserdata(L, 1);
uint64_t value{};
if (peffect) {
switch (type) {
case MEMBER_CATEGORY:
value = peffect->category;
break;
case MEMBER_RANGE:
value = peffect->range;
break;
case MEMBER_TYPE:
value = peffect->type;
break;
}
}
uint64_t x = lua_tointeger(L, 2);
if (value & x)
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
return 1;
}
int32_t scriptlib::effect_new(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_CARD, 1);
card* pcard = *(card**) lua_touserdata(L, 1);
......@@ -23,7 +78,7 @@ int32 scriptlib::effect_new(lua_State *L) {
interpreter::effect2value(L, peffect);
return 1;
}
int32 scriptlib::effect_newex(lua_State *L) {
int32_t scriptlib::effect_newex(lua_State *L) {
duel* pduel = interpreter::get_duel_info(L);
effect* peffect = pduel->new_effect();
peffect->effect_owner = 0;
......@@ -31,7 +86,7 @@ int32 scriptlib::effect_newex(lua_State *L) {
interpreter::effect2value(L, peffect);
return 1;
}
int32 scriptlib::effect_clone(lua_State *L) {
int32_t scriptlib::effect_clone(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
......@@ -39,7 +94,7 @@ int32 scriptlib::effect_clone(lua_State *L) {
interpreter::effect2value(L, ceffect);
return 1;
}
int32 scriptlib::effect_reset(lua_State *L) {
int32_t scriptlib::effect_reset(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
......@@ -51,55 +106,51 @@ int32 scriptlib::effect_reset(lua_State *L) {
peffect->handler->remove_effect(peffect);
return 0;
}
int32 scriptlib::effect_get_field_id(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
lua_pushinteger(L, peffect->id);
return 1;
int32_t scriptlib::effect_get_field_id(lua_State *L) {
return get_effect_property(L, MEMBER_ID);
}
int32 scriptlib::effect_set_description(lua_State *L) {
int32_t scriptlib::effect_set_description(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
uint32 v = (uint32)lua_tointeger(L, 2);
uint32_t v = (uint32_t)lua_tointeger(L, 2);
peffect->description = v;
return 0;
}
int32 scriptlib::effect_set_code(lua_State *L) {
int32_t scriptlib::effect_set_code(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
uint32 v = (uint32)lua_tointeger(L, 2);
uint32_t v = (uint32_t)lua_tointeger(L, 2);
peffect->code = v;
return 0;
}
int32 scriptlib::effect_set_range(lua_State *L) {
int32_t scriptlib::effect_set_range(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
uint32 v = (uint32)lua_tointeger(L, 2);
uint32_t v = (uint32_t)lua_tointeger(L, 2);
peffect->range = v;
return 0;
}
int32 scriptlib::effect_set_target_range(lua_State *L) {
int32_t scriptlib::effect_set_target_range(lua_State *L) {
check_param_count(L, 3);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
uint32 s = (uint32)lua_tointeger(L, 2);
uint32 o = (uint32)lua_tointeger(L, 3);
uint32_t s = (uint32_t)lua_tointeger(L, 2);
uint32_t o = (uint32_t)lua_tointeger(L, 3);
peffect->s_range = s;
peffect->o_range = o;
peffect->flag[0] &= ~EFFECT_FLAG_ABSOLUTE_TARGET;
return 0;
}
int32 scriptlib::effect_set_absolute_range(lua_State *L) {
int32_t scriptlib::effect_set_absolute_range(lua_State *L) {
check_param_count(L, 4);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
uint32 playerid = (uint32)lua_tointeger(L, 2);
uint32 s = (uint32)lua_tointeger(L, 3);
uint32 o = (uint32)lua_tointeger(L, 4);
int32_t playerid = (int32_t)lua_tointeger(L, 2);
uint32_t s = (uint32_t)lua_tointeger(L, 3);
uint32_t o = (uint32_t)lua_tointeger(L, 4);
if(playerid == 0) {
peffect->s_range = s;
peffect->o_range = o;
......@@ -110,28 +161,30 @@ int32 scriptlib::effect_set_absolute_range(lua_State *L) {
peffect->flag[0] |= EFFECT_FLAG_ABSOLUTE_TARGET;
return 0;
}
int32 scriptlib::effect_set_count_limit(lua_State *L) {
int32_t scriptlib::effect_set_count_limit(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
uint32 v = (uint32)lua_tointeger(L, 2);
uint32 code = 0;
uint32_t v = (uint32_t)lua_tointeger(L, 2);
uint32_t code = 0;
if(lua_gettop(L) >= 3)
code = (uint32)lua_tointeger(L, 3);
code = (uint32_t)lua_tointeger(L, 3);
if(v == 0)
v = 1;
if(code == EFFECT_COUNT_CODE_CHAIN)
code = EFFECT_COUNT_CODE_CHAIN | EFFECT_COUNT_CODE_SINGLE;
peffect->flag[0] |= EFFECT_FLAG_COUNT_LIMIT;
peffect->count_limit = v;
peffect->count_limit_max = v;
peffect->count_code = code;
return 0;
}
int32 scriptlib::effect_set_reset(lua_State *L) {
int32_t scriptlib::effect_set_reset(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
uint32 v = (uint32)lua_tointeger(L, 2);
uint32 c = (uint32)lua_tointeger(L, 3);
uint32_t v = (uint32_t)lua_tointeger(L, 2);
int32_t c = (int32_t)lua_tointeger(L, 3);
if(c == 0)
c = 1;
if(v & (RESET_PHASE) && !(v & (RESET_SELF_TURN | RESET_OPPO_TURN)))
......@@ -140,90 +193,101 @@ int32 scriptlib::effect_set_reset(lua_State *L) {
peffect->reset_count = c;
return 0;
}
int32 scriptlib::effect_set_type(lua_State *L) {
int32_t scriptlib::effect_set_type(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
uint32 v = (uint32)lua_tointeger(L, 2);
if (v & 0x0ff0)
v |= EFFECT_TYPE_ACTIONS;
else
v &= ~EFFECT_TYPE_ACTIONS;
if(v & (EFFECT_TYPE_ACTIVATE | EFFECT_TYPE_IGNITION | EFFECT_TYPE_QUICK_O | EFFECT_TYPE_QUICK_F))
v |= EFFECT_TYPE_FIELD;
if(v & EFFECT_TYPE_ACTIVATE)
uint32_t v = (uint32_t)lua_tointeger(L, 2);
if (v & EFFECT_TYPE_ACTIVATE) {
v = EFFECT_TYPE_FIELD | EFFECT_TYPE_ACTIVATE;
peffect->range = LOCATION_SZONE + LOCATION_FZONE + LOCATION_HAND;
if(v & EFFECT_TYPE_FLIP) {
}
else if(v & EFFECT_TYPE_FLIP) {
peffect->code = EVENT_FLIP;
if(!(v & EFFECT_TYPE_TRIGGER_O))
v |= EFFECT_TYPE_TRIGGER_F;
if (v & EFFECT_TYPE_TRIGGER_O) {
v = EFFECT_TYPE_SINGLE | EFFECT_TYPE_FLIP | EFFECT_TYPE_TRIGGER_O;
peffect->flag[0] |= EFFECT_FLAG_DELAY;
}
else {
v = EFFECT_TYPE_SINGLE | EFFECT_TYPE_FLIP | EFFECT_TYPE_TRIGGER_F;
}
}
else if (v & (EFFECT_TYPE_IGNITION | EFFECT_TYPE_QUICK_O | EFFECT_TYPE_QUICK_F)) {
v |= EFFECT_TYPE_FIELD;
}
if (v & (EFFECT_TYPES_CHAIN_LINK | EFFECT_TYPE_CONTINUOUS))
v |= EFFECT_TYPE_ACTIONS;
else
v &= ~EFFECT_TYPE_ACTIONS;
peffect->type = v;
return 0;
}
int32 scriptlib::effect_set_property(lua_State *L) {
int32_t scriptlib::effect_set_property(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
uint32 v1 = (uint32)lua_tointeger(L, 2);
uint32 v2 = (uint32)lua_tointeger(L, 3);
peffect->flag[0] = (peffect->flag[0] & 0x4f) | (v1 & ~0x4f);
uint64_t v1 = lua_tointeger(L, 2);
uint64_t v2 = lua_tointeger(L, 3);
peffect->flag[0] = (peffect->flag[0] & INTERNAL_FLAGS) | (v1 & ~INTERNAL_FLAGS);
peffect->flag[1] = v2;
return 0;
}
int32 scriptlib::effect_set_label(lua_State *L) {
int32_t scriptlib::effect_set_label(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
peffect->label.clear();
for(int32 i = 2; i <= lua_gettop(L); ++i) {
uint32 v = (uint32)lua_tointeger(L, i);
peffect->label.push_back(v);
for(int32_t i = 2; i <= lua_gettop(L); ++i) {
peffect->label.push_back(lua_tointeger(L, i));
}
return 0;
}
int32 scriptlib::effect_set_label_object(lua_State *L) {
int32_t scriptlib::effect_set_label_object(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
if(lua_isnil(L, 2)) {
peffect->label_object = 0;
peffect->object_type = PARAM_TYPE_INT;
return 0;
}
if(check_param(L, PARAM_TYPE_CARD, 2, TRUE)) {
card* p = *(card**)lua_touserdata(L, 2);
peffect->label_object = p->ref_handle;
peffect->object_type = PARAM_TYPE_CARD;
} else if(check_param(L, PARAM_TYPE_EFFECT, 2, TRUE)) {
effect* p = *(effect**)lua_touserdata(L, 2);
peffect->label_object = p->ref_handle;
peffect->object_type = PARAM_TYPE_EFFECT;
} else if(check_param(L, PARAM_TYPE_GROUP, 2, TRUE)) {
group* p = *(group**)lua_touserdata(L, 2);
peffect->label_object = p->ref_handle;
peffect->object_type = PARAM_TYPE_GROUP;
} else
return luaL_error(L, "Parameter 2 should be \"Card\" or \"Effect\" or \"Group\".");
return 0;
}
int32 scriptlib::effect_set_category(lua_State *L) {
int32_t scriptlib::effect_set_category(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
uint32 v = (uint32)lua_tointeger(L, 2);
uint32_t v = (uint32_t)lua_tointeger(L, 2);
peffect->category = v;
return 0;
}
int32 scriptlib::effect_set_hint_timing(lua_State *L) {
int32_t scriptlib::effect_set_hint_timing(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
uint32 vs = (uint32)lua_tointeger(L, 2);
uint32 vo = vs;
uint32_t vs = (uint32_t)lua_tointeger(L, 2);
uint32_t vo = vs;
if(lua_gettop(L) >= 3)
vo = (uint32)lua_tointeger(L, 3);
vo = (uint32_t)lua_tointeger(L, 3);
peffect->hint_timing[0] = vs;
peffect->hint_timing[1] = vo;
return 0;
}
int32 scriptlib::effect_set_condition(lua_State *L) {
int32_t scriptlib::effect_set_condition(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
check_param(L, PARAM_TYPE_FUNCTION, 2);
......@@ -233,7 +297,7 @@ int32 scriptlib::effect_set_condition(lua_State *L) {
peffect->condition = interpreter::get_function_handle(L, 2);
return 0;
}
int32 scriptlib::effect_set_target(lua_State *L) {
int32_t scriptlib::effect_set_target(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
check_param(L, PARAM_TYPE_FUNCTION, 2);
......@@ -243,7 +307,7 @@ int32 scriptlib::effect_set_target(lua_State *L) {
peffect->target = interpreter::get_function_handle(L, 2);
return 0;
}
int32 scriptlib::effect_set_cost(lua_State *L) {
int32_t scriptlib::effect_set_cost(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
check_param(L, PARAM_TYPE_FUNCTION, 2);
......@@ -253,7 +317,7 @@ int32 scriptlib::effect_set_cost(lua_State *L) {
peffect->cost = interpreter::get_function_handle(L, 2);
return 0;
}
int32 scriptlib::effect_set_value(lua_State *L) {
int32_t scriptlib::effect_set_value(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
......@@ -267,13 +331,13 @@ int32 scriptlib::effect_set_value(lua_State *L) {
if(lua_isboolean(L, 2))
peffect->value = lua_toboolean(L, 2);
else if(lua_isinteger(L, 2))
peffect->value = (int32)lua_tointeger(L, 2);
peffect->value = (int32_t)lua_tointeger(L, 2);
else
peffect->value = (int32)lua_tonumber(L, 2);
peffect->value = (int32_t)lua_tonumber(L, 2);
}
return 0;
}
int32 scriptlib::effect_set_operation(lua_State *L) {
int32_t scriptlib::effect_set_operation(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
......@@ -286,47 +350,26 @@ int32 scriptlib::effect_set_operation(lua_State *L) {
peffect->operation = 0;
return 0;
}
int32 scriptlib::effect_set_owner_player(lua_State *L) {
int32_t scriptlib::effect_set_owner_player(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
uint32 p = (uint32)lua_tointeger(L, 2);
int32_t p = (int32_t)lua_tointeger(L, 2);
if(p != 0 && p != 1)
return 0;
peffect->effect_owner = p;
return 0;
}
int32 scriptlib::effect_get_description(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
if (peffect) {
lua_pushinteger(L, peffect->description);
return 1;
}
return 0;
int32_t scriptlib::effect_get_description(lua_State *L) {
return get_effect_property(L, MEMBER_DESCRIPTION);
}
int32 scriptlib::effect_get_code(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
if (peffect) {
lua_pushinteger(L, peffect->code);
return 1;
}
return 0;
int32_t scriptlib::effect_get_code(lua_State *L) {
return get_effect_property(L, MEMBER_CODE);
}
int32 scriptlib::effect_get_type(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
if (peffect) {
lua_pushinteger(L, peffect->type);
return 1;
}
return 0;
int32_t scriptlib::effect_get_type(lua_State *L) {
return get_effect_property(L, MEMBER_TYPE);
}
int32 scriptlib::effect_get_property(lua_State *L) {
int32_t scriptlib::effect_get_property(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
......@@ -337,7 +380,7 @@ int32 scriptlib::effect_get_property(lua_State *L) {
}
return 0;
}
int32 scriptlib::effect_get_label(lua_State *L) {
int32_t scriptlib::effect_get_label(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
......@@ -348,11 +391,11 @@ int32 scriptlib::effect_get_label(lua_State *L) {
}
for(const auto& lab : peffect->label)
lua_pushinteger(L, lab);
return (int32)peffect->label.size();
return (int32_t)peffect->label.size();
}
return 0;
}
int32 scriptlib::effect_get_label_object(lua_State *L) {
int32_t scriptlib::effect_get_label_object(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
......@@ -369,141 +412,124 @@ int32 scriptlib::effect_get_label_object(lua_State *L) {
return 1;
}
}
int32 scriptlib::effect_get_category(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
if (peffect) {
lua_pushinteger(L, peffect->category);
return 1;
}
return 0;
int32_t scriptlib::effect_get_category(lua_State *L) {
return get_effect_property(L, MEMBER_CATEGORY);
}
int32_t scriptlib::effect_get_range(lua_State* L) {
return get_effect_property(L, MEMBER_RANGE);
}
int32 scriptlib::effect_get_owner(lua_State *L) {
int32_t scriptlib::effect_get_owner(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
interpreter::card2value(L, peffect->get_owner());
return 1;
}
int32 scriptlib::effect_get_handler(lua_State *L) {
int32_t scriptlib::effect_get_handler(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
interpreter::card2value(L, peffect->get_handler());
return 1;
}
int32 scriptlib::effect_get_owner_player(lua_State *L) {
int32_t scriptlib::effect_get_owner_player(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
lua_pushinteger(L, peffect->get_owner_player());
return 1;
}
int32 scriptlib::effect_get_handler_player(lua_State *L) {
int32_t scriptlib::effect_get_handler_player(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
lua_pushinteger(L, peffect->get_handler_player());
return 1;
}
int32 scriptlib::effect_get_condition(lua_State *L) {
int32_t scriptlib::effect_get_condition(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
interpreter::function2value(L, peffect->condition);
return 1;
}
int32 scriptlib::effect_get_target(lua_State *L) {
int32_t scriptlib::effect_get_target(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
interpreter::function2value(L, peffect->target);
return 1;
}
int32 scriptlib::effect_get_cost(lua_State *L) {
int32_t scriptlib::effect_get_cost(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
interpreter::function2value(L, peffect->cost);
return 1;
}
int32 scriptlib::effect_get_value(lua_State *L) {
int32_t scriptlib::effect_get_value(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
if(peffect->is_flag(EFFECT_FLAG_FUNC_VALUE))
interpreter::function2value(L, peffect->value);
else
lua_pushinteger(L, (int32)peffect->value);
lua_pushinteger(L, (int32_t)peffect->value);
return 1;
}
int32 scriptlib::effect_get_operation(lua_State *L) {
int32_t scriptlib::effect_get_operation(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
interpreter::function2value(L, peffect->operation);
return 1;
}
int32 scriptlib::effect_get_active_type(lua_State *L) {
int32_t scriptlib::effect_get_active_type(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
lua_pushinteger(L, peffect->get_active_type());
return 1;
}
int32 scriptlib::effect_is_active_type(lua_State *L) {
int32_t scriptlib::effect_is_active_type(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
uint32 type = (uint32)lua_tointeger(L, 2);
uint32_t type = (uint32_t)lua_tointeger(L, 2);
if(peffect->get_active_type() & type)
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
return 1;
}
int32 scriptlib::effect_is_has_property(lua_State *L) {
int32_t scriptlib::effect_is_has_property(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
uint32 tflag1 = (uint32)lua_tointeger(L, 2);
uint32 tflag2 = (uint32)lua_tointeger(L, 3);
uint64_t tflag1 = lua_tointeger(L, 2);
uint64_t tflag2 = lua_tointeger(L, 3);
if (peffect && (!tflag1 || (peffect->flag[0] & tflag1)) && (!tflag2 || (peffect->flag[1] & tflag2)))
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
return 1;
}
int32 scriptlib::effect_is_has_category(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
uint32 tcate = (uint32)lua_tointeger(L, 2);
if (peffect && (peffect->category & tcate))
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
return 1;
int32_t scriptlib::effect_is_has_category(lua_State *L) {
return is_effect_has_property(L, MEMBER_CATEGORY);
}
int32 scriptlib::effect_is_has_type(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
uint32 ttype = (uint32)lua_tointeger(L, 2);
if (peffect && (peffect->type & ttype))
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
return 1;
int32_t scriptlib::effect_is_has_type(lua_State *L) {
return is_effect_has_property(L, MEMBER_TYPE);
}
int32_t scriptlib::effect_is_has_range(lua_State* L) {
return is_effect_has_property(L, MEMBER_RANGE);
}
int32 scriptlib::effect_is_activatable(lua_State *L) {
int32_t scriptlib::effect_is_activatable(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
uint32 playerid = (uint32)lua_tointeger(L, 2);
int32_t playerid = (int32_t)lua_tointeger(L, 2);
effect* peffect = *(effect**) lua_touserdata(L, 1);
uint32 neglect_loc = 0;
uint32 neglect_target = 0;
uint32_t neglect_loc = 0;
uint32_t neglect_target = 0;
if(lua_gettop(L) > 2) {
neglect_loc = lua_toboolean(L, 3);
if (lua_gettop(L) > 3)
......@@ -512,67 +538,67 @@ int32 scriptlib::effect_is_activatable(lua_State *L) {
lua_pushboolean(L, peffect->is_activateable(playerid, peffect->pduel->game_field->nil_event, 0, 0, neglect_target, neglect_loc));
return 1;
}
int32 scriptlib::effect_is_activated(lua_State *L) {
int32_t scriptlib::effect_is_activated(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
lua_pushboolean(L, (peffect->type & 0x7f0));
lua_pushboolean(L, (peffect->type & EFFECT_TYPES_CHAIN_LINK));
return 1;
}
int32 scriptlib::effect_is_cost_checked(lua_State *L) {
int32_t scriptlib::effect_is_cost_checked(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**)lua_touserdata(L, 1);
lua_pushboolean(L, peffect->cost_checked);
return 1;
}
int32 scriptlib::effect_set_cost_check(lua_State *L) {
int32_t scriptlib::effect_set_cost_check(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
uint8 cost_check = lua_toboolean(L, 2);
uint8_t cost_check = lua_toboolean(L, 2);
peffect->cost_checked = cost_check;
return 0;
}
int32 scriptlib::effect_get_activate_location(lua_State *L) {
int32_t scriptlib::effect_get_activate_location(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
lua_pushinteger(L, peffect->active_location);
return 1;
}
int32 scriptlib::effect_get_activate_sequence(lua_State *L) {
int32_t scriptlib::effect_get_activate_sequence(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
lua_pushinteger(L, peffect->active_sequence);
return 1;
}
int32 scriptlib::effect_check_count_limit(lua_State *L) {
int32_t scriptlib::effect_check_count_limit(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
uint32 p = (uint32)lua_tointeger(L, 2);
int32_t p = (int32_t)lua_tointeger(L, 2);
lua_pushboolean(L, peffect->check_count_limit(p));
return 1;
}
int32 scriptlib::effect_use_count_limit(lua_State *L) {
int32_t scriptlib::effect_use_count_limit(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_EFFECT, 1);
effect* peffect = *(effect**) lua_touserdata(L, 1);
uint32 p = (uint32)lua_tointeger(L, 2);
uint32 count = 1;
uint32 oath_only = 0;
uint32 code = peffect->count_code;
int32_t p = (int32_t)lua_tointeger(L, 2);
int32_t count = 1;
int32_t oath_only = 0;
uint32_t code = peffect->count_code;
if(lua_gettop(L) > 2) {
count = (uint32)lua_tointeger(L, 3);
count = (int32_t)lua_tointeger(L, 3);
if (lua_gettop(L) > 3)
oath_only = lua_toboolean(L, 4);
}
if (!oath_only || code & EFFECT_COUNT_CODE_OATH)
while(count) {
peffect->dec_count(p);
count--;
--count;
}
return 0;
}
......@@ -609,6 +635,7 @@ static const struct luaL_Reg effectlib[] = {
{ "GetLabel", scriptlib::effect_get_label },
{ "GetLabelObject", scriptlib::effect_get_label_object },
{ "GetCategory", scriptlib::effect_get_category },
{ "GetRange", scriptlib::effect_get_range },
{ "GetOwner", scriptlib::effect_get_owner },
{ "GetHandler", scriptlib::effect_get_handler },
{ "GetCondition", scriptlib::effect_get_condition },
......@@ -623,6 +650,7 @@ static const struct luaL_Reg effectlib[] = {
{ "IsHasProperty", scriptlib::effect_is_has_property },
{ "IsHasCategory", scriptlib::effect_is_has_category },
{ "IsHasType", scriptlib::effect_is_has_type },
{ "IsHasRange", scriptlib::effect_is_has_range },
{ "IsActivatable", scriptlib::effect_is_activatable },
{ "IsActivated", scriptlib::effect_is_activated },
{ "IsCostChecked", scriptlib::effect_is_cost_checked },
......@@ -631,7 +659,7 @@ static const struct luaL_Reg effectlib[] = {
{ "GetActivateSequence", scriptlib::effect_get_activate_sequence },
{ "CheckCountLimit", scriptlib::effect_check_count_limit },
{ "UseCountLimit", scriptlib::effect_use_count_limit },
{ NULL, NULL }
{ nullptr, nullptr }
};
void scriptlib::open_effectlib(lua_State *L) {
luaL_newlib(L, effectlib);
......
libgroup.cpp
View file @ 287dd26c
......@@ -11,13 +11,13 @@
#include "effect.h"
#include "duel.h"
int32 scriptlib::group_new(lua_State *L) {
int32_t scriptlib::group_new(lua_State *L) {
duel* pduel = interpreter::get_duel_info(L);
group* pgroup = pduel->new_group();
interpreter::group2value(L, pgroup);
return 1;
}
int32 scriptlib::group_clone(lua_State *L) {
int32_t scriptlib::group_clone(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_GROUP, 1);
group* pgroup = *(group**) lua_touserdata(L, 1);
......@@ -26,10 +26,10 @@ int32 scriptlib::group_clone(lua_State *L) {
interpreter::group2value(L, newgroup);
return 1;
}
int32 scriptlib::group_from_cards(lua_State *L) {
int32_t scriptlib::group_from_cards(lua_State *L) {
duel* pduel = interpreter::get_duel_info(L);
group* pgroup = pduel->new_group();
for(int32 i = 0; i < lua_gettop(L); ++i) {
for(int32_t i = 0; i < lua_gettop(L); ++i) {
if(!lua_isnil(L, i + 1)) {
check_param(L, PARAM_TYPE_CARD, i + 1);
card* pcard = *(card**) lua_touserdata(L, i + 1);
......@@ -39,63 +39,70 @@ int32 scriptlib::group_from_cards(lua_State *L) {
interpreter::group2value(L, pgroup);
return 1;
}
int32 scriptlib::group_delete(lua_State *L) {
int32_t scriptlib::group_delete(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_GROUP, 1);
duel* pduel = interpreter::get_duel_info(L);
group* pgroup = *(group**) lua_touserdata(L, 1);
if(pgroup->is_readonly != 2)
if(pgroup->is_readonly != GTYPE_KEEP_ALIVE)
return 0;
pgroup->is_readonly = 0;
pgroup->is_iterator_dirty = true;
pgroup->is_readonly = GTYPE_DEFAULT;
pduel->sgroups.insert(pgroup);
return 0;
}
int32 scriptlib::group_keep_alive(lua_State *L) {
int32_t scriptlib::group_keep_alive(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_GROUP, 1);
duel* pduel = interpreter::get_duel_info(L);
group* pgroup = *(group**) lua_touserdata(L, 1);
if(pgroup->is_readonly == 1)
if(pgroup->is_readonly == GTYPE_READ_ONLY)
return 0;
pgroup->is_readonly = 2;
pgroup->is_readonly = GTYPE_KEEP_ALIVE;
pduel->sgroups.erase(pgroup);
return 0;
}
int32 scriptlib::group_clear(lua_State *L) {
int32_t scriptlib::group_clear(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_GROUP, 1);
group* pgroup = *(group**) lua_touserdata(L, 1);
if (pgroup->is_readonly != 1) {
if (pgroup->is_readonly != GTYPE_READ_ONLY) {
pgroup->is_iterator_dirty = true;
pgroup->container.clear();
}
return 0;
}
int32 scriptlib::group_add_card(lua_State *L) {
int32_t scriptlib::group_add_card(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_GROUP, 1);
check_param(L, PARAM_TYPE_CARD, 2);
group* pgroup = *(group**) lua_touserdata(L, 1);
card* pcard = *(card**) lua_touserdata(L, 2);
if (pgroup->is_readonly != 1) {
if (pgroup->is_readonly != GTYPE_READ_ONLY) {
pgroup->is_iterator_dirty = true;
pgroup->container.insert(pcard);
}
return 0;
}
int32 scriptlib::group_remove_card(lua_State *L) {
int32_t scriptlib::group_remove_card(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_GROUP, 1);
check_param(L, PARAM_TYPE_CARD, 2);
group* pgroup = *(group**) lua_touserdata(L, 1);
card* pcard = *(card**) lua_touserdata(L, 2);
if (pgroup->is_readonly != 1) {
if (pgroup->is_readonly != GTYPE_READ_ONLY) {
pgroup->is_iterator_dirty = true;
pgroup->container.erase(pcard);
}
return 0;
}
int32 scriptlib::group_get_next(lua_State *L) {
int32_t scriptlib::group_get_next(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_GROUP, 1);
group* pgroup = *(group**) lua_touserdata(L, 1);
if (pgroup->is_iterator_dirty) {
return luaL_error(L, "Called Group.GetNext without calling Group.GetFirst first.");
}
if(pgroup->it == pgroup->container.end())
lua_pushnil(L);
else {
......@@ -107,10 +114,11 @@ int32 scriptlib::group_get_next(lua_State *L) {
}
return 1;
}
int32 scriptlib::group_get_first(lua_State *L) {
int32_t scriptlib::group_get_first(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_GROUP, 1);
group* pgroup = *(group**) lua_touserdata(L, 1);
pgroup->is_iterator_dirty = false;
if (pgroup->container.size()) {
pgroup->it = pgroup->container.begin();
interpreter::card2value(L, (*(pgroup->it)));
......@@ -118,35 +126,19 @@ int32 scriptlib::group_get_first(lua_State *L) {
lua_pushnil(L);
return 1;
}
int32 scriptlib::group_get_count(lua_State *L) {
int32_t scriptlib::group_get_count(lua_State *L) {
check_param_count(L, 1);
check_param(L, PARAM_TYPE_GROUP, 1);
group* pgroup = *(group**) lua_touserdata(L, 1);
lua_pushinteger(L, pgroup->container.size());
return 1;
}
int32 scriptlib::group_for_each(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_GROUP, 1);
check_param(L, PARAM_TYPE_FUNCTION, 2);
duel* pduel = interpreter::get_duel_info(L);
group* pgroup = *(group**) lua_touserdata(L, 1);
int32 f = interpreter::get_function_handle(L, 2);
int32 extraargs = lua_gettop(L) - 2;
for (auto& pcard : pgroup->container) {
pduel->lua->add_param(pcard, PARAM_TYPE_CARD);
for(int32 i = 0; i < extraargs; ++i)
pduel->lua->add_param(-extraargs + i, PARAM_TYPE_INDEX);
pduel->lua->call_function(f, 1 + extraargs, 0);
}
return 0;
}
int32 scriptlib::group_filter(lua_State *L) {
int32_t scriptlib::group_filter(lua_State *L) {
check_param_count(L, 3);
check_param(L, PARAM_TYPE_GROUP, 1);
check_param(L, PARAM_TYPE_FUNCTION, 2);
group* pgroup = *(group**) lua_touserdata(L, 1);
field::card_set cset(pgroup->container);
card_set cset(pgroup->container);
if(check_param(L, PARAM_TYPE_CARD, 3, TRUE)) {
card* pexception = *(card**) lua_touserdata(L, 3);
cset.erase(pexception);
......@@ -157,21 +149,21 @@ int32 scriptlib::group_filter(lua_State *L) {
}
duel* pduel = pgroup->pduel;
group* new_group = pduel->new_group();
uint32 extraargs = lua_gettop(L) - 3;
uint32_t extraargs = lua_gettop(L) - 3;
for(auto& pcard : cset) {
if(pduel->lua->check_matching(pcard, 2, extraargs)) {
if(pduel->lua->check_filter(L, pcard, 2, extraargs)) {
new_group->container.insert(pcard);
}
}
interpreter::group2value(L, new_group);
return 1;
}
int32 scriptlib::group_filter_count(lua_State *L) {
int32_t scriptlib::group_filter_count(lua_State *L) {
check_param_count(L, 3);
check_param(L, PARAM_TYPE_GROUP, 1);
check_param(L, PARAM_TYPE_FUNCTION, 2);
group* pgroup = *(group**) lua_touserdata(L, 1);
field::card_set cset(pgroup->container);
card_set cset(pgroup->container);
if(check_param(L, PARAM_TYPE_CARD, 3, TRUE)) {
card* pexception = *(card**) lua_touserdata(L, 3);
cset.erase(pexception);
......@@ -181,22 +173,22 @@ int32 scriptlib::group_filter_count(lua_State *L) {
cset.erase(pcard);
}
duel* pduel = pgroup->pduel;
uint32 extraargs = lua_gettop(L) - 3;
uint32 count = 0;
uint32_t extraargs = lua_gettop(L) - 3;
uint32_t count = 0;
for (auto& pcard : cset) {
if(pduel->lua->check_matching(pcard, 2, extraargs))
count++;
if(pduel->lua->check_filter(L, pcard, 2, extraargs))
++count;
}
lua_pushinteger(L, count);
return 1;
}
int32 scriptlib::group_filter_select(lua_State *L) {
int32_t scriptlib::group_filter_select(lua_State *L) {
check_action_permission(L);
check_param_count(L, 6);
check_param(L, PARAM_TYPE_GROUP, 1);
check_param(L, PARAM_TYPE_FUNCTION, 3);
group* pgroup = *(group**) lua_touserdata(L, 1);
field::card_set cset(pgroup->container);
card_set cset(pgroup->container);
if(check_param(L, PARAM_TYPE_CARD, 6, TRUE)) {
card* pexception = *(card**) lua_touserdata(L, 6);
cset.erase(pexception);
......@@ -206,22 +198,22 @@ int32 scriptlib::group_filter_select(lua_State *L) {
cset.erase(pcard);
}
duel* pduel = pgroup->pduel;
uint32 playerid = (uint32)lua_tointeger(L, 2);
int32_t playerid = (int32_t)lua_tointeger(L, 2);
if(playerid != 0 && playerid != 1)
return 0;
uint32 min = (uint32)lua_tointeger(L, 4);
uint32 max = (uint32)lua_tointeger(L, 5);
uint32 extraargs = lua_gettop(L) - 6;
uint32_t min = (uint32_t)lua_tointeger(L, 4);
uint32_t max = (uint32_t)lua_tointeger(L, 5);
uint32_t extraargs = lua_gettop(L) - 6;
pduel->game_field->core.select_cards.clear();
for (auto& pcard : cset) {
if(pduel->lua->check_matching(pcard, 3, extraargs))
if(pduel->lua->check_filter(L, pcard, 3, extraargs))
pduel->game_field->core.select_cards.push_back(pcard);
}
pduel->game_field->add_process(PROCESSOR_SELECT_CARD, 0, 0, 0, playerid, min + (max << 16));
return lua_yieldk(L, 0, (lua_KContext)pduel, [](lua_State *L, int32 status, lua_KContext ctx) {
return lua_yieldk(L, 0, (lua_KContext)pduel, [](lua_State *L, int32_t status, lua_KContext ctx) {
duel* pduel = (duel*)ctx;
group* pgroup = pduel->new_group();
for(int32 i = 0; i < pduel->game_field->returns.bvalue[0]; ++i) {
for(int32_t i = 0; i < pduel->game_field->returns.bvalue[0]; ++i) {
card* pcard = pduel->game_field->core.select_cards[pduel->game_field->returns.bvalue[i + 1]];
pgroup->container.insert(pcard);
}
......@@ -229,12 +221,12 @@ int32 scriptlib::group_filter_select(lua_State *L) {
return 1;
});
}
int32 scriptlib::group_select(lua_State *L) {
int32_t scriptlib::group_select(lua_State *L) {
check_action_permission(L);
check_param_count(L, 5);
check_param(L, PARAM_TYPE_GROUP, 1);
group* pgroup = *(group**) lua_touserdata(L, 1);
field::card_set cset(pgroup->container);
card_set cset(pgroup->container);
if(check_param(L, PARAM_TYPE_CARD, 5, TRUE)) {
card* pexception = *(card**) lua_touserdata(L, 5);
cset.erase(pexception);
......@@ -244,20 +236,20 @@ int32 scriptlib::group_select(lua_State *L) {
cset.erase(pcard);
}
duel* pduel = pgroup->pduel;
uint32 playerid = (uint32)lua_tointeger(L, 2);
int32_t playerid = (int32_t)lua_tointeger(L, 2);
if(playerid != 0 && playerid != 1)
return 0;
uint32 min = (uint32)lua_tointeger(L, 3);
uint32 max = (uint32)lua_tointeger(L, 4);
uint32_t min = (uint32_t)lua_tointeger(L, 3);
uint32_t max = (uint32_t)lua_tointeger(L, 4);
pduel->game_field->core.select_cards.clear();
for (auto& pcard : cset) {
pduel->game_field->core.select_cards.push_back(pcard);
}
pduel->game_field->add_process(PROCESSOR_SELECT_CARD, 0, 0, 0, playerid, min + (max << 16));
return lua_yieldk(L, 0, (lua_KContext)pduel, [](lua_State *L, int32 status, lua_KContext ctx) {
return lua_yieldk(L, 0, (lua_KContext)pduel, [](lua_State *L, int32_t status, lua_KContext ctx) {
duel* pduel = (duel*)ctx;
group* pgroup = pduel->new_group();
for(int32 i = 0; i < pduel->game_field->returns.bvalue[0]; ++i) {
for(int32_t i = 0; i < pduel->game_field->returns.bvalue[0]; ++i) {
card* pcard = pduel->game_field->core.select_cards[pduel->game_field->returns.bvalue[i + 1]];
pgroup->container.insert(pcard);
}
......@@ -265,16 +257,16 @@ int32 scriptlib::group_select(lua_State *L) {
return 1;
});
}
int32 scriptlib::group_select_unselect(lua_State *L) {
int32_t scriptlib::group_select_unselect(lua_State *L) {
check_action_permission(L);
check_param_count(L, 3);
check_param(L, PARAM_TYPE_GROUP, 1);
group* select_group = *(group**)lua_touserdata(L, 1);
group* unselect_group = 0;
group* unselect_group = nullptr;
if(check_param(L, PARAM_TYPE_GROUP, 2, TRUE))
unselect_group = *(group**)lua_touserdata(L, 2);
duel* pduel = select_group->pduel;
uint32 playerid = (uint32)lua_tointeger(L, 3);
int32_t playerid = (int32_t)lua_tointeger(L, 3);
if(playerid != 0 && playerid != 1)
return 0;
if(select_group->container.size() == 0 && (!unselect_group || unselect_group->container.size() == 0))
......@@ -289,21 +281,21 @@ int32 scriptlib::group_select_unselect(lua_State *L) {
}
}
}
uint32 finishable = FALSE;
uint32_t finishable = FALSE;
if(lua_gettop(L) > 3) {
finishable = lua_toboolean(L, 4);
}
uint32 cancelable = FALSE;
uint32_t cancelable = FALSE;
if(lua_gettop(L) > 4) {
cancelable = lua_toboolean(L, 5);
}
uint32 min = 1;
uint32_t min = 1;
if(lua_gettop(L) > 5) {
min = (uint32)lua_tointeger(L, 6);
min = (uint32_t)lua_tointeger(L, 6);
}
uint32 max = 1;
uint32_t max = 1;
if(lua_gettop(L) > 6) {
max = (uint32)lua_tointeger(L, 7);
max = (uint32_t)lua_tointeger(L, 7);
}
if(min > max)
min = max;
......@@ -318,31 +310,32 @@ int32 scriptlib::group_select_unselect(lua_State *L) {
}
}
pduel->game_field->add_process(PROCESSOR_SELECT_UNSELECT_CARD, 0, 0, 0, playerid + (cancelable << 16), min + (max << 16), finishable);
return lua_yieldk(L, 0, (lua_KContext)pduel, [](lua_State *L, int32 status, lua_KContext ctx) {
return lua_yieldk(L, 0, (lua_KContext)pduel, [](lua_State *L, int32_t status, lua_KContext ctx) {
duel* pduel = (duel*)ctx;
if(pduel->game_field->returns.bvalue[0] == -1) {
if(pduel->game_field->returns.ivalue[0] == -1) {
lua_pushnil(L);
} else {
card* pcard;
if((size_t)pduel->game_field->returns.bvalue[1] < pduel->game_field->core.select_cards.size())
pcard = pduel->game_field->core.select_cards[pduel->game_field->returns.bvalue[1]];
const int32_t index = pduel->game_field->returns.bvalue[1];
if(index < (int32_t)pduel->game_field->core.select_cards.size())
pcard = pduel->game_field->core.select_cards[index];
else
pcard = pduel->game_field->core.unselect_cards[pduel->game_field->returns.bvalue[1] - pduel->game_field->core.select_cards.size()];
pcard = pduel->game_field->core.unselect_cards[index - pduel->game_field->core.select_cards.size()];
interpreter::card2value(L, pcard);
}
return 1;
});
}
int32 scriptlib::group_random_select(lua_State *L) {
int32_t scriptlib::group_random_select(lua_State *L) {
check_param_count(L, 3);
check_param(L, PARAM_TYPE_GROUP, 1);
group* pgroup = *(group**) lua_touserdata(L, 1);
int32 playerid = (int32)lua_tointeger(L, 2);
uint32 count = (uint32)lua_tointeger(L, 3);
int32_t playerid = (int32_t)lua_tointeger(L, 2);
uint32_t count = (uint32_t)lua_tointeger(L, 3);
duel* pduel = pgroup->pduel;
group* newgroup = pduel->new_group();
if(count > pgroup->container.size())
count = (uint32)pgroup->container.size();
count = (uint32_t)pgroup->container.size();
if(count == 0) {
interpreter::group2value(L, newgroup);
return 1;
......@@ -351,7 +344,7 @@ int32 scriptlib::group_random_select(lua_State *L) {
newgroup->container = pgroup->container;
else {
while(newgroup->container.size() < count) {
int32 i = pduel->get_next_integer(0, (int32)pgroup->container.size() - 1);
int32_t i = pduel->get_next_integer(0, (int32_t)pgroup->container.size() - 1);
auto cit = pgroup->container.begin();
std::advance(cit, i);
newgroup->container.insert(*cit);
......@@ -366,12 +359,52 @@ int32 scriptlib::group_random_select(lua_State *L) {
interpreter::group2value(L, newgroup);
return 1;
}
int32 scriptlib::group_is_exists(lua_State *L) {
int32_t scriptlib::group_cancelable_select(lua_State *L) {
check_action_permission(L);
check_param_count(L, 5);
check_param(L, PARAM_TYPE_GROUP, 1);
group* pgroup = *(group**) lua_touserdata(L, 1);
card_set cset(pgroup->container);
if(check_param(L, PARAM_TYPE_CARD, 5, TRUE)) {
card* pexception = *(card**) lua_touserdata(L, 5);
cset.erase(pexception);
} else if(check_param(L, PARAM_TYPE_GROUP, 5, TRUE)) {
group* pexgroup = *(group**) lua_touserdata(L, 5);
for(auto& pcard : pexgroup->container)
cset.erase(pcard);
}
duel* pduel = pgroup->pduel;
int32_t playerid = (int32_t)lua_tointeger(L, 2);
if(playerid != 0 && playerid != 1)
return 0;
uint32_t min = (uint32_t)lua_tointeger(L, 3);
uint32_t max = (uint32_t)lua_tointeger(L, 4);
pduel->game_field->core.select_cards.clear();
for (auto& pcard : cset) {
pduel->game_field->core.select_cards.push_back(pcard);
}
pduel->game_field->add_process(PROCESSOR_SELECT_CARD, 0, 0, 0, playerid + 0x10000, min + (max << 16));
return lua_yieldk(L, 0, (lua_KContext)pduel, [](lua_State *L, int32_t status, lua_KContext ctx) {
duel* pduel = (duel*)ctx;
if(pduel->game_field->returns.ivalue[0] == -1) {
lua_pushnil(L);
} else {
group* pgroup = pduel->new_group();
for(int32_t i = 0; i < pduel->game_field->returns.bvalue[0]; ++i) {
card* pcard = pduel->game_field->core.select_cards[pduel->game_field->returns.bvalue[i + 1]];
pgroup->container.insert(pcard);
}
interpreter::group2value(L, pgroup);
}
return 1;
});
}
int32_t scriptlib::group_is_exists(lua_State *L) {
check_param_count(L, 4);
check_param(L, PARAM_TYPE_GROUP, 1);
check_param(L, PARAM_TYPE_FUNCTION, 2);
group* pgroup = *(group**) lua_touserdata(L, 1);
field::card_set cset(pgroup->container);
card_set cset(pgroup->container);
if(check_param(L, PARAM_TYPE_CARD, 4, TRUE)) {
card* pexception = *(card**) lua_touserdata(L, 4);
cset.erase(pexception);
......@@ -381,13 +414,17 @@ int32 scriptlib::group_is_exists(lua_State *L) {
cset.erase(pcard);
}
duel* pduel = pgroup->pduel;
uint32 count = (uint32)lua_tointeger(L, 3);
uint32 extraargs = lua_gettop(L) - 4;
uint32 fcount = 0;
uint32 result = FALSE;
uint32_t count = (uint32_t)lua_tointeger(L, 3);
uint32_t extraargs = lua_gettop(L) - 4;
uint32_t fcount = 0;
uint32_t result = FALSE;
if (count > pgroup->container.size()) {
lua_pushboolean(L, 0);
return 1;
}
for (auto& pcard : cset) {
if(pduel->lua->check_matching(pcard, 2, extraargs)) {
fcount++;
if(pduel->lua->check_filter(L, pcard, 2, extraargs)) {
++fcount;
if(fcount >= count) {
result = TRUE;
break;
......@@ -397,22 +434,22 @@ int32 scriptlib::group_is_exists(lua_State *L) {
lua_pushboolean(L, result);
return 1;
}
int32 scriptlib::group_check_with_sum_equal(lua_State *L) {
int32_t scriptlib::group_check_with_sum_equal(lua_State *L) {
check_param_count(L, 5);
check_param(L, PARAM_TYPE_GROUP, 1);
check_param(L, PARAM_TYPE_FUNCTION, 2);
group* pgroup = *(group**) lua_touserdata(L, 1);
duel* pduel = pgroup->pduel;
int32 acc = (int32)lua_tointeger(L, 3);
int32 min = (int32)lua_tointeger(L, 4);
int32 max = (int32)lua_tointeger(L, 5);
int32_t acc = (int32_t)lua_tointeger(L, 3);
int32_t min = (int32_t)lua_tointeger(L, 4);
int32_t max = (int32_t)lua_tointeger(L, 5);
if(min < 0)
min = 0;
if(max < min)
max = min;
int32 extraargs = lua_gettop(L) - 5;
field::card_vector cv(pduel->game_field->core.must_select_cards);
int32 mcount = (int32)cv.size();
int32_t extraargs = lua_gettop(L) - 5;
card_vector cv(pduel->game_field->core.must_select_cards);
int32_t mcount = (int32_t)cv.size();
for(auto& pcard : pgroup->container) {
auto it = std::find(pduel->game_field->core.must_select_cards.begin(), pduel->game_field->core.must_select_cards.end(), pcard);
if(it == pduel->game_field->core.must_select_cards.end())
......@@ -424,33 +461,33 @@ int32 scriptlib::group_check_with_sum_equal(lua_State *L) {
lua_pushboolean(L, field::check_with_sum_limit_m(cv, acc, 0, min, max, 0xffff, mcount));
return 1;
}
int32 scriptlib::group_select_with_sum_equal(lua_State *L) {
int32_t scriptlib::group_select_with_sum_equal(lua_State *L) {
check_action_permission(L);
check_param_count(L, 6);
check_param(L, PARAM_TYPE_GROUP, 1);
check_param(L, PARAM_TYPE_FUNCTION, 3);
group* pgroup = *(group**) lua_touserdata(L, 1);
duel* pduel = pgroup->pduel;
int32 playerid = (int32)lua_tointeger(L, 2);
int32_t playerid = (int32_t)lua_tointeger(L, 2);
if(playerid != 0 && playerid != 1)
return 0;
int32 acc = (int32)lua_tointeger(L, 4);
int32 min = (int32)lua_tointeger(L, 5);
int32 max = (int32)lua_tointeger(L, 6);
int32_t acc = (int32_t)lua_tointeger(L, 4);
int32_t min = (int32_t)lua_tointeger(L, 5);
int32_t max = (int32_t)lua_tointeger(L, 6);
if(min < 0)
min = 0;
if(max < min)
max = min;
if(max > 127)
return luaL_error(L, "Parameter \"max\" exceeded 127.");
int32 extraargs = lua_gettop(L) - 6;
if(max > UINT8_MAX)
return luaL_error(L, "Parameter \"max\" exceeded 255.");
int32_t extraargs = lua_gettop(L) - 6;
pduel->game_field->core.select_cards.assign(pgroup->container.begin(), pgroup->container.end());
for(auto& pcard : pduel->game_field->core.must_select_cards) {
auto it = std::remove(pduel->game_field->core.select_cards.begin(), pduel->game_field->core.select_cards.end(), pcard);
pduel->game_field->core.select_cards.erase(it, pduel->game_field->core.select_cards.end());
}
field::card_vector cv(pduel->game_field->core.must_select_cards);
int32 mcount = (int32)cv.size();
card_vector cv(pduel->game_field->core.must_select_cards);
int32_t mcount = (int32_t)cv.size();
cv.insert(cv.end(), pduel->game_field->core.select_cards.begin(), pduel->game_field->core.select_cards.end());
for(auto& pcard : cv)
pcard->sum_param = pduel->lua->get_operation_value(pcard, 3, extraargs);
......@@ -460,12 +497,12 @@ int32 scriptlib::group_select_with_sum_equal(lua_State *L) {
interpreter::group2value(L, empty_group);
return 1;
}
pduel->game_field->add_process(PROCESSOR_SELECT_SUM, 0, 0, 0, acc, playerid + (min << 16) + (max << 24));
return lua_yieldk(L, 0, (lua_KContext)pduel, [](lua_State *L, int32 status, lua_KContext ctx) {
pduel->game_field->add_process(PROCESSOR_SELECT_SUM, 0, 0, 0, acc, playerid, min, max);
return lua_yieldk(L, 0, (lua_KContext)pduel, [](lua_State *L, int32_t status, lua_KContext ctx) {
duel* pduel = (duel*)ctx;
group* pgroup = pduel->new_group();
int32 mcount = (int32)pduel->game_field->core.must_select_cards.size();
for(int32 i = mcount; i < pduel->game_field->returns.bvalue[0]; ++i) {
int32_t mcount = (int32_t)pduel->game_field->core.must_select_cards.size();
for(int32_t i = mcount; i < pduel->game_field->returns.bvalue[0]; ++i) {
card* pcard = pduel->game_field->core.select_cards[pduel->game_field->returns.bvalue[i + 1]];
pgroup->container.insert(pcard);
}
......@@ -474,16 +511,16 @@ int32 scriptlib::group_select_with_sum_equal(lua_State *L) {
return 1;
});
}
int32 scriptlib::group_check_with_sum_greater(lua_State *L) {
int32_t scriptlib::group_check_with_sum_greater(lua_State *L) {
check_param_count(L, 3);
check_param(L, PARAM_TYPE_GROUP, 1);
check_param(L, PARAM_TYPE_FUNCTION, 2);
group* pgroup = *(group**) lua_touserdata(L, 1);
duel* pduel = pgroup->pduel;
int32 acc = (int32)lua_tointeger(L, 3);
int32 extraargs = lua_gettop(L) - 3;
field::card_vector cv(pduel->game_field->core.must_select_cards);
int32 mcount = (int32)cv.size();
int32_t acc = (int32_t)lua_tointeger(L, 3);
int32_t extraargs = lua_gettop(L) - 3;
card_vector cv(pduel->game_field->core.must_select_cards);
int32_t mcount = (int32_t)cv.size();
for(auto& pcard : pgroup->container) {
auto it = std::find(pduel->game_field->core.must_select_cards.begin(), pduel->game_field->core.must_select_cards.end(), pcard);
if(it == pduel->game_field->core.must_select_cards.end())
......@@ -495,25 +532,25 @@ int32 scriptlib::group_check_with_sum_greater(lua_State *L) {
lua_pushboolean(L, field::check_with_sum_greater_limit_m(cv, acc, 0, 0xffff, mcount));
return 1;
}
int32 scriptlib::group_select_with_sum_greater(lua_State *L) {
int32_t scriptlib::group_select_with_sum_greater(lua_State *L) {
check_action_permission(L);
check_param_count(L, 4);
check_param(L, PARAM_TYPE_GROUP, 1);
check_param(L, PARAM_TYPE_FUNCTION, 3);
group* pgroup = *(group**) lua_touserdata(L, 1);
duel* pduel = pgroup->pduel;
int32 playerid = (int32)lua_tointeger(L, 2);
int32_t playerid = (int32_t)lua_tointeger(L, 2);
if(playerid != 0 && playerid != 1)
return 0;
int32 acc = (int32)lua_tointeger(L, 4);
int32 extraargs = lua_gettop(L) - 4;
int32_t acc = (int32_t)lua_tointeger(L, 4);
int32_t extraargs = lua_gettop(L) - 4;
pduel->game_field->core.select_cards.assign(pgroup->container.begin(), pgroup->container.end());
for(auto& pcard : pduel->game_field->core.must_select_cards) {
auto it = std::remove(pduel->game_field->core.select_cards.begin(), pduel->game_field->core.select_cards.end(), pcard);
pduel->game_field->core.select_cards.erase(it, pduel->game_field->core.select_cards.end());
}
field::card_vector cv(pduel->game_field->core.must_select_cards);
int32 mcount = (int32)cv.size();
card_vector cv(pduel->game_field->core.must_select_cards);
int32_t mcount = (int32_t)cv.size();
cv.insert(cv.end(), pduel->game_field->core.select_cards.begin(), pduel->game_field->core.select_cards.end());
for(auto& pcard : cv)
pcard->sum_param = pduel->lua->get_operation_value(pcard, 3, extraargs);
......@@ -524,11 +561,11 @@ int32 scriptlib::group_select_with_sum_greater(lua_State *L) {
return 1;
}
pduel->game_field->add_process(PROCESSOR_SELECT_SUM, 0, 0, 0, acc, playerid);
return lua_yieldk(L, 0, (lua_KContext)pduel, [](lua_State *L, int32 status, lua_KContext ctx) {
return lua_yieldk(L, 0, (lua_KContext)pduel, [](lua_State *L, int32_t status, lua_KContext ctx) {
duel* pduel = (duel*)ctx;
group* pgroup = pduel->new_group();
int32 mcount = (int32)pduel->game_field->core.must_select_cards.size();
for(int32 i = mcount; i < pduel->game_field->returns.bvalue[0]; ++i) {
int32_t mcount = (int32_t)pduel->game_field->core.must_select_cards.size();
for(int32_t i = mcount; i < pduel->game_field->returns.bvalue[0]; ++i) {
card* pcard = pduel->game_field->core.select_cards[pduel->game_field->returns.bvalue[i + 1]];
pgroup->container.insert(pcard);
}
......@@ -537,7 +574,7 @@ int32 scriptlib::group_select_with_sum_greater(lua_State *L) {
return 1;
});
}
int32 scriptlib::group_get_min_group(lua_State *L) {
int32_t scriptlib::group_get_min_group(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_GROUP, 1);
check_param(L, PARAM_TYPE_FUNCTION, 2);
......@@ -546,8 +583,8 @@ int32 scriptlib::group_get_min_group(lua_State *L) {
if(pgroup->container.size() == 0)
return 0;
group* newgroup = pduel->new_group();
int32 min, op;
int32 extraargs = lua_gettop(L) - 2;
int32_t min, op;
int32_t extraargs = lua_gettop(L) - 2;
auto cit = pgroup->container.begin();
min = pduel->lua->get_operation_value(*cit, 2, extraargs);
newgroup->container.insert(*cit);
......@@ -566,7 +603,7 @@ int32 scriptlib::group_get_min_group(lua_State *L) {
lua_pushinteger(L, min);
return 2;
}
int32 scriptlib::group_get_max_group(lua_State *L) {
int32_t scriptlib::group_get_max_group(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_GROUP, 1);
check_param(L, PARAM_TYPE_FUNCTION, 2);
......@@ -575,8 +612,8 @@ int32 scriptlib::group_get_max_group(lua_State *L) {
if(pgroup->container.size() == 0)
return 0;
group* newgroup = pduel->new_group();
int32 max, op;
int32 extraargs = lua_gettop(L) - 2;
int32_t max, op;
int32_t extraargs = lua_gettop(L) - 2;
auto cit = pgroup->container.begin();
max = pduel->lua->get_operation_value(*cit, 2, extraargs);
newgroup->container.insert(*cit);
......@@ -595,81 +632,85 @@ int32 scriptlib::group_get_max_group(lua_State *L) {
lua_pushinteger(L, max);
return 2;
}
int32 scriptlib::group_get_sum(lua_State *L) {
int32_t scriptlib::group_get_sum(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_GROUP, 1);
check_param(L, PARAM_TYPE_FUNCTION, 2);
group* pgroup = *(group**) lua_touserdata(L, 1);
duel* pduel = pgroup->pduel;
int32 extraargs = lua_gettop(L) - 2;
int32 sum = 0;
int32_t extraargs = lua_gettop(L) - 2;
int32_t sum = 0;
for(auto& pcard : pgroup->container) {
sum += pduel->lua->get_operation_value(pcard, 2, extraargs);
}
lua_pushinteger(L, sum);
return 1;
}
int32 scriptlib::group_get_class_count(lua_State *L) {
int32_t scriptlib::group_get_class_count(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_GROUP, 1);
check_param(L, PARAM_TYPE_FUNCTION, 2);
group* pgroup = *(group**) lua_touserdata(L, 1);
duel* pduel = pgroup->pduel;
int32 extraargs = lua_gettop(L) - 2;
std::set<uint32> er;
int32_t extraargs = lua_gettop(L) - 2;
std::set<uint32_t> er;
for(auto& pcard : pgroup->container) {
er.insert(pduel->lua->get_operation_value(pcard, 2, extraargs));
}
lua_pushinteger(L, er.size());
return 1;
}
int32 scriptlib::group_remove(lua_State *L) {
int32_t scriptlib::group_remove(lua_State *L) {
check_param_count(L, 3);
check_param(L, PARAM_TYPE_GROUP, 1);
check_param(L, PARAM_TYPE_FUNCTION, 2);
card* pexception = 0;
card* pexception = nullptr;
if(!lua_isnil(L, 3)) {
check_param(L, PARAM_TYPE_CARD, 3);
pexception = *(card**) lua_touserdata(L, 3);
}
group* pgroup = *(group**) lua_touserdata(L, 1);
duel* pduel = pgroup->pduel;
uint32 extraargs = lua_gettop(L) - 3;
if(pgroup->is_readonly == 1)
uint32_t extraargs = lua_gettop(L) - 3;
if(pgroup->is_readonly == GTYPE_READ_ONLY)
return 0;
pgroup->is_iterator_dirty = true;
for (auto cit = pgroup->container.begin(); cit != pgroup->container.end();) {
auto rm = cit++;
if((*rm) != pexception && pduel->lua->check_matching(*rm, 2, extraargs)) {
pgroup->container.erase(rm);
if((*cit) != pexception && pduel->lua->check_filter(L, *cit, 2, extraargs)) {
cit = pgroup->container.erase(cit);
}
else
++cit;
}
return 0;
}
int32 scriptlib::group_merge(lua_State *L) {
int32_t scriptlib::group_merge(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_GROUP, 1);
check_param(L, PARAM_TYPE_GROUP, 2);
group* pgroup = *(group**) lua_touserdata(L, 1);
group* mgroup = *(group**) lua_touserdata(L, 2);
if(pgroup->is_readonly == 1)
if(pgroup->is_readonly == GTYPE_READ_ONLY)
return 0;
pgroup->is_iterator_dirty = true;
pgroup->container.insert(mgroup->container.begin(), mgroup->container.end());
return 0;
}
int32 scriptlib::group_sub(lua_State *L) {
int32_t scriptlib::group_sub(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_GROUP, 1);
check_param(L, PARAM_TYPE_GROUP, 2);
group* pgroup = *(group**) lua_touserdata(L, 1);
group* sgroup = *(group**) lua_touserdata(L, 2);
if(pgroup->is_readonly == 1)
if(pgroup->is_readonly == GTYPE_READ_ONLY)
return 0;
pgroup->is_iterator_dirty = true;
for (auto& pcard : sgroup->container) {
pgroup->container.erase(pcard);
}
return 0;
}
int32 scriptlib::group_equal(lua_State *L) {
int32_t scriptlib::group_equal(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_GROUP, 1);
check_param(L, PARAM_TYPE_GROUP, 2);
......@@ -690,7 +731,7 @@ int32 scriptlib::group_equal(lua_State *L) {
lua_pushboolean(L, 1);
return 1;
}
int32 scriptlib::group_is_contains(lua_State *L) {
int32_t scriptlib::group_is_contains(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_GROUP, 1);
check_param(L, PARAM_TYPE_CARD, 2);
......@@ -702,40 +743,41 @@ int32 scriptlib::group_is_contains(lua_State *L) {
lua_pushboolean(L, 0);
return 1;
}
int32 scriptlib::group_search_card(lua_State *L) {
int32_t scriptlib::group_search_card(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_GROUP, 1);
check_param(L, PARAM_TYPE_FUNCTION, 2);
group* pgroup = *(group**) lua_touserdata(L, 1);
duel* pduel = pgroup->pduel;
uint32 extraargs = lua_gettop(L) - 2;
for(auto& pcard : pgroup->container)
if(pduel->lua->check_matching(pcard, 2, extraargs)) {
uint32_t extraargs = lua_gettop(L) - 2;
for (auto& pcard : pgroup->container) {
if (pduel->lua->check_filter(L, pcard, 2, extraargs)) {
interpreter::card2value(L, pcard);
return 1;
}
}
return 0;
}
int32 scriptlib::group_get_bin_class_count(lua_State *L) {
int32_t scriptlib::group_get_bin_class_count(lua_State *L) {
check_param_count(L, 2);
check_param(L, PARAM_TYPE_GROUP, 1);
check_param(L, PARAM_TYPE_FUNCTION, 2);
group* pgroup = *(group**) lua_touserdata(L, 1);
duel* pduel = pgroup->pduel;
int32 extraargs = lua_gettop(L) - 2;
int32 er = 0;
int32_t extraargs = lua_gettop(L) - 2;
int32_t er = 0;
for(auto& pcard : pgroup->container) {
er |= pduel->lua->get_operation_value(pcard, 2, extraargs);
}
int32 ans = 0;
int32_t ans = 0;
while(er) {
er &= er - 1;
ans++;
++ans;
}
lua_pushinteger(L, ans);
return 1;
}
int32 scriptlib::group_meta_add(lua_State* L) {
int32_t scriptlib::group_meta_add(lua_State* L) {
check_param_count(L, 2);
if(!check_param(L, PARAM_TYPE_CARD, 1, TRUE) && !check_param(L, PARAM_TYPE_GROUP, 1, TRUE))
return luaL_error(L, "Parameter %d should be \"Card\" or \"Group\".", 1);
......@@ -762,7 +804,7 @@ int32 scriptlib::group_meta_add(lua_State* L) {
interpreter::group2value(L, pgroup);
return 1;
}
int32 scriptlib::group_meta_sub(lua_State* L) {
int32_t scriptlib::group_meta_sub(lua_State* L) {
check_param_count(L, 2);
if(!check_param(L, PARAM_TYPE_CARD, 1, TRUE) && !check_param(L, PARAM_TYPE_GROUP, 1, TRUE))
return luaL_error(L, "Parameter %d should be \"Card\" or \"Group\".", 1);
......@@ -789,7 +831,7 @@ int32 scriptlib::group_meta_sub(lua_State* L) {
interpreter::group2value(L, pgroup);
return 1;
}
int32 scriptlib::group_meta_band(lua_State* L) {
int32_t scriptlib::group_meta_band(lua_State* L) {
check_param_count(L, 2);
if(!check_param(L, PARAM_TYPE_CARD, 1, TRUE) && !check_param(L, PARAM_TYPE_GROUP, 1, TRUE))
return luaL_error(L, "Parameter %d should be \"Card\" or \"Group\".", 1);
......@@ -797,7 +839,7 @@ int32 scriptlib::group_meta_band(lua_State* L) {
return luaL_error(L, "Parameter %d should be \"Card\" or \"Group\".", 2);
duel* pduel = interpreter::get_duel_info(L);
group* pgroup = pduel->new_group();
field::card_set check_set;
card_set check_set;
if(check_param(L, PARAM_TYPE_CARD, 1, TRUE)) {
card* ccard = *(card**) lua_touserdata(L, 1);
check_set.insert(ccard);
......@@ -818,7 +860,7 @@ int32 scriptlib::group_meta_band(lua_State* L) {
interpreter::group2value(L, pgroup);
return 1;
}
int32 scriptlib::group_meta_bxor(lua_State* L) {
int32_t scriptlib::group_meta_bxor(lua_State* L) {
check_param_count(L, 2);
if(!check_param(L, PARAM_TYPE_CARD, 1, TRUE) && !check_param(L, PARAM_TYPE_GROUP, 1, TRUE))
return luaL_error(L, "Parameter %d should be \"Card\" or \"Group\".", 1);
......@@ -866,13 +908,13 @@ static const struct luaL_Reg grouplib[] = {
{ "GetFirst", scriptlib::group_get_first },
{ "GetCount", scriptlib::group_get_count },
{ "__len", scriptlib::group_get_count },
{ "ForEach", scriptlib::group_for_each },
{ "Filter", scriptlib::group_filter },
{ "FilterCount", scriptlib::group_filter_count },
{ "FilterSelect", scriptlib::group_filter_select },
{ "Select", scriptlib::group_select },
{ "SelectUnselect", scriptlib::group_select_unselect },
{ "RandomSelect", scriptlib::group_random_select },
{ "CancelableSelect", scriptlib::group_cancelable_select },
{ "IsExists", scriptlib::group_is_exists },
{ "CheckWithSumEqual", scriptlib::group_check_with_sum_equal },
{ "SelectWithSumEqual", scriptlib::group_select_with_sum_equal },
......@@ -894,7 +936,7 @@ static const struct luaL_Reg grouplib[] = {
{ "__sub", scriptlib::group_meta_sub },
{ "__band", scriptlib::group_meta_band },
{ "__bxor", scriptlib::group_meta_bxor },
{ NULL, NULL }
{ nullptr, nullptr }
};
void scriptlib::open_grouplib(lua_State *L) {
luaL_newlib(L, grouplib);
......
mtrandom.h
View file @ 287dd26c
......@@ -9,61 +9,77 @@
#define MTRANDOM_H_
#include <random>
#include <vector>
#include <utility>
class mt19937 {
class mtrandom {
public:
const unsigned int rand_max;
const unsigned int rand_max{ std::mt19937::max() };
mt19937() :
rng(), rand_max((rng.max)()) {}
explicit mt19937(unsigned int seed) :
rng(seed), rand_max((rng.max)()) {}
mtrandom() :
rng() {}
mtrandom(uint32_t seq[], size_t len) {
std::seed_seq q(seq, seq + len);
rng.seed(q);
}
explicit mtrandom(uint_fast32_t value) :
rng(value) {}
mtrandom(std::seed_seq& q) :
rng(q) {}
mtrandom(const mtrandom& other) = delete;
void operator=(const mtrandom& other) = delete;
// mersenne_twister_engine
void reset(unsigned int seed) {
rng.seed(seed);
void seed(uint32_t seq[], size_t len) {
std::seed_seq q(seq, seq + len);
rng.seed(q);
}
void seed(uint_fast32_t value) {
rng.seed(value);
}
unsigned int rand() {
void seed(std::seed_seq& q) {
rng.seed(q);
}
uint_fast32_t rand() {
return rng();
}
void discard(unsigned long long z) {
rng.discard(z);
}
// uniform_int_distribution
int get_random_integer(int l, int h) {
unsigned int range = (unsigned int)(h - l + 1);
unsigned int secureMax = rand_max - rand_max % range;
unsigned int x;
// old vesion, discard too many numbers
int get_random_integer_v1(int l, int h) {
uint32_t range = (h - l + 1);
uint32_t secureMax = rand_max - rand_max % range;
uint_fast32_t x;
do {
x = rng();
} while (x >= secureMax);
return (int)(l + x % range);
}
int get_random_integer_old(int l, int h) {
int result = (int)((double)rng() / rand_max * ((double)h - l + 1)) + l;
if (result > h)
result = h;
return result;
return l + (int)(x % range);
}
// Fisher-Yates shuffle v[a]~v[b]
template<typename T>
void shuffle_vector(std::vector<T>& v, int a = -1, int b = -1) {
if (a < 0)
a = 0;
if (b < 0)
b = (int)v.size() - 1;
for (int i = a; i < b; ++i) {
int r = get_random_integer(i, b);
std::swap(v[i], v[r]);
// N % k == (N - k) % k, discard the leftmost numbers
int get_random_integer_v2(int l, int h) {
uint32_t range = (h - l + 1);
uint32_t bound = -range % range;
auto x = rng();
while (x < bound) {
x = rng();
}
return l + (int)(x % range);
}
// Fisher-Yates shuffle [first, last)
template<typename T>
void shuffle_vector_old(std::vector<T>& v, int a = -1, int b = -1) {
if (a < 0)
a = 0;
if (b < 0)
b = (int)v.size() - 1;
for (int i = a; i < b; ++i) {
int r = get_random_integer_old(i, b);
void shuffle_vector(std::vector<T>& v, int first = 0, int last = INT32_MAX, int version = 2) {
if ((size_t)last > v.size())
last = v.size();
auto distribution = &mtrandom::get_random_integer_v2;
if (version == 1)
distribution = &mtrandom::get_random_integer_v1;
for (int i = first; i < last - 1; ++i) {
int r = (this->*distribution)(i, last - 1);
std::swap(v[i], v[r]);
}
}
......
ocgapi.cpp
View file @ 287dd26c
......@@ -4,8 +4,9 @@
* Created on: 2010-5-2
* Author: Argon
*/
#include <stdio.h>
#include <string.h>
#include <cstdio>
#include <cstring>
#include <set>
#include "ocgapi.h"
#include "duel.h"
#include "card.h"
......@@ -13,66 +14,83 @@
#include "effect.h"
#include "field.h"
#include "interpreter.h"
#include <set>
#include "buffer.h"
static uint32_t default_card_reader(uint32_t code, card_data* data) {
return 0;
}
static uint32_t default_message_handler(intptr_t pduel, uint32_t message_type) {
return 0;
}
static script_reader sreader = default_script_reader;
static card_reader creader = default_card_reader;
static message_handler mhandler = default_message_handler;
static byte buffer[0x20000];
static byte buffer[0x100000];
static std::set<duel*> duel_set;
extern "C" DECL_DLLEXPORT void set_script_reader(script_reader f) {
OCGCORE_API void set_script_reader(script_reader f) {
sreader = f;
}
extern "C" DECL_DLLEXPORT void set_card_reader(card_reader f) {
OCGCORE_API void set_card_reader(card_reader f) {
creader = f;
}
extern "C" DECL_DLLEXPORT void set_message_handler(message_handler f) {
OCGCORE_API void set_message_handler(message_handler f) {
mhandler = f;
}
byte* read_script(const char* script_name, int* len) {
return sreader(script_name, len);
}
uint32 read_card(uint32 code, card_data* data) {
uint32_t read_card(uint32_t code, card_data* data) {
if (code == TEMP_CARD_ID) {
data->clear();
return 0;
}
return creader(code, data);
}
uint32 handle_message(void* pduel, uint32 msg_type) {
return mhandler(pduel, msg_type);
uint32_t handle_message(void* pduel, uint32_t message_type) {
return mhandler((intptr_t)pduel, message_type);
}
byte* default_script_reader(const char* script_name, int* slen) {
OCGCORE_API byte* default_script_reader(const char* script_name, int* slen) {
FILE *fp;
fp = fopen(script_name, "rb");
fp = std::fopen(script_name, "rb");
if (!fp)
return 0;
int len = (int)fread(buffer, 1, sizeof(buffer), fp);
fclose(fp);
if(len >= sizeof(buffer))
return 0;
*slen = len;
return nullptr;
size_t len = std::fread(buffer, 1, sizeof buffer, fp);
std::fclose(fp);
if (len >= sizeof buffer)
return nullptr;
*slen = (int)len;
return buffer;
}
uint32 default_card_reader(uint32 code, card_data* data) {
return 0;
}
uint32 default_message_handler(void* pduel, uint32 message_type) {
return 0;
OCGCORE_API intptr_t create_duel(uint_fast32_t seed) {
duel* pduel = new duel();
duel_set.insert(pduel);
pduel->random.seed(seed);
pduel->rng_version = 1;
return (intptr_t)pduel;
}
extern "C" DECL_DLLEXPORT intptr_t create_duel(uint32 seed) {
OCGCORE_API intptr_t create_duel_v2(uint32_t seed_sequence[]) {
duel* pduel = new duel();
duel_set.insert(pduel);
pduel->random.reset(seed);
pduel->random.seed(seed_sequence, SEED_COUNT);
pduel->rng_version = 2;
return (intptr_t)pduel;
}
extern "C" DECL_DLLEXPORT void start_duel(intptr_t pduel, int32 options) {
OCGCORE_API void start_duel(intptr_t pduel, uint32_t options) {
duel* pd = (duel*)pduel;
pd->game_field->core.duel_options |= options & 0xffff;
int32 duel_rule = options >> 16;
if(duel_rule)
uint16_t duel_rule = options >> 16;
uint16_t duel_options = options & 0xffff;
pd->game_field->core.duel_options |= duel_options;
if (duel_rule >= 1 && duel_rule <= CURRENT_RULE)
pd->game_field->core.duel_rule = duel_rule;
else if(options & DUEL_OBSOLETE_RULING) //provide backward compatibility with replay
pd->game_field->core.duel_rule = 1;
else if(!pd->game_field->core.duel_rule)
pd->game_field->core.duel_rule = 5;
if (pd->game_field->core.duel_rule < 1 || pd->game_field->core.duel_rule > CURRENT_RULE)
pd->game_field->core.duel_rule = CURRENT_RULE;
if (pd->game_field->core.duel_rule == MASTER_RULE3) {
pd->game_field->player[0].szone_size = 8;
pd->game_field->player[1].szone_size = 8;
}
pd->game_field->core.shuffle_hand_check[0] = FALSE;
pd->game_field->core.shuffle_hand_check[1] = FALSE;
pd->game_field->core.shuffle_deck_check[0] = FALSE;
......@@ -88,7 +106,7 @@ extern "C" DECL_DLLEXPORT void start_duel(intptr_t pduel, int32 options) {
pd->game_field->player[0].tag_list_hand.push_back(pcard);
pcard->current.controler = 0;
pcard->current.location = LOCATION_HAND;
pcard->current.sequence = (uint8)pd->game_field->player[0].tag_list_hand.size() - 1;
pcard->current.sequence = (uint8_t)pd->game_field->player[0].tag_list_hand.size() - 1;
pcard->current.position = POS_FACEDOWN;
}
for(int i = 0; i < pd->game_field->player[1].start_count && pd->game_field->player[1].tag_list_main.size(); ++i) {
......@@ -97,20 +115,22 @@ extern "C" DECL_DLLEXPORT void start_duel(intptr_t pduel, int32 options) {
pd->game_field->player[1].tag_list_hand.push_back(pcard);
pcard->current.controler = 1;
pcard->current.location = LOCATION_HAND;
pcard->current.sequence = (uint8)pd->game_field->player[1].tag_list_hand.size() - 1;
pcard->current.sequence = (uint8_t)pd->game_field->player[1].tag_list_hand.size() - 1;
pcard->current.position = POS_FACEDOWN;
}
}
pd->game_field->add_process(PROCESSOR_TURN, 0, 0, 0, 0, 0);
}
extern "C" DECL_DLLEXPORT void end_duel(intptr_t pduel) {
OCGCORE_API void end_duel(intptr_t pduel) {
duel* pd = (duel*)pduel;
if(duel_set.count(pd)) {
duel_set.erase(pd);
delete pd;
}
}
extern "C" DECL_DLLEXPORT void set_player_info(intptr_t pduel, int32 playerid, int32 lp, int32 startcount, int32 drawcount) {
OCGCORE_API void set_player_info(intptr_t pduel, int32_t playerid, int32_t lp, int32_t startcount, int32_t drawcount) {
if (!check_playerid(playerid))
return;
duel* pd = (duel*)pduel;
if(lp > 0)
pd->game_field->player[playerid].lp = lp;
......@@ -119,22 +139,27 @@ extern "C" DECL_DLLEXPORT void set_player_info(intptr_t pduel, int32 playerid, i
if(drawcount >= 0)
pd->game_field->player[playerid].draw_count = drawcount;
}
extern "C" DECL_DLLEXPORT void get_log_message(intptr_t pduel, byte* buf) {
strcpy((char*)buf, ((duel*)pduel)->strbuffer);
OCGCORE_API void get_log_message(intptr_t pduel, char* buf) {
duel* pd = (duel*)pduel;
std::strncpy(buf, pd->strbuffer, sizeof pd->strbuffer - 1);
buf[sizeof pd->strbuffer - 1] = 0;
}
extern "C" DECL_DLLEXPORT int32 get_message(intptr_t pduel, byte* buf) {
int32 len = ((duel*)pduel)->read_buffer(buf);
OCGCORE_API int32_t get_message(intptr_t pduel, byte* buf) {
int32_t len = ((duel*)pduel)->read_buffer(buf);
((duel*)pduel)->clear_buffer();
return len;
}
extern "C" DECL_DLLEXPORT int32 process(intptr_t pduel) {
OCGCORE_API uint32_t process(intptr_t pduel) {
duel* pd = (duel*)pduel;
int result = pd->game_field->process();
while((result & 0xffff) == 0 && (result & 0xf0000) == 0)
uint32_t result = 0;
do {
result = pd->game_field->process();
} while ((result & PROCESSOR_BUFFER_LEN) == 0 && (result & PROCESSOR_FLAG) == 0);
return result;
}
extern "C" DECL_DLLEXPORT void new_card(intptr_t pduel, uint32 code, uint8 owner, uint8 playerid, uint8 location, uint8 sequence, uint8 position) {
OCGCORE_API void new_card(intptr_t pduel, uint32_t code, uint8_t owner, uint8_t playerid, uint8_t location, uint8_t sequence, uint8_t position) {
if (!check_playerid(owner) || !check_playerid(playerid))
return;
duel* ptduel = (duel*)pduel;
if(ptduel->game_field->is_location_useable(playerid, location, sequence)) {
card* pcard = ptduel->new_card(code);
......@@ -150,7 +175,7 @@ extern "C" DECL_DLLEXPORT void new_card(intptr_t pduel, uint32 code, uint8 owner
}
}
}
extern "C" DECL_DLLEXPORT void new_tag_card(intptr_t pduel, uint32 code, uint8 owner, uint8 location) {
OCGCORE_API void new_tag_card(intptr_t pduel, uint32_t code, uint8_t owner, uint8_t location) {
duel* ptduel = (duel*)pduel;
if(owner > 1 || !(location & (LOCATION_DECK | LOCATION_EXTRA)))
return;
......@@ -161,7 +186,7 @@ extern "C" DECL_DLLEXPORT void new_tag_card(intptr_t pduel, uint32 code, uint8 o
pcard->owner = owner;
pcard->current.controler = owner;
pcard->current.location = LOCATION_DECK;
pcard->current.sequence = (uint8)ptduel->game_field->player[owner].tag_list_main.size() - 1;
pcard->current.sequence = (uint8_t)ptduel->game_field->player[owner].tag_list_main.size() - 1;
pcard->current.position = POS_FACEDOWN_DEFENSE;
break;
case LOCATION_EXTRA:
......@@ -169,103 +194,109 @@ extern "C" DECL_DLLEXPORT void new_tag_card(intptr_t pduel, uint32 code, uint8 o
pcard->owner = owner;
pcard->current.controler = owner;
pcard->current.location = LOCATION_EXTRA;
pcard->current.sequence = (uint8)ptduel->game_field->player[owner].tag_list_extra.size() - 1;
pcard->current.sequence = (uint8_t)ptduel->game_field->player[owner].tag_list_extra.size() - 1;
pcard->current.position = POS_FACEDOWN_DEFENSE;
break;
}
}
extern "C" DECL_DLLEXPORT int32 query_card(intptr_t pduel, uint8 playerid, uint8 location, uint8 sequence, int32 query_flag, byte* buf, int32 use_cache) {
if(playerid != 0 && playerid != 1)
return 0;
/**
* @brief Get card information.
* @param buf int32_t array
* @return buffer length in bytes
*/
OCGCORE_API int32_t query_card(intptr_t pduel, uint8_t playerid, uint8_t location, uint8_t sequence, int32_t query_flag, byte* buf, int32_t use_cache) {
if (!check_playerid(playerid))
return LEN_FAIL;
duel* ptduel = (duel*)pduel;
card* pcard = 0;
card* pcard = nullptr;
location &= 0x7f;
if(location & LOCATION_ONFIELD)
if (location == LOCATION_MZONE || location == LOCATION_SZONE)
pcard = ptduel->game_field->get_field_card(playerid, location, sequence);
else {
field::card_vector* lst = 0;
if(location == LOCATION_HAND)
card_vector* lst = nullptr;
if (location == LOCATION_HAND)
lst = &ptduel->game_field->player[playerid].list_hand;
else if(location == LOCATION_GRAVE)
else if (location == LOCATION_GRAVE)
lst = &ptduel->game_field->player[playerid].list_grave;
else if(location == LOCATION_REMOVED)
else if (location == LOCATION_REMOVED)
lst = &ptduel->game_field->player[playerid].list_remove;
else if(location == LOCATION_EXTRA)
else if (location == LOCATION_EXTRA)
lst = &ptduel->game_field->player[playerid].list_extra;
else if(location == LOCATION_DECK)
else if (location == LOCATION_DECK)
lst = &ptduel->game_field->player[playerid].list_main;
if(!lst || sequence >= lst->size())
pcard = 0;
else
return LEN_FAIL;
if (sequence >= (int32_t)lst->size())
return LEN_FAIL;
pcard = (*lst)[sequence];
}
if (pcard) {
return pcard->get_infos(buf, query_flag, use_cache);
}
else {
*((int32*)buf) = 4;
return 4;
buffer_write<int32_t>(buf, LEN_EMPTY);
return LEN_EMPTY;
}
}
extern "C" DECL_DLLEXPORT int32 query_field_count(intptr_t pduel, uint8 playerid, uint8 location) {
OCGCORE_API int32_t query_field_count(intptr_t pduel, uint8_t playerid, uint8_t location) {
duel* ptduel = (duel*)pduel;
if(playerid != 0 && playerid != 1)
if (!check_playerid(playerid))
return 0;
auto& player = ptduel->game_field->player[playerid];
if(location == LOCATION_HAND)
return (int32)player.list_hand.size();
return (int32_t)player.list_hand.size();
if(location == LOCATION_GRAVE)
return (int32)player.list_grave.size();
return (int32_t)player.list_grave.size();
if(location == LOCATION_REMOVED)
return (int32)player.list_remove.size();
return (int32_t)player.list_remove.size();
if(location == LOCATION_EXTRA)
return (int32)player.list_extra.size();
return (int32_t)player.list_extra.size();
if(location == LOCATION_DECK)
return (int32)player.list_main.size();
return (int32_t)player.list_main.size();
if(location == LOCATION_MZONE) {
uint32 count = 0;
int32_t count = 0;
for(auto& pcard : player.list_mzone)
if(pcard) count++;
if(pcard)
++count;
return count;
}
if(location == LOCATION_SZONE) {
uint32 count = 0;
int32_t count = 0;
for(auto& pcard : player.list_szone)
if(pcard) count++;
if(pcard)
++count;
return count;
}
return 0;
}
extern "C" DECL_DLLEXPORT int32 query_field_card(intptr_t pduel, uint8 playerid, uint8 location, int32 query_flag, byte* buf, int32 use_cache) {
if(playerid != 0 && playerid != 1)
return 0;
OCGCORE_API int32_t query_field_card(intptr_t pduel, uint8_t playerid, uint8_t location, uint32_t query_flag, byte* buf, int32_t use_cache) {
if (!check_playerid(playerid))
return LEN_FAIL;
duel* ptduel = (duel*)pduel;
auto& player = ptduel->game_field->player[playerid];
byte* p = buf;
if(location == LOCATION_MZONE) {
for(auto& pcard : player.list_mzone) {
if(pcard) {
uint32 clen = pcard->get_infos(p, query_flag, use_cache);
int32_t clen = pcard->get_infos(p, query_flag, use_cache);
p += clen;
} else {
*((int32*)p) = 4;
p += 4;
buffer_write<int32_t>(p, LEN_EMPTY);
}
}
}
else if(location == LOCATION_SZONE) {
for(auto& pcard : player.list_szone) {
if(pcard) {
uint32 clen = pcard->get_infos(p, query_flag, use_cache);
int32_t clen = pcard->get_infos(p, query_flag, use_cache);
p += clen;
} else {
*((int32*)p) = 4;
p += 4;
buffer_write<int32_t>(p, LEN_EMPTY);
}
}
}
else {
field::card_vector* lst = nullptr;
card_vector* lst = nullptr;
if(location == LOCATION_HAND)
lst = &player.list_hand;
else if(location == LOCATION_GRAVE)
......@@ -277,28 +308,27 @@ extern "C" DECL_DLLEXPORT int32 query_field_card(intptr_t pduel, uint8 playerid,
else if(location == LOCATION_DECK)
lst = &player.list_main;
else
return 0;
return LEN_FAIL;
for(auto& pcard : *lst) {
uint32 clen = pcard->get_infos(p, query_flag, use_cache);
int32_t clen = pcard->get_infos(p, query_flag, use_cache);
p += clen;
}
}
return (int32)(p - buf);
return (int32_t)(p - buf);
}
extern "C" DECL_DLLEXPORT int32 query_field_info(intptr_t pduel, byte* buf) {
OCGCORE_API int32_t query_field_info(intptr_t pduel, byte* buf) {
duel* ptduel = (duel*)pduel;
byte* p = buf;
*p++ = MSG_RELOAD_FIELD;
*p++ = ptduel->game_field->core.duel_rule;
*p++ = (uint8_t)ptduel->game_field->core.duel_rule;
for(int playerid = 0; playerid < 2; ++playerid) {
auto& player = ptduel->game_field->player[playerid];
*((int*)p) = player.lp;
p += 4;
buffer_write<int32_t>(p, player.lp);
for(auto& pcard : player.list_mzone) {
if(pcard) {
*p++ = 1;
*p++ = pcard->current.position;
*p++ = (uint8)pcard->xyz_materials.size();
*p++ = (uint8_t)pcard->xyz_materials.size();
} else {
*p++ = 0;
}
......@@ -311,34 +341,31 @@ extern "C" DECL_DLLEXPORT int32 query_field_info(intptr_t pduel, byte* buf) {
*p++ = 0;
}
}
*p++ = (uint8)player.list_main.size();
*p++ = (uint8)player.list_hand.size();
*p++ = (uint8)player.list_grave.size();
*p++ = (uint8)player.list_remove.size();
*p++ = (uint8)player.list_extra.size();
*p++ = (uint8)player.extra_p_count;
*p++ = (uint8_t)player.list_main.size();
*p++ = (uint8_t)player.list_hand.size();
*p++ = (uint8_t)player.list_grave.size();
*p++ = (uint8_t)player.list_remove.size();
*p++ = (uint8_t)player.list_extra.size();
*p++ = (uint8_t)player.extra_p_count;
}
*p++ = (uint8)ptduel->game_field->core.current_chain.size();
*p++ = (uint8_t)ptduel->game_field->core.current_chain.size();
for(const auto& ch : ptduel->game_field->core.current_chain) {
effect* peffect = ch.triggering_effect;
*((int*)p) = peffect->get_handler()->data.code;
p += 4;
*((int*)p) = peffect->get_handler()->get_info_location();
p += 4;
buffer_write<uint32_t>(p, peffect->get_handler()->data.code);
buffer_write<uint32_t>(p, peffect->get_handler()->get_info_location());
*p++ = ch.triggering_controler;
*p++ = (uint8)ch.triggering_location;
*p++ = (uint8_t)ch.triggering_location;
*p++ = ch.triggering_sequence;
*((int*)p) = peffect->description;
p += 4;
buffer_write<uint32_t>(p, peffect->description);
}
return (int32)(p - buf);
return (int32_t)(p - buf);
}
extern "C" DECL_DLLEXPORT void set_responsei(intptr_t pduel, int32 value) {
OCGCORE_API void set_responsei(intptr_t pduel, int32_t value) {
((duel*)pduel)->set_responsei(value);
}
extern "C" DECL_DLLEXPORT void set_responseb(intptr_t pduel, byte* buf) {
OCGCORE_API void set_responseb(intptr_t pduel, byte* buf) {
((duel*)pduel)->set_responseb(buf);
}
extern "C" DECL_DLLEXPORT int32 preload_script(intptr_t pduel, const char* script, int32 len) {
return ((duel*)pduel)->lua->load_script(script);
OCGCORE_API int32_t preload_script(intptr_t pduel, const char* script_name) {
return ((duel*)pduel)->lua->load_script(script_name);
}
ocgapi.h
View file @ 287dd26c
......@@ -10,49 +10,56 @@
#include "common.h"
#ifdef WIN32
#define DECL_DLLEXPORT __declspec(dllexport)
#ifdef __cplusplus
#define EXTERN_C extern "C"
#else
#define DECL_DLLEXPORT
#define EXTERN_C
#endif
class card;
#ifdef _WIN32
#define OCGCORE_API EXTERN_C __declspec(dllexport)
#else
#define OCGCORE_API EXTERN_C __attribute__ ((visibility ("default")))
#endif
#define SEED_COUNT 8
#define LEN_FAIL 0
#define LEN_EMPTY 4
#define LEN_HEADER 8
#define TEMP_CARD_ID 0
struct card_data;
struct card_info;
class group;
class effect;
class interpreter;
typedef byte* (*script_reader)(const char*, int*);
typedef uint32 (*card_reader)(uint32, card_data*);
typedef uint32 (*message_handler)(void*, uint32);
typedef byte* (*script_reader)(const char* script_name, int* len);
typedef uint32_t (*card_reader)(uint32_t code, card_data* data);
typedef uint32_t (*message_handler)(intptr_t pduel, uint32_t msg_type);
extern "C" DECL_DLLEXPORT void set_script_reader(script_reader f);
extern "C" DECL_DLLEXPORT void set_card_reader(card_reader f);
extern "C" DECL_DLLEXPORT void set_message_handler(message_handler f);
OCGCORE_API void set_script_reader(script_reader f);
OCGCORE_API void set_card_reader(card_reader f);
OCGCORE_API void set_message_handler(message_handler f);
byte* read_script(const char* script_name, int* len);
uint32 read_card(uint32 code, card_data* data);
uint32 handle_message(void* pduel, uint32 message_type);
extern "C" DECL_DLLEXPORT intptr_t create_duel(uint32 seed);
extern "C" DECL_DLLEXPORT void start_duel(intptr_t pduel, int32 options);
extern "C" DECL_DLLEXPORT void end_duel(intptr_t pduel);
extern "C" DECL_DLLEXPORT void set_player_info(intptr_t pduel, int32 playerid, int32 lp, int32 startcount, int32 drawcount);
extern "C" DECL_DLLEXPORT void get_log_message(intptr_t pduel, byte* buf);
extern "C" DECL_DLLEXPORT int32 get_message(intptr_t pduel, byte* buf);
extern "C" DECL_DLLEXPORT int32 process(intptr_t pduel);
extern "C" DECL_DLLEXPORT void new_card(intptr_t pduel, uint32 code, uint8 owner, uint8 playerid, uint8 location, uint8 sequence, uint8 position);
extern "C" DECL_DLLEXPORT void new_tag_card(intptr_t pduel, uint32 code, uint8 owner, uint8 location);
extern "C" DECL_DLLEXPORT int32 query_card(intptr_t pduel, uint8 playerid, uint8 location, uint8 sequence, int32 query_flag, byte* buf, int32 use_cache);
extern "C" DECL_DLLEXPORT int32 query_field_count(intptr_t pduel, uint8 playerid, uint8 location);
extern "C" DECL_DLLEXPORT int32 query_field_card(intptr_t pduel, uint8 playerid, uint8 location, int32 query_flag, byte* buf, int32 use_cache);
extern "C" DECL_DLLEXPORT int32 query_field_info(intptr_t pduel, byte* buf);
extern "C" DECL_DLLEXPORT void set_responsei(intptr_t pduel, int32 value);
extern "C" DECL_DLLEXPORT void set_responseb(intptr_t pduel, byte* buf);
extern "C" DECL_DLLEXPORT int32 preload_script(intptr_t pduel, const char* script, int32 len);
byte* default_script_reader(const char* script_name, int* len);
uint32 default_card_reader(uint32 code, card_data* data);
uint32 default_message_handler(void* pduel, uint32 msg_type);
uint32_t read_card(uint32_t code, card_data* data);
uint32_t handle_message(void* pduel, uint32_t message_type);
OCGCORE_API intptr_t create_duel(uint_fast32_t seed);
OCGCORE_API intptr_t create_duel_v2(uint32_t seed_sequence[]);
OCGCORE_API void start_duel(intptr_t pduel, uint32_t options);
OCGCORE_API void end_duel(intptr_t pduel);
OCGCORE_API void set_player_info(intptr_t pduel, int32_t playerid, int32_t lp, int32_t startcount, int32_t drawcount);
OCGCORE_API void get_log_message(intptr_t pduel, char* buf);
OCGCORE_API int32_t get_message(intptr_t pduel, byte* buf);
OCGCORE_API uint32_t process(intptr_t pduel);
OCGCORE_API void new_card(intptr_t pduel, uint32_t code, uint8_t owner, uint8_t playerid, uint8_t location, uint8_t sequence, uint8_t position);
OCGCORE_API void new_tag_card(intptr_t pduel, uint32_t code, uint8_t owner, uint8_t location);
OCGCORE_API int32_t query_card(intptr_t pduel, uint8_t playerid, uint8_t location, uint8_t sequence, int32_t query_flag, byte* buf, int32_t use_cache);
OCGCORE_API int32_t query_field_count(intptr_t pduel, uint8_t playerid, uint8_t location);
OCGCORE_API int32_t query_field_card(intptr_t pduel, uint8_t playerid, uint8_t location, uint32_t query_flag, byte* buf, int32_t use_cache);
OCGCORE_API int32_t query_field_info(intptr_t pduel, byte* buf);
OCGCORE_API void set_responsei(intptr_t pduel, int32_t value);
OCGCORE_API void set_responseb(intptr_t pduel, byte* buf);
OCGCORE_API int32_t preload_script(intptr_t pduel, const char* script_name);
OCGCORE_API byte* default_script_reader(const char* script_name, int* len);
#endif /* OCGAPI_H_ */
operations.cpp
View file @ 287dd26c
This source diff could not be displayed because it is too large. You can view the blob instead.
playerop.cpp
View file @ 287dd26c
......@@ -14,12 +14,26 @@
#include <algorithm>
#include <stack>
int32 field::select_battle_command(uint16 step, uint8 playerid) {
bool field::check_response(size_t vector_size, int32_t min_len, int32_t max_len) const {
const int32_t len = returns.bvalue[0];
if (len < min_len || len > max_len)
return false;
std::set<uint8_t> index_set;
for (int32_t i = 0; i < len; ++i) {
uint8_t index = returns.bvalue[1 + i];
if (index >= (int32_t)vector_size || index_set.count(index)) {
return false;
}
index_set.insert(index);
}
return true;
}
int32_t field::select_battle_command(uint16_t step, uint8_t playerid) {
if(step == 0) {
pduel->write_buffer8(MSG_SELECT_BATTLECMD);
pduel->write_buffer8(playerid);
//Activatable
pduel->write_buffer8((uint8)core.select_chains.size());
pduel->write_buffer8((uint8_t)core.select_chains.size());
std::sort(core.select_chains.begin(), core.select_chains.end(), chain::chain_operation_sort);
for(const auto& ch : core.select_chains) {
effect* peffect = ch.triggering_effect;
......@@ -34,7 +48,7 @@ int32 field::select_battle_command(uint16 step, uint8 playerid) {
pduel->write_buffer32(peffect->description);
}
//Attackable
pduel->write_buffer8((uint8)core.attackable_cards.size());
pduel->write_buffer8((uint8_t)core.attackable_cards.size());
for(auto& pcard : core.attackable_cards) {
pduel->write_buffer32(pcard->data.code);
pduel->write_buffer8(pcard->current.controler);
......@@ -53,11 +67,11 @@ int32 field::select_battle_command(uint16 step, uint8 playerid) {
pduel->write_buffer8(0);
return FALSE;
} else {
uint32 t = returns.ivalue[0] & 0xffff;
uint32 s = returns.ivalue[0] >> 16;
int32_t t = (uint32_t)returns.ivalue[0] & 0xffff;
int32_t s = (uint32_t)returns.ivalue[0] >> 16;
if(t < 0 || t > 3 || s < 0
|| (t == 0 && s >= core.select_chains.size())
|| (t == 1 && s >= core.attackable_cards.size())
|| (t == 0 && s >= (int32_t)core.select_chains.size())
|| (t == 1 && s >= (int32_t)core.attackable_cards.size())
|| (t == 2 && !core.to_m2)
|| (t == 3 && !core.to_ep)) {
pduel->write_buffer8(MSG_RETRY);
......@@ -66,12 +80,12 @@ int32 field::select_battle_command(uint16 step, uint8 playerid) {
return TRUE;
}
}
int32 field::select_idle_command(uint16 step, uint8 playerid) {
int32_t field::select_idle_command(uint16_t step, uint8_t playerid) {
if(step == 0) {
pduel->write_buffer8(MSG_SELECT_IDLECMD);
pduel->write_buffer8(playerid);
//idle summon
pduel->write_buffer8((uint8)core.summonable_cards.size());
pduel->write_buffer8((uint8_t)core.summonable_cards.size());
for(auto& pcard : core.summonable_cards) {
pduel->write_buffer32(pcard->data.code);
pduel->write_buffer8(pcard->current.controler);
......@@ -79,7 +93,7 @@ int32 field::select_idle_command(uint16 step, uint8 playerid) {
pduel->write_buffer8(pcard->current.sequence);
}
//idle spsummon
pduel->write_buffer8((uint8)core.spsummonable_cards.size());
pduel->write_buffer8((uint8_t)core.spsummonable_cards.size());
for(auto& pcard : core.spsummonable_cards) {
pduel->write_buffer32(pcard->data.code);
pduel->write_buffer8(pcard->current.controler);
......@@ -87,7 +101,7 @@ int32 field::select_idle_command(uint16 step, uint8 playerid) {
pduel->write_buffer8(pcard->current.sequence);
}
//idle pos change
pduel->write_buffer8((uint8)core.repositionable_cards.size());
pduel->write_buffer8((uint8_t)core.repositionable_cards.size());
for(auto& pcard : core.repositionable_cards) {
pduel->write_buffer32(pcard->data.code);
pduel->write_buffer8(pcard->current.controler);
......@@ -95,7 +109,7 @@ int32 field::select_idle_command(uint16 step, uint8 playerid) {
pduel->write_buffer8(pcard->current.sequence);
}
//idle mset
pduel->write_buffer8((uint8)core.msetable_cards.size());
pduel->write_buffer8((uint8_t)core.msetable_cards.size());
for(auto& pcard : core.msetable_cards) {
pduel->write_buffer32(pcard->data.code);
pduel->write_buffer8(pcard->current.controler);
......@@ -103,7 +117,7 @@ int32 field::select_idle_command(uint16 step, uint8 playerid) {
pduel->write_buffer8(pcard->current.sequence);
}
//idle sset
pduel->write_buffer8((uint8)core.ssetable_cards.size());
pduel->write_buffer8((uint8_t)core.ssetable_cards.size());
for(auto& pcard : core.ssetable_cards) {
pduel->write_buffer32(pcard->data.code);
pduel->write_buffer8(pcard->current.controler);
......@@ -111,7 +125,7 @@ int32 field::select_idle_command(uint16 step, uint8 playerid) {
pduel->write_buffer8(pcard->current.sequence);
}
//idle activate
pduel->write_buffer8((uint8)core.select_chains.size());
pduel->write_buffer8((uint8_t)core.select_chains.size());
std::sort(core.select_chains.begin(), core.select_chains.end(), chain::chain_operation_sort);
for(const auto& ch : core.select_chains) {
effect* peffect = ch.triggering_effect;
......@@ -140,25 +154,25 @@ int32 field::select_idle_command(uint16 step, uint8 playerid) {
pduel->write_buffer8(0);
return FALSE;
} else {
uint32 t = returns.ivalue[0] & 0xffff;
uint32 s = returns.ivalue[0] >> 16;
int32_t t = (uint32_t)returns.ivalue[0] & 0xffff;
int32_t s = (uint32_t)returns.ivalue[0] >> 16;
if(t < 0 || t > 8 || s < 0
|| (t == 0 && s >= core.summonable_cards.size())
|| (t == 1 && s >= core.spsummonable_cards.size())
|| (t == 2 && s >= core.repositionable_cards.size())
|| (t == 3 && s >= core.msetable_cards.size())
|| (t == 4 && s >= core.ssetable_cards.size())
|| (t == 5 && s >= core.select_chains.size())
|| (t == 0 && s >= (int32_t)core.summonable_cards.size())
|| (t == 1 && s >= (int32_t)core.spsummonable_cards.size())
|| (t == 2 && s >= (int32_t)core.repositionable_cards.size())
|| (t == 3 && s >= (int32_t)core.msetable_cards.size())
|| (t == 4 && s >= (int32_t)core.ssetable_cards.size())
|| (t == 5 && s >= (int32_t)core.select_chains.size())
|| (t == 6 && (infos.phase != PHASE_MAIN1 || !core.to_bp))
|| (t == 7 && !core.to_ep)
|| (t == 8 && !(infos.can_shuffle && player[playerid].list_hand.size() > 1))) {
|| (t == 8 && !(infos.can_shuffle && (int32_t)player[playerid].list_hand.size() > 1))) {
pduel->write_buffer8(MSG_RETRY);
return FALSE;
}
return TRUE;
}
}
int32 field::select_effect_yes_no(uint16 step, uint8 playerid, uint32 description, card* pcard) {
int32_t field::select_effect_yes_no(uint16_t step, uint8_t playerid, uint32_t description, card* pcard) {
if(step == 0) {
if((playerid == 1) && (core.duel_options & DUEL_SIMPLE_AI)) {
returns.ivalue[0] = 1;
......@@ -179,7 +193,7 @@ int32 field::select_effect_yes_no(uint16 step, uint8 playerid, uint32 descriptio
return TRUE;
}
}
int32 field::select_yes_no(uint16 step, uint8 playerid, uint32 description) {
int32_t field::select_yes_no(uint16_t step, uint8_t playerid, uint32_t description) {
if(step == 0) {
if((playerid == 1) && (core.duel_options & DUEL_SIMPLE_AI)) {
returns.ivalue[0] = 1;
......@@ -198,7 +212,7 @@ int32 field::select_yes_no(uint16 step, uint8 playerid, uint32 description) {
return TRUE;
}
}
int32 field::select_option(uint16 step, uint8 playerid) {
int32_t field::select_option(uint16_t step, uint8_t playerid) {
if(step == 0) {
returns.ivalue[0] = -1;
if(core.select_options.size() == 0)
......@@ -209,95 +223,97 @@ int32 field::select_option(uint16 step, uint8 playerid) {
}
pduel->write_buffer8(MSG_SELECT_OPTION);
pduel->write_buffer8(playerid);
pduel->write_buffer8((uint8)core.select_options.size());
pduel->write_buffer8((uint8_t)core.select_options.size());
for(auto& option : core.select_options)
pduel->write_buffer32(option);
return FALSE;
} else {
if(returns.ivalue[0] < 0 || returns.ivalue[0] >= (int32)core.select_options.size()) {
if(returns.ivalue[0] < 0 || returns.ivalue[0] >= (int32_t)core.select_options.size()) {
pduel->write_buffer8(MSG_RETRY);
return FALSE;
}
return TRUE;
}
}
int32 field::select_card(uint16 step, uint8 playerid, uint8 cancelable, uint8 min, uint8 max) {
int32_t field::select_card(uint16_t step, uint8_t playerid, uint8_t cancelable, uint8_t min, uint8_t max) {
if(step == 0) {
returns.bvalue[0] = 0;
if(max == 0 || core.select_cards.empty())
return TRUE;
if(max > 127)
max = 127;
core.selecting_player = playerid;
std::sort(core.select_cards.begin(), core.select_cards.end(), card::card_operation_sort);
if (core.select_cards.size() > UINT8_MAX)
core.select_cards.resize(UINT8_MAX);
if(max > core.select_cards.size())
max = (uint8)core.select_cards.size();
max = (uint8_t)core.select_cards.size();
if(min > max)
min = max;
if((playerid == 1) && (core.duel_options & DUEL_SIMPLE_AI)) {
returns.bvalue[0] = min;
for(uint8 i = 0; i < min; ++i)
for(uint8_t i = 0; i < min; ++i)
returns.bvalue[i + 1] = i;
return TRUE;
}
core.units.begin()->arg2 = ((uint32)min) + (((uint32)max) << 16);
core.units.begin()->arg2 = ((uint32_t)min) + (((uint32_t)max) << 16);
pduel->write_buffer8(MSG_SELECT_CARD);
pduel->write_buffer8(playerid);
pduel->write_buffer8(cancelable);
pduel->write_buffer8(min);
pduel->write_buffer8(max);
pduel->write_buffer8((uint8)core.select_cards.size());
std::sort(core.select_cards.begin(), core.select_cards.end(), card::card_operation_sort);
pduel->write_buffer8((uint8_t)core.select_cards.size());
uint8_t deck_seq = 0;
for(auto& pcard : core.select_cards) {
pduel->write_buffer32(pcard->data.code);
pduel->write_buffer32(pcard->get_info_location());
pduel->write_buffer32(pcard->get_select_info_location(&deck_seq));
}
return FALSE;
} else {
if(cancelable && returns.ivalue[0] == -1)
if (returns.ivalue[0] == -1) {
if (cancelable)
return TRUE;
if(returns.bvalue[0] < min || returns.bvalue[0] > max) {
pduel->write_buffer8(MSG_RETRY);
return FALSE;
}
std::set<int8> c;
uint8 m = (uint8)core.select_cards.size();
for(int32 i = 0; i < returns.bvalue[0]; ++i) {
int8 v = returns.bvalue[i + 1];
if(v < 0 || v >= m || c.count(v)) {
if (!check_response(core.select_cards.size(), min, max)) {
pduel->write_buffer8(MSG_RETRY);
return FALSE;
}
c.insert(v);
}
return TRUE;
}
}
int32 field::select_unselect_card(uint16 step, uint8 playerid, uint8 cancelable, uint8 min, uint8 max, uint8 finishable) {
int32_t field::select_unselect_card(uint16_t step, uint8_t playerid, uint8_t cancelable, uint8_t min, uint8_t max, uint8_t finishable) {
if(step == 0) {
returns.bvalue[0] = 0;
if(core.select_cards.empty() && core.unselect_cards.empty())
return TRUE;
if((playerid == 1) && (core.duel_options & DUEL_SIMPLE_AI)) {
returns.bvalue[0] = 1;
for(uint8 i = 0; i < 1; ++i)
for(uint8_t i = 0; i < 1; ++i)
returns.bvalue[i + 1] = i;
return TRUE;
}
core.selecting_player = playerid;
std::sort(core.select_cards.begin(), core.select_cards.end(), card::card_operation_sort);
if (core.select_cards.size() > UINT8_MAX)
core.select_cards.resize(UINT8_MAX);
if (core.unselect_cards.size() > UINT8_MAX)
core.unselect_cards.resize(UINT8_MAX);
pduel->write_buffer8(MSG_SELECT_UNSELECT_CARD);
pduel->write_buffer8(playerid);
pduel->write_buffer8(finishable);
pduel->write_buffer8(cancelable);
pduel->write_buffer8(min);
pduel->write_buffer8(max);
pduel->write_buffer8((uint8)core.select_cards.size());
std::sort(core.select_cards.begin(), core.select_cards.end(), card::card_operation_sort);
pduel->write_buffer8((uint8_t)core.select_cards.size());
uint8_t deck_seq = 0;
for(auto& pcard : core.select_cards) {
pduel->write_buffer32(pcard->data.code);
pduel->write_buffer32(pcard->get_info_location());
pduel->write_buffer32(pcard->get_select_info_location(&deck_seq));
}
pduel->write_buffer8((uint8)core.unselect_cards.size());
pduel->write_buffer8((uint8_t)core.unselect_cards.size());
for(auto& pcard : core.unselect_cards) {
pduel->write_buffer32(pcard->data.code);
pduel->write_buffer32(pcard->get_info_location());
pduel->write_buffer32(pcard->get_select_info_location(&deck_seq));
}
return FALSE;
} else {
......@@ -307,20 +323,14 @@ int32 field::select_unselect_card(uint16 step, uint8 playerid, uint8 cancelable,
pduel->write_buffer8(MSG_RETRY);
return FALSE;
}
if(returns.bvalue[0] == 0 || returns.bvalue[0] > 1) {
pduel->write_buffer8(MSG_RETRY);
return FALSE;
}
uint8 m = (uint8)core.select_cards.size() + (uint8)core.unselect_cards.size();
uint8 v = returns.bvalue[1];
if(v < 0 || v >= m) {
if (!check_response(core.select_cards.size() + core.unselect_cards.size(), 1, 1)) {
pduel->write_buffer8(MSG_RETRY);
return FALSE;
}
return TRUE;
}
}
int32 field::select_chain(uint16 step, uint8 playerid, uint8 spe_count, uint8 forced) {
int32_t field::select_chain(uint16_t step, uint8_t playerid, uint8_t spe_count, uint8_t forced) {
if(step == 0) {
returns.ivalue[0] = -1;
if((playerid == 1) && (core.duel_options & DUEL_SIMPLE_AI)) {
......@@ -342,7 +352,7 @@ int32 field::select_chain(uint16 step, uint8 playerid, uint8 spe_count, uint8 fo
}
pduel->write_buffer8(MSG_SELECT_CHAIN);
pduel->write_buffer8(playerid);
pduel->write_buffer8((uint8)core.select_chains.size());
pduel->write_buffer8((uint8_t)core.select_chains.size());
pduel->write_buffer8(spe_count);
pduel->write_buffer8(forced);
pduel->write_buffer32(pduel->game_field->core.hint_timing[playerid]);
......@@ -363,21 +373,25 @@ int32 field::select_chain(uint16 step, uint8 playerid, uint8 spe_count, uint8 fo
}
return FALSE;
} else {
if(!forced && returns.ivalue[0] == -1)
if (returns.ivalue[0] == -1) {
if (!forced)
return TRUE;
if(returns.ivalue[0] < 0 || returns.ivalue[0] >= (int32)core.select_chains.size()) {
pduel->write_buffer8(MSG_RETRY);
return FALSE;
}
if(returns.ivalue[0] < 0 || returns.ivalue[0] >= (int32_t)core.select_chains.size()) {
pduel->write_buffer8(MSG_RETRY);
return FALSE;
}
return TRUE;
}
}
int32 field::select_place(uint16 step, uint8 playerid, uint32 flag, uint8 count) {
int32_t field::select_place(uint16_t step, uint8_t playerid, uint32_t flag, uint8_t count) {
if(step == 0) {
if((playerid == 1) && (core.duel_options & DUEL_SIMPLE_AI)) {
flag = ~flag;
int32 filter;
int32 pzone = 0;
uint32_t filter;
int32_t pzone = 0;
if(flag & 0x7f) {
returns.bvalue[0] = 1;
returns.bvalue[1] = LOCATION_MZONE;
......@@ -429,13 +443,14 @@ int32 field::select_place(uint16 step, uint8 playerid, uint32 flag, uint8 count)
returns.bvalue[0] = 0;
return FALSE;
} else {
uint8 pt = 0;
uint32 selected = 0;
for(int8 i = 0; i < 1 || i < count; ++i) {
uint8 p = returns.bvalue[pt];
uint8 l = returns.bvalue[pt + 1];
uint8 s = returns.bvalue[pt + 2];
uint32 sel = 0x1u << (s + (p == playerid ? 0 : 16) + (l == LOCATION_MZONE ? 0 : 8));
uint8_t pt = 0;
uint32_t selected = 0;
int32_t len = std::max(1, (int32_t)count);
for (int32_t i = 0; i < len; ++i) {
uint8_t p = returns.bvalue[pt];
uint8_t l = returns.bvalue[pt + 1];
uint8_t s = returns.bvalue[pt + 2];
uint32_t sel = 0x1u << (s + (p == playerid ? 0 : 16) + (l == LOCATION_MZONE ? 0 : 8));
if(!(count == 0 && i == 0 && l == 0)
&& ((p != 0 && p != 1)
|| ((l != LOCATION_MZONE) && (l != LOCATION_SZONE))
......@@ -443,17 +458,17 @@ int32 field::select_place(uint16 step, uint8 playerid, uint32 flag, uint8 count)
pduel->write_buffer8(MSG_RETRY);
return FALSE;
}
if(sel & (0x1 << 5))
sel |= 0x1 << (16 + 6);
if(sel & (0x1 << 6))
sel |= 0x1 << (16 + 5);
if(sel & (0x1u << 5))
sel |= 0x1u << (16 + 6);
if(sel & (0x1u << 6))
sel |= 0x1u << (16 + 5);
selected |= sel;
pt += 3;
}
return TRUE;
}
}
int32 field::select_position(uint16 step, uint8 playerid, uint32 code, uint8 positions) {
int32_t field::select_position(uint16_t step, uint8_t playerid, uint32_t code, uint8_t positions) {
if(step == 0) {
if(positions == 0) {
returns.ivalue[0] = POS_FACEUP_ATTACK;
......@@ -465,11 +480,11 @@ int32 field::select_position(uint16 step, uint8 playerid, uint32 code, uint8 pos
return TRUE;
}
if((playerid == 1) && (core.duel_options & DUEL_SIMPLE_AI)) {
if(positions & 0x4)
if((uint32_t)positions & 0x4)
returns.ivalue[0] = 0x4;
else if(positions & 0x1)
else if((uint32_t)positions & 0x1)
returns.ivalue[0] = 0x1;
else if(positions & 0x8)
else if((uint32_t)positions & 0x8)
returns.ivalue[0] = 0x8;
else
returns.ivalue[0] = 0x2;
......@@ -482,7 +497,7 @@ int32 field::select_position(uint16 step, uint8 playerid, uint32 code, uint8 pos
returns.ivalue[0] = 0;
return FALSE;
} else {
uint32 pos = returns.ivalue[0];
uint32_t pos = returns.ivalue[0];
if(pos != 0x1 && pos != 0x2 && pos != 0x4 && pos != 0x8 || !(pos & positions)) {
pduel->write_buffer8(MSG_RETRY);
return FALSE;
......@@ -490,12 +505,16 @@ int32 field::select_position(uint16 step, uint8 playerid, uint32 code, uint8 pos
return TRUE;
}
}
int32 field::select_tribute(uint16 step, uint8 playerid, uint8 cancelable, uint8 min, uint8 max) {
int32_t field::select_tribute(uint16_t step, uint8_t playerid, uint8_t cancelable, uint8_t min, uint8_t max) {
if(step == 0) {
returns.bvalue[0] = 0;
if(max == 0 || core.select_cards.empty())
return TRUE;
uint8 tm = 0;
core.selecting_player = playerid;
std::sort(core.select_cards.begin(), core.select_cards.end(), card::card_operation_sort);
if (core.select_cards.size() > UINT8_MAX)
core.select_cards.resize(UINT8_MAX);
uint8_t tm = 0;
for(auto& pcard : core.select_cards)
tm += pcard->release_param;
if(max > 5)
......@@ -504,34 +523,38 @@ int32 field::select_tribute(uint16 step, uint8 playerid, uint8 cancelable, uint8
max = tm;
if(min > max)
min = max;
core.units.begin()->arg2 = ((uint32)min) + (((uint32)max) << 16);
core.units.begin()->arg2 = ((uint32_t)min) + (((uint32_t)max) << 16);
pduel->write_buffer8(MSG_SELECT_TRIBUTE);
pduel->write_buffer8(playerid);
pduel->write_buffer8(cancelable);
pduel->write_buffer8(min);
pduel->write_buffer8(max);
pduel->write_buffer8((uint8)core.select_cards.size());
std::sort(core.select_cards.begin(), core.select_cards.end(), card::card_operation_sort);
pduel->write_buffer8((uint8_t)core.select_cards.size());
uint8_t deck_seq = 0;
for(auto& pcard : core.select_cards) {
pduel->write_buffer32(pcard->data.code);
pduel->write_buffer8(pcard->current.controler);
pduel->write_buffer8(pcard->current.location);
pduel->write_buffer8(pcard->current.sequence);
pduel->write_buffer8(pcard->get_select_sequence(&deck_seq));
pduel->write_buffer8(pcard->release_param);
}
return FALSE;
} else {
if(cancelable && returns.ivalue[0] == -1)
if (returns.ivalue[0] == -1) {
if (cancelable)
return TRUE;
pduel->write_buffer8(MSG_RETRY);
return FALSE;
}
if(returns.bvalue[0] > max) {
pduel->write_buffer8(MSG_RETRY);
return FALSE;
}
std::set<int8> c;
uint8 m = (uint8)core.select_cards.size(), tt = 0;
for(int32 i = 0; i < returns.bvalue[0]; ++i) {
int8 v = returns.bvalue[i + 1];
if(v < 0 || v >= m || c.count(v)) {
std::set<uint8_t> c;
int32_t m = (int32_t)core.select_cards.size(), tt = 0;
for(int32_t i = 0; i < returns.bvalue[0]; ++i) {
uint8_t v = returns.bvalue[i + 1];
if(v >= m || c.count(v)) {
pduel->write_buffer8(MSG_RETRY);
return FALSE;
}
......@@ -545,13 +568,13 @@ int32 field::select_tribute(uint16 step, uint8 playerid, uint8 cancelable, uint8
return TRUE;
}
}
int32 field::select_counter(uint16 step, uint8 playerid, uint16 countertype, uint16 count, uint8 s, uint8 o) {
int32_t field::select_counter(uint16_t step, uint8_t playerid, uint16_t countertype, uint16_t count, uint8_t s, uint8_t o) {
if(step == 0) {
if(count == 0)
return TRUE;
uint8 avail = s;
uint8 fp = playerid;
uint32 total = 0;
uint8_t avail = s;
uint8_t fp = playerid;
uint32_t total = 0;
core.select_cards.clear();
for(int p = 0; p < 2; ++p) {
if(avail) {
......@@ -579,19 +602,21 @@ int32 field::select_counter(uint16 step, uint8 playerid, uint16 countertype, uin
pduel->write_buffer8(playerid);
pduel->write_buffer16(countertype);
pduel->write_buffer16(count);
pduel->write_buffer8((uint8)core.select_cards.size());
pduel->write_buffer8((uint8_t)core.select_cards.size());
core.selecting_player = playerid;
std::sort(core.select_cards.begin(), core.select_cards.end(), card::card_operation_sort);
uint8_t deck_seq = 0;
for(auto& pcard : core.select_cards) {
pduel->write_buffer32(pcard->data.code);
pduel->write_buffer8(pcard->current.controler);
pduel->write_buffer8(pcard->current.location);
pduel->write_buffer8(pcard->current.sequence);
pduel->write_buffer8(pcard->get_select_sequence(&deck_seq));
pduel->write_buffer16(pcard->get_counter(countertype));
}
return FALSE;
} else {
uint16 ct = 0;
for(uint32 i = 0; i < core.select_cards.size(); ++i) {
int32_t ct = 0;
for(int32_t i = 0; i < (int32_t)core.select_cards.size(); ++i) {
if(core.select_cards[i]->get_counter(countertype) < returns.svalue[i]) {
pduel->write_buffer8(MSG_RETRY);
return FALSE;
......@@ -605,21 +630,27 @@ int32 field::select_counter(uint16 step, uint8 playerid, uint16 countertype, uin
}
return TRUE;
}
static int32 select_sum_check1(const int32* oparam, int32 size, int32 index, int32 acc, int32 opmin) {
static int32_t select_sum_check1(const uint32_t* oparam, int32_t size, int32_t index, int32_t acc, int32_t opmin) {
if(acc == 0 || index == size)
return FALSE;
int32 o1 = oparam[index] & 0xffff;
int32 o2 = oparam[index] >> 16;
int32_t o1 = oparam[index] & 0xffff;
int32_t o2 = oparam[index] >> 16;
if(index == size - 1)
return (acc == o1 && acc + opmin > o1) || (o2 && acc == o2 && acc + opmin > o2);
return (acc > o1 && select_sum_check1(oparam, size, index + 1, acc - o1, std::min(o1, opmin)))
|| (o2 > 0 && acc > o2 && select_sum_check1(oparam, size, index + 1, acc - o2, std::min(o2, opmin)));
}
int32 field::select_with_sum_limit(int16 step, uint8 playerid, int32 acc, int32 min, int32 max) {
int32_t field::select_with_sum_limit(int16_t step, uint8_t playerid, int32_t acc, int32_t min, int32_t max) {
if(step == 0) {
returns.bvalue[0] = 0;
if(core.select_cards.empty())
return TRUE;
core.selecting_player = playerid;
std::sort(core.select_cards.begin(), core.select_cards.end(), card::card_operation_sort);
if (core.select_cards.size() > UINT8_MAX)
core.select_cards.resize(UINT8_MAX);
if (core.must_select_cards.size() > UINT8_MAX)
core.must_select_cards.resize(UINT8_MAX);
pduel->write_buffer8(MSG_SELECT_SUM);
if(max)
pduel->write_buffer8(0);
......@@ -628,41 +659,43 @@ int32 field::select_with_sum_limit(int16 step, uint8 playerid, int32 acc, int32
if(max < min)
max = min;
pduel->write_buffer8(playerid);
pduel->write_buffer32(acc & 0xffff);
pduel->write_buffer32((uint32_t)acc & 0xffff);
pduel->write_buffer8(min);
pduel->write_buffer8(max);
pduel->write_buffer8((uint8)core.must_select_cards.size());
pduel->write_buffer8((uint8_t)core.must_select_cards.size());
uint8_t deck_seq = 0;
for(auto& pcard : core.must_select_cards) {
pduel->write_buffer32(pcard->data.code);
pduel->write_buffer8(pcard->current.controler);
pduel->write_buffer8(pcard->current.location);
pduel->write_buffer8(pcard->current.sequence);
pduel->write_buffer8(pcard->get_select_sequence(&deck_seq));
pduel->write_buffer32(pcard->sum_param);
}
pduel->write_buffer8((uint8)core.select_cards.size());
std::sort(core.select_cards.begin(), core.select_cards.end(), card::card_operation_sort);
pduel->write_buffer8((uint8_t)core.select_cards.size());
for(auto& pcard : core.select_cards) {
pduel->write_buffer32(pcard->data.code);
pduel->write_buffer8(pcard->current.controler);
pduel->write_buffer8(pcard->current.location);
pduel->write_buffer8(pcard->current.sequence);
pduel->write_buffer8(pcard->get_select_sequence(&deck_seq));
pduel->write_buffer32(pcard->sum_param);
}
return FALSE;
} else {
std::set<int32> c;
std::set<int32_t> c;
int32_t mcount = (int32_t)core.must_select_cards.size();
if (mcount > UINT8_MAX)
mcount = UINT8_MAX;
if(max) {
int32 oparam[16];
int32 mcount = (int32)core.must_select_cards.size();
uint32_t oparam[512]{};
if(returns.bvalue[0] < min + mcount || returns.bvalue[0] > max + mcount) {
pduel->write_buffer8(MSG_RETRY);
return FALSE;
}
for(int32 i = 0; i < mcount; ++i)
for(int32_t i = 0; i < mcount; ++i)
oparam[i] = core.must_select_cards[i]->sum_param;
int32 m = (int32)core.select_cards.size();
for(int32 i = mcount; i < returns.bvalue[0]; ++i) {
int32 v = returns.bvalue[i + 1];
int32_t m = (int32_t)core.select_cards.size();
for(int32_t i = mcount; i < returns.bvalue[0]; ++i) {
int32_t v = returns.bvalue[i + 1];
if(v < 0 || v >= m || c.count(v)) {
pduel->write_buffer8(MSG_RETRY);
return FALSE;
......@@ -676,32 +709,31 @@ int32 field::select_with_sum_limit(int16 step, uint8 playerid, int32 acc, int32
}
return TRUE;
} else {
int32 mcount = (int32)core.must_select_cards.size();
int32 sum = 0, mx = 0, mn = 0x7fffffff;
for(int32 i = 0; i < mcount; ++i) {
int32 op = core.must_select_cards[i]->sum_param;
int32 o1 = op & 0xffff;
int32 o2 = op >> 16;
int32 ms = (o2 && o2 < o1) ? o2 : o1;
int32_t sum = 0, mx = 0, mn = 0x7fffffff;
for(int32_t i = 0; i < mcount; ++i) {
uint32_t op = core.must_select_cards[i]->sum_param;
int32_t o1 = op & 0xffff;
int32_t o2 = op >> 16;
int32_t ms = (o2 && o2 < o1) ? o2 : o1;
sum += ms;
mx += (o2 > o1) ? o2 : o1;
mx += std::max(o1, o2);
if(ms < mn)
mn = ms;
}
int32 m = (int32)core.select_cards.size();
for(int32 i = mcount; i < returns.bvalue[0]; ++i) {
int32 v = returns.bvalue[i + 1];
int32_t m = (int32_t)core.select_cards.size();
for(int32_t i = mcount; i < returns.bvalue[0]; ++i) {
int32_t v = returns.bvalue[i + 1];
if(v < 0 || v >= m || c.count(v)) {
pduel->write_buffer8(MSG_RETRY);
return FALSE;
}
c.insert(v);
int32 op = core.select_cards[v]->sum_param;
int32 o1 = op & 0xffff;
int32 o2 = op >> 16;
int32 ms = (o2 && o2 < o1) ? o2 : o1;
uint32_t op = core.select_cards[v]->sum_param;
int32_t o1 = op & 0xffff;
int32_t o2 = op >> 16;
int32_t ms = (o2 && o2 < o1) ? o2 : o1;
sum += ms;
mx += (o2 > o1) ? o2 : o1;
mx += std::max(o1, o2);
if(ms < mn)
mn = ms;
}
......@@ -714,18 +746,20 @@ int32 field::select_with_sum_limit(int16 step, uint8 playerid, int32 acc, int32
}
return TRUE;
}
int32 field::sort_card(int16 step, uint8 playerid) {
int32_t field::sort_card(int16_t step, uint8_t playerid) {
if(step == 0) {
returns.bvalue[0] = 0;
if((playerid == 1) && (core.duel_options & DUEL_SIMPLE_AI)) {
returns.bvalue[0] = -1;
returns.bvalue[0] = 0xff;
return TRUE;
}
if(core.select_cards.empty())
return TRUE;
if (core.select_cards.size() > UINT8_MAX)
core.select_cards.resize(UINT8_MAX);
pduel->write_buffer8(MSG_SORT_CARD);
pduel->write_buffer8(playerid);
pduel->write_buffer8((uint8)core.select_cards.size());
pduel->write_buffer8((uint8_t)core.select_cards.size());
for(auto& pcard : core.select_cards) {
pduel->write_buffer32(pcard->data.code);
pduel->write_buffer8(pcard->current.controler);
......@@ -734,13 +768,13 @@ int32 field::sort_card(int16 step, uint8 playerid) {
}
return FALSE;
} else {
if(returns.bvalue[0] == -1)
if(returns.bvalue[0] == 0xff)
return TRUE;
std::set<int8> c;
uint8 m = (uint8)core.select_cards.size();
for(uint8 i = 0; i < m; ++i) {
int8 v = returns.bvalue[i];
if(v < 0 || v >= m || c.count(v)) {
std::set<uint8_t> c;
int32_t m = (int32_t)core.select_cards.size();
for(int32_t i = 0; i < m; ++i) {
uint8_t v = returns.bvalue[i];
if(v >= m || c.count(v)) {
pduel->write_buffer8(MSG_RETRY);
return FALSE;
}
......@@ -750,12 +784,12 @@ int32 field::sort_card(int16 step, uint8 playerid) {
}
return TRUE;
}
int32 field::announce_race(int16 step, uint8 playerid, int32 count, int32 available) {
int32_t field::announce_race(int16_t step, uint8_t playerid, int32_t count, int32_t available) {
if(step == 0) {
int32 scount = 0;
for(int32 ft = 0x1; ft != 0x2000000; ft <<= 1) {
int32_t scount = 0;
for(uint32_t ft = 0x1; ft < (0x1U << RACES_COUNT); ft <<= 1) {
if(ft & available)
scount++;
++scount;
}
if(scount <= count) {
count = scount;
......@@ -767,15 +801,16 @@ int32 field::announce_race(int16 step, uint8 playerid, int32 count, int32 availa
pduel->write_buffer32(available);
return FALSE;
} else {
int32 rc = returns.ivalue[0];
int32 sel = 0;
for(int32 ft = 0x1; ft != 0x2000000; ft <<= 1) {
if(!(ft & rc)) continue;
int32_t rc = returns.ivalue[0];
int32_t sel = 0;
for(uint32_t ft = 0x1; ft < (0x1U << RACES_COUNT); ft <<= 1) {
if(!(ft & rc))
continue;
if(!(ft & available)) {
pduel->write_buffer8(MSG_RETRY);
return FALSE;
}
sel++;
++sel;
}
if(sel != count) {
pduel->write_buffer8(MSG_RETRY);
......@@ -789,12 +824,12 @@ int32 field::announce_race(int16 step, uint8 playerid, int32 count, int32 availa
}
return TRUE;
}
int32 field::announce_attribute(int16 step, uint8 playerid, int32 count, int32 available) {
int32_t field::announce_attribute(int16_t step, uint8_t playerid, int32_t count, int32_t available) {
if(step == 0) {
int32 scount = 0;
for(int32 ft = 0x1; ft != 0x80; ft <<= 1) {
int32_t scount = 0;
for(int32_t ft = 0x1; ft != 0x80; ft <<= 1) {
if(ft & available)
scount++;
++scount;
}
if(scount <= count) {
count = scount;
......@@ -806,15 +841,15 @@ int32 field::announce_attribute(int16 step, uint8 playerid, int32 count, int32 a
pduel->write_buffer32(available);
return FALSE;
} else {
int32 rc = returns.ivalue[0];
int32 sel = 0;
for(int32 ft = 0x1; ft != 0x80; ft <<= 1) {
int32_t rc = returns.ivalue[0];
int32_t sel = 0;
for(int32_t ft = 0x1; ft != 0x80; ft <<= 1) {
if(!(ft & rc)) continue;
if(!(ft & available)) {
pduel->write_buffer8(MSG_RETRY);
return FALSE;
}
sel++;
++sel;
}
if(sel != count) {
pduel->write_buffer8(MSG_RETRY);
......@@ -828,15 +863,15 @@ int32 field::announce_attribute(int16 step, uint8 playerid, int32 count, int32 a
}
return TRUE;
}
static int32 is_declarable(card_data const& cd, const std::vector<uint32>& opcode) {
std::stack<int32> stack;
static int32_t is_declarable(card_data const& cd, const std::vector<uint32_t>& opcode) {
std::stack<int32_t> stack;
for(auto& it : opcode) {
switch(it) {
case OPCODE_ADD: {
if(stack.size() >= 2) {
int32 rhs = stack.top();
int32_t rhs = stack.top();
stack.pop();
int32 lhs = stack.top();
int32_t lhs = stack.top();
stack.pop();
stack.push(lhs + rhs);
}
......@@ -844,9 +879,9 @@ static int32 is_declarable(card_data const& cd, const std::vector<uint32>& opcod
}
case OPCODE_SUB: {
if(stack.size() >= 2) {
int32 rhs = stack.top();
int32_t rhs = stack.top();
stack.pop();
int32 lhs = stack.top();
int32_t lhs = stack.top();
stack.pop();
stack.push(lhs - rhs);
}
......@@ -854,9 +889,9 @@ static int32 is_declarable(card_data const& cd, const std::vector<uint32>& opcod
}
case OPCODE_MUL: {
if(stack.size() >= 2) {
int32 rhs = stack.top();
int32_t rhs = stack.top();
stack.pop();
int32 lhs = stack.top();
int32_t lhs = stack.top();
stack.pop();
stack.push(lhs * rhs);
}
......@@ -864,9 +899,9 @@ static int32 is_declarable(card_data const& cd, const std::vector<uint32>& opcod
}
case OPCODE_DIV: {
if(stack.size() >= 2) {
int32 rhs = stack.top();
int32_t rhs = stack.top();
stack.pop();
int32 lhs = stack.top();
int32_t lhs = stack.top();
stack.pop();
stack.push(lhs / rhs);
}
......@@ -874,27 +909,27 @@ static int32 is_declarable(card_data const& cd, const std::vector<uint32>& opcod
}
case OPCODE_AND: {
if(stack.size() >= 2) {
int32 rhs = stack.top();
int32_t rhs = stack.top();
stack.pop();
int32 lhs = stack.top();
int32_t lhs = stack.top();
stack.pop();
stack.push(lhs && rhs);
stack.push(static_cast<int32_t>(lhs && rhs));
}
break;
}
case OPCODE_OR: {
if(stack.size() >= 2) {
int32 rhs = stack.top();
int32_t rhs = stack.top();
stack.pop();
int32 lhs = stack.top();
int32_t lhs = stack.top();
stack.pop();
stack.push(lhs || rhs);
stack.push(static_cast<int32_t>(lhs || rhs));
}
break;
}
case OPCODE_NEG: {
if(stack.size() >= 1) {
int32 val = stack.top();
int32_t val = stack.top();
stack.pop();
stack.push(-val);
}
......@@ -902,15 +937,15 @@ static int32 is_declarable(card_data const& cd, const std::vector<uint32>& opcod
}
case OPCODE_NOT: {
if(stack.size() >= 1) {
int32 val = stack.top();
int32_t val = stack.top();
stack.pop();
stack.push(!val);
stack.push(static_cast<int32_t>(!val));
}
break;
}
case OPCODE_ISCODE: {
if(stack.size() >= 1) {
int32 code = stack.top();
int32_t code = stack.top();
stack.pop();
stack.push(cd.code == code);
}
......@@ -918,24 +953,16 @@ static int32 is_declarable(card_data const& cd, const std::vector<uint32>& opcod
}
case OPCODE_ISSETCARD: {
if(stack.size() >= 1) {
int32 set_code = stack.top();
int32_t set_code = stack.top();
stack.pop();
uint64 sc = cd.setcode;
bool res = false;
uint32 settype = set_code & 0xfff;
uint32 setsubtype = set_code & 0xf000;
while(sc) {
if((sc & 0xfff) == settype && (sc & 0xf000 & setsubtype) == setsubtype)
res = true;
sc = sc >> 16;
}
bool res = cd.is_setcode(set_code);
stack.push(res);
}
break;
}
case OPCODE_ISTYPE: {
if(stack.size() >= 1) {
int32 val = stack.top();
int32_t val = stack.top();
stack.pop();
stack.push(cd.type & val);
}
......@@ -943,7 +970,7 @@ static int32 is_declarable(card_data const& cd, const std::vector<uint32>& opcod
}
case OPCODE_ISRACE: {
if(stack.size() >= 1) {
int32 race = stack.top();
int32_t race = stack.top();
stack.pop();
stack.push(cd.race & race);
}
......@@ -951,7 +978,7 @@ static int32 is_declarable(card_data const& cd, const std::vector<uint32>& opcod
}
case OPCODE_ISATTRIBUTE: {
if(stack.size() >= 1) {
int32 attribute = stack.top();
int32_t attribute = stack.top();
stack.pop();
stack.push(cd.attribute & attribute);
}
......@@ -966,20 +993,20 @@ static int32 is_declarable(card_data const& cd, const std::vector<uint32>& opcod
if(stack.size() != 1 || stack.top() == 0)
return FALSE;
return cd.code == CARD_MARINE_DOLPHIN || cd.code == CARD_TWINKLE_MOSS
|| (!cd.alias && (cd.type & (TYPE_MONSTER + TYPE_TOKEN)) != (TYPE_MONSTER + TYPE_TOKEN));
|| (!cd.alias && (cd.type & (TYPE_MONSTER | TYPE_TOKEN)) != (TYPE_MONSTER | TYPE_TOKEN));
}
int32 field::announce_card(int16 step, uint8 playerid) {
int32_t field::announce_card(int16_t step, uint8_t playerid) {
if(step == 0) {
pduel->write_buffer8(MSG_ANNOUNCE_CARD);
pduel->write_buffer8(playerid);
pduel->write_buffer8((uint8)core.select_options.size());
pduel->write_buffer8((uint8_t)core.select_options.size());
for(auto& option : core.select_options)
pduel->write_buffer32(option);
return FALSE;
} else {
int32 code = returns.ivalue[0];
int32_t code = returns.ivalue[0];
card_data data;
read_card(code, &data);
::read_card(code, &data);
if(!data.code) {
pduel->write_buffer8(MSG_RETRY);
return FALSE;
......@@ -997,17 +1024,19 @@ int32 field::announce_card(int16 step, uint8 playerid) {
}
return TRUE;
}
int32 field::announce_number(int16 step, uint8 playerid) {
int32_t field::announce_number(int16_t step, uint8_t playerid) {
if(step == 0) {
if (core.select_options.size() > UINT8_MAX)
core.select_options.resize(UINT8_MAX);
pduel->write_buffer8(MSG_ANNOUNCE_NUMBER);
pduel->write_buffer8(playerid);
pduel->write_buffer8((uint8)core.select_options.size());
pduel->write_buffer8((uint8_t)core.select_options.size());
for(auto& option : core.select_options)
pduel->write_buffer32(option);
return FALSE;
} else {
int32 ret = returns.ivalue[0];
if(ret < 0 || ret >= (int32)core.select_options.size()) {
int32_t ret = returns.ivalue[0];
if(ret < 0 || ret >= (int32_t)core.select_options.size()) {
pduel->write_buffer8(MSG_RETRY);
return FALSE;
}
......
premake/dll.lua 0 → 100644
View file @ 287dd26c
newoption { trigger = "lua-dir", description = "", value = "PATH", default = "./lua" }
function GetParam(param)
return _OPTIONS[param] or os.getenv(string.upper(string.gsub(param,"-","_")))
end
LUA_DIR=GetParam("lua-dir")
if not os.isdir(LUA_DIR) then
LUA_DIR="../lua"
end
workspace "ocgcoredll"
location "build"
language "C++"
cppdialect "C++14"
configurations { "Release", "Debug" }
platforms { "x32", "x64" }
filter "platforms:x32"
architecture "x32"
filter "platforms:x64"
architecture "x64"
filter "configurations:Release"
optimize "Speed"
filter "configurations:Debug"
symbols "On"
defines "_DEBUG"
filter "system:windows"
systemversion "latest"
startproject "ocgcore"
filter { "configurations:Release", "action:vs*" }
linktimeoptimization "On"
staticruntime "On"
disablewarnings { "4146", "4334" }
filter "action:vs*"
cdialect "C11"
conformancemode "On"
buildoptions { "/utf-8" }
defines { "_CRT_SECURE_NO_WARNINGS" }
filter "system:bsd"
defines { "LUA_USE_POSIX" }
filter "system:macosx"
defines { "LUA_USE_MACOSX" }
filter "system:linux"
defines { "LUA_USE_LINUX" }
pic "On"
filter {}
include(LUA_DIR)
project "ocgcore"
kind "SharedLib"
cppdialect "C++14"
files { "*.cpp", "*.h" }
links { "lua" }
includedirs { LUA_DIR .. "/src" }
premake/lua.lua 0 → 100644
View file @ 287dd26c
project "lua"
kind "StaticLib"
compileas "C++"
files { "src/*.c", "src/*.h" }
removefiles { "src/lua.c", "src/luac.c", "src/linit.c", "src/onelua.c" }
filter "configurations:Debug"
defines { "LUA_USE_APICHECK" }
filter "system:bsd"
defines { "LUA_USE_POSIX" }
filter "system:macosx"
defines { "LUA_USE_MACOSX" }
filter "system:linux"
defines { "LUA_USE_LINUX" }
premake5.lua
View file @ 287dd26c
project "ocgcore"
kind "StaticLib"
cppdialect "C++14"
files { "*.cpp", "*.h" }
links { LUA_LIB_NAME }
if BUILD_LUA then
includedirs { "../lua/src" }
else
includedirs { LUA_INCLUDE_DIR }
libdirs { LUA_LIB_DIR }
end
filter "not action:vs*"
buildoptions { "-std=c++14" }
filter "system:bsd"
defines { "LUA_USE_POSIX" }
......
processor.cpp
View file @ 287dd26c
This source diff could not be displayed because it is too large. You can view the blob instead.
scriptlib.cpp
View file @ 287dd26c
......@@ -7,8 +7,9 @@
#include "scriptlib.h"
#include "duel.h"
static int32 check_data_type(lua_State* L, int32 index, const char* tname) {
int32 result = FALSE;
static int32_t check_data_type(lua_State* L, int32_t index, const char* tname) {
luaL_checkstack(L, 2, nullptr);
int32_t result = FALSE;
if(lua_getmetatable(L, index)) {
lua_getglobal(L, tname);
if(lua_rawequal(L, -1, -2))
......@@ -17,10 +18,11 @@ static int32 check_data_type(lua_State* L, int32 index, const char* tname) {
}
return result;
}
int32 scriptlib::check_param(lua_State* L, int32 param_type, int32 index, int32 retfalse) {
int32_t scriptlib::check_param(lua_State* L, int32_t param_type, int32_t index, int32_t retfalse) {
switch (param_type) {
case PARAM_TYPE_CARD: {
int32 result = FALSE;
luaL_checkstack(L, 1, nullptr);
int32_t result = FALSE;
if(lua_isuserdata(L, index) && lua_getmetatable(L, index)) {
result = check_data_type(L, -1, "Card");
lua_pop(L, 1);
......@@ -68,12 +70,12 @@ int32 scriptlib::check_param(lua_State* L, int32 param_type, int32 index, int32
return FALSE;
}
int32 scriptlib::check_param_count(lua_State* L, int32 count) {
int32_t scriptlib::check_param_count(lua_State* L, int32_t count) {
if (lua_gettop(L) < count)
return luaL_error(L, "%d Parameters are needed.", count);
return TRUE;
}
int32 scriptlib::check_action_permission(lua_State* L) {
int32_t scriptlib::check_action_permission(lua_State* L) {
duel* pduel = interpreter::get_duel_info(L);
if(pduel->lua->no_action)
return luaL_error(L, "Action is not allowed here.");
......
scriptlib.h
View file @ 287dd26c
......@@ -11,618 +11,658 @@
#include "common.h"
#include "interpreter.h"
constexpr bool match_all(uint32_t x, uint32_t y) {
return (x & y) == y;
}
class scriptlib {
public:
static int32 check_param(lua_State* L, int32 param_type, int32 index, BOOL retfalse = FALSE);
static int32 check_param_count(lua_State* L, int32 count);
static int32 check_action_permission(lua_State* L);
enum effect_member : int32_t {
MEMBER_CATEGORY,
MEMBER_CODE,
MEMBER_DESCRIPTION,
MEMBER_ID,
MEMBER_RANGE,
MEMBER_TYPE,
};
static int32_t check_param(lua_State* L, int32_t param_type, int32_t index, int32_t retfalse = FALSE);
static int32_t check_param_count(lua_State* L, int32_t count);
static int32_t check_action_permission(lua_State* L);
//card lib
static int32 card_get_code(lua_State *L);
static int32 card_get_origin_code(lua_State *L);
static int32 card_get_origin_code_rule(lua_State *L);
static int32 card_get_fusion_code(lua_State *L);
static int32 card_get_link_code(lua_State *L);
static int32 card_is_fusion_code(lua_State *L);
static int32 card_is_link_code(lua_State *L);
static int32 card_is_set_card(lua_State *L);
static int32 card_is_origin_set_card(lua_State *L);
static int32 card_is_pre_set_card(lua_State *L);
static int32 card_is_fusion_set_card(lua_State *L);
static int32 card_is_link_set_card(lua_State *L);
static int32 card_get_type(lua_State *L);
static int32 card_get_origin_type(lua_State *L);
static int32 card_get_fusion_type(lua_State *L);
static int32 card_get_synchro_type(lua_State *L);
static int32 card_get_xyz_type(lua_State *L);
static int32 card_get_link_type(lua_State *L);
static int32 card_get_level(lua_State *L);
static int32 card_get_rank(lua_State *L);
static int32 card_get_link(lua_State *L);
static int32 card_get_synchro_level(lua_State *L);
static int32 card_get_ritual_level(lua_State *L);
static int32 card_get_origin_level(lua_State *L);
static int32 card_get_origin_rank(lua_State *L);
static int32 card_is_xyz_level(lua_State *L);
static int32 card_get_lscale(lua_State *L);
static int32 card_get_origin_lscale(lua_State *L);
static int32 card_get_rscale(lua_State *L);
static int32 card_get_origin_rscale(lua_State *L);
static int32 card_get_current_scale(lua_State *L);
static int32 card_is_link_marker(lua_State *L);
static int32 card_get_linked_group(lua_State *L);
static int32 card_get_linked_group_count(lua_State *L);
static int32 card_get_linked_zone(lua_State *L);
static int32 card_get_mutual_linked_group(lua_State *L);
static int32 card_get_mutual_linked_group_count(lua_State *L);
static int32 card_get_mutual_linked_zone(lua_State *L);
static int32 card_is_link_state(lua_State *L);
static int32 card_is_extra_link_state(lua_State *L);
static int32 card_get_column_group(lua_State *L);
static int32 card_get_column_group_count(lua_State *L);
static int32 card_get_column_zone(lua_State *L);
static int32 card_is_all_column(lua_State *L);
static int32 card_get_attribute(lua_State *L);
static int32 card_get_origin_attribute(lua_State *L);
static int32 card_get_fusion_attribute(lua_State *L);
static int32 card_get_link_attribute(lua_State *L);
static int32 card_get_attribute_in_grave(lua_State *L);
static int32 card_get_race(lua_State *L);
static int32 card_get_origin_race(lua_State *L);
static int32 card_get_link_race(lua_State *L);
static int32 card_get_race_in_grave(lua_State *L);
static int32 card_get_attack(lua_State *L);
static int32 card_get_origin_attack(lua_State *L);
static int32 card_get_text_attack(lua_State *L);
static int32 card_get_defense(lua_State *L);
static int32 card_get_origin_defense(lua_State *L);
static int32 card_get_text_defense(lua_State *L);
static int32 card_get_previous_code_onfield(lua_State *L);
static int32 card_get_previous_type_onfield(lua_State *L);
static int32 card_get_previous_level_onfield(lua_State *L);
static int32 card_get_previous_rank_onfield(lua_State *L);
static int32 card_get_previous_attribute_onfield(lua_State *L);
static int32 card_get_previous_race_onfield(lua_State *L);
static int32 card_get_previous_attack_onfield(lua_State *L);
static int32 card_get_previous_defense_onfield(lua_State *L);
static int32 card_get_owner(lua_State *L);
static int32 card_get_controler(lua_State *L);
static int32 card_get_previous_controler(lua_State *L);
static int32 card_set_reason(lua_State *L);
static int32 card_get_reason(lua_State *L);
static int32 card_get_reason_card(lua_State *L);
static int32 card_get_reason_player(lua_State *L);
static int32 card_get_reason_effect(lua_State *L);
static int32 card_get_position(lua_State *L);
static int32 card_get_previous_position(lua_State *L);
static int32 card_get_battle_position(lua_State *L);
static int32 card_get_location(lua_State *L);
static int32 card_get_previous_location(lua_State *L);
static int32 card_get_sequence(lua_State *L);
static int32 card_get_previous_sequence(lua_State *L);
static int32 card_get_summon_type(lua_State *L);
static int32 card_get_summon_location(lua_State *L);
static int32 card_get_summon_player(lua_State *L);
static int32 card_get_destination(lua_State *L);
static int32 card_get_leave_field_dest(lua_State *L);
static int32 card_get_turnid(lua_State *L);
static int32 card_get_fieldid(lua_State *L);
static int32 card_get_fieldidr(lua_State *L);
static int32 card_is_origin_code_rule(lua_State *L);
static int32 card_is_code(lua_State *L);
static int32 card_is_type(lua_State *L);
static int32 card_is_fusion_type(lua_State *L);
static int32 card_is_synchro_type(lua_State *L);
static int32 card_is_xyz_type(lua_State *L);
static int32 card_is_link_type(lua_State *L);
static int32 card_is_level(lua_State *L);
static int32 card_is_rank(lua_State *L);
static int32 card_is_link(lua_State *L);
static int32 card_is_attack(lua_State *L);
static int32 card_is_defense(lua_State *L);
static int32 card_is_race(lua_State *L);
static int32 card_is_link_race(lua_State *L);
static int32 card_is_attribute(lua_State *L);
static int32 card_is_fusion_attribute(lua_State *L);
static int32 card_is_link_attribute(lua_State *L);
static int32 card_is_extra_deck_monster(lua_State *L);
static int32 card_is_reason(lua_State *L);
static int32 card_is_summon_type(lua_State *L);
static int32 card_is_summon_location(lua_State *L);
static int32 card_is_summon_player(lua_State *L);
static int32 card_is_status(lua_State *L);
static int32 card_is_not_tuner(lua_State *L);
static int32 card_set_status(lua_State *L);
static int32 card_is_dual_state(lua_State *L);
static int32 card_enable_dual_state(lua_State *L);
static int32 card_set_turn_counter(lua_State *L);
static int32 card_get_turn_counter(lua_State *L);
static int32 card_set_material(lua_State *L);
static int32 card_get_material(lua_State *L);
static int32 card_get_material_count(lua_State *L);
static int32 card_get_equip_group(lua_State *L);
static int32 card_get_equip_count(lua_State *L);
static int32 card_get_equip_target(lua_State *L);
static int32 card_get_pre_equip_target(lua_State *L);
static int32 card_check_equip_target(lua_State *L);
static int32 card_check_union_target(lua_State *L);
static int32 card_get_union_count(lua_State *L);
static int32 card_get_overlay_group(lua_State *L);
static int32 card_get_overlay_count(lua_State *L);
static int32 card_get_overlay_target(lua_State *L);
static int32 card_check_remove_overlay_card(lua_State *L);
static int32 card_remove_overlay_card(lua_State *L);
static int32 card_get_attacked_group(lua_State *L);
static int32 card_get_attacked_group_count(lua_State *L);
static int32 card_get_attacked_count(lua_State *L);
static int32 card_get_battled_group(lua_State *L);
static int32 card_get_battled_group_count(lua_State *L);
static int32 card_get_attack_announced_count(lua_State *L);
static int32 card_is_direct_attacked(lua_State *L);
static int32 card_set_card_target(lua_State *L);
static int32 card_get_card_target(lua_State *L);
static int32 card_get_first_card_target(lua_State *L);
static int32 card_get_card_target_count(lua_State *L);
static int32 card_is_has_card_target(lua_State *L);
static int32 card_cancel_card_target(lua_State *L);
static int32 card_get_owner_target(lua_State *L);
static int32 card_get_owner_target_count(lua_State *L);
static int32 card_get_activate_effect(lua_State *L);
static int32 card_check_activate_effect(lua_State *L);
static int32 card_get_tuner_limit(lua_State * L);
static int32 card_get_hand_synchro(lua_State * L);
static int32 card_register_effect(lua_State *L);
static int32 card_is_has_effect(lua_State *L);
static int32 card_reset_effect(lua_State *L);
static int32 card_get_effect_count(lua_State *L);
static int32 card_register_flag_effect(lua_State *L);
static int32 card_get_flag_effect(lua_State *L);
static int32 card_reset_flag_effect(lua_State *L);
static int32 card_set_flag_effect_label(lua_State *L);
static int32 card_get_flag_effect_label(lua_State *L);
static int32 card_create_relation(lua_State *L);
static int32 card_release_relation(lua_State *L);
static int32 card_create_effect_relation(lua_State *L);
static int32 card_release_effect_relation(lua_State *L);
static int32 card_clear_effect_relation(lua_State *L);
static int32 card_is_relate_to_effect(lua_State *L);
static int32 card_is_relate_to_chain(lua_State *L);
static int32 card_is_relate_to_card(lua_State *L);
static int32 card_is_relate_to_battle(lua_State *L);
static int32 card_copy_effect(lua_State *L);
static int32 card_replace_effect(lua_State *L);
static int32 card_enable_revive_limit(lua_State *L);
static int32 card_complete_procedure(lua_State *L);
static int32 card_is_disabled(lua_State *L);
static int32 card_is_destructable(lua_State *L);
static int32 card_is_summonable(lua_State *L);
static int32 card_is_special_summonable_card(lua_State *L);
static int32 card_is_fusion_summonable_card(lua_State *L);
static int32 card_is_msetable(lua_State *L);
static int32 card_is_ssetable(lua_State *L);
static int32 card_is_special_summonable(lua_State *L);
static int32 card_is_synchro_summonable(lua_State *L);
static int32 card_is_xyz_summonable(lua_State *L);
static int32 card_is_link_summonable(lua_State *L);
static int32 card_is_can_be_summoned(lua_State *L);
static int32 card_is_can_be_special_summoned(lua_State *L);
static int32 card_is_able_to_hand(lua_State *L);
static int32 card_is_able_to_grave(lua_State *L);
static int32 card_is_able_to_deck(lua_State *L);
static int32 card_is_able_to_extra(lua_State *L);
static int32 card_is_able_to_remove(lua_State *L);
static int32 card_is_able_to_hand_as_cost(lua_State *L);
static int32 card_is_able_to_grave_as_cost(lua_State *L);
static int32 card_is_able_to_deck_as_cost(lua_State *L);
static int32 card_is_able_to_extra_as_cost(lua_State *L);
static int32 card_is_able_to_deck_or_extra_as_cost(lua_State *L);
static int32 card_is_able_to_remove_as_cost(lua_State *L);
static int32 card_is_releasable(lua_State *L);
static int32 card_is_releasable_by_effect(lua_State *L);
static int32 card_is_discardable(lua_State *L);
static int32 card_is_attackable(lua_State *L);
static int32 card_is_chain_attackable(lua_State *L);
static int32 card_is_faceup(lua_State *L);
static int32 card_is_faceup_ex(lua_State *L);
static int32 card_is_attack_pos(lua_State *L);
static int32 card_is_facedown(lua_State *L);
static int32 card_is_defense_pos(lua_State *L);
static int32 card_is_position(lua_State *L);
static int32 card_is_pre_position(lua_State *L);
static int32 card_is_controler(lua_State *L);
static int32 card_is_pre_controler(lua_State *L);
static int32 card_is_onfield(lua_State *L);
static int32 card_is_location(lua_State *L);
static int32 card_is_pre_location(lua_State *L);
static int32 card_is_level_below(lua_State *L);
static int32 card_is_level_above(lua_State *L);
static int32 card_is_rank_below(lua_State *L);
static int32 card_is_rank_above(lua_State *L);
static int32 card_is_link_below(lua_State *L);
static int32 card_is_link_above(lua_State *L);
static int32 card_is_attack_below(lua_State *L);
static int32 card_is_attack_above(lua_State *L);
static int32 card_is_defense_below(lua_State *L);
static int32 card_is_defense_above(lua_State *L);
static int32 card_is_public(lua_State *L);
static int32 card_is_forbidden(lua_State *L);
static int32 card_is_able_to_change_controler(lua_State *L);
static int32 card_is_controler_can_be_changed(lua_State *L);
static int32 card_add_counter(lua_State *L);
static int32 card_remove_counter(lua_State *L);
static int32 card_get_counter(lua_State *L);
static int32 card_enable_counter_permit(lua_State *L);
static int32 card_set_counter_limit(lua_State *L);
static int32 card_is_can_change_position(lua_State *L);
static int32 card_is_can_turn_set(lua_State *L);
static int32 card_is_can_add_counter(lua_State *L);
static int32 card_is_can_remove_counter(lua_State *L);
static int32 card_is_can_have_counter(lua_State* L);
static int32 card_is_can_overlay(lua_State *L);
static int32 card_is_can_be_fusion_material(lua_State *L);
static int32 card_is_can_be_synchro_material(lua_State *L);
static int32 card_is_can_be_ritual_material(lua_State *L);
static int32 card_is_can_be_xyz_material(lua_State *L);
static int32 card_is_can_be_link_material(lua_State *L);
static int32 card_check_fusion_material(lua_State *L);
static int32 card_check_fusion_substitute(lua_State *L);
static int32 card_is_immune_to_effect(lua_State *L);
static int32 card_is_can_be_disabled_by_effect(lua_State* L);
static int32 card_is_can_be_effect_target(lua_State *L);
static int32 card_is_can_be_battle_target(lua_State *L);
static int32 card_add_monster_attribute(lua_State *L);
static int32 card_cancel_to_grave(lua_State *L);
static int32 card_get_tribute_requirement(lua_State *L);
static int32 card_get_battle_target(lua_State *L);
static int32 card_get_attackable_target(lua_State *L);
static int32 card_set_hint(lua_State *L);
static int32 card_reverse_in_deck(lua_State *L);
static int32 card_set_unique_onfield(lua_State *L);
static int32 card_check_unique_onfield(lua_State *L);
static int32 card_reset_negate_effect(lua_State *L);
static int32 card_assume_prop(lua_State *L);
static int32 card_set_spsummon_once(lua_State *L);
static int32_t card_get_code(lua_State *L);
static int32_t card_get_origin_code(lua_State *L);
static int32_t card_get_origin_code_rule(lua_State *L);
static int32_t card_get_fusion_code(lua_State *L);
static int32_t card_get_link_code(lua_State *L);
static int32_t card_is_fusion_code(lua_State *L);
static int32_t card_is_link_code(lua_State *L);
static int32_t card_is_set_card(lua_State *L);
static int32_t card_is_origin_set_card(lua_State *L);
static int32_t card_is_pre_set_card(lua_State *L);
static int32_t card_is_fusion_set_card(lua_State *L);
static int32_t card_is_link_set_card(lua_State *L);
static int32_t card_is_special_summon_set_card(lua_State *L);
static int32_t card_get_type(lua_State *L);
static int32_t card_get_origin_type(lua_State *L);
static int32_t card_get_fusion_type(lua_State *L);
static int32_t card_get_synchro_type(lua_State *L);
static int32_t card_get_xyz_type(lua_State *L);
static int32_t card_get_link_type(lua_State *L);
static int32_t card_get_level(lua_State *L);
static int32_t card_get_rank(lua_State *L);
static int32_t card_get_link(lua_State *L);
static int32_t card_get_synchro_level(lua_State *L);
static int32_t card_get_ritual_level(lua_State *L);
static int32_t card_get_origin_level(lua_State *L);
static int32_t card_get_origin_rank(lua_State *L);
static int32_t card_is_xyz_level(lua_State *L);
static int32_t card_get_lscale(lua_State *L);
static int32_t card_get_origin_lscale(lua_State *L);
static int32_t card_get_rscale(lua_State *L);
static int32_t card_get_origin_rscale(lua_State *L);
static int32_t card_get_current_scale(lua_State *L);
static int32_t card_is_link_marker(lua_State *L);
static int32_t card_get_linked_group(lua_State *L);
static int32_t card_get_linked_group_count(lua_State *L);
static int32_t card_get_linked_zone(lua_State *L);
static int32_t card_get_mutual_linked_group(lua_State *L);
static int32_t card_get_mutual_linked_group_count(lua_State *L);
static int32_t card_get_mutual_linked_zone(lua_State *L);
static int32_t card_is_link_state(lua_State *L);
static int32_t card_is_extra_link_state(lua_State *L);
static int32_t card_get_column_group(lua_State *L);
static int32_t card_get_column_group_count(lua_State *L);
static int32_t card_get_column_zone(lua_State *L);
static int32_t card_is_all_column(lua_State *L);
static int32_t card_get_attribute(lua_State *L);
static int32_t card_get_origin_attribute(lua_State *L);
static int32_t card_get_fusion_attribute(lua_State *L);
static int32_t card_get_link_attribute(lua_State *L);
static int32_t card_get_attribute_in_grave(lua_State *L);
static int32_t card_get_race(lua_State *L);
static int32_t card_get_origin_race(lua_State *L);
static int32_t card_get_link_race(lua_State *L);
static int32_t card_get_race_in_grave(lua_State *L);
static int32_t card_get_attack(lua_State *L);
static int32_t card_get_origin_attack(lua_State *L);
static int32_t card_get_text_attack(lua_State *L);
static int32_t card_get_defense(lua_State *L);
static int32_t card_get_origin_defense(lua_State *L);
static int32_t card_get_text_defense(lua_State *L);
static int32_t card_get_previous_code_onfield(lua_State *L);
static int32_t card_get_previous_type_onfield(lua_State *L);
static int32_t card_get_previous_level_onfield(lua_State *L);
static int32_t card_get_previous_rank_onfield(lua_State *L);
static int32_t card_get_previous_attribute_onfield(lua_State *L);
static int32_t card_get_previous_race_onfield(lua_State *L);
static int32_t card_get_previous_attack_onfield(lua_State *L);
static int32_t card_get_previous_defense_onfield(lua_State *L);
static int32_t card_get_previous_overlay_count_onfield(lua_State *L);
static int32_t card_get_owner(lua_State *L);
static int32_t card_get_controler(lua_State *L);
static int32_t card_get_previous_controler(lua_State *L);
static int32_t card_set_reason(lua_State *L);
static int32_t card_get_reason(lua_State *L);
static int32_t card_get_reason_card(lua_State *L);
static int32_t card_get_reason_player(lua_State *L);
static int32_t card_get_reason_effect(lua_State *L);
static int32_t card_get_position(lua_State *L);
static int32_t card_get_previous_position(lua_State *L);
static int32_t card_get_battle_position(lua_State *L);
static int32_t card_get_location(lua_State *L);
static int32_t card_get_previous_location(lua_State *L);
static int32_t card_get_sequence(lua_State *L);
static int32_t card_get_previous_sequence(lua_State *L);
static int32_t card_get_summon_type(lua_State *L);
static int32_t card_get_summon_location(lua_State *L);
static int32_t card_get_summon_player(lua_State *L);
static int32_t card_get_destination(lua_State *L);
static int32_t card_get_leave_field_dest(lua_State *L);
static int32_t card_get_turnid(lua_State *L);
static int32_t card_get_fieldid(lua_State *L);
static int32_t card_get_fieldidr(lua_State *L);
static int32_t card_is_origin_code_rule(lua_State *L);
static int32_t card_is_code(lua_State *L);
static int32_t card_is_type(lua_State *L);
static int32_t card_is_all_types(lua_State *L);
static int32_t card_is_fusion_type(lua_State *L);
static int32_t card_is_synchro_type(lua_State *L);
static int32_t card_is_xyz_type(lua_State *L);
static int32_t card_is_link_type(lua_State *L);
static int32_t card_is_level(lua_State *L);
static int32_t card_is_rank(lua_State *L);
static int32_t card_is_link(lua_State *L);
static int32_t card_is_attack(lua_State *L);
static int32_t card_is_defense(lua_State *L);
static int32_t card_is_race(lua_State *L);
static int32_t card_is_link_race(lua_State *L);
static int32_t card_is_attribute(lua_State *L);
static int32_t card_is_fusion_attribute(lua_State *L);
static int32_t card_is_link_attribute(lua_State *L);
static int32_t card_is_non_attribute(lua_State *L);
static int32_t card_is_extra_deck_monster(lua_State *L);
static int32_t card_is_reason(lua_State *L);
static int32_t card_is_all_reasons(lua_State *L);
static int32_t card_is_summon_type(lua_State *L);
static int32_t card_is_summon_location(lua_State *L);
static int32_t card_is_summon_player(lua_State *L);
static int32_t card_get_special_summon_info(lua_State *L);
static int32_t card_is_status(lua_State *L);
static int32_t card_is_not_tuner(lua_State *L);
static int32_t card_is_tuner(lua_State* L);
static int32_t card_is_original_effect_property(lua_State* L);
static int32_t card_is_effect_property(lua_State* L);
static int32_t card_set_status(lua_State *L);
static int32_t card_is_dual_state(lua_State *L);
static int32_t card_enable_dual_state(lua_State *L);
static int32_t card_set_turn_counter(lua_State *L);
static int32_t card_get_turn_counter(lua_State *L);
static int32_t card_set_material(lua_State *L);
static int32_t card_get_material(lua_State *L);
static int32_t card_get_material_count(lua_State *L);
static int32_t card_get_equip_group(lua_State *L);
static int32_t card_get_equip_count(lua_State *L);
static int32_t card_get_equip_target(lua_State *L);
static int32_t card_get_pre_equip_target(lua_State *L);
static int32_t card_check_equip_target(lua_State *L);
static int32_t card_check_union_target(lua_State *L);
static int32_t card_get_union_count(lua_State *L);
static int32_t card_get_overlay_group(lua_State *L);
static int32_t card_get_overlay_count(lua_State *L);
static int32_t card_get_overlay_target(lua_State *L);
static int32_t card_check_remove_overlay_card(lua_State *L);
static int32_t card_remove_overlay_card(lua_State *L);
static int32_t card_get_attacked_group(lua_State *L);
static int32_t card_get_attacked_group_count(lua_State *L);
static int32_t card_get_attacked_count(lua_State *L);
static int32_t card_get_battled_group(lua_State *L);
static int32_t card_get_battled_group_count(lua_State *L);
static int32_t card_get_attack_announced_count(lua_State *L);
static int32_t card_is_direct_attacked(lua_State *L);
static int32_t card_set_card_target(lua_State *L);
static int32_t card_get_card_target(lua_State *L);
static int32_t card_get_first_card_target(lua_State *L);
static int32_t card_get_card_target_count(lua_State *L);
static int32_t card_is_has_card_target(lua_State *L);
static int32_t card_cancel_card_target(lua_State *L);
static int32_t card_get_owner_target(lua_State *L);
static int32_t card_get_owner_target_count(lua_State *L);
static int32_t card_get_activate_effect(lua_State *L);
static int32_t card_check_activate_effect(lua_State *L);
static int32_t card_get_tuner_limit(lua_State * L);
static int32_t card_get_hand_synchro(lua_State * L);
static int32_t card_register_effect(lua_State *L);
static int32_t card_is_has_effect(lua_State *L);
static int32_t card_reset_effect(lua_State *L);
static int32_t card_get_effect_count(lua_State *L);
static int32_t card_register_flag_effect(lua_State *L);
static int32_t card_get_flag_effect(lua_State *L);
static int32_t card_reset_flag_effect(lua_State *L);
static int32_t card_set_flag_effect_label(lua_State *L);
static int32_t card_get_flag_effect_label(lua_State *L);
static int32_t card_create_relation(lua_State *L);
static int32_t card_release_relation(lua_State *L);
static int32_t card_create_effect_relation(lua_State *L);
static int32_t card_release_effect_relation(lua_State *L);
static int32_t card_clear_effect_relation(lua_State *L);
static int32_t card_is_relate_to_effect(lua_State *L);
static int32_t card_is_relate_to_chain(lua_State *L);
static int32_t card_is_relate_to_card(lua_State *L);
static int32_t card_is_relate_to_battle(lua_State *L);
static int32_t card_copy_effect(lua_State *L);
static int32_t card_replace_effect(lua_State *L);
static int32_t card_enable_revive_limit(lua_State *L);
static int32_t card_complete_procedure(lua_State *L);
static int32_t card_is_disabled(lua_State *L);
static int32_t card_is_destructable(lua_State *L);
static int32_t card_is_summonable(lua_State *L);
static int32_t card_is_special_summonable_card(lua_State *L);
static int32_t card_is_fusion_summonable_card(lua_State *L);
static int32_t card_is_msetable(lua_State *L);
static int32_t card_is_ssetable(lua_State *L);
static int32_t card_is_special_summonable(lua_State *L);
static int32_t card_is_synchro_summonable(lua_State *L);
static int32_t card_is_xyz_summonable(lua_State *L);
static int32_t card_is_link_summonable(lua_State *L);
static int32_t card_is_can_be_summoned(lua_State *L);
static int32_t card_is_can_be_special_summoned(lua_State *L);
static int32_t card_is_can_be_placed_on_field(lua_State *L);
static int32_t card_is_able_to_hand(lua_State *L);
static int32_t card_is_able_to_grave(lua_State *L);
static int32_t card_is_able_to_deck(lua_State *L);
static int32_t card_is_able_to_extra(lua_State *L);
static int32_t card_is_able_to_remove(lua_State *L);
static int32_t card_is_able_to_hand_as_cost(lua_State *L);
static int32_t card_is_able_to_grave_as_cost(lua_State *L);
static int32_t card_is_able_to_deck_as_cost(lua_State *L);
static int32_t card_is_able_to_extra_as_cost(lua_State *L);
static int32_t card_is_able_to_deck_or_extra_as_cost(lua_State *L);
static int32_t card_is_able_to_remove_as_cost(lua_State *L);
static int32_t card_is_releasable(lua_State *L);
static int32_t card_is_releasable_by_effect(lua_State *L);
static int32_t card_is_discardable(lua_State *L);
static int32_t card_is_attackable(lua_State *L);
static int32_t card_is_chain_attackable(lua_State *L);
static int32_t card_is_faceup(lua_State *L);
static int32_t card_is_faceup_ex(lua_State *L);
static int32_t card_is_attack_pos(lua_State *L);
static int32_t card_is_facedown(lua_State *L);
static int32_t card_is_defense_pos(lua_State *L);
static int32_t card_is_position(lua_State *L);
static int32_t card_is_pre_position(lua_State *L);
static int32_t card_is_controler(lua_State *L);
static int32_t card_is_pre_controler(lua_State *L);
static int32_t card_is_onfield(lua_State *L);
static int32_t card_is_location(lua_State *L);
static int32_t card_is_pre_location(lua_State *L);
static int32_t card_is_level_below(lua_State *L);
static int32_t card_is_level_above(lua_State *L);
static int32_t card_is_rank_below(lua_State *L);
static int32_t card_is_rank_above(lua_State *L);
static int32_t card_is_link_below(lua_State *L);
static int32_t card_is_link_above(lua_State *L);
static int32_t card_is_attack_below(lua_State *L);
static int32_t card_is_attack_above(lua_State *L);
static int32_t card_is_defense_below(lua_State *L);
static int32_t card_is_defense_above(lua_State *L);
static int32_t card_is_has_level(lua_State *L);
static int32_t card_is_has_defense(lua_State *L);
static int32_t card_is_public(lua_State *L);
static int32_t card_is_forbidden(lua_State *L);
static int32_t card_is_able_to_change_controler(lua_State *L);
static int32_t card_is_controler_can_be_changed(lua_State *L);
static int32_t card_add_counter(lua_State *L);
static int32_t card_remove_counter(lua_State *L);
static int32_t card_get_counter(lua_State *L);
static int32_t card_enable_counter_permit(lua_State *L);
static int32_t card_set_counter_limit(lua_State *L);
static int32_t card_is_can_change_position(lua_State *L);
static int32_t card_is_can_turn_set(lua_State *L);
static int32_t card_is_can_add_counter(lua_State *L);
static int32_t card_is_can_remove_counter(lua_State *L);
static int32_t card_is_can_have_counter(lua_State* L);
static int32_t card_is_can_overlay(lua_State *L);
static int32_t card_is_can_be_fusion_material(lua_State *L);
static int32_t card_is_can_be_synchro_material(lua_State *L);
static int32_t card_is_can_be_ritual_material(lua_State *L);
static int32_t card_is_can_be_xyz_material(lua_State *L);
static int32_t card_is_can_be_link_material(lua_State *L);
static int32_t card_check_fusion_material(lua_State *L);
static int32_t card_check_fusion_substitute(lua_State *L);
static int32_t card_is_immune_to_effect(lua_State *L);
static int32_t card_is_can_be_disabled_by_effect(lua_State* L);
static int32_t card_is_can_be_effect_target(lua_State *L);
static int32_t card_is_can_be_battle_target(lua_State *L);
static int32_t card_add_monster_attribute(lua_State *L);
static int32_t card_cancel_to_grave(lua_State *L);
static int32_t card_get_tribute_requirement(lua_State *L);
static int32_t card_get_battle_target(lua_State *L);
static int32_t card_get_attackable_target(lua_State *L);
static int32_t card_set_hint(lua_State *L);
static int32_t card_reverse_in_deck(lua_State *L);
static int32_t card_set_unique_onfield(lua_State *L);
static int32_t card_check_unique_onfield(lua_State *L);
static int32_t card_reset_negate_effect(lua_State *L);
static int32_t card_assume_prop(lua_State *L);
static int32_t card_set_spsummon_once(lua_State *L);
static void open_cardlib(lua_State *L);
//Effect functions
static int32 effect_new(lua_State *L);
static int32 effect_newex(lua_State *L);
static int32 effect_clone(lua_State *L);
static int32 effect_reset(lua_State *L);
static int32 effect_get_field_id(lua_State *L);
static int32 effect_set_description(lua_State *L);
static int32 effect_set_code(lua_State *L);
static int32 effect_set_range(lua_State *L);
static int32 effect_set_target_range(lua_State *L);
static int32 effect_set_absolute_range(lua_State *L);
static int32 effect_set_count_limit(lua_State *L);
static int32 effect_set_reset(lua_State *L);
static int32 effect_set_type(lua_State *L);
static int32 effect_set_property(lua_State *L);
static int32 effect_set_label(lua_State *L);
static int32 effect_set_label_object(lua_State *L);
static int32 effect_set_category(lua_State *L);
static int32 effect_set_hint_timing(lua_State *L);
static int32 effect_set_condition(lua_State *L);
static int32 effect_set_target(lua_State *L);
static int32 effect_set_cost(lua_State *L);
static int32 effect_set_value(lua_State *L);
static int32 effect_set_operation(lua_State *L);
static int32 effect_set_owner_player(lua_State *L);
static int32 effect_get_description(lua_State *L);
static int32 effect_get_code(lua_State *L);
static int32 effect_get_type(lua_State *L);
static int32 effect_get_property(lua_State *L);
static int32 effect_get_label(lua_State *L);
static int32 effect_get_label_object(lua_State *L);
static int32 effect_get_category(lua_State *L);
static int32 effect_get_owner(lua_State *L);
static int32 effect_get_handler(lua_State *L);
static int32 effect_get_owner_player(lua_State *L);
static int32 effect_get_handler_player(lua_State *L);
static int32 effect_get_condition(lua_State *L);
static int32 effect_get_target(lua_State *L);
static int32 effect_get_cost(lua_State *L);
static int32 effect_get_value(lua_State *L);
static int32 effect_get_operation(lua_State *L);
static int32 effect_get_active_type(lua_State *L);
static int32 effect_is_active_type(lua_State *L);
static int32 effect_is_has_property(lua_State *L);
static int32 effect_is_has_category(lua_State *L);
static int32 effect_is_has_type(lua_State *L);
static int32 effect_is_activatable(lua_State *L);
static int32 effect_is_activated(lua_State *L);
static int32 effect_is_cost_checked(lua_State *L);
static int32 effect_set_cost_check(lua_State *L);
static int32 effect_get_activate_location(lua_State *L);
static int32 effect_get_activate_sequence(lua_State *L);
static int32 effect_check_count_limit(lua_State *L);
static int32 effect_use_count_limit(lua_State *L);
static int32_t get_effect_property(lua_State* L, effect_member type);
static int32_t is_effect_has_property(lua_State* L, effect_member type);
static int32_t effect_new(lua_State *L);
static int32_t effect_newex(lua_State *L);
static int32_t effect_clone(lua_State *L);
static int32_t effect_reset(lua_State *L);
static int32_t effect_get_field_id(lua_State *L);
static int32_t effect_set_description(lua_State *L);
static int32_t effect_set_code(lua_State *L);
static int32_t effect_set_range(lua_State *L);
static int32_t effect_set_target_range(lua_State *L);
static int32_t effect_set_absolute_range(lua_State *L);
static int32_t effect_set_count_limit(lua_State *L);
static int32_t effect_set_reset(lua_State *L);
static int32_t effect_set_type(lua_State *L);
static int32_t effect_set_property(lua_State *L);
static int32_t effect_set_label(lua_State *L);
static int32_t effect_set_label_object(lua_State *L);
static int32_t effect_set_category(lua_State *L);
static int32_t effect_set_hint_timing(lua_State *L);
static int32_t effect_set_condition(lua_State *L);
static int32_t effect_set_target(lua_State *L);
static int32_t effect_set_cost(lua_State *L);
static int32_t effect_set_value(lua_State *L);
static int32_t effect_set_operation(lua_State *L);
static int32_t effect_set_owner_player(lua_State *L);
static int32_t effect_get_description(lua_State *L);
static int32_t effect_get_code(lua_State *L);
static int32_t effect_get_type(lua_State *L);
static int32_t effect_get_property(lua_State *L);
static int32_t effect_get_label(lua_State *L);
static int32_t effect_get_label_object(lua_State *L);
static int32_t effect_get_category(lua_State *L);
static int32_t effect_get_range(lua_State* L);
static int32_t effect_get_owner(lua_State *L);
static int32_t effect_get_handler(lua_State *L);
static int32_t effect_get_owner_player(lua_State *L);
static int32_t effect_get_handler_player(lua_State *L);
static int32_t effect_get_condition(lua_State *L);
static int32_t effect_get_target(lua_State *L);
static int32_t effect_get_cost(lua_State *L);
static int32_t effect_get_value(lua_State *L);
static int32_t effect_get_operation(lua_State *L);
static int32_t effect_get_active_type(lua_State *L);
static int32_t effect_is_active_type(lua_State *L);
static int32_t effect_is_has_property(lua_State *L);
static int32_t effect_is_has_category(lua_State *L);
static int32_t effect_is_has_range(lua_State* L);
static int32_t effect_is_has_type(lua_State *L);
static int32_t effect_is_activatable(lua_State *L);
static int32_t effect_is_activated(lua_State *L);
static int32_t effect_is_cost_checked(lua_State *L);
static int32_t effect_set_cost_check(lua_State *L);
static int32_t effect_get_activate_location(lua_State *L);
static int32_t effect_get_activate_sequence(lua_State *L);
static int32_t effect_check_count_limit(lua_State *L);
static int32_t effect_use_count_limit(lua_State *L);
static void open_effectlib(lua_State *L);
//Group functions
static int32 group_new(lua_State *L);
static int32 group_clone(lua_State *L);
static int32 group_from_cards(lua_State *L);
static int32 group_delete(lua_State *L);
static int32 group_keep_alive(lua_State *L);
static int32 group_clear(lua_State *L);
static int32 group_add_card(lua_State *L);
static int32 group_remove_card(lua_State *L);
static int32 group_get_next(lua_State *L);
static int32 group_get_first(lua_State *L);
static int32 group_get_count(lua_State *L);
static int32 group_for_each(lua_State *L);
static int32 group_filter(lua_State *L);
static int32 group_filter_count(lua_State *L);
static int32 group_filter_select(lua_State *L);
static int32 group_select(lua_State *L);
static int32 group_select_unselect(lua_State *L);
static int32 group_random_select(lua_State *L);
static int32 group_is_exists(lua_State *L);
static int32 group_check_with_sum_equal(lua_State *L);
static int32 group_select_with_sum_equal(lua_State *L);
static int32 group_check_with_sum_greater(lua_State *L);
static int32 group_select_with_sum_greater(lua_State *L);
static int32 group_get_min_group(lua_State *L);
static int32 group_get_max_group(lua_State *L);
static int32 group_get_sum(lua_State *L);
static int32 group_get_class_count(lua_State *L);
static int32 group_remove(lua_State *L);
static int32 group_merge(lua_State *L);
static int32 group_sub(lua_State *L);
static int32 group_equal(lua_State *L);
static int32 group_is_contains(lua_State *L);
static int32 group_search_card(lua_State *L);
static int32 group_get_bin_class_count(lua_State *L);
static int32_t group_new(lua_State *L);
static int32_t group_clone(lua_State *L);
static int32_t group_from_cards(lua_State *L);
static int32_t group_delete(lua_State *L);
static int32_t group_keep_alive(lua_State *L);
static int32_t group_clear(lua_State *L);
static int32_t group_add_card(lua_State *L);
static int32_t group_remove_card(lua_State *L);
static int32_t group_get_next(lua_State *L);
static int32_t group_get_first(lua_State *L);
static int32_t group_get_count(lua_State *L);
static int32_t group_filter(lua_State *L);
static int32_t group_filter_count(lua_State *L);
static int32_t group_filter_select(lua_State *L);
static int32_t group_select(lua_State *L);
static int32_t group_select_unselect(lua_State *L);
static int32_t group_random_select(lua_State *L);
static int32_t group_cancelable_select(lua_State *L);
static int32_t group_is_exists(lua_State *L);
static int32_t group_check_with_sum_equal(lua_State *L);
static int32_t group_select_with_sum_equal(lua_State *L);
static int32_t group_check_with_sum_greater(lua_State *L);
static int32_t group_select_with_sum_greater(lua_State *L);
static int32_t group_get_min_group(lua_State *L);
static int32_t group_get_max_group(lua_State *L);
static int32_t group_get_sum(lua_State *L);
static int32_t group_get_class_count(lua_State *L);
static int32_t group_remove(lua_State *L);
static int32_t group_merge(lua_State *L);
static int32_t group_sub(lua_State *L);
static int32_t group_equal(lua_State *L);
static int32_t group_is_contains(lua_State *L);
static int32_t group_search_card(lua_State *L);
static int32_t group_get_bin_class_count(lua_State *L);
static void open_grouplib(lua_State *L);
//Duel functions
static int32 duel_enable_global_flag(lua_State *L);
static int32 duel_get_lp(lua_State *L);
static int32 duel_set_lp(lua_State *L);
static int32 duel_get_turn_player(lua_State *L);
static int32 duel_get_turn_count(lua_State *L);
static int32 duel_get_draw_count(lua_State *L);
static int32 duel_register_effect(lua_State *L);
static int32 duel_register_flag_effect(lua_State *L);
static int32 duel_get_flag_effect(lua_State *L);
static int32 duel_reset_flag_effect(lua_State *L);
static int32 duel_set_flag_effect_label(lua_State *L);
static int32 duel_get_flag_effect_label(lua_State *L);
static int32 duel_destroy(lua_State *L);
static int32 duel_remove(lua_State *L);
static int32 duel_sendto_grave(lua_State *L);
static int32 duel_summon(lua_State *L);
static int32 duel_special_summon_rule(lua_State *L);
static int32 duel_synchro_summon(lua_State *L);
static int32 duel_xyz_summon(lua_State *L);
static int32 duel_link_summon(lua_State *L);
static int32 duel_setm(lua_State *L);
static int32 duel_sets(lua_State *L);
static int32 duel_create_token(lua_State *L);
static int32 duel_special_summon(lua_State *L);
static int32 duel_special_summon_step(lua_State *L);
static int32 duel_special_summon_complete(lua_State *L);
static int32 duel_sendto_hand(lua_State *L);
static int32 duel_sendto_deck(lua_State *L);
static int32 duel_sendto_extra(lua_State *L);
static int32 duel_get_operated_group(lua_State *L);
static int32 duel_is_can_add_counter(lua_State *L);
static int32 duel_remove_counter(lua_State *L);
static int32 duel_is_can_remove_counter(lua_State *L);
static int32 duel_get_counter(lua_State *L);
static int32 duel_change_form(lua_State *L);
static int32 duel_release(lua_State *L);
static int32 duel_move_to_field(lua_State *L);
static int32 duel_return_to_field(lua_State *L);
static int32 duel_move_sequence(lua_State *L);
static int32 duel_swap_sequence(lua_State *L);
static int32 duel_activate_effect(lua_State *L);
static int32 duel_set_chain_limit(lua_State *L);
static int32 duel_set_chain_limit_p(lua_State *L);
static int32 duel_get_chain_material(lua_State *L);
static int32 duel_confirm_decktop(lua_State *L);
static int32 duel_confirm_extratop(lua_State *L);
static int32 duel_confirm_cards(lua_State *L);
static int32 duel_sort_decktop(lua_State *L);
static int32 duel_check_event(lua_State *L);
static int32 duel_raise_event(lua_State *L);
static int32 duel_raise_single_event(lua_State *L);
static int32 duel_check_timing(lua_State *L);
static int32 duel_is_environment(lua_State *L);
static int32_t duel_enable_global_flag(lua_State *L);
static int32_t duel_get_lp(lua_State *L);
static int32_t duel_set_lp(lua_State *L);
static int32_t duel_is_turn_player(lua_State *L);
static int32_t duel_get_turn_player(lua_State *L);
static int32_t duel_get_turn_count(lua_State *L);
static int32_t duel_get_draw_count(lua_State *L);
static int32_t duel_register_effect(lua_State *L);
static int32_t duel_register_flag_effect(lua_State *L);
static int32_t duel_get_flag_effect(lua_State *L);
static int32_t duel_reset_flag_effect(lua_State *L);
static int32_t duel_set_flag_effect_label(lua_State *L);
static int32_t duel_get_flag_effect_label(lua_State *L);
static int32_t duel_destroy(lua_State *L);
static int32_t duel_remove(lua_State *L);
static int32_t duel_sendto_grave(lua_State *L);
static int32_t duel_summon(lua_State *L);
static int32_t duel_special_summon_rule(lua_State *L);
static int32_t duel_synchro_summon(lua_State *L);
static int32_t duel_xyz_summon(lua_State *L);
static int32_t duel_link_summon(lua_State *L);
static int32_t duel_setm(lua_State *L);
static int32_t duel_sets(lua_State *L);
static int32_t duel_create_token(lua_State *L);
static int32_t duel_special_summon(lua_State *L);
static int32_t duel_special_summon_step(lua_State *L);
static int32_t duel_special_summon_complete(lua_State *L);
static int32_t duel_sendto_hand(lua_State *L);
static int32_t duel_sendto_deck(lua_State *L);
static int32_t duel_sendto_extra(lua_State *L);
static int32_t duel_get_operated_group(lua_State *L);
static int32_t duel_is_can_add_counter(lua_State *L);
static int32_t duel_remove_counter(lua_State *L);
static int32_t duel_is_can_remove_counter(lua_State *L);
static int32_t duel_get_counter(lua_State *L);
static int32_t duel_change_form(lua_State *L);
static int32_t duel_release(lua_State *L);
static int32_t duel_move_to_field(lua_State *L);
static int32_t duel_return_to_field(lua_State *L);
static int32_t duel_move_sequence(lua_State *L);
static int32_t duel_swap_sequence(lua_State *L);
static int32_t duel_activate_effect(lua_State *L);
static int32_t duel_set_chain_limit(lua_State *L);
static int32_t duel_set_chain_limit_p(lua_State *L);
static int32_t duel_get_chain_material(lua_State *L);
static int32_t duel_confirm_decktop(lua_State *L);
static int32_t duel_confirm_extratop(lua_State *L);
static int32_t duel_confirm_cards(lua_State *L);
static int32_t duel_sort_decktop(lua_State *L);
static int32_t duel_check_event(lua_State *L);
static int32_t duel_raise_event(lua_State *L);
static int32_t duel_raise_single_event(lua_State *L);
static int32_t duel_check_timing(lua_State *L);
static int32_t duel_is_environment(lua_State *L);
static int32 duel_win(lua_State *L);
static int32 duel_draw(lua_State *L);
static int32 duel_damage(lua_State *L);
static int32 duel_recover(lua_State *L);
static int32 duel_rd_complete(lua_State *L);
static int32 duel_equip(lua_State *L);
static int32 duel_equip_complete(lua_State *L);
static int32 duel_get_control(lua_State *L);
static int32 duel_swap_control(lua_State *L);
static int32 duel_check_lp_cost(lua_State *L);
static int32 duel_pay_lp_cost(lua_State *L);
static int32 duel_discard_deck(lua_State *L);
static int32 duel_discard_hand(lua_State *L);
static int32 duel_disable_shuffle_check(lua_State *L);
static int32 duel_disable_self_destroy_check(lua_State *L);
static int32 duel_shuffle_deck(lua_State *L);
static int32 duel_shuffle_extra(lua_State *L);
static int32 duel_shuffle_hand(lua_State *L);
static int32 duel_shuffle_setcard(lua_State *L);
static int32 duel_change_attacker(lua_State *L);
static int32 duel_change_attack_target(lua_State *L);
static int32 duel_calculate_damage(lua_State *L);
static int32 duel_get_battle_damage(lua_State *L);
static int32 duel_change_battle_damage(lua_State *L);
static int32 duel_change_target(lua_State *L);
static int32 duel_change_target_player(lua_State *L);
static int32 duel_change_target_param(lua_State *L);
static int32 duel_break_effect(lua_State *L);
static int32 duel_change_effect(lua_State *L);
static int32 duel_negate_activate(lua_State *L);
static int32 duel_negate_effect(lua_State *L);
static int32 duel_negate_related_chain(lua_State *L);
static int32 duel_disable_summon(lua_State *L);
static int32 duel_increase_summon_count(lua_State *L);
static int32 duel_check_summon_count(lua_State *L);
static int32 duel_get_location_count(lua_State *L);
static int32 duel_get_mzone_count(lua_State *L);
static int32 duel_get_location_count_fromex(lua_State *L);
static int32 duel_get_usable_mzone_count(lua_State *L);
static int32 duel_get_linked_group(lua_State *L);
static int32 duel_get_linked_group_count(lua_State *L);
static int32 duel_get_linked_zone(lua_State *L);
static int32 duel_get_field_card(lua_State *L);
static int32 duel_check_location(lua_State *L);
static int32 duel_get_current_chain(lua_State *L);
static int32 duel_get_chain_info(lua_State *L);
static int32 duel_get_chain_event(lua_State *L);
static int32 duel_get_first_target(lua_State *L);
static int32 duel_get_targets_relate_to_chain(lua_State *L);
static int32 duel_get_current_phase(lua_State *L);
static int32 duel_skip_phase(lua_State *L);
static int32 duel_is_damage_calculated(lua_State *L);
static int32 duel_get_attacker(lua_State *L);
static int32 duel_get_attack_target(lua_State* L);
static int32 duel_get_battle_monster(lua_State* L);
static int32 duel_disable_attack(lua_State *L);
static int32 duel_chain_attack(lua_State *L);
static int32 duel_readjust(lua_State *L);
static int32 duel_adjust_instantly(lua_State *L);
static int32 duel_adjust_all(lua_State *L);
static int32_t duel_win(lua_State *L);
static int32_t duel_draw(lua_State *L);
static int32_t duel_damage(lua_State *L);
static int32_t duel_recover(lua_State *L);
static int32_t duel_rd_complete(lua_State *L);
static int32_t duel_equip(lua_State *L);
static int32_t duel_equip_complete(lua_State *L);
static int32_t duel_get_control(lua_State *L);
static int32_t duel_swap_control(lua_State *L);
static int32_t duel_check_lp_cost(lua_State *L);
static int32_t duel_pay_lp_cost(lua_State *L);
static int32_t duel_discard_deck(lua_State *L);
static int32_t duel_discard_hand(lua_State *L);
static int32_t duel_disable_shuffle_check(lua_State *L);
static int32_t duel_disable_self_destroy_check(lua_State *L);
static int32_t duel_reveal_select_deck_sequence(lua_State *L);
static int32_t duel_shuffle_deck(lua_State *L);
static int32_t duel_shuffle_extra(lua_State *L);
static int32_t duel_shuffle_hand(lua_State *L);
static int32_t duel_shuffle_setcard(lua_State *L);
static int32_t duel_change_attacker(lua_State *L);
static int32_t duel_change_attack_target(lua_State *L);
static int32_t duel_calculate_damage(lua_State *L);
static int32_t duel_get_battle_damage(lua_State *L);
static int32_t duel_change_battle_damage(lua_State *L);
static int32_t duel_change_target(lua_State *L);
static int32_t duel_change_target_player(lua_State *L);
static int32_t duel_change_target_param(lua_State *L);
static int32_t duel_break_effect(lua_State *L);
static int32_t duel_change_effect(lua_State *L);
static int32_t duel_negate_activate(lua_State *L);
static int32_t duel_negate_effect(lua_State *L);
static int32_t duel_negate_related_chain(lua_State *L);
static int32_t duel_disable_summon(lua_State *L);
static int32_t duel_increase_summon_count(lua_State *L);
static int32_t duel_check_summon_count(lua_State *L);
static int32_t duel_get_location_count(lua_State *L);
static int32_t duel_get_mzone_count(lua_State *L);
static int32_t duel_get_szone_count(lua_State *L);
static int32_t duel_get_location_count_fromex(lua_State *L);
static int32_t duel_get_usable_mzone_count(lua_State *L);
static int32_t duel_get_linked_group(lua_State *L);
static int32_t duel_get_linked_group_count(lua_State *L);
static int32_t duel_get_linked_zone(lua_State *L);
static int32_t duel_get_field_card(lua_State *L);
static int32_t duel_check_location(lua_State *L);
static int32_t duel_get_current_chain(lua_State *L);
static int32_t duel_get_ready_chain(lua_State* L);
static int32_t duel_get_chain_info(lua_State *L);
static int32_t duel_get_chain_event(lua_State *L);
static int32_t duel_get_first_target(lua_State *L);
static int32_t duel_get_targets_relate_to_chain(lua_State *L);
static int32_t duel_is_phase(lua_State *L);
static int32_t duel_is_main_phase(lua_State *L);
static int32_t duel_is_battle_phase(lua_State *L);
static int32_t duel_get_current_phase(lua_State *L);
static int32_t duel_skip_phase(lua_State *L);
static int32_t duel_is_damage_calculated(lua_State *L);
static int32_t duel_get_attacker(lua_State *L);
static int32_t duel_get_attack_target(lua_State* L);
static int32_t duel_get_battle_monster(lua_State* L);
static int32_t duel_disable_attack(lua_State *L);
static int32_t duel_chain_attack(lua_State *L);
static int32_t duel_readjust(lua_State *L);
static int32_t duel_adjust_instantly(lua_State *L);
static int32_t duel_adjust_all(lua_State *L);
static int32 duel_get_field_group(lua_State *L);
static int32 duel_get_field_group_count(lua_State *L);
static int32 duel_get_decktop_group(lua_State *L);
static int32 duel_get_extratop_group(lua_State *L);
static int32 duel_get_matching_group(lua_State *L);
static int32 duel_get_matching_count(lua_State *L);
static int32 duel_get_first_matching_card(lua_State *L);
static int32 duel_is_existing_matching_card(lua_State *L);
static int32 duel_select_matching_cards(lua_State *L);
static int32 duel_get_release_group(lua_State *L);
static int32 duel_get_release_group_count(lua_State *L);
static int32 duel_check_release_group(lua_State *L);
static int32 duel_select_release_group(lua_State *L);
static int32 duel_check_release_group_ex(lua_State *L);
static int32 duel_select_release_group_ex(lua_State *L);
static int32 duel_get_tribute_group(lua_State *L);
static int32 duel_get_tribute_count(lua_State *L);
static int32 duel_check_tribute(lua_State *L);
static int32 duel_select_tribute(lua_State *L);
static int32 duel_get_target_count(lua_State *L);
static int32 duel_is_existing_target(lua_State *L);
static int32 duel_select_target(lua_State *L);
static int32 duel_select_fusion_material(lua_State *L);
static int32 duel_set_fusion_material(lua_State *L);
static int32 duel_set_synchro_material(lua_State *L);
static int32 duel_select_synchro_material(lua_State *L);
static int32 duel_check_synchro_material(lua_State *L);
static int32 duel_select_tuner_material(lua_State *L);
static int32 duel_check_tuner_material(lua_State *L);
static int32 duel_get_ritual_material(lua_State *L);
static int32 duel_get_ritual_material_ex(lua_State *L);
static int32 duel_release_ritual_material(lua_State *L);
static int32 duel_get_fusion_material(lua_State *L);
static int32 duel_is_summon_cancelable(lua_State *L);
static int32 duel_set_must_select_cards(lua_State *L);
static int32 duel_grab_must_select_cards(lua_State *L);
static int32 duel_set_target_card(lua_State *L);
static int32 duel_clear_target_card(lua_State *L);
static int32 duel_set_target_player(lua_State *L);
static int32 duel_set_target_param(lua_State *L);
static int32 duel_set_operation_info(lua_State *L);
static int32 duel_get_operation_info(lua_State *L);
static int32 duel_get_operation_count(lua_State *L);
static int32 duel_clear_operation_info(lua_State *L);
static int32 duel_check_xyz_material(lua_State *L);
static int32 duel_select_xyz_material(lua_State *L);
static int32 duel_overlay(lua_State *L);
static int32 duel_get_overlay_group(lua_State *L);
static int32 duel_get_overlay_count(lua_State *L);
static int32 duel_check_remove_overlay_card(lua_State *L);
static int32 duel_remove_overlay_card(lua_State *L);
static int32_t duel_get_field_group(lua_State *L);
static int32_t duel_get_field_group_count(lua_State *L);
static int32_t duel_get_decktop_group(lua_State *L);
static int32_t duel_get_extratop_group(lua_State *L);
static int32_t duel_get_matching_group(lua_State *L);
static int32_t duel_get_matching_count(lua_State *L);
static int32_t duel_get_first_matching_card(lua_State *L);
static int32_t duel_is_existing_matching_card(lua_State *L);
static int32_t duel_select_matching_cards(lua_State *L);
static int32_t duel_get_release_group(lua_State *L);
static int32_t duel_get_release_group_count(lua_State *L);
static int32_t duel_check_release_group(lua_State *L);
static int32_t duel_select_release_group(lua_State *L);
static int32_t duel_check_release_group_ex(lua_State *L);
static int32_t duel_select_release_group_ex(lua_State *L);
static int32_t duel_get_tribute_group(lua_State *L);
static int32_t duel_get_tribute_count(lua_State *L);
static int32_t duel_check_tribute(lua_State *L);
static int32_t duel_select_tribute(lua_State *L);
static int32_t duel_get_target_count(lua_State *L);
static int32_t duel_is_existing_target(lua_State *L);
static int32_t duel_select_target(lua_State *L);
static int32_t duel_get_must_material(lua_State *L);
static int32_t duel_check_must_material(lua_State *L);
static int32_t duel_select_fusion_material(lua_State *L);
static int32_t duel_set_fusion_material(lua_State *L);
static int32_t duel_set_synchro_material(lua_State *L);
static int32_t duel_get_synchro_material(lua_State *L);
static int32_t duel_select_synchro_material(lua_State *L);
static int32_t duel_check_synchro_material(lua_State *L);
static int32_t duel_select_tuner_material(lua_State *L);
static int32_t duel_check_tuner_material(lua_State *L);
static int32_t duel_get_ritual_material(lua_State *L);
static int32_t duel_get_ritual_material_ex(lua_State *L);
static int32_t duel_release_ritual_material(lua_State *L);
static int32_t duel_get_fusion_material(lua_State *L);
static int32_t duel_is_summon_cancelable(lua_State *L);
static int32_t duel_set_must_select_cards(lua_State *L);
static int32_t duel_grab_must_select_cards(lua_State *L);
static int32_t duel_set_target_card(lua_State *L);
static int32_t duel_clear_target_card(lua_State *L);
static int32_t duel_set_target_player(lua_State *L);
static int32_t duel_set_target_param(lua_State *L);
static int32_t duel_set_operation_info(lua_State *L);
static int32_t duel_get_operation_info(lua_State *L);
static int32_t duel_get_operation_count(lua_State *L);
static int32_t duel_clear_operation_info(lua_State *L);
static int32_t duel_check_xyz_material(lua_State *L);
static int32_t duel_select_xyz_material(lua_State *L);
static int32_t duel_overlay(lua_State *L);
static int32_t duel_get_overlay_group(lua_State *L);
static int32_t duel_get_overlay_count(lua_State *L);
static int32_t duel_check_remove_overlay_card(lua_State *L);
static int32_t duel_remove_overlay_card(lua_State *L);
static int32 duel_hint(lua_State *L);
static int32 duel_hint_selection(lua_State *L);
static int32 duel_select_effect_yesno(lua_State *L);
static int32 duel_select_yesno(lua_State *L);
static int32 duel_select_option(lua_State *L);
static int32 duel_select_sequence(lua_State *L);
static int32 duel_select_position(lua_State *L);
static int32 duel_select_disable_field(lua_State *L);
static int32 duel_select_field(lua_State *L);
static int32 duel_announce_race(lua_State *L);
static int32 duel_announce_attribute(lua_State *L);
static int32 duel_announce_level(lua_State *L);
static int32 duel_announce_card(lua_State *L);
static int32 duel_announce_type(lua_State *L);
static int32 duel_announce_number(lua_State *L);
static int32 duel_announce_coin(lua_State *L);
static int32 duel_toss_coin(lua_State *L);
static int32 duel_toss_dice(lua_State *L);
static int32 duel_rock_paper_scissors(lua_State *L);
static int32 duel_get_coin_result(lua_State *L);
static int32 duel_get_dice_result(lua_State *L);
static int32 duel_set_coin_result(lua_State *L);
static int32 duel_set_dice_result(lua_State *L);
static int32_t duel_hint(lua_State *L);
static int32_t duel_get_last_select_hint(lua_State *L);
static int32_t duel_hint_selection(lua_State *L);
static int32_t duel_select_effect_yesno(lua_State *L);
static int32_t duel_select_yesno(lua_State *L);
static int32_t duel_select_option(lua_State *L);
static int32_t duel_select_sequence(lua_State *L);
static int32_t duel_select_position(lua_State *L);
static int32_t duel_select_disable_field(lua_State *L);
static int32_t duel_select_field(lua_State *L);
static int32_t duel_announce_race(lua_State *L);
static int32_t duel_announce_attribute(lua_State *L);
static int32_t duel_announce_level(lua_State *L);
static int32_t duel_announce_card(lua_State *L);
static int32_t duel_announce_type(lua_State *L);
static int32_t duel_announce_number(lua_State *L);
static int32_t duel_announce_coin(lua_State *L);
static int32_t duel_toss_coin(lua_State *L);
static int32_t duel_toss_dice(lua_State *L);
static int32_t duel_rock_paper_scissors(lua_State *L);
static int32_t duel_get_coin_result(lua_State *L);
static int32_t duel_get_dice_result(lua_State *L);
static int32_t duel_set_coin_result(lua_State *L);
static int32_t duel_set_dice_result(lua_State *L);
static int32 duel_is_player_affected_by_effect(lua_State *L);
static int32 duel_is_player_can_draw(lua_State *L);
static int32 duel_is_player_can_discard_deck(lua_State *L);
static int32 duel_is_player_can_discard_deck_as_cost(lua_State *L);
static int32 duel_is_player_can_summon(lua_State *L);
static int32 duel_is_player_can_mset(lua_State *L);
static int32 duel_is_player_can_sset(lua_State *L);
static int32 duel_is_player_can_spsummon(lua_State *L);
static int32 duel_is_player_can_flipsummon(lua_State *L);
static int32 duel_is_player_can_spsummon_monster(lua_State *L);
static int32 duel_is_player_can_spsummon_count(lua_State *L);
static int32 duel_is_player_can_release(lua_State *L);
static int32 duel_is_player_can_remove(lua_State *L);
static int32 duel_is_player_can_send_to_hand(lua_State *L);
static int32 duel_is_player_can_send_to_grave(lua_State *L);
static int32 duel_is_player_can_send_to_deck(lua_State *L);
static int32 duel_is_player_can_additional_summon(lua_State *L);
static int32 duel_is_chain_negatable(lua_State *L);
static int32 duel_is_chain_disablable(lua_State *L);
static int32 duel_is_chain_disabled(lua_State *L);
static int32 duel_check_chain_target(lua_State *L);
static int32 duel_check_chain_uniqueness(lua_State *L);
static int32 duel_get_activity_count(lua_State *L);
static int32 duel_check_phase_activity(lua_State *L);
static int32 duel_add_custom_activity_counter(lua_State *L);
static int32 duel_get_custom_activity_count(lua_State *L);
static int32 duel_is_able_to_enter_bp(lua_State *L);
static int32 duel_get_battled_count(lua_State *L);
static int32_t duel_is_player_affected_by_effect(lua_State *L);
static int32_t duel_is_player_can_draw(lua_State *L);
static int32_t duel_is_player_can_discard_deck(lua_State *L);
static int32_t duel_is_player_can_discard_deck_as_cost(lua_State *L);
static int32_t duel_is_player_can_summon(lua_State *L);
static int32_t duel_is_player_can_mset(lua_State *L);
static int32_t duel_is_player_can_sset(lua_State *L);
static int32_t duel_is_player_can_spsummon(lua_State *L);
static int32_t duel_is_player_can_flipsummon(lua_State *L);
static int32_t duel_is_player_can_spsummon_monster(lua_State *L);
static int32_t duel_is_player_can_spsummon_count(lua_State *L);
static int32_t duel_is_player_can_release(lua_State *L);
static int32_t duel_is_player_can_remove(lua_State *L);
static int32_t duel_is_player_can_send_to_hand(lua_State *L);
static int32_t duel_is_player_can_send_to_grave(lua_State *L);
static int32_t duel_is_player_can_send_to_deck(lua_State *L);
static int32_t duel_is_player_can_additional_summon(lua_State *L);
static int32_t duel_is_chain_solving(lua_State *L);
static int32_t duel_is_chain_negatable(lua_State *L);
static int32_t duel_is_chain_disablable(lua_State *L);
static int32_t duel_is_chain_disabled(lua_State *L);
static int32_t duel_check_chain_target(lua_State *L);
static int32_t duel_check_chain_uniqueness(lua_State *L);
static int32_t duel_get_activity_count(lua_State *L);
static int32_t duel_check_phase_activity(lua_State *L);
static int32_t duel_add_custom_activity_counter(lua_State *L);
static int32_t duel_get_custom_activity_count(lua_State *L);
static int32_t duel_is_able_to_enter_bp(lua_State *L);
static int32_t duel_get_battled_count(lua_State *L);
//specific card functions
static int32 duel_swap_deck_and_grave(lua_State *L);
static int32 duel_majestic_copy(lua_State *L);
static int32_t duel_swap_deck_and_grave(lua_State *L);
static int32_t duel_majestic_copy(lua_State *L);
static void open_duellib(lua_State *L);
//group metamethods
//__len is in the group lib, which is same as group_get_count
static int32 group_meta_add(lua_State *L);
static int32 group_meta_sub(lua_State *L);
static int32 group_meta_band(lua_State *L);
static int32 group_meta_bxor(lua_State *L);
static int32_t group_meta_add(lua_State *L);
static int32_t group_meta_sub(lua_State *L);
static int32_t group_meta_band(lua_State *L);
static int32_t group_meta_bxor(lua_State *L);
//preload
static int32 debug_message(lua_State *L);
static int32 debug_add_card(lua_State *L);
static int32 debug_set_player_info(lua_State *L);
static int32 debug_pre_summon(lua_State *L);
static int32 debug_pre_equip(lua_State *L);
static int32 debug_pre_set_target(lua_State *L);
static int32 debug_pre_add_counter(lua_State *L);
static int32 debug_reload_field_begin(lua_State *L);
static int32 debug_reload_field_end(lua_State *L);
static int32 debug_set_ai_name(lua_State *L);
static int32 debug_show_hint(lua_State *L);
static int32_t debug_message(lua_State *L);
static int32_t debug_add_card(lua_State *L);
static int32_t debug_set_player_info(lua_State *L);
static int32_t debug_pre_summon(lua_State *L);
static int32_t debug_pre_equip(lua_State *L);
static int32_t debug_pre_set_target(lua_State *L);
static int32_t debug_pre_add_counter(lua_State *L);
static int32_t debug_reload_field_begin(lua_State *L);
static int32_t debug_reload_field_end(lua_State *L);
static int32_t debug_set_ai_name(lua_State *L);
static int32_t debug_show_hint(lua_State *L);
static void open_debuglib(lua_State *L);
};
......
sort.h 0 → 100644
View file @ 287dd26c
#ifndef SORT_H_
#define SORT_H_
class card;
struct card_sort {
bool operator()(card* const& c1, card* const& c2) const;
};
#endif /* SORT_H_ */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment