Deukhoofd
/
Gen7Tests
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Initial commit; Load Species and Types, test all type effectivenesses.

This commit is contained in:
Deukhoofd 2020-02-09 13:22:54 +01:00
commit bb5ae114c4
Signed by: Deukhoofd
GPG Key ID: ADF2E9256009EDCE
15 changed files with 41363 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

121
.clang-format Normal file
View File

@ -0,0 +1,121 @@
# ClangFormatConfigureSource: 'LLVM'
---
Language: Cpp
# BasedOnStyle: LLVM
AccessModifierOffset: -4
AlignAfterOpenBracket: Align
AlignConsecutiveAssignments: false
AlignConsecutiveDeclarations: false
AlignEscapedNewlines: Right
AlignOperands: true
AlignTrailingComments: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: true
AllowShortFunctionsOnASingleLine: All
AllowShortIfStatementsOnASingleLine: Never
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: MultiLine
BinPackArguments: true
BinPackParameters: true
BraceWrapping:
AfterClass: false
AfterControlStatement: false
AfterEnum: false
AfterFunction: false
AfterNamespace: false
AfterObjCDeclaration: false
AfterStruct: false
AfterUnion: false
AfterExternBlock: false
BeforeCatch: false
BeforeElse: false
IndentBraces: false
SplitEmptyFunction: true
SplitEmptyRecord: true
SplitEmptyNamespace: true
BreakBeforeBinaryOperators: None
BreakBeforeBraces: Attach
BreakBeforeInheritanceComma: false
BreakInheritanceList: BeforeColon
BreakBeforeTernaryOperators: true
BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: BeforeColon
BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: true
ColumnLimit: 120
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
DerivePointerAlignment: false
DisableFormat: false
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: false
ForEachMacros:
- foreach
- Q_FOREACH
- BOOST_FOREACH
IncludeBlocks: Merge
IncludeCategories:
- Regex: '^"(llvm|llvm-c|clang|clang-c)/'
Priority: 2
- Regex: '^(<|"(gtest|gmock|isl|json)/)'
Priority: 1
- Regex: '.*'
Priority: 3
IncludeIsMainRegex: '(Test)?$'
IndentCaseLabels: true
IndentPPDirectives: None
IndentWidth: 4
IndentWrappedFunctionNames: false
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: true
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: All
ObjCBinPackProtocolList: Auto
ObjCBlockIndentWidth: 2
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 60
PointerAlignment: Left
ReflowComments: true
SortIncludes: true
SortUsingDeclarations: true
SpaceAfterCStyleCast: false
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: false
SpacesInContainerLiterals: true
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
Standard: Cpp11
StatementMacros:
- Q_UNUSED
- QT_REQUIRE_VERSION
TabWidth: 8
UseTab: Never
...

3
.gitignore vendored Normal file
View File

@ -0,0 +1,3 @@
/cmake-build-debug/
/cmake-build-release/
/.idea/

45
CMakeLists.txt Normal file
View File

@ -0,0 +1,45 @@
cmake_minimum_required(VERSION 3.13)
# Make warnings trigger errors.
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror")
project(Gen7Tests)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
if (NOT EXISTS ${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
message(WARNING "The file conanbuildinfo.cmake doesn't exist, running conan install.")
string(REPLACE "." ";" VERSION_LIST "${CMAKE_C_COMPILER_VERSION}")
list(GET VERSION_LIST 0 VERSION)
list(GET VERSION_LIST 1 MINOR)
if (NOT MINOR MATCHES 0)
SET(VERSION ${VERSION}.${MINOR})
endif()
if (NOT WINDOWS)
execute_process(COMMAND conan install ${CMAKE_SOURCE_DIR} --install-folder=${CMAKE_BINARY_DIR} --build missing
-s compiler=clang -s compiler.libcxx=libstdc++11 -s compiler.version=${VERSION} -s build_type=Debug)
else()
execute_process(COMMAND conan install ${CMAKE_SOURCE_DIR} --install-folder=${CMAKE_BINARY_DIR} --build missing
-s compiler=gcc -s compiler.libcxx=libstdc++11 -s compiler.version=${VERSION} -s os=Windows)
endif()
endif ()
include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
conan_basic_setup()
message(STATUS "Using Conan Libs:")
foreach (_conanLib ${CONAN_LIBS})
message(STATUS "\t ${_conanLib}")
endforeach()
SET(FILE_SOURCE
"src/*.cpp"
"src/*.hpp"
)
file(GLOB_RECURSE CORE_SRC_FILES ${FILE_SOURCE})
add_executable(Gen7Tests ${CORE_SRC_FILES})
SET(_LINKS CreatureLibCore CreatureLibLibrary CreatureLibBattling pkmnLib)
target_link_libraries(Gen7Tests PUBLIC ${_LINKS})

6
angelscript.supp Normal file
View File

@ -0,0 +1,6 @@
{
SkipAngelScriptMemCheck
Memcheck:Cond
fun:_ZN10asCContext11ExecuteNextEv
fun:_ZN10asCContext7ExecuteEv
}

29
conanfile.py Normal file
View File

@ -0,0 +1,29 @@
from conans import ConanFile, CMake
from conans.errors import ConanInvalidConfiguration
class PkmnLibConan(ConanFile):
name = "PkmnLib-Gen7"
license = "TODO"
url = "https://git.p-epsilon.com/Deukhoofd/PkmnLib"
description = "An implementation of CreatureLib to handle Pokemon battling."
settings = "os", "compiler", "build_type"
generators = "cmake"
exports_sources = "*"
compiler = "clang"
def build(self):
cmake = CMake(self)
self.output.info("Target OS: %s." % self.settings.os)
if self.settings.os == "Windows":
self.output.warn("Noticed Windows target, setting Cmake WINDOWS=On.")
cmake.definitions["WINDOWS"] = "On"
cmake.configure()
cmake.build()
def imports(self):
if self.settings.os == "Windows":
self.copy("*.dll", "bin", "bin")
def requirements(self):
self.requires("PkmnLib/4ee5a14b4c58b97fa511aad4be7cc0cb039bc634@pkmnlib/master")

17615
extern/catch.hpp vendored Normal file
View File

File diff suppressed because it is too large Load Diff

22875
extern/json.hpp vendored Normal file
View File

File diff suppressed because it is too large Load Diff

104
src/BuildData/BuildSpecies.cpp Normal file
View File

@ -0,0 +1,104 @@
#include "BuildSpecies.hpp"
#include <fstream>
#include <iostream>
#define GET(o, objectKey, key) \
auto _##objectKey = o[#objectKey]; \
if (_##objectKey.is_null()) { \
std::cout << "Failed to retrieve key '" << #objectKey << "' for object with key '" << key << "' in file '" \
<< path << "'\n"; \
return nullptr; \
}
PkmnLib::Library::SpeciesLibrary* BuildSpecies::BuildLibrary(const std::string& path,
const CreatureLib::Library::TypeLibrary* types) {
std::ifstream fileStream(path.c_str());
if (fileStream.fail()) {
std::cout << "Failed to load Pokemon data file at '" << path << "'\n";
return nullptr;
}
auto lib = new PkmnLib::Library::SpeciesLibrary();
json j;
fileStream >> j;
for (json::iterator it = j.begin(); it != j.end(); ++it) {
auto val = it.value();
GET(val, id, it.key());
GET(val, species, it.key());
GET(val, genderRatio, it.key());
GET(val, growthRate, it.key());
GET(val, baseHappiness, it.key());
GET(val, catchRate, it.key());
GET(val, color, it.key());
GET(val, genderDifference, it.key());
GET(val, eggGroups, it.key());
GET(val, eggCycles, it.key());
GET(val, tags, it.key());
GET(val, formes, it.key());
PkmnLib::Library::PokemonSpecies* species = nullptr;
auto defaultForme = _formes["default"];
if (!defaultForme.is_null()) {
auto forme = BuildForme("default", defaultForme, it.key(), path, types);
species = new PkmnLib::Library::PokemonSpecies(_id.get<uint16_t>(), _species.get<std::string>(), forme,
_genderRatio.get<int8_t>() / static_cast<float>(100),
_growthRate.get<std::string>(), _catchRate.get<uint8_t>(),
_baseHappiness.get<uint8_t>());
}
for (json::iterator formeIt = _formes.begin(); formeIt != _formes.end(); ++formeIt) {
if (formeIt.key() == "default") {
continue;
}
auto forme = BuildForme(formeIt.key(), formeIt.value(), it.key(), path, types);
if (forme == nullptr)
return nullptr;
if (species == nullptr) {
species = new PkmnLib::Library::PokemonSpecies(
_id.get<uint16_t>(), _species.get<std::string>(), forme,
static_cast<float>(_genderRatio.get<int8_t>()) / static_cast<float>(100),
_growthRate.get<std::string>(), _catchRate.get<uint8_t>(), _baseHappiness.get<uint8_t>());
} else {
species->SetVariant(formeIt.key(), forme);
}
}
if (species == nullptr) {
std::cout << "Pokemon with key '" << it.key() << "' does not have any formes.\n";
return nullptr;
}
lib->LoadSpecies(it.key(), species);
}
return lib;
}
static CreatureLib::Core::StatisticSet<uint16_t> ParseStatistics(json& json) {
return CreatureLib::Core::StatisticSet<uint16_t>(
json["hp"].get<uint16_t>(), json["attack"].get<uint16_t>(), json["defense"].get<uint16_t>(),
json["specialAttack"].get<uint16_t>(), json["specialDefense"].get<uint16_t>(), json["speed"].get<uint16_t>());
}
const PkmnLib::Library::PokemonForme* BuildSpecies::BuildForme(const std::string& name, json& forme,
const std::string& baseKeyName, const std::string& path,
const CreatureLib::Library::TypeLibrary* typeLibrary) {
GET(forme, abilities, baseKeyName << " -> " << name);
GET(forme, hiddenAbilities, baseKeyName << " -> " << name);
GET(forme, baseStats, baseKeyName << " -> " << name);
GET(forme, evReward, baseKeyName << " -> " << name);
GET(forme, types, baseKeyName << " -> " << name);
GET(forme, height, baseKeyName << " -> " << name);
GET(forme, weight, baseKeyName << " -> " << name);
GET(forme, baseExp, baseKeyName << " -> " << name);
GET(forme, moves, baseKeyName << " -> " << name);
auto typeStrings = _types.get<std::vector<std::string>>();
auto types = std::vector<uint8_t>(typeStrings.size());
for (auto i = 0; i < typeStrings.size(); i++) {
types[i] = typeLibrary->GetTypeId(typeStrings[i]);
}
auto stats = ParseStatistics(_baseStats);
return new PkmnLib::Library::PokemonForme(
name, _height.get<float>(), _weight.get<float>(), _baseExp.get<uint32_t>(), types, stats,
_abilities.get<std::vector<std::string>>(), _hiddenAbilities.get<std::vector<std::string>>(), nullptr);
}

19
src/BuildData/BuildSpecies.hpp Normal file
View File

@ -0,0 +1,19 @@
#ifndef GEN7TESTS_BUILDSPECIES_HPP
#define GEN7TESTS_BUILDSPECIES_HPP
#include <PkmnLib/Library/PokemonLibrary.hpp>
#include <CreatureLib/Library/TypeLibrary.hpp>
#include <string>
#include "../../extern/json.hpp"
using json = nlohmann::json;
class BuildSpecies {
static const PkmnLib::Library::PokemonForme* BuildForme(const std::string& name, json& forme,
const std::string& baseKeyName, const std::string& path,
const CreatureLib::Library::TypeLibrary* typeLibrary);
public:
static PkmnLib::Library::SpeciesLibrary* BuildLibrary(const std::string& path,
const CreatureLib::Library::TypeLibrary* types);
};
#endif // GEN7TESTS_BUILDSPECIES_HPP

1
src/BuildData/BuildTypes.cpp Normal file
View File

@ -0,0 +1 @@
#include "BuildTypes.hpp"

81
src/BuildData/BuildTypes.hpp Normal file
View File

@ -0,0 +1,81 @@
#ifndef GEN7TESTS_BUILDTYPES_HPP
#define GEN7TESTS_BUILDTYPES_HPP
#include <CreatureLib/Library/TypeLibrary.hpp>
#include <cstring>
#include <fstream>
#include <iostream>
class BuildTypes {
public:
static CreatureLib::Library::TypeLibrary* Build(const std::string& path) {
std::ifstream file(path);
if (file.fail()) {
std::cout << "Failed to load Types data file at '" << path << "'\n";
return nullptr;
}
std::string line;
if (!std::getline(file, line)) {
std::cout << "Failed to read Types data file at '" << path << "'\n";
return nullptr;
}
auto divider = ',';
if (strncmp(line.c_str(), "sep=", 4) == 0) {
divider = line[4];
std::getline(file, line);
}
auto library = new CreatureLib::Library::TypeLibrary();
bool hasSkippedFirst = false;
size_t lastStart = 0;
std::vector<uint8_t > types;
for (size_t i = 0; i < line.length(); i++) {
if (line[i] == divider) {
auto substr = line.substr(lastStart, i - lastStart);
lastStart = i + 1;
if (hasSkippedFirst) {
std::cout << "Registered type: " << substr << "\n";
auto val = library->RegisterType(substr);
types.push_back(val);
} else {
hasSkippedFirst = true;
}
i++;
}
}
auto substr = line.substr(lastStart, line.length() - lastStart);
std::cout << "Registered type: " << substr << "\n";
auto val = library->RegisterType(substr);
types.push_back(val);
while (std::getline(file, line)) {
uint8_t attackingType = 0;
bool gotType = false;
lastStart = 0;
int current = 0;
for (size_t i = 0; i < line.length(); i++) {
if (line[i] == divider) {
substr = line.substr(lastStart, i - lastStart);
lastStart = i + 1;
if (gotType) {
auto eff = std::atof(substr.c_str());
library->SetEffectiveness(attackingType, types[current], eff);
current++;
} else {
gotType = true;
attackingType = library->GetTypeId(substr);
}
i++;
}
}
substr = line.substr(lastStart, line.length() - lastStart);
auto eff = std::atof(substr.c_str());
library->SetEffectiveness(attackingType, types[current], eff);
}
return library;
}
};
#endif // GEN7TESTS_BUILDTYPES_HPP

4
src/Library.cpp Normal file
View File

@ -0,0 +1,4 @@
#include "Library.hpp"
PkmnLib::Library::PokemonLibrary* Library::_staticLib = nullptr;
PkmnLib::Battling::BattleLibrary* Library::_library = nullptr;

19
src/Library.hpp Normal file
View File

@ -0,0 +1,19 @@
#ifndef GEN7TESTS_LIBRARY_HPP
#define GEN7TESTS_LIBRARY_HPP
#include <PkmnLib/Battling/Library/BattleLibrary.hpp>
#include <PkmnLib/Library/PokemonLibrary.hpp>
class Library {
static PkmnLib::Library::PokemonLibrary* _staticLib;
static PkmnLib::Battling::BattleLibrary* _library;
public:
static const PkmnLib::Library::PokemonLibrary* GetStaticLib() { return _staticLib; }
static const PkmnLib::Battling::BattleLibrary* GetLibrary() { return _library; }
static void SetStaticLib(PkmnLib::Library::PokemonLibrary* lib) { _staticLib = lib; }
static void SetLibrary(PkmnLib::Battling::BattleLibrary* lib) { _library = lib; }
};
#endif // GEN7TESTS_LIBRARY_HPP

407
src/LibraryTests/TypeTests.cpp Normal file
View File

@ -0,0 +1,407 @@
#include "../../extern/catch.hpp"
#include "../Library.hpp"
#define CHECK_EFFECTIVENESS(attack, defense, expected) \
CHECK(typeLib->GetSingleEffectiveness(typeLib->GetTypeId(#attack), typeLib->GetTypeId(#defense)) == expected);
TEST_CASE("Type Effectiveness - Normal Attacking", "[type]") {
auto typeLib = Library::GetStaticLib()->GetTypeLibrary();
CHECK_EFFECTIVENESS(Normal, Normal, 1);
CHECK_EFFECTIVENESS(Normal, Fighting, 1);
CHECK_EFFECTIVENESS(Normal, Flying, 1);
CHECK_EFFECTIVENESS(Normal, Poison, 1);
CHECK_EFFECTIVENESS(Normal, Ground, 1);
CHECK_EFFECTIVENESS(Normal, Rock, 0.5);
CHECK_EFFECTIVENESS(Normal, Bug, 1);
CHECK_EFFECTIVENESS(Normal, Ghost, 0);
CHECK_EFFECTIVENESS(Normal, Steel, 0.5)
CHECK_EFFECTIVENESS(Normal, Fire, 1);
CHECK_EFFECTIVENESS(Normal, Water, 1);
CHECK_EFFECTIVENESS(Normal, Grass, 1);
CHECK_EFFECTIVENESS(Normal, Electric, 1);
CHECK_EFFECTIVENESS(Normal, Psychic, 1);
CHECK_EFFECTIVENESS(Normal, Ice, 1);
CHECK_EFFECTIVENESS(Normal, Dragon, 1);
CHECK_EFFECTIVENESS(Normal, Dark, 1);
CHECK_EFFECTIVENESS(Normal, Fairy, 1);
}
TEST_CASE("Type Effectiveness - Fighting Attacking", "[type]") {
auto typeLib = Library::GetStaticLib()->GetTypeLibrary();
CHECK_EFFECTIVENESS(Fighting, Normal, 2);
CHECK_EFFECTIVENESS(Fighting, Fighting, 1);
CHECK_EFFECTIVENESS(Fighting, Flying, 0.5);
CHECK_EFFECTIVENESS(Fighting, Poison, 0.5);
CHECK_EFFECTIVENESS(Fighting, Ground, 1);
CHECK_EFFECTIVENESS(Fighting, Rock, 2);
CHECK_EFFECTIVENESS(Fighting, Bug, 0.5);
CHECK_EFFECTIVENESS(Fighting, Ghost, 0);
CHECK_EFFECTIVENESS(Fighting, Steel, 2);
CHECK_EFFECTIVENESS(Fighting, Fire, 1);
CHECK_EFFECTIVENESS(Fighting, Water, 1);
CHECK_EFFECTIVENESS(Fighting, Grass, 1);
CHECK_EFFECTIVENESS(Fighting, Electric, 1);
CHECK_EFFECTIVENESS(Fighting, Psychic, 0.5);
CHECK_EFFECTIVENESS(Fighting, Ice, 2);
CHECK_EFFECTIVENESS(Fighting, Dragon, 1);
CHECK_EFFECTIVENESS(Fighting, Dark, 2);
CHECK_EFFECTIVENESS(Fighting, Fairy, 0.5);
}
TEST_CASE("Type Effectiveness - Flying Attacking", "[type]") {
auto typeLib = Library::GetStaticLib()->GetTypeLibrary();
CHECK_EFFECTIVENESS(Flying, Normal, 1);
CHECK_EFFECTIVENESS(Flying, Fighting, 2);
CHECK_EFFECTIVENESS(Flying, Flying, 1);
CHECK_EFFECTIVENESS(Flying, Poison, 1);
CHECK_EFFECTIVENESS(Flying, Ground, 1);
CHECK_EFFECTIVENESS(Flying, Rock, 0.5);
CHECK_EFFECTIVENESS(Flying, Bug, 2);
CHECK_EFFECTIVENESS(Flying, Ghost, 1);
CHECK_EFFECTIVENESS(Flying, Steel, 0.5);
CHECK_EFFECTIVENESS(Flying, Fire, 1);
CHECK_EFFECTIVENESS(Flying, Water, 1);
CHECK_EFFECTIVENESS(Flying, Grass, 2);
CHECK_EFFECTIVENESS(Flying, Electric, 0.5);
CHECK_EFFECTIVENESS(Flying, Psychic, 1);
CHECK_EFFECTIVENESS(Flying, Ice, 1);
CHECK_EFFECTIVENESS(Flying, Dragon, 1);
CHECK_EFFECTIVENESS(Flying, Dark, 1);
CHECK_EFFECTIVENESS(Flying, Fairy, 1);
}
TEST_CASE("Type Effectiveness - Poison Attacking", "[type]") {
auto typeLib = Library::GetStaticLib()->GetTypeLibrary();
CHECK_EFFECTIVENESS(Poison, Normal, 1);
CHECK_EFFECTIVENESS(Poison, Fighting, 1);
CHECK_EFFECTIVENESS(Poison, Flying, 1);
CHECK_EFFECTIVENESS(Poison, Poison, 0.5);
CHECK_EFFECTIVENESS(Poison, Ground, 0.5);
CHECK_EFFECTIVENESS(Poison, Rock, 0.5);
CHECK_EFFECTIVENESS(Poison, Bug, 1);
CHECK_EFFECTIVENESS(Poison, Ghost, 0.5);
CHECK_EFFECTIVENESS(Poison, Steel, 0);
CHECK_EFFECTIVENESS(Poison, Fire, 1);
CHECK_EFFECTIVENESS(Poison, Water, 1);
CHECK_EFFECTIVENESS(Poison, Grass, 2);
CHECK_EFFECTIVENESS(Poison, Electric, 1);
CHECK_EFFECTIVENESS(Poison, Psychic, 1);
CHECK_EFFECTIVENESS(Poison, Ice, 1);
CHECK_EFFECTIVENESS(Poison, Dragon, 1);
CHECK_EFFECTIVENESS(Poison, Dark, 1);
CHECK_EFFECTIVENESS(Poison, Fairy, 2);
}
TEST_CASE("Type Effectiveness - Ground Attacking", "[type]") {
auto typeLib = Library::GetStaticLib()->GetTypeLibrary();
CHECK_EFFECTIVENESS(Ground, Normal, 1);
CHECK_EFFECTIVENESS(Ground, Fighting, 1);
CHECK_EFFECTIVENESS(Ground, Flying, 0);
CHECK_EFFECTIVENESS(Ground, Poison, 2);
CHECK_EFFECTIVENESS(Ground, Ground, 1);
CHECK_EFFECTIVENESS(Ground, Rock, 2);
CHECK_EFFECTIVENESS(Ground, Bug, 0.5);
CHECK_EFFECTIVENESS(Ground, Ghost, 1);
CHECK_EFFECTIVENESS(Ground, Steel, 2);
CHECK_EFFECTIVENESS(Ground, Fire, 2);
CHECK_EFFECTIVENESS(Ground, Water, 1);
CHECK_EFFECTIVENESS(Ground, Grass, 0.5);
CHECK_EFFECTIVENESS(Ground, Electric, 2);
CHECK_EFFECTIVENESS(Ground, Psychic, 1);
CHECK_EFFECTIVENESS(Ground, Ice, 1);
CHECK_EFFECTIVENESS(Ground, Dragon, 1);
CHECK_EFFECTIVENESS(Ground, Dark, 1);
CHECK_EFFECTIVENESS(Ground, Fairy, 1);
}
TEST_CASE("Type Effectiveness - Rock Attacking", "[type]") {
auto typeLib = Library::GetStaticLib()->GetTypeLibrary();
CHECK_EFFECTIVENESS(Rock, Normal, 1);
CHECK_EFFECTIVENESS(Rock, Fighting, 0.5);
CHECK_EFFECTIVENESS(Rock, Flying, 2);
CHECK_EFFECTIVENESS(Rock, Poison, 1);
CHECK_EFFECTIVENESS(Rock, Ground, 0.5);
CHECK_EFFECTIVENESS(Rock, Rock, 1);
CHECK_EFFECTIVENESS(Rock, Bug, 2);
CHECK_EFFECTIVENESS(Rock, Ghost, 1);
CHECK_EFFECTIVENESS(Rock, Steel, 0.5);
CHECK_EFFECTIVENESS(Rock, Fire, 2);
CHECK_EFFECTIVENESS(Rock, Water, 1);
CHECK_EFFECTIVENESS(Rock, Grass, 1);
CHECK_EFFECTIVENESS(Rock, Electric, 1);
CHECK_EFFECTIVENESS(Rock, Psychic, 1);
CHECK_EFFECTIVENESS(Rock, Ice, 2);
CHECK_EFFECTIVENESS(Rock, Dragon, 1);
CHECK_EFFECTIVENESS(Rock, Dark, 1);
CHECK_EFFECTIVENESS(Rock, Fairy, 1);
}
TEST_CASE("Type Effectiveness - Bug Attacking", "[type]") {
auto typeLib = Library::GetStaticLib()->GetTypeLibrary();
CHECK_EFFECTIVENESS(Bug, Normal, 1);
CHECK_EFFECTIVENESS(Bug, Fighting, 0.5);
CHECK_EFFECTIVENESS(Bug, Flying, 0.5);
CHECK_EFFECTIVENESS(Bug, Poison, 0.5);
CHECK_EFFECTIVENESS(Bug, Ground, 1);
CHECK_EFFECTIVENESS(Bug, Rock, 1);
CHECK_EFFECTIVENESS(Bug, Bug, 1);
CHECK_EFFECTIVENESS(Bug, Ghost, 0.5);
CHECK_EFFECTIVENESS(Bug, Steel, 0.5);
CHECK_EFFECTIVENESS(Bug, Fire, 0.5);
CHECK_EFFECTIVENESS(Bug, Water, 1);
CHECK_EFFECTIVENESS(Bug, Grass, 2);
CHECK_EFFECTIVENESS(Bug, Electric, 1);
CHECK_EFFECTIVENESS(Bug, Psychic, 2);
CHECK_EFFECTIVENESS(Bug, Ice, 1);
CHECK_EFFECTIVENESS(Bug, Dragon, 1);
CHECK_EFFECTIVENESS(Bug, Dark, 2);
CHECK_EFFECTIVENESS(Bug, Fairy, 0.5);
}
TEST_CASE("Type Effectiveness - Ghost Attacking", "[type]") {
auto typeLib = Library::GetStaticLib()->GetTypeLibrary();
CHECK_EFFECTIVENESS(Ghost, Normal, 0);
CHECK_EFFECTIVENESS(Ghost, Fighting, 1);
CHECK_EFFECTIVENESS(Ghost, Flying, 1);
CHECK_EFFECTIVENESS(Ghost, Poison, 1);
CHECK_EFFECTIVENESS(Ghost, Ground, 1);
CHECK_EFFECTIVENESS(Ghost, Rock, 1);
CHECK_EFFECTIVENESS(Ghost, Bug, 1);
CHECK_EFFECTIVENESS(Ghost, Ghost, 2);
CHECK_EFFECTIVENESS(Ghost, Steel, 1);
CHECK_EFFECTIVENESS(Ghost, Fire, 1);
CHECK_EFFECTIVENESS(Ghost, Water, 1);
CHECK_EFFECTIVENESS(Ghost, Grass, 1);
CHECK_EFFECTIVENESS(Ghost, Electric, 1);
CHECK_EFFECTIVENESS(Ghost, Psychic, 2);
CHECK_EFFECTIVENESS(Ghost, Ice, 1);
CHECK_EFFECTIVENESS(Ghost, Dragon, 1);
CHECK_EFFECTIVENESS(Ghost, Dark, 0.5);
CHECK_EFFECTIVENESS(Ghost, Fairy, 1);
}
TEST_CASE("Type Effectiveness - Steel Attacking", "[type]") {
auto typeLib = Library::GetStaticLib()->GetTypeLibrary();
CHECK_EFFECTIVENESS(Steel, Normal, 1);
CHECK_EFFECTIVENESS(Steel, Fighting, 1);
CHECK_EFFECTIVENESS(Steel, Flying, 1);
CHECK_EFFECTIVENESS(Steel, Poison, 1);
CHECK_EFFECTIVENESS(Steel, Ground, 1);
CHECK_EFFECTIVENESS(Steel, Rock, 2);
CHECK_EFFECTIVENESS(Steel, Bug, 1);
CHECK_EFFECTIVENESS(Steel, Ghost, 1);
CHECK_EFFECTIVENESS(Steel, Steel, 0.5);
CHECK_EFFECTIVENESS(Steel, Fire, 0.5);
CHECK_EFFECTIVENESS(Steel, Water, 0.5);
CHECK_EFFECTIVENESS(Steel, Grass, 1);
CHECK_EFFECTIVENESS(Steel, Electric, 0.5);
CHECK_EFFECTIVENESS(Steel, Psychic, 1);
CHECK_EFFECTIVENESS(Steel, Ice, 2);
CHECK_EFFECTIVENESS(Steel, Dragon, 1);
CHECK_EFFECTIVENESS(Steel, Dark, 1);
CHECK_EFFECTIVENESS(Steel, Fairy, 2);
}
TEST_CASE("Type Effectiveness - Fire Attacking", "[type]") {
auto typeLib = Library::GetStaticLib()->GetTypeLibrary();
CHECK_EFFECTIVENESS(Fire, Normal, 1);
CHECK_EFFECTIVENESS(Fire, Fighting, 1);
CHECK_EFFECTIVENESS(Fire, Flying, 1);
CHECK_EFFECTIVENESS(Fire, Poison, 1);
CHECK_EFFECTIVENESS(Fire, Ground, 1);
CHECK_EFFECTIVENESS(Fire, Rock, 0.5);
CHECK_EFFECTIVENESS(Fire, Bug, 2);
CHECK_EFFECTIVENESS(Fire, Ghost, 1);
CHECK_EFFECTIVENESS(Fire, Steel, 2);
CHECK_EFFECTIVENESS(Fire, Fire, 0.5);
CHECK_EFFECTIVENESS(Fire, Water, 0.5);
CHECK_EFFECTIVENESS(Fire, Grass, 2);
CHECK_EFFECTIVENESS(Fire, Electric, 1);
CHECK_EFFECTIVENESS(Fire, Psychic, 1);
CHECK_EFFECTIVENESS(Fire, Ice, 2);
CHECK_EFFECTIVENESS(Fire, Dragon, 0.5);
CHECK_EFFECTIVENESS(Fire, Dark, 1);
CHECK_EFFECTIVENESS(Fire, Fairy, 1);
}
TEST_CASE("Type Effectiveness - Water Attacking", "[type]") {
auto typeLib = Library::GetStaticLib()->GetTypeLibrary();
CHECK_EFFECTIVENESS(Water, Normal, 1);
CHECK_EFFECTIVENESS(Water, Fighting, 1);
CHECK_EFFECTIVENESS(Water, Flying, 1);
CHECK_EFFECTIVENESS(Water, Poison, 1);
CHECK_EFFECTIVENESS(Water, Ground, 2);
CHECK_EFFECTIVENESS(Water, Rock, 2);
CHECK_EFFECTIVENESS(Water, Bug, 1);
CHECK_EFFECTIVENESS(Water, Ghost, 1);
CHECK_EFFECTIVENESS(Water, Steel, 1);
CHECK_EFFECTIVENESS(Water, Fire, 2);
CHECK_EFFECTIVENESS(Water, Water, 0.5);
CHECK_EFFECTIVENESS(Water, Grass, 0.5);
CHECK_EFFECTIVENESS(Water, Electric, 1);
CHECK_EFFECTIVENESS(Water, Psychic, 1);
CHECK_EFFECTIVENESS(Water, Ice, 1);
CHECK_EFFECTIVENESS(Water, Dragon, 0.5);
CHECK_EFFECTIVENESS(Water, Dark, 1);
CHECK_EFFECTIVENESS(Water, Fairy, 1);
}
TEST_CASE("Type Effectiveness - Grass Attacking", "[type]") {
auto typeLib = Library::GetStaticLib()->GetTypeLibrary();
CHECK_EFFECTIVENESS(Grass, Normal, 1);
CHECK_EFFECTIVENESS(Grass, Fighting, 1);
CHECK_EFFECTIVENESS(Grass, Flying, 0.5);
CHECK_EFFECTIVENESS(Grass, Poison, 0.5);
CHECK_EFFECTIVENESS(Grass, Ground, 2);
CHECK_EFFECTIVENESS(Grass, Rock, 2);
CHECK_EFFECTIVENESS(Grass, Bug, 0.5);
CHECK_EFFECTIVENESS(Grass, Ghost, 1);
CHECK_EFFECTIVENESS(Grass, Steel, 0.5);
CHECK_EFFECTIVENESS(Grass, Fire, 0.5);
CHECK_EFFECTIVENESS(Grass, Water, 2);
CHECK_EFFECTIVENESS(Grass, Grass, 0.5);
CHECK_EFFECTIVENESS(Grass, Electric, 1);
CHECK_EFFECTIVENESS(Grass, Psychic, 1);
CHECK_EFFECTIVENESS(Grass, Ice, 1);
CHECK_EFFECTIVENESS(Grass, Dragon, 0.5);
CHECK_EFFECTIVENESS(Grass, Dark, 1);
CHECK_EFFECTIVENESS(Grass, Fairy, 1);
}
TEST_CASE("Type Effectiveness - Electric Attacking", "[type]") {
auto typeLib = Library::GetStaticLib()->GetTypeLibrary();
CHECK_EFFECTIVENESS(Electric, Normal, 1);
CHECK_EFFECTIVENESS(Electric, Fighting, 1);
CHECK_EFFECTIVENESS(Electric, Flying, 2);
CHECK_EFFECTIVENESS(Electric, Poison, 1);
CHECK_EFFECTIVENESS(Electric, Ground, 0);
CHECK_EFFECTIVENESS(Electric, Rock, 1);
CHECK_EFFECTIVENESS(Electric, Bug, 1);
CHECK_EFFECTIVENESS(Electric, Ghost, 1);
CHECK_EFFECTIVENESS(Electric, Steel, 1);
CHECK_EFFECTIVENESS(Electric, Fire, 1);
CHECK_EFFECTIVENESS(Electric, Water, 2);
CHECK_EFFECTIVENESS(Electric, Grass, 0.5);
CHECK_EFFECTIVENESS(Electric, Electric, 0.5);
CHECK_EFFECTIVENESS(Electric, Psychic, 1);
CHECK_EFFECTIVENESS(Electric, Ice, 1);
CHECK_EFFECTIVENESS(Electric, Dragon, 0.5);
CHECK_EFFECTIVENESS(Electric, Dark, 1);
CHECK_EFFECTIVENESS(Electric, Fairy, 1);
}
TEST_CASE("Type Effectiveness - Psychic Attacking", "[type]") {
auto typeLib = Library::GetStaticLib()->GetTypeLibrary();
CHECK_EFFECTIVENESS(Psychic, Normal, 1);
CHECK_EFFECTIVENESS(Psychic, Fighting, 2);
CHECK_EFFECTIVENESS(Psychic, Flying, 1);
CHECK_EFFECTIVENESS(Psychic, Poison, 2);
CHECK_EFFECTIVENESS(Psychic, Ground, 1);
CHECK_EFFECTIVENESS(Psychic, Rock, 1);
CHECK_EFFECTIVENESS(Psychic, Bug, 1);
CHECK_EFFECTIVENESS(Psychic, Ghost, 1);
CHECK_EFFECTIVENESS(Psychic, Steel, 0.5);
CHECK_EFFECTIVENESS(Psychic, Fire, 1);
CHECK_EFFECTIVENESS(Psychic, Water, 1);
CHECK_EFFECTIVENESS(Psychic, Grass, 1);
CHECK_EFFECTIVENESS(Psychic, Electric, 1);
CHECK_EFFECTIVENESS(Psychic, Psychic, 0.5);
CHECK_EFFECTIVENESS(Psychic, Ice, 1);
CHECK_EFFECTIVENESS(Psychic, Dragon, 1);
CHECK_EFFECTIVENESS(Psychic, Dark, 0);
CHECK_EFFECTIVENESS(Psychic, Fairy, 1);
}
TEST_CASE("Type Effectiveness - Ice Attacking", "[type]") {
auto typeLib = Library::GetStaticLib()->GetTypeLibrary();
CHECK_EFFECTIVENESS(Ice, Normal, 1);
CHECK_EFFECTIVENESS(Ice, Fighting, 1);
CHECK_EFFECTIVENESS(Ice, Flying, 2);
CHECK_EFFECTIVENESS(Ice, Poison, 1);
CHECK_EFFECTIVENESS(Ice, Ground, 2);
CHECK_EFFECTIVENESS(Ice, Rock, 1);
CHECK_EFFECTIVENESS(Ice, Bug, 1);
CHECK_EFFECTIVENESS(Ice, Ghost, 1);
CHECK_EFFECTIVENESS(Ice, Steel, 0.5);
CHECK_EFFECTIVENESS(Ice, Fire, 0.5);
CHECK_EFFECTIVENESS(Ice, Water, 0.5);
CHECK_EFFECTIVENESS(Ice, Grass, 2);
CHECK_EFFECTIVENESS(Ice, Electric, 1);
CHECK_EFFECTIVENESS(Ice, Psychic, 1);
CHECK_EFFECTIVENESS(Ice, Ice, 0.5);
CHECK_EFFECTIVENESS(Ice, Dragon, 2);
CHECK_EFFECTIVENESS(Ice, Dark, 1);
CHECK_EFFECTIVENESS(Ice, Fairy, 1);
}
TEST_CASE("Type Effectiveness - Dragon Attacking", "[type]") {
auto typeLib = Library::GetStaticLib()->GetTypeLibrary();
CHECK_EFFECTIVENESS(Dragon, Normal, 1);
CHECK_EFFECTIVENESS(Dragon, Fighting, 1);
CHECK_EFFECTIVENESS(Dragon, Flying, 1);
CHECK_EFFECTIVENESS(Dragon, Poison, 1);
CHECK_EFFECTIVENESS(Dragon, Ground, 1);
CHECK_EFFECTIVENESS(Dragon, Rock, 1);
CHECK_EFFECTIVENESS(Dragon, Bug, 1);
CHECK_EFFECTIVENESS(Dragon, Ghost, 1);
CHECK_EFFECTIVENESS(Dragon, Steel, 0.5);
CHECK_EFFECTIVENESS(Dragon, Fire, 1);
CHECK_EFFECTIVENESS(Dragon, Water, 1);
CHECK_EFFECTIVENESS(Dragon, Grass, 1);
CHECK_EFFECTIVENESS(Dragon, Electric, 1);
CHECK_EFFECTIVENESS(Dragon, Psychic, 1);
CHECK_EFFECTIVENESS(Dragon, Ice, 1);
CHECK_EFFECTIVENESS(Dragon, Dragon, 2);
CHECK_EFFECTIVENESS(Dragon, Dark, 1);
CHECK_EFFECTIVENESS(Dragon, Fairy, 0);
}
TEST_CASE("Type Effectiveness - Dark Attacking", "[type]") {
auto typeLib = Library::GetStaticLib()->GetTypeLibrary();
CHECK_EFFECTIVENESS(Dark, Normal, 1);
CHECK_EFFECTIVENESS(Dark, Fighting, 0.5);
CHECK_EFFECTIVENESS(Dark, Flying, 1);
CHECK_EFFECTIVENESS(Dark, Poison, 1);
CHECK_EFFECTIVENESS(Dark, Ground, 1);
CHECK_EFFECTIVENESS(Dark, Rock, 1);
CHECK_EFFECTIVENESS(Dark, Bug, 1);
CHECK_EFFECTIVENESS(Dark, Ghost, 2);
CHECK_EFFECTIVENESS(Dark, Steel, 1);
CHECK_EFFECTIVENESS(Dark, Fire, 1);
CHECK_EFFECTIVENESS(Dark, Water, 1);
CHECK_EFFECTIVENESS(Dark, Grass, 1);
CHECK_EFFECTIVENESS(Dark, Electric, 1);
CHECK_EFFECTIVENESS(Dark, Psychic, 2);
CHECK_EFFECTIVENESS(Dark, Ice, 1);
CHECK_EFFECTIVENESS(Dark, Dragon, 1);
CHECK_EFFECTIVENESS(Dark, Dark, 0.5);
CHECK_EFFECTIVENESS(Dark, Fairy, 0.5);
}
TEST_CASE("Type Effectiveness - Fairy Attacking", "[type]") {
auto typeLib = Library::GetStaticLib()->GetTypeLibrary();
CHECK_EFFECTIVENESS(Fairy, Normal, 1);
CHECK_EFFECTIVENESS(Fairy, Fighting, 2);
CHECK_EFFECTIVENESS(Fairy, Flying, 1);
CHECK_EFFECTIVENESS(Fairy, Poison, 0.5);
CHECK_EFFECTIVENESS(Fairy, Ground, 1);
CHECK_EFFECTIVENESS(Fairy, Rock, 1);
CHECK_EFFECTIVENESS(Fairy, Bug, 1);
CHECK_EFFECTIVENESS(Fairy, Ghost, 1);
CHECK_EFFECTIVENESS(Fairy, Steel, 0.5);
CHECK_EFFECTIVENESS(Fairy, Fire, 0.5);
CHECK_EFFECTIVENESS(Fairy, Water, 1);
CHECK_EFFECTIVENESS(Fairy, Grass, 1);
CHECK_EFFECTIVENESS(Fairy, Electric, 1);
CHECK_EFFECTIVENESS(Fairy, Psychic, 1);
CHECK_EFFECTIVENESS(Fairy, Ice, 1);
CHECK_EFFECTIVENESS(Fairy, Dragon, 2);
CHECK_EFFECTIVENESS(Fairy, Dark, 2);
CHECK_EFFECTIVENESS(Fairy, Fairy, 1);
}
#undef CHECK_EFFECTIVENESS

34
src/main.cpp Normal file
View File

@ -0,0 +1,34 @@
#define CATCH_CONFIG_RUNNER
#include "../extern/catch.hpp"
#include "BuildData/BuildSpecies.hpp"
#include "BuildData/BuildTypes.hpp"
#include "Library.hpp"
int main(int argc, char* argv[]) {
Catch::Session session;
std::string typesFile = "Types.csv";
std::string pokemonFile = "Pokemon.json";
using namespace Catch::clara;
auto cli = session.cli()
| Opt(pokemonFile, "Species")["--species"]("Which species file to load.")
| Opt(typesFile, "Types")["--types"]("Which Types file to load.");
session.cli(cli);
int returnCode = session.applyCommandLine(argc, argv);
if (returnCode != 0) // Indicates a command line error
return returnCode;
auto typesLibrary = BuildTypes::Build(typesFile);
auto speciesLibrary = BuildSpecies::BuildLibrary(pokemonFile, typesLibrary);
auto settings = new PkmnLib::Library::LibrarySettings(100, 4, 4096);
auto library = new PkmnLib::Library::PokemonLibrary(settings, speciesLibrary,nullptr,nullptr, nullptr,typesLibrary,
nullptr);
Library::SetStaticLib(library);
return session.run();
}