jake/elseware
1
0
Fork 0
Code Issues 63 Pull Requests 1 Projects Releases Wiki Activity

add esweapon to item mod.rs and fix dumb mistakes

Browse Source
This commit is contained in:
andy 2020-09-06 23:46:52 -03:00
parent 85798c83a2
commit 48b162f221
2 changed files with 85 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

156
src/entity/item/esweapon.rs
View File

@ -1,11 +1,13 @@
// TODO: actually use this // TODO: actually use this
pub enum SrankError { #[derive(Debug)]
InvalidSrankType, pub enum ESWeaponError {
InvalidSrankSpecial, InvalidESWeaponType,
InvalidSrankName, InvalidESWeaponSpecial,
InvalidESWeaponName,
} }
pub enum SrankType { #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum ESWeaponType {
Saber = 0, Saber = 0,
Sword, Sword,
Blade, Blade,
@ -38,49 +40,50 @@ pub enum SrankType {
Axe, Axe,
} }
impl SrankType { impl ESWeaponType {
pub fn to_value(&self) -> u8 { pub fn to_value(&self) -> u8 {
*self as u8 *self as u8
} }
pub fn from_value(value: u8) -> Result<SrankType, SRankError> { pub fn from_value(value: u8) -> Result<ESWeaponType, ESWeaponError> {
match value { match value {
0 => Ok(SrankType::Saber), 0 => Ok(ESWeaponType::Saber),
1 => Ok(SrankType::Sword), 1 => Ok(ESWeaponType::Sword),
2 => Ok(SrankType::Blade), 2 => Ok(ESWeaponType::Blade),
3 => Ok(SrankType::Partisan), 3 => Ok(ESWeaponType::Partisan),
4 => Ok(SrankType::Slicer), 4 => Ok(ESWeaponType::Slicer),
5 => Ok(SrankType::Gun), 5 => Ok(ESWeaponType::Gun),
6 => Ok(SrankType::Rifle), 6 => Ok(ESWeaponType::Rifle),
7 => Ok(SrankType::Mechgun), 7 => Ok(ESWeaponType::Mechgun),
8 => Ok(SrankType::Shot), 8 => Ok(ESWeaponType::Shot),
9 => Ok(SrankType::Can), 9 => Ok(ESWeaponType::Can),
10 => Ok(SrankType::Rod), 10 => Ok(ESWeaponType::Rod),
11 => Ok(SrankType::Wand), 11 => Ok(ESWeaponType::Wand),
12 => Ok(SrankType::Twin), 12 => Ok(ESWeaponType::Twin),
13 => Ok(SrankType::Claw), 13 => Ok(ESWeaponType::Claw),
14 => Ok(SrankType::Bazooka), 14 => Ok(ESWeaponType::Bazooka),
15 => Ok(SrankType::Needle), 15 => Ok(ESWeaponType::Needle),
16 => Ok(SrankType::Scythe), 16 => Ok(ESWeaponType::Scythe),
17 => Ok(SrankType::Hammer), 17 => Ok(ESWeaponType::Hammer),
18 => Ok(SrankType::Moon), 18 => Ok(ESWeaponType::Moon),
19 => Ok(SrankType::Psychogun), 19 => Ok(ESWeaponType::Psychogun),
20 => Ok(SrankType::Punch), 20 => Ok(ESWeaponType::Punch),
21 => Ok(SrankType::Windmill), 21 => Ok(ESWeaponType::Windmill),
22 => Ok(SrankType::Harisen), 22 => Ok(ESWeaponType::Harisen),
23 => Ok(SrankType::Katana), 23 => Ok(ESWeaponType::Katana),
24 => Ok(SrankType::JCutter), 24 => Ok(ESWeaponType::JCutter),
25 => Ok(SrankType::Swords), 25 => Ok(ESWeaponType::Swords),
26 => Ok(SrankType::Launcher), 26 => Ok(ESWeaponType::Launcher),
27 => Ok(SrankType::Cards), 27 => Ok(ESWeaponType::Cards),
28 => Ok(SrankType::Knuckle), 28 => Ok(ESWeaponType::Knuckle),
29 => Ok(SrankType::Axe), 29 => Ok(ESWeaponType::Axe),
_ => Err(SrankError::InvalidSrankype), _ => Err(ESWeaponError::InvalidESWeaponType),
} }
} }
} }
pub enum SrankSpecial { #[derive(Clone, Copy, Debug, PartialEq)]
pub enum ESWeaponSpecial {
Jellen = 0, Jellen = 0,
Zalure, Zalure,
HPRegen, HPRegen,
@ -99,45 +102,46 @@ pub enum SrankSpecial {
Kings, Kings,
} }
impl SrankSpecial { impl ESWeaponSpecial {
pub fn to_value(&self) -> u8 { pub fn to_value(&self) -> u8 {
*self as u8 *self as u8
} }
pub fn from_value(value: u8) -> Result<SrankSpecial, SrankError> { pub fn from_value(value: u8) -> Result<ESWeaponSpecial, ESWeaponError> {
match value{ match value{
0 => Ok(SrankSpecial::Jellen), 0 => Ok(ESWeaponSpecial::Jellen),
1 => Ok(SrankSpecial::Zalure), 1 => Ok(ESWeaponSpecial::Zalure),
2 => Ok(SrankSpecial::HPRegen), 2 => Ok(ESWeaponSpecial::HPRegen),
3 => Ok(SrankSpecial::TPRegen), 3 => Ok(ESWeaponSpecial::TPRegen),
4 => Ok(SrankSpecial::Burning), 4 => Ok(ESWeaponSpecial::Burning),
5 => Ok(SrankSpecial::Tempest), 5 => Ok(ESWeaponSpecial::Tempest),
6 => Ok(SrankSpecial::Blizzard), 6 => Ok(ESWeaponSpecial::Blizzard),
7 => Ok(SrankSpecial::Arrest), 7 => Ok(ESWeaponSpecial::Arrest),
8 => Ok(SrankSpecial::Chaos), 8 => Ok(ESWeaponSpecial::Chaos),
9 => Ok(SrankSpecial::Hell), 9 => Ok(ESWeaponSpecial::Hell),
10 => Ok(SrankSpecial::Spirit), 10 => Ok(ESWeaponSpecial::Spirit),
11 => Ok(SrankSpecial::Berserk), 11 => Ok(ESWeaponSpecial::Berserk),
12 => Ok(SrankSpecial::Demons), 12 => Ok(ESWeaponSpecial::Demons),
13 => Ok(SrankSpecial::Gush), 13 => Ok(ESWeaponSpecial::Gush),
14 => Ok(SrankSpecial::Geist), 14 => Ok(ESWeaponSpecial::Geist),
15 => Ok(SrankSpecial::Kings), 15 => Ok(ESWeaponSpecial::Kings),
_ => Err(SrankError::InvalidSrankSpecial), _ => Err(ESWeaponError::InvalidESWeaponSpecial),
} }
} }
} }
pub struct SRankWeapon { #[derive(Clone, Debug, PartialEq)]
pub type: SrankType, pub struct ESWeapon {
pub special: Option<SrankSpecial>, pub esweapon: ESWeaponType,
pub special: Option<ESWeaponSpecial>,
pub name: String, pub name: String,
pub grind: u8, pub grind: u8,
} }
impl SRankWeapon { impl ESWeapon {
pub fn new(t: SrankType) -> SRankWeapon { pub fn new(t: ESWeaponType) -> ESWeapon {
SRankWeapon { ESWeapon {
type: t, esweapon: t,
special: None, special: None,
name: "".to_owned(), name: "".to_owned(),
grind: 0, grind: 0,
@ -195,24 +199,24 @@ impl SRankWeapon {
pub fn as_bytes(&self) -> [u8; 16] { pub fn as_bytes(&self) -> [u8; 16] {
let mut result = [0u8; 16]; let mut result = [0u8; 16];
result[1] = 0x70 + self.type.to_value(); result[1] = 0x70 + self.esweapon.to_value();
result[2] = self.special.to_value(); result[2] = self.special.map(|s| s.to_value()).unwrap_or(0);
result[3] = self.grind; result[3] = self.grind;
//result[4] = tekked/untekked flag //result[4] = tekked/untekked flag
result[6..12].clone_from_slice(self.name.bytes_from_name()); result[6..12].clone_from_slice(&self.bytes_from_name());
result result
} }
// TODO: return Result<SRankWeapon, SRankError> // TODO: return Result<ESWeapon, ESWeaponError>
pub fn from_bytes(bytes: [u8; 16]) -> SRankWeapon { pub fn from_bytes(bytes: [u8; 16]) -> ESWeapon {
let type = SrankType.from_value(bytes[1] - 0x70).unwrap(); let esweapon = ESWeaponType::from_value(bytes[1] - 0x70).unwrap();
let special = SrankSpecial.from_value(bytes[2]).unwrap(); let special = ESWeaponSpecial::from_value(bytes[2]);
let grind = bytes[3]; let grind = bytes[3];
let name = SRankWeapon::name_from_bytes(bytes[6..12]); let name = ESWeapon::name_from_bytes(&bytes[6..12]);
SRankWeapon { ESWeapon {
type: type, esweapon: esweapon,
special: special, special: special.ok(),
grind: grind, grind: grind,
name: name, name: name,
} }

5
src/entity/item/mod.rs
View File

@ -6,6 +6,7 @@ pub mod tool;
pub mod tech; pub mod tech;
pub mod unit; pub mod unit;
pub mod mag; pub mod mag;
pub mod esweapon;
use crate::entity::character::CharacterEntityId; use crate::entity::character::CharacterEntityId;
use crate::ship::map::MapArea; use crate::ship::map::MapArea;
@ -75,6 +76,7 @@ pub enum ItemType {
Tool(tool::ToolType), Tool(tool::ToolType),
TechniqueDisk(tech::Technique), TechniqueDisk(tech::Technique),
Mag(mag::MagType), Mag(mag::MagType),
ESWeapon(esweapon::ESWeaponType),
} }
#[derive(Clone, Debug, PartialEq)] #[derive(Clone, Debug, PartialEq)]
@ -91,6 +93,7 @@ pub enum ItemDetail {
Tool(tool::Tool), Tool(tool::Tool),
TechniqueDisk(tech::TechniqueDisk), TechniqueDisk(tech::TechniqueDisk),
Mag(mag::Mag), Mag(mag::Mag),
ESWeapon(esweapon::ESWeapon),
} }
impl ItemDetail { impl ItemDetail {
@ -110,6 +113,7 @@ impl ItemDetail {
ItemDetail::Tool(t) => ItemType::Tool(t.tool), ItemDetail::Tool(t) => ItemType::Tool(t.tool),
ItemDetail::TechniqueDisk(d) => ItemType::TechniqueDisk(d.tech), ItemDetail::TechniqueDisk(d) => ItemType::TechniqueDisk(d.tech),
ItemDetail::Mag(m) => ItemType::Mag(m.mag), ItemDetail::Mag(m) => ItemType::Mag(m.mag),
ItemDetail::ESWeapon(e) => ItemType::ESWeapon(e.esweapon),
} }
} }
@ -141,6 +145,7 @@ impl ItemDetail {
ItemDetail::Tool(t) => t.as_individual_bytes(), ItemDetail::Tool(t) => t.as_individual_bytes(),
ItemDetail::TechniqueDisk(d) => d.as_bytes(), ItemDetail::TechniqueDisk(d) => d.as_bytes(),
ItemDetail::Mag(m) => m.as_bytes(), ItemDetail::Mag(m) => m.as_bytes(),
ItemDetail::ESWeapon(e) => e.as_bytes(),
} }
} }
} }