hheik
/
iv-tools
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

added ability info

master
hheik 2023-04-01 19:28:19 +03:00
parent b071b55a58
commit a8fd4e8ba1
8 changed files with 1268 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1066
data/abilities.json Normal file
View File

File diff suppressed because it is too large Load Diff

8
src/database.rs
View File

@ -7,10 +7,7 @@ use std::{
use bevy::prelude::*;
use json::JsonValue;
use crate::{
json::{read_characteristics, read_natures, read_pokedex},
pokemon::*,
};
use crate::{json::*, pokemon::*};
pub struct DatabasePlugin;
@ -19,6 +16,7 @@ impl Plugin for DatabasePlugin {
app.insert_resource(Database::<Pokemon>::default())
.insert_resource(Database::<Nature>::default())
.insert_resource(Database::<Characteristic>::default())
.insert_resource(Database::<Ability>::default())
.add_startup_system(database_setup);
}
}
@ -46,9 +44,11 @@ where
fn database_setup(
mut pokemon_database: ResMut<Database<Pokemon>>,
mut ability_database: ResMut<Database<Ability>>,
mut nature_database: ResMut<Database<Nature>>,
mut characteristic_database: ResMut<Database<Characteristic>>,
) {
ability_database.populate_from_json(&read_abilities());
nature_database.populate_from_json(&read_natures());
pokemon_database.populate_from_json(&read_pokedex());
characteristic_database.populate_from_json(&read_characteristics());

58
src/ivpeek/battle.rs
View File

@ -1,4 +1,4 @@
use super::inspector::{Battle, PokemonInstance};
use super::inspector::{Battle, ParsedPokemonInstance};
use crate::pokemon::*;
const PLAYER_PARTY_OFFSET: usize = 0x21E42C;
@ -29,7 +29,7 @@ struct Header {
checksum: u16,
}
pub fn parse_battle_party(data: &Vec<u8>) -> Result<Battle, String> {
pub fn parse_battle_party(data: &Vec<u8>) -> Result<Battle<ParsedPokemonInstance>, String> {
let mut battle = Battle::default();
for i in 0..PARTY_MAX_SIZE {
if let Some(instance) = try_parse(data, PLAYER_PARTY_OFFSET + i * POKEMON_SIZE) {
@ -42,13 +42,13 @@ pub fn parse_battle_party(data: &Vec<u8>) -> Result<Battle, String> {
Ok(battle)
}
fn try_parse(data: &[u8], offset: usize) -> Option<PokemonInstance> {
fn try_parse(data: &[u8], offset: usize) -> Option<ParsedPokemonInstance> {
let encrypted = &data[offset..offset + POKEMON_SIZE];
if !contains_pokemon(encrypted) {
return None;
}
let decrypted = decrypt_pokemon(encrypted).ok()?;
// println!("{}", debug_pokemon_data(&decrypted));
println!("{}", debug_pokemon_data(&decrypted));
let pokemon = parse_pokemon(&decrypted).ok()?;
Some(pokemon)
}
@ -113,40 +113,18 @@ fn decrypt_pokemon(encrypted: &[u8]) -> Result<Vec<u8>, String> {
Ok(unshuffled)
}
fn parse_pokemon(data: &[u8]) -> Result<PokemonInstance, String> {
fn parse_pokemon(data: &[u8]) -> Result<ParsedPokemonInstance, String> {
validate_size(data)?;
let mut instance = PokemonInstance::default();
let mut instance = ParsedPokemonInstance::default();
let offset_a: usize = 0x08 + 0 * BLOCK_SIZE;
let offset_b: usize = 0x08 + 1 * BLOCK_SIZE;
let offset_c: usize = 0x08 + 2 * BLOCK_SIZE;
let offset_d: usize = 0x08 + 3 * BLOCK_SIZE;
instance.pokemon.national = read_short(data, offset_a + 0x00);
let ivs = read_long(data, offset_b + 0x10);
instance.ivs.insert(BaseStat::Hp, ((ivs >> 0) & 31) as u8);
instance
.ivs
.insert(BaseStat::Attack, ((ivs >> 5) & 31) as u8);
instance
.ivs
.insert(BaseStat::Defense, ((ivs >> 10) & 31) as u8);
instance
.ivs
.insert(BaseStat::Speed, ((ivs >> 15) & 31) as u8);
instance
.ivs
.insert(BaseStat::SpecialAttack, ((ivs >> 20) & 31) as u8);
instance
.ivs
.insert(BaseStat::SpecialDefense, ((ivs >> 25) & 31) as u8);
instance.nature = Some(Nature {
pid: read_byte(data, offset_b + 0x19),
..Default::default()
});
instance.pokemon = read_short(data, offset_a + 0x00);
instance.ability = read_byte(data, offset_a + 0x0D);
instance
.evs
@ -167,6 +145,26 @@ fn parse_pokemon(data: &[u8]) -> Result<PokemonInstance, String> {
.evs
.insert(BaseStat::SpecialDefense, read_byte(data, offset_a + 0x15));
let ivs = read_long(data, offset_b + 0x10);
instance.ivs.insert(BaseStat::Hp, ((ivs >> 0) & 31) as u8);
instance
.ivs
.insert(BaseStat::Attack, ((ivs >> 5) & 31) as u8);
instance
.ivs
.insert(BaseStat::Defense, ((ivs >> 10) & 31) as u8);
instance
.ivs
.insert(BaseStat::Speed, ((ivs >> 15) & 31) as u8);
instance
.ivs
.insert(BaseStat::SpecialAttack, ((ivs >> 20) & 31) as u8);
instance
.ivs
.insert(BaseStat::SpecialDefense, ((ivs >> 25) & 31) as u8);
instance.nature = read_byte(data, offset_b + 0x19);
Ok(instance)
}

72
src/ivpeek/inspector.rs
View File

@ -3,7 +3,10 @@ use std::collections::HashMap;
use bevy::prelude::*;
use bevy_egui::EguiContexts;
use crate::{database::load_url_asset, pokemon::*};
use crate::{
database::{load_url_asset, Database},
pokemon::*,
};
use super::ui::{EguiAsset, UiAssets};
@ -18,23 +21,82 @@ impl Plugin for InspectorPlugin {
#[derive(Resource, Default)]
pub struct Inspector {
pub battle: Battle,
pub battle: Battle<PokemonInstance>,
}
#[derive(Default, Clone)]
pub struct Battle {
pub player_party: Vec<PokemonInstance>,
pub enemy_party: Vec<PokemonInstance>,
pub struct Battle<T> {
pub player_party: Vec<T>,
pub enemy_party: Vec<T>,
}
#[derive(Default, Clone)]
pub struct PokemonInstance {
pub pokemon: Pokemon,
pub ability: Option<Ability>,
pub nature: Option<Nature>,
pub ivs: HashMap<BaseStat, u8>,
pub evs: HashMap<BaseStat, u8>,
}
impl PokemonInstance {
pub fn from_parsed(
parsed: &ParsedPokemonInstance,
pokedex: &Res<Database<Pokemon>>,
natures: &Res<Database<Nature>>,
abilities: &Res<Database<Ability>>,
) -> Result<Self, String> {
let mut instance = PokemonInstance::default();
// pokemon data
if let Some(pokemon) = pokedex
.map
.values()
.find(|pokemon| pokemon.national == parsed.pokemon)
{
instance.pokemon = pokemon.clone();
} else {
return Err(format!("National dex not found: {}", parsed.pokemon));
}
// ability data
if let Some(ability) = abilities
.map
.values()
.find(|ability| ability.id == parsed.ability as u16)
{
instance.ability = Some(ability.clone());
} else {
return Err(format!("Ability id not found: {}", parsed.ability));
}
// nature data
if let Some(nature) = natures
.map
.values()
.find(|nature| nature.pid == parsed.nature)
{
instance.nature = Some(nature.clone());
} else {
return Err(format!("Nature pid not found: {}", parsed.nature));
}
instance.ivs = parsed.ivs.clone();
instance.evs = parsed.evs.clone();
Ok(instance)
}
}
#[derive(Default, Clone)]
pub struct ParsedPokemonInstance {
pub pokemon: u16,
pub ability: u8,
pub nature: u8,
pub ivs: HashMap<BaseStat, u8>,
pub evs: HashMap<BaseStat, u8>,
}
fn state_changed(
inspector: Res<Inspector>,
assets: Res<AssetServer>,

61
src/ivpeek/memory_reader.rs
View File

@ -9,16 +9,13 @@ use std::{
use crate::{database::Database, pokemon::*};
use super::{
battle::parse_battle_party,
inspector::{Battle, Inspector},
};
use super::{battle::parse_battle_party, inspector::*};
pub struct MemoryReaderPlugin;
impl Plugin for MemoryReaderPlugin {
fn build(&self, app: &mut App) {
app.add_event::<ParsedBattleEvent>()
app.add_event::<BattleEvent>()
.insert_resource(EventQueue::default())
.add_startup_system(init_memory_reader)
.add_system(flush_updates)
@ -27,54 +24,40 @@ impl Plugin for MemoryReaderPlugin {
}
#[derive(Default)]
pub struct ParsedBattleEvent(Battle);
pub struct BattleEvent(Battle<PokemonInstance>);
#[derive(Resource, Default)]
struct EventQueue {
updates: Arc<Mutex<Vec<ParsedBattleEvent>>>,
updates: Arc<Mutex<Vec<Battle<ParsedPokemonInstance>>>>,
}
fn flush_updates(
queue: Res<EventQueue>,
pokedex: Res<Database<Pokemon>>,
abilities: Res<Database<Ability>>,
natures: Res<Database<Nature>>,
mut events: EventWriter<ParsedBattleEvent>,
mut events: EventWriter<BattleEvent>,
) {
match queue.updates.lock() {
Ok(mut updates) => {
for mut update in updates.drain(..) {
for mut instance in update
.0
.player_party
.iter_mut()
.chain(update.0.enemy_party.iter_mut())
{
// Fill pokemon data
if let Some(pokemon) = pokedex
.map
.values()
.find(|pokemon| pokemon.national == instance.pokemon.national)
{
instance.pokemon = pokemon.clone();
} else {
warn!("National dex not found: {}", instance.pokemon.national);
}
for update in updates.drain(..) {
let mut battle = Battle::default();
// Fill nature data
if let Some(instance_nature) = instance.nature.clone() {
if let Some(nature) = natures
.map
.values()
.find(|nature| nature.pid == instance_nature.pid)
{
instance.nature = Some(nature.clone());
} else {
warn!("Nature pid not found: {}", instance_nature.pid);
}
for parsed in update.player_party.iter() {
match PokemonInstance::from_parsed(parsed, &pokedex, &natures, &abilities) {
Ok(instance) => battle.player_party.push(instance),
Err(err) => warn!("{err}"),
}
}
events.send(update)
for parsed in update.enemy_party.iter() {
match PokemonInstance::from_parsed(parsed, &pokedex, &natures, &abilities) {
Ok(instance) => battle.enemy_party.push(instance),
Err(err) => warn!("{err}"),
}
}
events.send(BattleEvent(battle))
}
}
Err(err) => {
@ -83,7 +66,7 @@ fn flush_updates(
}
}
fn update_inspector(mut inspector: ResMut<Inspector>, mut events: EventReader<ParsedBattleEvent>) {
fn update_inspector(mut inspector: ResMut<Inspector>, mut events: EventReader<BattleEvent>) {
for event in events.iter() {
inspector.battle = event.0.clone();
}
@ -113,7 +96,7 @@ fn init_memory_reader(queue: Res<EventQueue>) {
match fs::read(&event.path) {
Ok(data) => match parse_battle_party(&data) {
Ok(battle) => match updates.lock() {
Ok(mut updates) => updates.push(ParsedBattleEvent(battle)),
Ok(mut updates) => updates.push(battle),
Err(err) => error!("{err}"),
},
Err(err) => error!("Failed to parse party data: ${err}"),

103
src/ivpeek/ui.rs
View File

@ -9,7 +9,7 @@ use super::inspector::{Inspector, PokemonInstance};
const BAR_HEIGHT: f32 = 12.0;
const SPRITE_SIZE: f32 = 128.0;
const SPRITE_PADDING: f32 = 32.0;
const SPRITE_PADDING: f32 = 16.0;
const BASE_STAT_WIDTH_MULT: f32 = 0.5;
const IV_WIDTH_MULT: f32 = 4.0;
const EV_WIDTH_MULT: f32 = 0.25;
@ -106,66 +106,69 @@ fn render_pokemon_instance(
) {
let sprite_size = egui::Vec2::new(SPRITE_SIZE, SPRITE_SIZE);
let pokemon = instance.pokemon.clone();
let ability = instance.ability.clone();
let nature = instance.nature.clone();
ui.horizontal(|ui| {
ui.horizontal(|ui| {
ui.set_min_width(sprite_size.x + SPRITE_PADDING);
ui.set_max_width(sprite_size.x + SPRITE_PADDING);
// Name
ui.label(egui::RichText::new(&pokemon.full_name).color(egui::Color32::LIGHT_GRAY));
ui.vertical(|ui| {
ui.horizontal(|ui| {
ui.set_min_width(sprite_size.x + SPRITE_PADDING);
ui.set_max_width(sprite_size.x + SPRITE_PADDING);
// Name
ui.label(egui::RichText::new(&pokemon.full_name).color(egui::Color32::LIGHT_GRAY));
// Types
ui.label(format!(
"{} / {}",
pokemon.type1.as_ref().map_or("-", |t| t.name.as_str()),
pokemon.type2.as_ref().map_or("-", |t| t.name.as_str())
));
});
// Types
ui.label(format!(
"{} / {}",
pokemon.type1.as_ref().map_or("-", |t| t.name.as_str()),
pokemon.type2.as_ref().map_or("-", |t| t.name.as_str())
));
});
// Headings
ui.horizontal(|ui| {
for (i, width) in COLUMNS.iter().enumerate() {
ui.horizontal(|ui| {
ui.set_width(*width);
match i {
1 => {
ui.label(egui::RichText::new("Base stat"));
}
2 => {
ui.label(egui::RichText::new("EV"));
}
3 => {
ui.label(egui::RichText::new(format!(
"{} / 510",
instance.evs.values().map(|v| *v as i32).sum::<i32>()
)));
}
5 => {
ui.label(egui::RichText::new("IV"));
}
_ => (),
}
});
}
});
});
ui.label(ability.as_ref().map_or("-", |a| a.name.as_str()));
ui.horizontal(|ui| {
// Sprite
ui.horizontal(|ui| {
ui.set_min_size(sprite_size);
ui.set_max_size(sprite_size);
if let Some(EguiAsset(_, rendered_texture_id)) =
ui_assets.sprite_map.get(&pokemon.key())
{
ui.add(egui::Image::new(*rendered_texture_id, sprite_size));
}
// Sprite
ui.horizontal(|ui| {
ui.set_min_size(sprite_size);
ui.set_max_size(sprite_size);
if let Some(EguiAsset(_, rendered_texture_id)) =
ui_assets.sprite_map.get(&pokemon.key())
{
ui.add(egui::Image::new(*rendered_texture_id, sprite_size));
}
});
});
ui.add_space(SPRITE_PADDING);
ui.vertical(|ui| {
ui.add_space(16.);
// Headings
ui.horizontal(|ui| {
for (i, width) in COLUMNS.iter().enumerate() {
ui.horizontal(|ui| {
ui.set_width(*width);
match i {
1 => {
ui.label(egui::RichText::new("Base stat"));
}
2 => {
ui.label(egui::RichText::new("EV"));
}
3 => {
ui.label(egui::RichText::new(format!(
"{} / 510",
instance.evs.values().map(|v| *v as i32).sum::<i32>()
)));
}
5 => {
ui.label(egui::RichText::new("IV"));
}
_ => (),
}
});
}
});
for stat in BaseStat::all() {
ui.horizontal(|ui| {
let mut column_size = COLUMNS.iter();

4
src/json.rs
View File

@ -26,6 +26,10 @@ pub fn parse_json_file<P: AsRef<Path>>(path: P) -> JsonValue {
json::parse(fs::read_to_string(path).unwrap().as_ref()).unwrap()
}
pub fn read_abilities() -> JsonValue {
parse_json_file(DATA_DIR.join("abilities.json"))
}
pub fn read_natures() -> JsonValue {
parse_json_file(DATA_DIR.join("natures.json"))
}

24
src/pokemon.rs
View File

@ -247,6 +247,30 @@ impl GetKey for Type {
}
}
#[derive(Default, Debug, Clone)]
pub struct Ability {
pub id: u16,
pub name: String,
}
impl FromJson for Ability {
fn from_json(json: &json::JsonValue) -> Option<Self>
where
Self: Sized,
{
Some(Self {
id: json["id"].as_u16()?,
name: json["name"].as_str()?.to_string(),
})
}
}
impl GetKey for Ability {
fn key(&self) -> String {
self.name.clone()
}
}
#[derive(Default, Debug, Clone, Reflect, FromReflect, PartialEq)]
pub struct Nature {
pub id: u8,