27 changed files with 1379 additions and 69 deletions
-
6Cargo.toml
-
3data/item_stats/mag_stats.toml
-
10src/bin/main.rs
-
2src/common/mainloop/client.rs
-
9src/common/mainloop/interserver.rs
-
13src/entity/account.rs
-
10src/entity/character.rs
-
4src/entity/gateway/entitygateway.rs
-
2src/entity/gateway/inmemory.rs
-
2src/entity/gateway/mod.rs
-
121src/entity/gateway/postgres/migrations/V0001__initial.sql
-
3src/entity/gateway/postgres/migrations/mod.rs
-
5src/entity/gateway/postgres/mod.rs
-
691src/entity/gateway/postgres/models.rs
-
404src/entity/gateway/postgres/postgres.rs
-
5src/entity/item/esweapon.rs
-
25src/entity/item/tech.rs
-
2src/entity/item/unit.rs
-
4src/entity/item/weapon.rs
-
12src/login/character.rs
-
20src/login/login.rs
-
4src/ship/items/inventory.rs
-
34src/ship/items/manager.rs
-
3src/ship/map/area.rs
-
7tests/common.rs
-
1tests/test_shops.rs
@ -1,5 +1,7 @@ |
|||
pub mod entitygateway;
|
|||
pub mod inmemory;
|
|||
pub mod postgres;
|
|||
|
|||
pub use entitygateway::EntityGateway;
|
|||
pub use inmemory::InMemoryGateway;
|
|||
pub use self::postgres::PostgresGateway;
|
|||
@ -0,0 +1,121 @@ |
|||
create table user_accounts ( |
|||
id serial primary key not null, |
|||
email varchar(128) not null unique, |
|||
username varchar(128) not null unique, |
|||
password varchar(128) not null, |
|||
banned timestamptz, |
|||
muted timestamptz, |
|||
created_at timestamptz default current_timestamp not null, |
|||
flags integer default 0 not null, |
|||
activated boolean default false not null, |
|||
game_session integer, |
|||
interserver_session integer |
|||
); |
|||
|
|||
create table user_settings ( |
|||
id serial primary key not null, |
|||
user_account integer references user_accounts (id) not null, |
|||
blocked_users bytea not null, |
|||
key_config bytea not null, |
|||
joystick_config bytea not null, |
|||
option_flags integer not null, |
|||
shortcuts bytea not null, |
|||
symbol_chats bytea not null, |
|||
team_name bytea not null |
|||
); |
|||
|
|||
/* TODO: guild card data */ |
|||
|
|||
create table player_character ( |
|||
id serial primary key not null, |
|||
user_account integer references user_accounts (id) not null, |
|||
slot smallint not null, |
|||
name varchar(12) not null, |
|||
exp integer not null, |
|||
class varchar(12) null, |
|||
section_id varchar(12) not null, |
|||
|
|||
costume smallint not null, |
|||
skin smallint not null, |
|||
face smallint not null, |
|||
head smallint not null, |
|||
hair smallint not null, |
|||
hair_r smallint not null, |
|||
hair_g smallint not null, |
|||
hair_b smallint not null, |
|||
prop_x real not null, |
|||
prop_y real not null, |
|||
|
|||
techs bytea not null, |
|||
|
|||
config bytea not null, |
|||
infoboard varchar(172) not null, |
|||
guildcard varchar(172) not null, |
|||
option_flags integer not null, |
|||
|
|||
power smallint not null, |
|||
mind smallint not null, |
|||
def smallint not null, |
|||
evade smallint not null, |
|||
luck smallint not null, |
|||
hp smallint not null, |
|||
tp smallint not null, |
|||
|
|||
tech_menu bytea not null, |
|||
meseta integer not null, |
|||
bank_meseta integer not null |
|||
|
|||
); |
|||
|
|||
|
|||
create table item ( |
|||
id serial primary key not null, |
|||
item jsonb not null |
|||
); |
|||
|
|||
create table item_location ( |
|||
item integer references item (id) not null, |
|||
location jsonb not null, |
|||
created_at timestamptz default current_timestamp not null |
|||
); |
|||
|
|||
create table inventory_slots ( |
|||
pchar integer references player_character not null, |
|||
items integer[30] /* references item (id) */ |
|||
); |
|||
|
|||
create table weapon_modifier ( |
|||
weapon integer references item (id) not null, |
|||
modifier jsonb not null, |
|||
created_at timestamptz default current_timestamp not null |
|||
); |
|||
|
|||
create table armor_modifier ( |
|||
armor integer references item (id) not null, |
|||
modifier jsonb not null, |
|||
created_at timestamptz default current_timestamp not null |
|||
); |
|||
|
|||
create table shield_modifier ( |
|||
shield integer references item (id) not null, |
|||
modifier jsonb not null, |
|||
created_at timestamptz default current_timestamp not null |
|||
); |
|||
|
|||
create table unit_modifier ( |
|||
unit integer references item (id) not null, |
|||
modifier jsonb not null, |
|||
created_at timestamptz default current_timestamp not null |
|||
); |
|||
|
|||
create table esweapon_modifier ( |
|||
esweapon integer references item (id) not null, |
|||
modifier jsonb not null, |
|||
created_at timestamptz default current_timestamp not null |
|||
); |
|||
|
|||
create table mag_modifier ( |
|||
mag integer references item (id) not null, |
|||
modifier jsonb not null, |
|||
created_at timestamptz default current_timestamp not null |
|||
); |
|||
@ -0,0 +1,3 @@ |
|||
use refinery::include_migration_mods;
|
|||
|
|||
include_migration_mods!("src/entity/gateway/postgres/migrations");
|
|||
@ -0,0 +1,5 @@ |
|||
pub mod postgres;
|
|||
pub mod migrations;
|
|||
pub mod models;
|
|||
|
|||
pub use self::postgres::PostgresGateway;
|
|||
@ -0,0 +1,691 @@ |
|||
use std::collections::HashMap;
|
|||
use std::convert::Into;
|
|||
use serde::{Serialize, Deserialize};
|
|||
use futures::TryStreamExt;
|
|||
use libpso::character::{settings, guildcard};
|
|||
use libpso::util::vec_to_array;
|
|||
use crate::entity::account::*;
|
|||
use crate::entity::character::*;
|
|||
use crate::entity::gateway::EntityGateway;
|
|||
use crate::entity::item::*;
|
|||
use crate::ship::map::MapArea;
|
|||
|
|||
use sqlx::postgres::PgPoolOptions;
|
|||
use sqlx::Row;
|
|||
use sqlx::Execute;
|
|||
use postgres::{Client, NoTls};
|
|||
|
|||
|
|||
#[derive(Debug, sqlx::FromRow)]
|
|||
pub struct PgUserAccount {
|
|||
id: i32,
|
|||
username: String,
|
|||
password: String,
|
|||
banned: Option<chrono::DateTime<chrono::Utc>>,
|
|||
muted: Option<chrono::DateTime<chrono::Utc>>,
|
|||
created_at: chrono::DateTime<chrono::Utc>,
|
|||
flags: i32,
|
|||
}
|
|||
|
|||
impl Into<UserAccountEntity> for PgUserAccount {
|
|||
fn into(self) -> UserAccountEntity {
|
|||
UserAccountEntity {
|
|||
id: UserAccountId(self.id as u32),
|
|||
username: self.username,
|
|||
password: self.password,
|
|||
banned_until: self.banned,
|
|||
muted_until: self.muted,
|
|||
created_at: self.created_at,
|
|||
flags: self.flags as u32,
|
|||
// TOOD
|
|||
guildcard: self.id as u32 + 1,
|
|||
team_id: None,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
#[derive(Debug, sqlx::FromRow)]
|
|||
pub struct PgUserSettings {
|
|||
id: i32,
|
|||
user_account: i32,
|
|||
blocked_users: Vec<u8>, //[u32; 0x1E],
|
|||
key_config: Vec<u8>, //[u8; 0x16C],
|
|||
joystick_config: Vec<u8>, //[u8; 0x38],
|
|||
option_flags: i32,
|
|||
shortcuts: Vec<u8>, //[u8; 0xA40],
|
|||
symbol_chats: Vec<u8>, //[u8; 0x4E0],
|
|||
team_name: Vec<u8>, //[u16; 0x10],
|
|||
}
|
|||
|
|||
impl Into<UserSettingsEntity> for PgUserSettings {
|
|||
fn into(self) -> UserSettingsEntity {
|
|||
UserSettingsEntity {
|
|||
id: UserSettingsId(self.id as u32),
|
|||
user_id: UserAccountId(self.user_account as u32),
|
|||
settings: settings::UserSettings {
|
|||
blocked_users: vec_to_array(self.blocked_users.chunks(4).map(|b| u32::from_le_bytes([b[0], b[1], b[2], b[3]])).collect()),
|
|||
key_config: vec_to_array(self.key_config),
|
|||
joystick_config: vec_to_array(self.joystick_config),
|
|||
option_flags: self.option_flags as u32,
|
|||
shortcuts: vec_to_array(self.shortcuts),
|
|||
symbol_chats: vec_to_array(self.symbol_chats),
|
|||
team_name: vec_to_array(self.team_name.chunks(2).map(|b| u16::from_le_bytes([b[0], b[1]])).collect()),
|
|||
}
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
#[derive(sqlx::Type, Debug)]
|
|||
#[sqlx(rename_all = "lowercase")]
|
|||
pub enum PgCharacterClass {
|
|||
HUmar,
|
|||
HUnewearl,
|
|||
HUcast,
|
|||
HUcaseal,
|
|||
RAmar,
|
|||
RAmarl,
|
|||
RAcast,
|
|||
RAcaseal,
|
|||
FOmar,
|
|||
FOmarl,
|
|||
FOnewm,
|
|||
FOnewearl,
|
|||
}
|
|||
|
|||
impl Into<CharacterClass> for PgCharacterClass {
|
|||
fn into(self) -> CharacterClass {
|
|||
match self {
|
|||
PgCharacterClass::HUmar => CharacterClass::HUmar,
|
|||
PgCharacterClass::HUnewearl => CharacterClass::HUnewearl,
|
|||
PgCharacterClass::HUcast => CharacterClass::HUcast,
|
|||
PgCharacterClass::HUcaseal => CharacterClass::HUcaseal,
|
|||
PgCharacterClass::RAmar => CharacterClass::RAmar,
|
|||
PgCharacterClass::RAmarl => CharacterClass::RAmarl,
|
|||
PgCharacterClass::RAcast => CharacterClass::RAcast,
|
|||
PgCharacterClass::RAcaseal => CharacterClass::RAcaseal,
|
|||
PgCharacterClass::FOmar => CharacterClass::FOmar,
|
|||
PgCharacterClass::FOmarl => CharacterClass::FOmarl,
|
|||
PgCharacterClass::FOnewm => CharacterClass::FOnewm,
|
|||
PgCharacterClass::FOnewearl => CharacterClass::FOnewearl,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
impl From<CharacterClass> for PgCharacterClass {
|
|||
fn from(other: CharacterClass) -> PgCharacterClass {
|
|||
match other {
|
|||
CharacterClass::HUmar => PgCharacterClass::HUmar,
|
|||
CharacterClass::HUnewearl => PgCharacterClass::HUnewearl,
|
|||
CharacterClass::HUcast => PgCharacterClass::HUcast,
|
|||
CharacterClass::HUcaseal => PgCharacterClass::HUcaseal,
|
|||
CharacterClass::RAmar => PgCharacterClass::RAmar,
|
|||
CharacterClass::RAmarl => PgCharacterClass::RAmarl,
|
|||
CharacterClass::RAcast => PgCharacterClass::RAcast,
|
|||
CharacterClass::RAcaseal => PgCharacterClass::RAcaseal,
|
|||
CharacterClass::FOmar => PgCharacterClass::FOmar,
|
|||
CharacterClass::FOmarl => PgCharacterClass::FOmarl,
|
|||
CharacterClass::FOnewm => PgCharacterClass::FOnewm,
|
|||
CharacterClass::FOnewearl => PgCharacterClass::FOnewearl,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
#[derive(sqlx::Type, Debug)]
|
|||
#[sqlx(rename_all = "lowercase")]
|
|||
pub enum PgSectionId {
|
|||
Viridia,
|
|||
Greenill,
|
|||
Skyly,
|
|||
Bluefull,
|
|||
Purplenum,
|
|||
Pinkal,
|
|||
Redria,
|
|||
Oran,
|
|||
Yellowboze,
|
|||
Whitill,
|
|||
}
|
|||
|
|||
impl Into<SectionID> for PgSectionId {
|
|||
fn into(self) -> SectionID {
|
|||
match self {
|
|||
PgSectionId::Viridia => SectionID::Viridia,
|
|||
PgSectionId::Greenill => SectionID::Greenill,
|
|||
PgSectionId::Skyly => SectionID::Skyly,
|
|||
PgSectionId::Bluefull => SectionID::Bluefull,
|
|||
PgSectionId::Purplenum => SectionID::Purplenum,
|
|||
PgSectionId::Pinkal => SectionID::Pinkal,
|
|||
PgSectionId::Redria => SectionID::Redria,
|
|||
PgSectionId::Oran => SectionID::Oran,
|
|||
PgSectionId::Yellowboze => SectionID::Yellowboze,
|
|||
PgSectionId::Whitill => SectionID::Whitill,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
impl From<SectionID> for PgSectionId {
|
|||
fn from(other: SectionID) -> PgSectionId {
|
|||
match other {
|
|||
SectionID::Viridia => PgSectionId::Viridia,
|
|||
SectionID::Greenill => PgSectionId::Greenill,
|
|||
SectionID::Skyly => PgSectionId::Skyly,
|
|||
SectionID::Bluefull => PgSectionId::Bluefull,
|
|||
SectionID::Purplenum => PgSectionId::Purplenum,
|
|||
SectionID::Pinkal => PgSectionId::Pinkal,
|
|||
SectionID::Redria => PgSectionId::Redria,
|
|||
SectionID::Oran => PgSectionId::Oran,
|
|||
SectionID::Yellowboze => PgSectionId::Yellowboze,
|
|||
SectionID::Whitill => PgSectionId::Whitill,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
|
|||
#[derive(Debug, sqlx::FromRow)]
|
|||
pub struct PgCharacter {
|
|||
pub id: i32,
|
|||
user_account: i32,
|
|||
pub slot: i16,
|
|||
name: String,
|
|||
exp: i32,
|
|||
class: String,
|
|||
section_id: String,
|
|||
|
|||
costume: i16,
|
|||
skin: i16,
|
|||
face: i16,
|
|||
head: i16,
|
|||
hair: i16,
|
|||
hair_r: i16,
|
|||
hair_g: i16,
|
|||
hair_b: i16,
|
|||
prop_x: f32,
|
|||
prop_y: f32,
|
|||
|
|||
techs: Vec<u8>,
|
|||
|
|||
config: Vec<u8>,
|
|||
infoboard: String,
|
|||
guildcard: String,
|
|||
option_flags: i32,
|
|||
|
|||
power: i16,
|
|||
mind: i16,
|
|||
def: i16,
|
|||
evade: i16,
|
|||
luck: i16,
|
|||
hp: i16,
|
|||
tp: i16,
|
|||
|
|||
tech_menu: Vec<u8>,
|
|||
meseta: i32,
|
|||
bank_meseta: i32,
|
|||
}
|
|||
|
|||
impl Into<CharacterEntity> for PgCharacter {
|
|||
fn into(self) -> CharacterEntity {
|
|||
CharacterEntity {
|
|||
id: CharacterEntityId(self.id as u32),
|
|||
user_id: UserAccountId(self.user_account as u32),
|
|||
slot: self.slot as u32,
|
|||
name: self.name,
|
|||
exp: self.exp as u32,
|
|||
char_class: self.class.parse().unwrap(),
|
|||
section_id: self.section_id.parse().unwrap(),
|
|||
appearance: CharacterAppearance {
|
|||
costume: self.costume as u16,
|
|||
skin: self.skin as u16,
|
|||
face: self.face as u16,
|
|||
head: self.head as u16,
|
|||
hair: self.hair as u16,
|
|||
hair_r: self.hair_r as u16,
|
|||
hair_g: self.hair_g as u16,
|
|||
hair_b: self.hair_b as u16,
|
|||
prop_x: self.prop_x,
|
|||
prop_y: self.prop_y,
|
|||
},
|
|||
techs: CharacterTechniques {
|
|||
techs: self.techs.iter().enumerate().take(19).map(|(i, t)| (tech::Technique::from_value(i as u8), TechLevel(*t)) ).collect()
|
|||
},
|
|||
config: CharacterConfig {
|
|||
raw_data: vec_to_array(self.config)
|
|||
},
|
|||
info_board: CharacterInfoboard {
|
|||
board: libpso::utf8_to_utf16_array!(self.infoboard, 172),
|
|||
},
|
|||
guildcard: CharacterGuildCard {
|
|||
description: self.guildcard,
|
|||
},
|
|||
option_flags: self.option_flags as u32,
|
|||
materials: CharacterMaterials {
|
|||
power: self.power as u32,
|
|||
mind: self.mind as u32,
|
|||
def: self.def as u32,
|
|||
evade: self.evade as u32,
|
|||
luck: self.luck as u32,
|
|||
hp: self.hp as u32,
|
|||
tp: self.tp as u32,
|
|||
},
|
|||
tech_menu: CharacterTechMenu {
|
|||
tech_menu: vec_to_array(self.tech_menu)
|
|||
},
|
|||
meseta: self.meseta as u32,
|
|||
bank_meseta: self.bank_meseta as u32,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
#[derive(Debug, sqlx::FromRow)]
|
|||
pub struct PgGuildCard {
|
|||
}
|
|||
|
|||
|
|||
|
|||
#[derive(Debug, Serialize, Deserialize)]
|
|||
pub struct PgWeapon {
|
|||
weapon: weapon::WeaponType,
|
|||
special: Option<weapon::WeaponSpecial>,
|
|||
grind: u8,
|
|||
attrs: HashMap<weapon::Attribute, i8>,
|
|||
tekked: bool,
|
|||
}
|
|||
|
|||
impl From<weapon::Weapon> for PgWeapon {
|
|||
fn from(other: weapon::Weapon) -> PgWeapon {
|
|||
PgWeapon {
|
|||
weapon: other.weapon,
|
|||
special: other.special,
|
|||
grind: other.grind,
|
|||
attrs: other.attrs.iter().flatten().map(|attr| (attr.attr, attr.value)).collect(),
|
|||
tekked: other.tekked,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
impl Into<weapon::Weapon> for PgWeapon {
|
|||
fn into(self) -> weapon::Weapon {
|
|||
let mut attrs: [Option<weapon::WeaponAttribute>; 3] = [None; 3];
|
|||
for (attr, (atype, value)) in attrs.iter_mut().zip(self.attrs.iter()) {
|
|||
*attr = Some(weapon::WeaponAttribute {
|
|||
attr: *atype,
|
|||
value: *value
|
|||
});
|
|||
}
|
|||
|
|||
weapon::Weapon {
|
|||
weapon: self.weapon,
|
|||
special: self.special,
|
|||
grind: self.grind,
|
|||
attrs: attrs,
|
|||
tekked: self.tekked,
|
|||
modifiers: Vec::new(),
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
#[derive(Debug, Serialize, Deserialize)]
|
|||
pub struct PgArmor {
|
|||
armor: armor::ArmorType,
|
|||
dfp: u8,
|
|||
evp: u8,
|
|||
slots: u8,
|
|||
}
|
|||
|
|||
impl From<armor::Armor> for PgArmor {
|
|||
fn from(other: armor::Armor) -> PgArmor {
|
|||
PgArmor {
|
|||
armor: other.armor,
|
|||
dfp: other.dfp,
|
|||
evp: other.evp,
|
|||
slots: other.slots,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
impl Into<armor::Armor> for PgArmor {
|
|||
fn into(self) -> armor::Armor {
|
|||
armor::Armor {
|
|||
armor: self.armor,
|
|||
dfp: self.dfp,
|
|||
evp: self.evp,
|
|||
slots: self.slots,
|
|||
modifiers: Vec::new(),
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
#[derive(Debug, Serialize, Deserialize)]
|
|||
pub struct PgShield {
|
|||
shield: shield::ShieldType,
|
|||
dfp: u8,
|
|||
evp: u8,
|
|||
}
|
|||
|
|||
impl From<shield::Shield> for PgShield {
|
|||
fn from(other: shield::Shield) -> PgShield {
|
|||
PgShield {
|
|||
shield: other.shield,
|
|||
dfp: other.dfp,
|
|||
evp: other.evp,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
impl Into<shield::Shield> for PgShield {
|
|||
fn into(self) -> shield::Shield {
|
|||
shield::Shield {
|
|||
shield: self.shield,
|
|||
dfp: self.dfp,
|
|||
evp: self.evp,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
#[derive(Debug, Serialize, Deserialize)]
|
|||
pub struct PgUnit {
|
|||
unit: unit::UnitType,
|
|||
modifier: Option<unit::UnitModifier>,
|
|||
}
|
|||
|
|||
impl From<unit::Unit> for PgUnit {
|
|||
fn from(other: unit::Unit) -> PgUnit {
|
|||
PgUnit {
|
|||
unit: other.unit,
|
|||
modifier: other.modifier,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
impl Into<unit::Unit> for PgUnit {
|
|||
fn into(self) -> unit::Unit {
|
|||
unit::Unit {
|
|||
unit: self.unit,
|
|||
modifier: self.modifier,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
#[derive(Debug, Serialize, Deserialize)]
|
|||
pub struct PgTool {
|
|||
pub tool: tool::ToolType,
|
|||
}
|
|||
|
|||
impl From<tool::Tool> for PgTool {
|
|||
fn from(other: tool::Tool) -> PgTool {
|
|||
PgTool {
|
|||
tool: other.tool,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
impl Into<tool::Tool> for PgTool {
|
|||
fn into(self) -> tool::Tool {
|
|||
tool::Tool {
|
|||
tool: self.tool,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
#[derive(Debug, Serialize, Deserialize)]
|
|||
pub struct PgTechDisk {
|
|||
tech: tech::Technique,
|
|||
level: u32,
|
|||
}
|
|||
|
|||
impl From<tech::TechniqueDisk> for PgTechDisk {
|
|||
fn from(other: tech::TechniqueDisk) -> PgTechDisk {
|
|||
PgTechDisk {
|
|||
tech: other.tech,
|
|||
level: other.level,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
impl Into<tech::TechniqueDisk> for PgTechDisk {
|
|||
fn into(self) -> tech::TechniqueDisk {
|
|||
tech::TechniqueDisk {
|
|||
tech: self.tech,
|
|||
level: self.level
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
#[derive(Debug, Serialize, Deserialize)]
|
|||
pub struct PgMag {
|
|||
mag: mag::MagType,
|
|||
synchro: u8,
|
|||
color: u8,
|
|||
}
|
|||
|
|||
impl From<mag::Mag> for PgMag {
|
|||
fn from(other: mag::Mag) -> PgMag {
|
|||
PgMag {
|
|||
mag: other.mag,
|
|||
synchro: other.synchro,
|
|||
color: other.color,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
impl Into<mag::Mag> for PgMag {
|
|||
fn into(self) -> mag::Mag {
|
|||
/*mag::Mag {
|
|||
mag: self.mag,
|
|||
synchro: self.synchro,
|
|||
color: self.color,
|
|||
def: 500,
|
|||
pow: 0,
|
|||
dex: 0,
|
|||
mnd: 0,
|
|||
iq: 0,
|
|||
photon_blast: [None; 3],
|
|||
class: CharacterClass::HUmar,
|
|||
id: SectionID::Viridia,
|
|||
}*/
|
|||
let mut mag = mag::Mag::baby_mag(self.color as u16);
|
|||
mag.mag = self.mag;
|
|||
mag.synchro = self.synchro;
|
|||
mag
|
|||
}
|
|||
}
|
|||
|
|||
#[derive(Debug, Serialize, Deserialize)]
|
|||
pub struct PgESWeapon {
|
|||
esweapon: esweapon::ESWeaponType,
|
|||
special: Option<esweapon::ESWeaponSpecial>,
|
|||
name: String,
|
|||
grind: u8,
|
|||
}
|
|||
|
|||
impl From<esweapon::ESWeapon> for PgESWeapon {
|
|||
fn from(other: esweapon::ESWeapon) -> PgESWeapon {
|
|||
PgESWeapon {
|
|||
esweapon: other.esweapon,
|
|||
special: other.special,
|
|||
name: other.name,
|
|||
grind: other.grind,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
impl Into<esweapon::ESWeapon> for PgESWeapon {
|
|||
fn into(self) -> esweapon::ESWeapon {
|
|||
esweapon::ESWeapon {
|
|||
esweapon: self.esweapon,
|
|||
special: self.special,
|
|||
name: self.name,
|
|||
grind: self.grind,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
#[derive(Debug, Serialize, Deserialize)]
|
|||
pub enum PgItemDetail {
|
|||
Weapon(PgWeapon),
|
|||
Armor(PgArmor),
|
|||
Shield(PgShield),
|
|||
Unit(PgUnit),
|
|||
Tool(PgTool),
|
|||
TechDisk(PgTechDisk),
|
|||
Mag(PgMag),
|
|||
ESWeapon(PgESWeapon),
|
|||
}
|
|||
|
|||
impl From<ItemDetail> for PgItemDetail {
|
|||
fn from(other: ItemDetail) -> PgItemDetail {
|
|||
match other {
|
|||
ItemDetail::Weapon(weapon) => PgItemDetail::Weapon(weapon.into()),
|
|||
ItemDetail::Armor(armor) => PgItemDetail::Armor(armor.into()),
|
|||
ItemDetail::Shield(shield) => PgItemDetail::Shield(shield.into()),
|
|||
ItemDetail::Unit(unit) => PgItemDetail::Unit(unit.into()),
|
|||
ItemDetail::Tool(tool) => PgItemDetail::Tool(tool.into()),
|
|||
ItemDetail::TechniqueDisk(tech_disk) => PgItemDetail::TechDisk(tech_disk.into()),
|
|||
ItemDetail::Mag(mag) => PgItemDetail::Mag(mag.into()),
|
|||
ItemDetail::ESWeapon(esweapon) => PgItemDetail::ESWeapon(esweapon.into()),
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
impl Into<ItemDetail> for PgItemDetail {
|
|||
fn into(self) -> ItemDetail {
|
|||
match self {
|
|||
PgItemDetail::Weapon(weapon) => ItemDetail::Weapon(weapon.into()),
|
|||
PgItemDetail::Armor(armor) => ItemDetail::Armor(armor.into()),
|
|||
PgItemDetail::Shield(shield) => ItemDetail::Shield(shield.into()),
|
|||
PgItemDetail::Unit(unit) => ItemDetail::Unit(unit.into()),
|
|||
PgItemDetail::Tool(tool) => ItemDetail::Tool(tool.into()),
|
|||
PgItemDetail::TechDisk(tech_disk) => ItemDetail::TechniqueDisk(tech_disk.into()),
|
|||
PgItemDetail::Mag(mag) => ItemDetail::Mag(mag.into()),
|
|||
PgItemDetail::ESWeapon(esweapon) => ItemDetail::ESWeapon(esweapon.into()),
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
#[derive(Debug, sqlx::FromRow)]
|
|||
pub struct PgItem {
|
|||
pub id: i32,
|
|||
pub item: sqlx::types::Json<PgItemDetail>,
|
|||
}
|
|||
|
|||
|
|||
#[derive(Debug, Serialize, Deserialize)]
|
|||
pub enum PgItemLocationDetail {
|
|||
Inventory {
|
|||
character_id: u32,
|
|||
#[serde(skip_serializing)]
|
|||
slot: usize,
|
|||
equipped: bool,
|
|||
},
|
|||
Bank {
|
|||
character_id: u32,
|
|||
name: String,
|
|||
},
|
|||
LocalFloor {
|
|||
character_id: u32,
|
|||
map_area: MapArea,
|
|||
x: f32,
|
|||
y: f32,
|
|||
z: f32,
|
|||
},
|
|||
SharedFloor {
|
|||
map_area: MapArea,
|
|||
x: f32,
|
|||
y: f32,
|
|||
z: f32,
|
|||
},
|
|||
Consumed,
|
|||
FedToMag {
|
|||
mag: u32,
|
|||
},
|
|||
Shop,
|
|||
}
|
|||
|
|||
impl From<ItemLocation> for PgItemLocationDetail {
|
|||
fn from(other: ItemLocation) -> PgItemLocationDetail {
|
|||
match other {
|
|||
ItemLocation::Inventory{character_id, slot, equipped} => PgItemLocationDetail::Inventory{character_id: character_id.0, slot, equipped},
|
|||
ItemLocation::Bank{character_id, name} => PgItemLocationDetail::Bank{character_id: character_id.0, name: name.0},
|
|||
ItemLocation::LocalFloor{character_id, map_area, x,y,z} => PgItemLocationDetail::LocalFloor{character_id: character_id.0, map_area, x,y,z},
|
|||
ItemLocation::SharedFloor{map_area, x,y,z} => PgItemLocationDetail::SharedFloor{map_area, x,y,z},
|
|||
ItemLocation::Consumed => PgItemLocationDetail::Consumed,
|
|||
ItemLocation::FedToMag{mag} => PgItemLocationDetail::FedToMag{mag: mag.0},
|
|||
ItemLocation::Shop => PgItemLocationDetail::Shop,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
impl Into<ItemLocation> for PgItemLocationDetail {
|
|||
fn into(self) -> ItemLocation {
|
|||
match self {
|
|||
PgItemLocationDetail::Inventory{character_id, slot, equipped} => ItemLocation::Inventory{character_id: CharacterEntityId(character_id), slot, equipped},
|
|||
PgItemLocationDetail::Bank{character_id, name} => ItemLocation::Bank{character_id: CharacterEntityId(character_id), name: BankName(name)},
|
|||
PgItemLocationDetail::LocalFloor{character_id, map_area, x,y,z} => ItemLocation::LocalFloor{character_id: CharacterEntityId(character_id), map_area, x,y,z},
|
|||
PgItemLocationDetail::SharedFloor{map_area, x,y,z} => ItemLocation::SharedFloor{map_area, x,y,z},
|
|||
PgItemLocationDetail::Consumed => ItemLocation::Consumed,
|
|||
PgItemLocationDetail::FedToMag{mag} => ItemLocation::FedToMag{mag: ItemEntityId(mag)},
|
|||
PgItemLocationDetail::Shop => ItemLocation::Shop,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
|
|||
#[derive(Debug, sqlx::FromRow)]
|
|||
pub struct PgItemLocation {
|
|||
//pub id: i32,
|
|||
pub location: sqlx::types::Json<PgItemLocationDetail>,
|
|||
created_at: chrono::DateTime<chrono::Utc>,
|
|||
}
|
|||
|
|||
|
|||
#[derive(Debug, Serialize, Deserialize)]
|
|||
pub enum PgMagModifierDetail {
|
|||
FeedMag(i32),
|
|||
BankMag,
|
|||
MagCell(i32),
|
|||
OwnerChange(CharacterClass, SectionID)
|
|||
}
|
|||
|
|||
impl From<mag::MagModifier> for PgMagModifierDetail {
|
|||
fn from(other: mag::MagModifier) -> PgMagModifierDetail {
|
|||
match other {
|
|||
mag::MagModifier::FeedMag{food} => PgMagModifierDetail::FeedMag(food.0 as i32),
|
|||
mag::MagModifier::BankMag => PgMagModifierDetail::BankMag,
|
|||
mag::MagModifier::MagCell(cell) => PgMagModifierDetail::MagCell(cell.0 as i32),
|
|||
mag::MagModifier::OwnerChange(class, section_id) => PgMagModifierDetail::OwnerChange(class, section_id),
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
impl Into<mag::MagModifier> for PgMagModifierDetail {
|
|||
fn into(self) -> mag::MagModifier {
|
|||
match self {
|
|||
PgMagModifierDetail::FeedMag(food) => mag::MagModifier::FeedMag{food: ItemEntityId(food as u32)},
|
|||
PgMagModifierDetail::BankMag => mag::MagModifier::BankMag,
|
|||
PgMagModifierDetail::MagCell(cell) => mag::MagModifier::MagCell(ItemEntityId(cell as u32)),
|
|||
PgMagModifierDetail::OwnerChange(class, section_id) => mag::MagModifier::OwnerChange(class, section_id),
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
#[derive(Debug, sqlx::FromRow)]
|
|||
pub struct PgMagModifier {
|
|||
mag: i32,
|
|||
pub modifier: sqlx::types::Json<PgMagModifierDetail>,
|
|||
created_at: chrono::DateTime<chrono::Utc>,
|
|||
}
|
|||
|
|||
|
|||
#[derive(Debug, sqlx::FromRow)]
|
|||
pub struct PgItemWithLocation {
|
|||
pub id: i32,
|
|||
pub item: sqlx::types::Json<PgItemDetail>,
|
|||
pub location: sqlx::types::Json<PgItemLocationDetail>,
|
|||
}
|
|||
|
|||
|
|||
#[derive(Debug, sqlx::FromRow)]
|
|||
pub struct PgMagModifierWithParameters {
|
|||
pub mag: i32,
|
|||
pub modifier: sqlx::types::Json<PgMagModifierDetail>,
|
|||
pub feed: Option<sqlx::types::Json<PgTool>>,
|
|||
pub cell: Option<sqlx::types::Json<PgTool>>,
|
|||
}
|
|||
@ -0,0 +1,404 @@ |
|||
use std::convert::{From, TryFrom, Into, TryInto};
|
|||
use serde::{Serialize, Deserialize};
|
|||
use futures::future::join_all;
|
|||
use futures::TryStreamExt;
|
|||
//use futures::StreamExt;
|
|||
use async_std::stream::StreamExt;
|
|||
//use futures::StreamExt;
|
|||
use libpso::character::{settings, guildcard};
|
|||
use libpso::util::vec_to_array;
|
|||
use crate::entity::account::*;
|
|||
use crate::entity::character::*;
|
|||
use crate::entity::gateway::EntityGateway;
|
|||
use crate::entity::item::*;
|
|||
use super::models::*;
|
|||
|
|||
use sqlx::postgres::PgPoolOptions;
|
|||
use sqlx::Row;
|
|||
use sqlx::Execute;
|
|||
use postgres::{Client, NoTls};
|
|||
|
|||
mod embedded {
|
|||
use refinery::embed_migrations;
|
|||
embed_migrations!("src/entity/gateway/postgres/migrations");
|
|||
}
|
|||
|
|||
|
|||
#[derive(Clone)]
|
|||
pub struct PostgresGateway {
|
|||
pool: sqlx::Pool<sqlx::Postgres>,
|
|||
}
|
|||
|
|||
impl PostgresGateway {
|
|||
pub fn new(host: &str, dbname: &str, username: &str, password: &str) -> PostgresGateway {
|
|||
// the postgres dep can be removed once refinery supports sqlx
|
|||
let mut conn = Client::connect(&format!("host='{}' dbname='{}' user='{}' password='{}'", host, dbname, username, password), NoTls).unwrap();
|
|||
embedded::migrations::runner().run(&mut conn).unwrap();
|
|||
|
|||
let pool = async_std::task::block_on(async move {
|
|||
let pool = PgPoolOptions::new()
|
|||
.max_connections(5)
|
|||
.connect(&format!("postgresql://{}:{}@{}:5432/{}", username, password, host, dbname)).await.unwrap();
|
|||
|
|||
pool
|
|||
});
|
|||
|
|||
PostgresGateway {
|
|||
pool: pool,
|
|||
}
|
|||
}
|
|||
|
|||
async fn apply_item_modifications(&self, item: ItemEntity) -> ItemEntity {
|
|||
let ItemEntity {id, item, location} = item;
|
|||
|
|||
let item = match item {
|
|||
ItemDetail::Mag(mut mag) => {
|
|||
let q = r#"select mag, modifier, item.item -> 'Tool' as feed, item2.item -> 'Tool' as cell
|
|||
from mag_modifier
|
|||
left join item on item.id = cast (modifier ->> 'FeedMag' as integer)
|
|||
left join item as item2 on item2.id = cast (modifier ->> 'MagCell' as integer)
|
|||
where mag = $1 order by created_at"#;
|
|||
let mag_modifiers = sqlx::query_as::<_, PgMagModifierWithParameters>(q)
|
|||
.bind(id.0 as i32)
|
|||
.fetch(&self.pool);
|
|||
|
|||
mag_modifiers.for_each(|modifier| {
|
|||
let PgMagModifierWithParameters {modifier, feed, cell, ..} = modifier.unwrap();
|
|||
let modifier: mag::MagModifier = modifier.0.into();
|
|||
match modifier {
|
|||
mag::MagModifier::FeedMag{..} => {
|
|||
mag.feed(feed.unwrap().tool)
|
|||
},
|
|||
mag::MagModifier::BankMag => {
|
|||
mag.bank()
|
|||
},
|
|||
mag::MagModifier::MagCell(_) => {
|
|||
mag.apply_mag_cell(mag::MagCell::try_from(Into::<tool::Tool>::into(cell.unwrap().0).tool).unwrap())
|
|||
},
|
|||
mag::MagModifier::OwnerChange(class, section_id) => {
|
|||
mag.change_owner(class, section_id)
|
|||
},
|
|||
}
|
|||
}).await;
|
|||
|
|||
ItemDetail::Mag(mag)
|
|||
},
|
|||
item @ _ => item
|
|||
};
|
|||
|
|||
ItemEntity {
|
|||
id: id,
|
|||
item: item,
|
|||
location: location
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
#[async_trait::async_trait]
|
|||
impl EntityGateway for PostgresGateway {
|
|||
async fn create_user(&mut self, user: NewUserAccountEntity) -> Option<UserAccountEntity> {
|
|||
let new_user = sqlx::query_as::<_, PgUserAccount>("insert into user_accounts (email, username, password) values ($1, $2, $3) returning *;")
|
|||
.bind(user.email)
|
|||
.bind(user.username)
|
|||
.bind(user.password)
|
|||
.fetch_one(&self.pool).await.unwrap();
|
|||
Some(new_user.into())
|
|||
}
|
|||
|
|||
async fn get_user_by_id(&self, id: UserAccountId) -> Option<UserAccountEntity> {
|
|||
let user = sqlx::query_as::<_, PgUserAccount>("select * from user_accounts where id = $1")
|
|||
.bind(id.0)
|
|||
.fetch_one(&self.pool).await.unwrap();
|
|||
Some(user.into())
|
|||
}
|
|||
|
|||
async fn get_user_by_name(&self, username: String) -> Option<UserAccountEntity> {
|
|||
let user = sqlx::query_as::<_, PgUserAccount>("select * from user_accounts where username = $1")
|
|||
.bind(username)
|
|||
.fetch_one(&self.pool).await.unwrap();
|
|||
Some(user.into())
|
|||
}
|
|||
|
|||
async fn save_user(&mut self, user: &UserAccountEntity) {
|
|||
sqlx::query("UPDATE user_accounts set name=$1, password=$2, banned=$3, muted=$4, flags=$5 where id=$6")
|
|||
.bind(&user.username)
|
|||
.bind(&user.password)
|
|||
.bind(&user.banned_until)
|
|||
.bind(&user.muted_until)
|
|||
.bind(&user.flags)
|
|||
.bind(&user.id.0)
|
|||
.fetch_one(&self.pool).await.unwrap();
|
|||
}
|
|||
|
|||
async fn create_user_settings(&mut self, settings: NewUserSettingsEntity) -> Option<UserSettingsEntity> {
|
|||
let new_settings = sqlx::query_as::<_, PgUserSettings>("insert into user_settings (user_account, blocked_users, key_config, joystick_config, option_flags, shortcuts, symbol_chats, team_name)
|
|||
values ($1, $2, $3, $4, $5, $6, $7, $8) returning *;")
|
|||
.bind(settings.user_id.0)
|
|||
.bind(settings.settings.blocked_users.to_vec().into_iter().map(|i| i.to_le_bytes().to_vec()).flatten().collect::<Vec<u8>>())
|
|||
.bind(settings.settings.key_config.to_vec())
|
|||
.bind(settings.settings.joystick_config.to_vec())
|
|||
.bind(settings.settings.option_flags as i32)
|
|||
.bind(settings.settings.shortcuts.to_vec())
|
|||
.bind(settings.settings.symbol_chats.to_vec())
|
|||
.bind(settings.settings.team_name.to_vec().into_iter().map(|i| i.to_le_bytes().to_vec()).flatten().collect::<Vec<u8>>())
|
|||
.fetch_one(&self.pool).await.unwrap();
|
|||
Some(new_settings.into())
|
|||
}
|
|||
|
|||
async fn get_user_settings_by_user(&self, user: &UserAccountEntity) -> Option<UserSettingsEntity> {
|
|||
let settings = sqlx::query_as::<_, PgUserSettings>("select * from user_settings where id = $1")
|
|||
.bind(user.id.0)
|
|||
.fetch_one(&self.pool).await.unwrap();
|
|||
Some(settings.into())
|
|||
}
|
|||
|
|||
async fn save_user_settings(&mut self, settings: &UserSettingsEntity) {
|
|||
sqlx::query("update user_settings set blocked_users=$1, key_config=$2, joystick_config=$3, option_flags=$4, shortcuts=$5, symbol_chats=$6, team_name=$7 where id=$8")
|
|||
.bind(settings.settings.blocked_users.to_vec().into_iter().map(|i| i.to_le_bytes().to_vec()).flatten().collect::<Vec<u8>>())
|
|||
.bind(&settings.settings.key_config.to_vec())
|
|||
.bind(&settings.settings.joystick_config.to_vec())
|
|||
.bind(&settings.settings.option_flags)
|
|||
.bind(&settings.settings.shortcuts.to_vec())
|
|||
.bind(&settings.settings.symbol_chats.to_vec())
|
|||
.bind(settings.settings.team_name.to_vec().into_iter().map(|i| i.to_le_bytes().to_vec()).flatten().collect::<Vec<u8>>())
|
|||
.bind(&settings.id.0)
|
|||
.fetch_one(&self.pool).await.unwrap();
|
|||
}
|
|||
|
|||
async fn create_character(&mut self, char: NewCharacterEntity) -> Option<CharacterEntity> {
|
|||
let q = r#"insert into player_character
|
|||
(user_account, slot, name, exp, class, section_id, costume, skin, face, head, hair, hair_r, hair_g, hair_b, prop_x, prop_y, techs,
|
|||
config, infoboard, guildcard, power, mind, def, evade, luck, hp, tp, tech_menu, meseta, bank_meseta, option_flags)
|
|||
values
|
|||
($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25, $26, $27, $28, $29, $30, $31)
|
|||
returning *;"#;
|
|||
let character = sqlx::query_as::<_, PgCharacter>(q)
|
|||
//sqlx::query(q)
|
|||
.bind(char.user_id.0)
|
|||
.bind(char.slot as i16)
|
|||
.bind(char.name)
|
|||
.bind(char.exp as i32)
|
|||
.bind(char.char_class.to_string())
|
|||
.bind(char.section_id.to_string())
|
|||
.bind(char.appearance.costume as i16)
|
|||
.bind(char.appearance.skin as i16)
|
|||
.bind(char.appearance.face as i16)
|
|||
.bind(char.appearance.head as i16)
|
|||
.bind(char.appearance.hair as i16)
|
|||
.bind(char.appearance.hair_r as i16)
|
|||
.bind(char.appearance.hair_g as i16)
|
|||
.bind(char.appearance.hair_b as i16)
|
|||
.bind(char.appearance.prop_x)
|
|||
.bind(char.appearance.prop_y)
|
|||
.bind(&char.techs.as_bytes().to_vec())
|
|||
.bind(&char.config.as_bytes().to_vec())
|
|||
.bind(String::from_utf16_lossy(&char.info_board.board).trim_matches(char::from(0)))
|
|||
.bind(char.guildcard.description)
|
|||
.bind(char.materials.power as i16)
|
|||
.bind(char.materials.mind as i16)
|
|||
.bind(char.materials.def as i16)
|
|||
.bind(char.materials.evade as i16)
|
|||
.bind(char.materials.luck as i16)
|
|||
.bind(char.materials.hp as i16)
|
|||
.bind(char.materials.tp as i16)
|
|||
.bind(char.tech_menu.tech_menu.to_vec())
|
|||
.bind(char.meseta as i32)
|
|||
.bind(char.bank_meseta as i32)
|
|||
.bind(char.option_flags as i32)
|
|||
.fetch_one(&self.pool).await.unwrap();
|
|||
|
|||
sqlx::query("insert into inventory_slots (pchar) values ($1)")
|
|||
.bind(character.id)
|
|||
.execute(&self.pool).await.unwrap();
|
|||
Some(character.into())
|
|||
}
|
|||
|
|||
async fn get_characters_by_user(&self, user: &UserAccountEntity) -> [Option<CharacterEntity>; 4] {
|
|||
let mut stream = sqlx::query_as::<_, PgCharacter>("select * from player_character where user_account = $1 and slot < 4 order by slot")
|
|||
.bind(user.id.0)
|
|||
.fetch(&self.pool);
|
|||
let mut result = [None; 4];
|
|||
while let Some(character) = stream.try_next().await.unwrap() {
|
|||
let index = character.slot as usize;
|
|||
result[index] = Some(character.into())
|
|||
}
|
|||
|
|||
result
|
|||
}
|
|||
|
|||
async fn save_character(&mut self, char: &CharacterEntity) {
|
|||
let q = r#"update player_character set
|
|||
user_account=$1, slot=$2, name=$3, exp=$4, class=$5, section_id=$6, costume=$7, skin=$8, face=$9, head=$10, hair=$11, hair_r=$12,
|
|||
hair_g=$13, hair_b=$14, prop_x=$15, prop_y=$16, techs=$17, config=$18, infoboard=$19, guildcard=$20, power=$21, mind=$22, def=$23,
|
|||
evade=$24, luck=$25, hp=$26, tp=$27, tech_menu=$28, meseta=$29, bank_meseta=$30
|
|||
where id=$31;"#;
|
|||
sqlx::query(q)
|
|||
.bind(char.user_id.0)
|
|||
.bind(char.slot as i16)
|
|||
.bind(&char.name)
|
|||
.bind(char.exp as i32)
|
|||
.bind(char.char_class.to_string())
|
|||
.bind(char.section_id.to_string())
|
|||
.bind(char.appearance.costume as i16)
|
|||
.bind(char.appearance.skin as i16)
|
|||
.bind(char.appearance.face as i16)
|
|||
.bind(char.appearance.head as i16)
|
|||
.bind(char.appearance.hair as i16)
|
|||
.bind(char.appearance.hair_r as i16)
|
|||
.bind(char.appearance.hair_g as i16)
|
|||
.bind(char.appearance.hair_b as i16)
|
|||
.bind(char.appearance.prop_x)
|
|||
.bind(char.appearance.prop_y)
|
|||
.bind(&char.techs.as_bytes().to_vec())
|
|||
.bind(&char.config.as_bytes().to_vec())
|
|||
.bind(String::from_utf16_lossy(&char.info_board.board).trim_matches(char::from(0)))
|
|||
.bind(&char.guildcard.description)
|
|||
.bind(char.materials.power as i16)
|
|||
.bind(char.materials.mind as i16)
|
|||
.bind(char.materials.def as i16)
|
|||
.bind(char.materials.evade as i16)
|
|||
.bind(char.materials.luck as i16)
|
|||
.bind(char.materials.hp as i16)
|
|||
.bind(char.materials.tp as i16)
|
|||
.bind(char.tech_menu.tech_menu.to_vec())
|
|||
.bind(char.meseta as i32)
|
|||
.bind(char.bank_meseta as i32)
|
|||
.bind(char.id.0 as i32)
|
|||
.execute(&self.pool).await.unwrap();
|
|||
}
|
|||
|
|||
async fn get_guild_card_data_by_user(&self, user: &UserAccountEntity) -> GuildCardDataEntity {
|
|||
GuildCardDataEntity {
|
|||
id: GuildCardDataId(0),
|
|||
user_id: user.id,
|
|||
guildcard: guildcard::GuildCardData::default(),
|
|||
}
|
|||
}
|
|||
|
|||
async fn create_item(&mut self, item: NewItemEntity) -> Option<ItemEntity> {
|
|||
let new_item = sqlx::query_as::<_, PgItem>("insert into item (item) values ($1) returning *;")
|
|||
.bind(sqlx::types::Json(PgItemDetail::from(item.item)))
|
|||
.fetch_one(&self.pool).await.unwrap();
|
|||
let location = if let ItemLocation::Inventory{character_id, slot, ..} = &item.location {
|
|||
sqlx::query("insert into item_location (item, location) values ($1, $2)")
|
|||
.bind(new_item.id)
|
|||
.bind(sqlx::types::Json(PgItemLocationDetail::from(item.location.clone())))
|
|||
.execute(&self.pool).await.unwrap();
|
|||
sqlx::query("update inventory_slots set items[$2] = $1 where pchar = $3")
|
|||
.bind(new_item.id)
|
|||
.bind(*slot as i32)
|
|||
.bind(character_id.0 as i32)
|
|||
.execute(&self.pool).await.unwrap();
|
|||
sqlx::query_as::<_, PgItemLocation>(r#"select
|
|||
item_location.item,
|
|||
jsonb_set(item_location.location, '{Inventory,slot}', (array_position(inventory_slots.items, item.id))::text::jsonb) as location,
|
|||
item_location.created_at
|
|||
from item_location
|
|||
join item on item.id = item_location.item
|
|||
join inventory_slots on inventory_slots.pchar = cast (item_location.location -> 'Inventory' ->> 'character_id' as integer)
|
|||
where item.id = $1
|
|||
order by item_location.created_at
|
|||
limit 1"#)
|
|||
.bind(new_item.id)
|
|||
.fetch_one(&self.pool).await.unwrap()
|
|||
}
|
|||
else {
|
|||
sqlx::query_as::<_, PgItemLocation>("insert into item_location (item, location) values ($1, $2) returning *")
|
|||
.bind(new_item.id)
|
|||
.bind(sqlx::types::Json(PgItemLocationDetail::from(item.location)))
|
|||
.fetch_one(&self.pool).await.unwrap()
|
|||
};
|
|||
Some(ItemEntity {
|
|||
id: ItemEntityId(new_item.id as u32),
|
|||
item: new_item.item.0.into(),
|
|||
location: location.location.0.into(),
|
|||
})
|
|||
}
|
|||
|
|||
async fn change_item_location(&mut self, item_id: &ItemEntityId, item_location: ItemLocation) {
|
|||
if let ItemLocation::Inventory{character_id, slot, ..} = &item_location {
|
|||
sqlx::query("update inventory_slots set items[array_position(items, $1)] = null where pchar = $2 and items[array_position(items, $1)] is not null")
|
|||
.bind(item_id.0 as i32)
|
|||
.bind(character_id.0 as i32)
|
|||
.execute(&self.pool).await.unwrap();
|
|||
sqlx::query("update inventory_slots set items[$2] = $1 where pchar = $3")
|
|||
.bind(item_id.0 as i32)
|
|||
.bind(*slot as i32)
|
|||
.bind(character_id.0 as i32)
|
|||
.execute(&self.pool).await.unwrap();
|
|||
sqlx::query(r#"insert into item_location (item, location)
|
|||
select $1, $2
|
|||
where (select jsonb_object_keys(location) from item_location where item=$1
|
|||
order by created_at desc limit 1) != 'Inventory'"#)
|
|||
.bind(item_id.0)
|
|||
.bind(sqlx::types::Json(PgItemLocationDetail::from(item_location)))
|
|||
.execute(&self.pool).await.unwrap();
|
|||
}
|
|||
else {
|
|||
sqlx::query("insert into item_location (item, location) values ($1, $2)")
|
|||
.bind(item_id.0)
|
|||
.bind(sqlx::types::Json(PgItemLocationDetail::from(item_location)))
|
|||
.execute(&self.pool).await.unwrap();
|
|||
}
|
|||
}
|
|||
|
|||
async fn feed_mag(&mut self, mag_item_id: &ItemEntityId, tool_item_id: &ItemEntityId) {
|
|||
sqlx::query("insert into mag_modifier (mag, modifier) values ($1, $2);")
|
|||
.bind(mag_item_id.0)
|
|||
.bind(sqlx::types::Json(PgMagModifierDetail::from(mag::MagModifier::FeedMag{food: *tool_item_id})))
|
|||
.execute(&self.pool).await.unwrap();
|
|||
}
|
|||
|
|||
async fn change_mag_owner(&mut self, mag_item_id: &ItemEntityId, character: &CharacterEntity) {
|
|||
sqlx::query("insert into mag_modifier (mag, modifier) values ($1, $2);")
|
|||
.bind(mag_item_id.0)
|
|||
.bind(sqlx::types::Json(PgMagModifierDetail::from(mag::MagModifier::OwnerChange(character.char_class, character.section_id))))
|
|||
.execute(&self.pool).await.unwrap();
|
|||
}
|
|||
|
|||
async fn use_mag_cell(&mut self, mag_item_id: &ItemEntityId, mag_cell_id: &ItemEntityId) {
|
|||
sqlx::query("insert into mag_modifier (mag, modifier) values ($1, $2);")
|
|||
.bind(mag_item_id.0)
|
|||
.bind(sqlx::types::Json(PgMagModifierDetail::from(mag::MagModifier::MagCell(*mag_cell_id))))
|
|||
.execute(&self.pool).await.unwrap();
|
|||
}
|
|||
|
|||
async fn get_items_by_character(&self, char: &CharacterEntity) -> Vec<ItemEntity> {
|
|||
let q = r#"select * from (
|
|||
select distinct on (item_location.item)
|
|||
item.id,
|
|||
case
|
|||
when item_location.location -> 'Inventory' is not null then
|
|||
jsonb_set(item_location.location, '{Inventory,slot}', (array_position(inventory_slots.items, item.id))::text::jsonb)
|
|||
else
|
|||
item_location.location
|
|||
end,
|
|||
item.item
|
|||
from item_location
|
|||
join item on item.id = item_location.item
|
|||
join inventory_slots on inventory_slots.pchar = $1
|
|||
order by item_location.item, item_location.created_at desc
|
|||
) as i
|
|||
where cast (location -> 'Inventory' ->> 'character_id' as integer) = $1
|
|||
or cast (location -> 'Bank' ->> 'character_id' as integer) = $1
|
|||
"#;
|
|||
let items = sqlx::query_as::<_, PgItemWithLocation>(q)
|
|||
.bind(char.id.0)
|
|||
.fetch(&self.pool);
|
|||
join_all(items
|
|||
.filter_map(|item: Result<PgItemWithLocation, _>| {
|
|||
let item = item.ok()?;
|
|||
Some(ItemEntity {
|
|||
id: ItemEntityId(item.id as u32),
|
|||
item: item.item.0.into(),
|
|||
location: item.location.0.into()
|
|||
})
|
|||
})
|
|||
.map(|item: ItemEntity| {
|
|||
self.apply_item_modifications(item)
|
|||
})
|
|||
.collect::<Vec<_>>()
|
|||
.await
|
|||
).await
|
|||
}
|
|||
}
|
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue