void pokemon_box_gcnimpl::set_pokemon(
        int index,
        const pkmn::pokemon::sptr& new_pokemon
    )
    {
        int max_index = get_capacity();
        pkmn::enforce_bounds("Box index", index, 0, max_index);

        if(_pokemon_list.at(index)->get_native_pc_data() == new_pokemon->get_native_pc_data())
        {
            throw std::invalid_argument("Cannot set a Pokémon to itself.");
        }

        boost::lock_guard<pokemon_box_gcnimpl> lock(*this);

        // If the given Pokémon isn't from this box's game, convert it if we can.
        pkmn::pokemon::sptr actual_new_pokemon;
        if(_game_id == new_pokemon->get_database_entry().get_game_id())
        {
            actual_new_pokemon = new_pokemon;
        }
        else
        {
            actual_new_pokemon = new_pokemon->to_game(get_game());
        }

        // Make sure no one else is using the new Pokémon variable.
        pokemon_gcnimpl* p_new_pokemon = dynamic_cast<pokemon_gcnimpl*>(
                                             actual_new_pokemon.get()
                                         );
        BOOST_ASSERT(p_new_pokemon != nullptr);
        boost::lock_guard<pokemon_gcnimpl> new_pokemon_lock(*p_new_pokemon);

        // Copy the underlying memory to the party. At the end of this process,
        // all existing variables will correspond to the same Pokémon, even if
        // their underlying memory has changed.
        //
        // Note: as we control the implementation, we know the PC data points
        // to the whole Pokémon data structure.
        delete _libpkmgc_box_uptr->pkm[index];

        _libpkmgc_box_uptr->pkm[index] =
            static_cast<LibPkmGC::GC::Pokemon*>(
                actual_new_pokemon->get_native_pc_data()
            )->clone();
        _pokemon_list[index] = std::make_shared<pokemon_gcnimpl>(
                                   dynamic_cast<LibPkmGC::GC::Pokemon*>(
                                       _libpkmgc_box_uptr->pkm[index]
                                   ),
                                   _game_id
                               );
    }
void pokemon_equality_check(pkmn::pokemon::sptr pkmn1, pkmn::pokemon::sptr pkmn2)
{
    BOOST_CHECK_EQUAL(pkmn1->get_species_id(), pkmn2->get_species_id());
    BOOST_CHECK_EQUAL(pkmn1->get_game_id(), pkmn2->get_game_id());

    if(pkmn1->get_species_id() == pkmn::Species::NONE)
        return;
    else if(pkmn1->get_species_id() == pkmn::Species::INVALID)
    {
        BOOST_CHECK(!memcmp(pkmn1->get_native(), pkmn2->get_native(), native_sizes[pkmn1->get_generation()]));
        return;
    }

    BOOST_CHECK_EQUAL(pkmn1->get_original_game_id(), pkmn2->get_original_game_id());
    BOOST_CHECK_EQUAL(pkmn1->get_pokemon_id(), pkmn2->get_pokemon_id());
    BOOST_CHECK_EQUAL(pkmn1->get_ability_id(), pkmn2->get_ability_id());
    BOOST_CHECK_EQUAL(pkmn1->get_item_id(), pkmn2->get_item_id());
    BOOST_CHECK_EQUAL(pkmn1->get_nature_id(), pkmn2->get_nature_id());
    BOOST_CHECK_EQUAL(pkmn1->get_form_id(), pkmn2->get_form_id());
    BOOST_CHECK(pkmn1->get_markings() == pkmn2->get_markings());
    BOOST_CHECK(pkmn1->get_ribbons().hoenn == pkmn2->get_ribbons().hoenn);
    BOOST_CHECK(pkmn1->get_ribbons().sinnoh.ribbons1 == pkmn2->get_ribbons().sinnoh.ribbons1);
    BOOST_CHECK(pkmn1->get_ribbons().sinnoh.ribbons2 == pkmn2->get_ribbons().sinnoh.ribbons2);
    BOOST_CHECK(pkmn1->get_ribbons().sinnoh.ribbons3 == pkmn2->get_ribbons().sinnoh.ribbons3);
    BOOST_CHECK(pkmn1->get_ribbons().unova == pkmn2->get_ribbons().unova);
    BOOST_CHECK(pkmn1->get_ribbons().kalos == pkmn2->get_ribbons().kalos);
    BOOST_CHECK(pkmn1->get_super_training_medals() == pkmn2->get_super_training_medals());
    BOOST_CHECK(pkmn1->get_pokerus() == pkmn2->get_pokerus());
    BOOST_CHECK(pkmn1->get_nickname() == pkmn2->get_nickname());
    BOOST_CHECK(pkmn1->get_trainer_name() == pkmn2->get_trainer_name());
    BOOST_CHECK(pkmn1->get_trainer_gender() == pkmn2->get_trainer_gender());
    BOOST_CHECK_EQUAL(pkmn1->get_trainer_id(), pkmn2->get_trainer_id());
    BOOST_CHECK(pkmn1->get_ball() == pkmn2->get_ball());
    BOOST_CHECK_EQUAL(pkmn1->get_met_level(), pkmn2->get_met_level());
    BOOST_CHECK_EQUAL(pkmn1->get_personality(), pkmn2->get_personality());
    BOOST_CHECK_EQUAL(pkmn1->get_friendship(), pkmn2->get_friendship());
    BOOST_CHECK_EQUAL(pkmn1->get_level(), pkmn2->get_level());
    BOOST_CHECK_EQUAL(pkmn1->get_experience(), pkmn2->get_experience());
    BOOST_CHECK(pkmn1->get_gender() == pkmn2->get_gender());
    BOOST_CHECK_EQUAL(pkmn1->is_shiny(), pkmn2->is_shiny());

    pkmn::dict<pkmn::pkstring, int> pkmn1_stats = pkmn1->get_stats();
    pkmn::dict<pkmn::pkstring, int> pkmn2_stats = pkmn2->get_stats();
    BOOST_CHECK_EQUAL(pkmn1_stats.at("HP"), pkmn2_stats.at("HP"));
    BOOST_CHECK_EQUAL(pkmn1_stats.at("Attack"), pkmn2_stats.at("Attack"));
    BOOST_CHECK_EQUAL(pkmn1_stats.at("Defense"), pkmn2_stats.at("Defense"));
    BOOST_CHECK_EQUAL(pkmn1_stats.at("Speed"), pkmn2_stats.at("Speed"));

    if(pkmn1->get_generation() == 1)
        BOOST_CHECK_EQUAL(pkmn1_stats.at("Special"), pkmn2_stats.at("Special"));
    else
    {
        BOOST_CHECK_EQUAL(pkmn1_stats.at("Special Attack"), pkmn2_stats.at("Special Attack"));
        BOOST_CHECK_EQUAL(pkmn1_stats.at("Special Defense"), pkmn2_stats.at("Special Defense"));
    }

    pkmn::dict<pkmn::pkstring, int> pkmn1_EVs = pkmn1->get_EVs();
    pkmn::dict<pkmn::pkstring, int> pkmn2_EVs = pkmn2->get_EVs();
    BOOST_CHECK_EQUAL(pkmn1_EVs.at("HP"), pkmn2_EVs.at("HP"));
    BOOST_CHECK_EQUAL(pkmn1_EVs.at("Attack"), pkmn2_EVs.at("Attack"));
    BOOST_CHECK_EQUAL(pkmn1_EVs.at("Defense"), pkmn2_EVs.at("Defense"));
    BOOST_CHECK_EQUAL(pkmn1_EVs.at("Speed"), pkmn2_EVs.at("Speed"));

    if(pkmn1->get_generation() < 3)
        BOOST_CHECK_EQUAL(pkmn1_EVs.at("Special"), pkmn2_EVs.at("Special"));
    else
    {
        BOOST_CHECK_EQUAL(pkmn1_EVs.at("Special Attack"), pkmn2_EVs.at("Special Attack"));
        BOOST_CHECK_EQUAL(pkmn1_EVs.at("Special Defense"), pkmn2_EVs.at("Special Defense"));
    }

    pkmn::dict<pkmn::pkstring, int> pkmn1_IVs = pkmn1->get_IVs();
    pkmn::dict<pkmn::pkstring, int> pkmn2_IVs = pkmn2->get_IVs();
    BOOST_CHECK_EQUAL(pkmn1_IVs.at("HP"), pkmn2_IVs.at("HP"));
    BOOST_CHECK_EQUAL(pkmn1_IVs.at("Attack"), pkmn2_IVs.at("Attack"));
    BOOST_CHECK_EQUAL(pkmn1_IVs.at("Defense"), pkmn2_IVs.at("Defense"));
    BOOST_CHECK_EQUAL(pkmn1_IVs.at("Speed"), pkmn2_IVs.at("Speed"));

    if(pkmn1->get_generation() < 3)
        BOOST_CHECK_EQUAL(pkmn1_IVs.at("Special"), pkmn2_IVs.at("Special"));
    else
    {
        BOOST_CHECK_EQUAL(pkmn1_IVs.at("Special Attack"), pkmn2_IVs.at("Special Attack"));
        BOOST_CHECK_EQUAL(pkmn1_IVs.at("Special Defense"), pkmn2_IVs.at("Special Defense"));
    }

    pkmn::moveset_t moves1, moves2;
    pkmn1->get_moves(moves1);
    pkmn2->get_moves(moves2);
    BOOST_CHECK(moves1[0].name == moves2[0].name);
    BOOST_CHECK(moves1[1].name == moves2[1].name);
    BOOST_CHECK(moves1[2].name == moves2[2].name);
    BOOST_CHECK(moves1[3].name == moves2[3].name);

    pkmn::dict<pkmn::pkstring, int> pkmn1_attributes = pkmn1->get_attributes();
    pkmn::dict<pkmn::pkstring, int> pkmn2_attributes = pkmn2->get_attributes();
    BOOST_CHECK_EQUAL(pkmn1_attributes.size(), pkmn2_attributes.size());
    BOOST_FOREACH(const pkmn::pkstring &key, pkmn1_attributes.keys())
    {
        BOOST_CHECK_EQUAL(pkmn1_attributes.at(key), pkmn1_attributes.at(key,(pkmn1_attributes.at(key)-1)));
    }
}
Exemple #3
0
// Make sure parsing doesn't crash.
void read_all_pokemon_fields(const pkmn::pokemon::sptr& pokemon)
{
    std::string game = pokemon->get_game();
    int generation = game_generations.at(game);
    (void)generation;

    (void)pokemon->get_species();
    (void)pokemon->get_form();
    (void)pokemon->get_condition();
    (void)pokemon->get_nickname();
    (void)pokemon->get_original_trainer_name();
    (void)pokemon->get_experience();
    (void)pokemon->get_level();
    (void)pokemon->get_moves();
    (void)pokemon->get_EVs();
    (void)pokemon->get_IVs();
    (void)pokemon->get_current_hp();
    (void)pokemon->get_stats();
    (void)pokemon->get_icon_filepath();
    (void)pokemon->get_sprite_filepath();

    for(const std::string& attribute: pokemon->get_numeric_attribute_names())
    {
        (void)pokemon->get_numeric_attribute(attribute);
    }
    for(const std::string& attribute: pokemon->get_string_attribute_names())
    {
        (void)pokemon->get_string_attribute(attribute);
    }
    for(const std::string& attribute: pokemon->get_boolean_attribute_names())
    {
        (void)pokemon->get_boolean_attribute(attribute);
    }

    if(generation >= 2)
    {
        (void)pokemon->is_egg();
        (void)pokemon->get_gender();
        (void)pokemon->is_shiny();
        (void)pokemon->get_held_item();
        (void)pokemon->get_pokerus_duration();
        (void)pokemon->get_original_trainer_gender();
        (void)pokemon->get_current_trainer_friendship();
        (void)pokemon->get_level_met();
        (void)pokemon->get_location_met(false);
    }
    if(generation >= 3)
    {
        (void)pokemon->get_ability();
        (void)pokemon->get_ball();
        (void)pokemon->get_personality();
        (void)pokemon->get_markings();
        (void)pokemon->get_ribbons();
        (void)pokemon->get_contest_stats();
    }
    if(generation >= 4)
    {
        (void)pokemon->get_location_met(true);
    }
}