implements teleports

gameserver/Cargo.toml

@@ -28,3 +28,5 @@ tracing-bunyan-formatter.workspace = true
 
 prost.workspace = true
 proto.workspace = true
+
+rand.workspace = true

gameserver/src/net/handlers/scene.rs

@@ -1,79 +1,394 @@
+use lazy_static::lazy_static;
+use prost::Message;
+use rand::Rng;
+use tokio::sync::Mutex;
+
+use crate::{net::{tools::{AvatarJson, JsonData}, tools_res::PropState}, util};
+
 use super::*;
 
+#[derive(Message)]
+struct Dummy {
+
+}
+
 pub async fn on_get_cur_scene_info_cs_req(
     session: &mut PlayerSession,
     _body: &GetCurSceneInfoCsReq,
 ) -> Result<()> {
+    let mut player = JsonData::load().await;
+    let entry = player.scene.entry_id.clone();
+
+    let scene = load_scene(session, &mut player, entry, false, Option::<u32>::None).await;
+
+    let resp = GetCurSceneInfoScRsp {
+        retcode: 0,
+        scene: if let Ok(scene) = scene {
+            Some(scene)
+        } else {
+            Some(SceneInfo {
+                game_mode_type: 1,
+                entry_id: player.scene.entry_id,
+                plane_id: player.scene.plane_id,
+                floor_id: player.scene.floor_id,
+                ..Default::default()
+            })
+        },
+    };
+
+    session.send(CMD_GET_CUR_SCENE_INFO_SC_RSP, resp).await?;
+    if !player.position.is_empty() {
+        session
+            .send(
+                CMD_SCENE_ENTITY_MOVE_SC_NOTIFY,
+                SceneEntityMoveScNotify {
+                    entity_id: 0,
+                    entry_id: player.scene.entry_id,
+                    motion: Some(player.position.to_motion()),
+                    ..Default::default()
+                },
+            )
+            .await?;
+    };
+
+    Ok(())
+}
+
+// enterscene
+pub async fn on_lckgkdehclb(session: &mut PlayerSession, request: &Lckgkdehclb) -> Result<()> {
+    let mut player = JsonData::load().await;
+
+    // send packet first
     session
-        .send(
+        .send(CMD_ENTER_SCENE_SC_RSP, Dummy::default())
-            CMD_GET_CUR_SCENE_INFO_SC_RSP,
+        .await?;
-            GetCurSceneInfoScRsp {
+
-                retcode: 0,
+    let _ = load_scene(session, &mut player, request.entry_id, true, Some(request.maplanefddc)).await;
-                scene: Some(SceneInfo {
+
-                    plane_id: 20101,
+
-                    floor_id: 20101001,
+    Ok(())
-                    entry_id: 2010101,
+}
-                    game_mode_type: 2,
+
-                    chhmmbdhjpg: vec![
+// getscenemapinfocsreq
-                        Dhkacjhaoid {
+pub async fn on_fkjoeabiioe(sesison: &mut PlayerSession, request: &Fkjoeabiioe) -> Result<()> {
-                            state: 1,
+    let player = JsonData::load().await;
-                            group_id: 0,
+
-                            entity_list: vec![SceneEntityInfo {
+    let back = vec![
-                                group_id: 0,
+        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,
-                                inst_id: 0,
+        26, 27, 28, 29, 30, 31, 32, 33, 34, 0,
-                                entity_id: 0,
+    ];
-                                actor: Some(SceneActorInfo {
+
-                                    avatar_type: 3,
+    let mut map_info = Fjniajephmj {
-                                    base_avatar_id: 1309,
+        retcode: 0,
-                                    map_layer: 2,
+        // lighten section list
-                                    uid: 1337,
+        phicefeaigb: back.clone(),
-                                }),
+        // maze chest
-                                motion: Some(MotionInfo {
+        dcbdhkkkpgd: vec![
-                                    aomilajjmii: Some(Vector {
+            Gbiimoglajl {
-                                        bagloppgnpb: 4480,
+                gommoeicmjg: Kihbdaniehp::MapInfoChestTypeNormal.into(),
-                                        bemlopmcgch: 19364,
+                ..Default::default()
-                                        baimdminomk: -550,
+            },
-                                    }),
+            Gbiimoglajl {
-                                    eiaoiankefd: Some(Vector {
+                gommoeicmjg: Kihbdaniehp::MapInfoChestTypePuzzle.into(),
-                                        bagloppgnpb: 4480,
+                ..Default::default()
-                                        bemlopmcgch: 19364,
+            },
-                                        baimdminomk: -550,
+            Gbiimoglajl {
-                                    }),
+                gommoeicmjg: Kihbdaniehp::MapInfoChestTypeChallenge.into(),
-                                }),
+                ..Default::default()
-                                ..Default::default()
+            },
-                            }],
+        ],
-                        },
+
-                        Dhkacjhaoid {
+        ..Default::default()
-                            state: 1,
+    };
-                            group_id: 19,
+
-                            entity_list: vec![SceneEntityInfo {
+    if let Some((level, enterance, _)) = player
-                                group_id: 19,
+        .get_level_group(request.dmkkkfnkofh[0])
-                                inst_id: 300001,
+        .await
-                                entity_id: 228,
+    {
-                                prop: Some(ScenePropInfo {
+        // add teleports
-                                    prop_id: 808,
+        for teleport in &level.teleports {
-                                    prop_state: 1,
+            map_info.ojlnmnehgai.push(*teleport.0)
-                                    ..Default::default()
+        }
-                                }),
+
-                                motion: Some(MotionInfo {
+        // prop
-                                    aomilajjmii: Some(Vector {
+        for prop in &level.props {
-                                        bagloppgnpb: 4480,
+            let group = Gecjjlmabhp {
-                                        bemlopmcgch: 19364,
+                group_id: prop.group_id,
-                                        baimdminomk: -570,
+                ..Default::default()
-                                    }),
+            };
-                                    eiaoiankefd: Some(Vector {
+            if !map_info.pmolfbcbfpe.contains(&group) {
-                                        bagloppgnpb: 4480,
+                map_info.pmolfbcbfpe.push(group);
-                                        bemlopmcgch: 19364,
+            }
-                                        baimdminomk: -570,
+
-                                    }),
+            map_info.cgkfbhoadpc.push(Kangcibfhee {
-                                }),
+                group_id: prop.group_id,
-                                ..Default::default()
+                state: if prop.prop_state_list.contains(&PropState::CheckPointEnable) {
-                            }],
+                    PropState::CheckPointEnable as u32
-                        },
+                } else {
-                    ],
+                    (prop.prop_state_list.first().unwrap_or(&PropState::Closed)).clone() as u32
+                },
+                ifjocipnpgd: prop.id as u32,
+            });
+        }
+
+        map_info.entry_id = enterance.id;
+    }
+    sesison.send(
+        CMD_GET_SCENE_MAP_INFO_SC_RSP,
+        Cegeebldbke {
+            retcode: 0,
+            mhefdgcamjl: vec![map_info],
+            ..Default::default()
+        },
+    )
+    .await?;
+
+    Ok(())
+}
+
+lazy_static! {
+    static ref NEXT_SCENE_SAVE: Mutex<u64> = Mutex::new(0);
+}
+
+pub async fn on_scene_entity_move_cs_req(session: &mut PlayerSession, request: &SceneEntityMoveCsReq) -> Result<()> {
+    let mut player = JsonData::load().await;
+    let mut timestamp = NEXT_SCENE_SAVE.lock().await;
+
+    if util::cur_timestamp_ms() <= *timestamp {
+        session
+        .send(CMD_SCENE_ENTITY_MOVE_SC_RSP, Dummy::default())
+        .await?;
+
+        return Ok(());
+    }
+    
+    // save every 5 minute
+    *timestamp = util::cur_timestamp_ms() + (5 * 1000);
+    
+    for entity in &request.entity_motion_list {
+        if entity.entity_id != 0 {
+            continue;
+        }
+
+        if let Some(motion) = &entity.motion {
+            if let Some(pos) = &motion.aomilajjmii {
+                player.position.x = pos.baimdminomk;
+                player.position.y = pos.bemlopmcgch;
+                player.position.z = pos.bagloppgnpb;
+            }
+            if let Some(rot) = &motion.eiaoiankefd {
+                player.position.rot_y = rot.bemlopmcgch;
+            }
+        }
+    }
+
+    player.save().await;
+    session
+        .send(CMD_SCENE_ENTITY_MOVE_SC_RSP, Dummy::default())
+        .await?;
+
+    Ok(())
+}
+
+async fn load_scene(
+    session: &mut PlayerSession,
+    json: &mut JsonData,
+    entry_id: u32,
+    _save: bool,
+    teleport_id: Option<u32>,
+) -> Result<SceneInfo> {
+    if let Some((level, enterance, plane)) = json.get_level_group( entry_id).await {
+        let mut position = json.position.clone();
+        if let Some(teleport_id) = teleport_id {
+            if let Some(teleport) = level.teleports.get(&teleport_id) {
+                position.x = (teleport.pos_x * 1000f64) as i32;
+                position.y = (teleport.pos_y * 1000f64) as i32;
+                position.z = (teleport.pos_z * 1000f64) as i32;
+                position.rot_y = (teleport.rot_y * 1000f64) as i32;
+            }
+        }
+
+        let mut scene_info = SceneInfo {
+            floor_id: enterance.floor_id as u32,
+            plane_id: enterance.plane_id as u32,
+            entry_id,
+            game_mode_type: plane
+                .as_ref()
+                .map(|v| v.plane_type)
+                .unwrap_or(enterance.entrance_type) as u32,
+
+            // world_id: plane.map(|v| v.world_id).unwrap_or_default(),
+            ..Default::default()
+        };
+
+        let lineup_info = AvatarJson::to_lineup_info(&json.lineups);
+        let player_pos = MotionInfo {
+            // rot
+            eiaoiankefd: Some(Vector {
+                baimdminomk:0,
+                bemlopmcgch: position.rot_y,
+                bagloppgnpb: 0,
+            }),
+            // pos
+            aomilajjmii: Some(Vector {
+                baimdminomk: position.x,
+                bemlopmcgch: position.y,
+                bagloppgnpb: position.z,
+            }),
+        };
+
+        let mut entities = 0;
+
+        // LOAD PROPS
+        for prop in level.props {
+            if entities >= 500 {
+                continue;
+            }
+            entities += 1;
+
+            let mut rng = rand::thread_rng();
+
+            let prop_state = if prop.anchor_id.unwrap_or_default() > 0 {
+                8
+            } else {
+                prop.prop_state_list.first().unwrap().clone() as u32
+            };
+            let info = SceneEntityInfo {
+                inst_id: prop.id as u32,
+                group_id: prop.group_id,
+                entity_id: rng.gen(),
+                motion: Some(MotionInfo {
+                    // pos
+                    aomilajjmii: Some(Vector {
+                        baimdminomk: (prop.pos_x * 1000f64) as i32,
+                        bemlopmcgch: (prop.pos_y * 1000f64) as i32,
+                        bagloppgnpb: (prop.pos_z * 1000f64) as i32,
+                    }),
+                    // rot
+                    eiaoiankefd: Some(Vector {
+                        baimdminomk: 0,
+                        bemlopmcgch: (prop.rot_y * 1000f64) as i32,
+                        bagloppgnpb: 0,
+                    }),
+                }),
+                prop: Some(ScenePropInfo {
+                    prop_id: prop.prop_id as u32,
+                    prop_state: prop_state,
                     ..Default::default()
                 }),
-            },
+                ..Default::default()
-        )
+            };
-        .await
+
+            // only add check
+            // if prop_state == 8 {
+            //     group_info.entity_list.push(info);
+            // }
+            if let Some(group) = scene_info
+                .chhmmbdhjpg
+                .iter_mut()
+                .find(|v| v.group_id == prop.group_id)
+            {
+                group.entity_list.push(info)
+            } else {
+                let mut group_info = Dhkacjhaoid {
+                    state: 0,
+                    group_id: prop.group_id,
+                    ..Default::default()
+                };
+                group_info.entity_list.push(info);
+                scene_info.chhmmbdhjpg.push(group_info);
+            }
+        }
+
+        // LOAD MONSTERS
+        for monster in level.monsters {
+            if entities >= 500 {
+                continue;
+            }
+            entities += 1;
+
+            let mut rng = rand::thread_rng();
+
+            let info = SceneEntityInfo {
+                inst_id: monster.id as u32,
+                group_id: monster.group_id,
+                entity_id: rng.gen(),
+                motion: Some(MotionInfo {
+                    // pos
+                    aomilajjmii: Some(Vector {
+                        baimdminomk: (monster.pos_x * 1000f64) as i32,
+                        bemlopmcgch: (monster.pos_y * 1000f64) as i32,
+                        bagloppgnpb: (monster.pos_z * 1000f64) as i32,
+                    }),
+                    // rot
+                    eiaoiankefd: Some(Vector {
+                        baimdminomk: 0,
+                        bemlopmcgch: (monster.rot_y * 1000f64) as i32,
+                        bagloppgnpb: 0,
+                    }),
+                }),
+                npc_monster: Some(SceneNpcMonsterInfo {
+                    monster_id: monster.npcmonster_id as u32,
+                    event_id: monster.event_id as u32,
+                    world_level: 6,
+                    ..Default::default()
+                }),
+                ..Default::default()
+            };
+
+            if let Some(group) = scene_info
+                .chhmmbdhjpg
+                .iter_mut()
+                .find(|v| v.group_id == monster.group_id)
+            {
+                group.entity_list.push(info)
+            } else {
+                let mut group_info = Dhkacjhaoid {
+                    state: 0,
+                    group_id: monster.group_id,
+                    ..Default::default()
+                };
+                group_info.entity_list.push(info);
+                scene_info.chhmmbdhjpg.push(group_info);
+            }
+        }
+
+        if _save {
+            session
+                .send(
+                    CMD_ENTER_SCENE_BY_SERVER_SC_NOTIFY,
+                    Jdokmmikidp {
+                        scene: Some(scene_info.clone()),
+                        lineup: Some(lineup_info),
+                        ..Default::default()
+                    },
+                )
+                .await?;
+
+            session
+                .send(
+                    CMD_SCENE_ENTITY_MOVE_SC_NOTIFY,
+                    SceneEntityMoveScNotify {
+                        entity_id: 0,
+                        entry_id: entry_id,
+                        motion: Some(player_pos),
+                        ..Default::default()
+                    },
+                )
+                .await?;
+
+            json.scene.entry_id = entry_id;
+            json.scene.floor_id = enterance.floor_id as u32;
+            json.scene.plane_id = enterance.plane_id as u32;
+            json.position.x = position.x;
+            json.position.y = position.y;
+            json.position.z = position.z;
+            json.position.rot_y = position.rot_y;
+            json.save().await;
+        }
+
+        return Ok(scene_info);
+    }
+
+    Err(anyhow::format_err!("Scene Not Found"))
 }

gameserver/src/net/mod.rs

@@ -4,6 +4,7 @@ mod handlers;
 mod packet;
 mod session;
 mod tools;
+mod tools_res;
 
 
 pub use packet::NetPacket;

gameserver/src/net/packet.rs

@@ -1241,7 +1241,7 @@ trait_handler! {
     // SetCurInteractEntityScRsp 1497;
     // SceneCastSkillCsReq 1402;
     StartCocoonStageCsReq 1408;
-    // GetSceneMapInfoCsReq 1470;
+    Fkjoeabiioe 1470; //getscenemapinfocsreq
     // SceneEntityMoveScRsp 1448;
     // DeactivateFarmElementScRsp 1467;
     // SetCurInteractEntityCsReq 1491;
@@ -1253,7 +1253,7 @@ trait_handler! {
     // StartCocoonStageScRsp 1454;
     // SceneCastSkillCostMpScRsp 1433;
     // GroupStateChangeCsReq 1476;
-    // SceneEntityMoveCsReq 1434;
+    SceneEntityMoveCsReq 1434;
     // GetUnlockTeleportScRsp 1469;
     // GameplayCounterUpdateScNotify 1478;
     // SceneEnterStageScRsp 1456;
@@ -1263,7 +1263,7 @@ trait_handler! {
     // GetSpringRecoverDataCsReq 1466;
     // SceneEntityTeleportScRsp 1415;
     // SetClientPausedScRsp 1465;
-    // EnterSceneCsReq 1472;
+    Lckgkdehclb 1472; // enterscenecsreq
     // GetAllServerPrefsDataScRsp 6148;
     // GetServerPrefsDataCsReq 6162;
     // UpdateServerPrefsDataScRsp 6109;

gameserver/src/net/tools.rs

@@ -3,6 +3,8 @@ use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, HashMap};
 use proto::*;
 
+use super::tools_res::{MapEntrance, MazePlane, SimpleLevelGroup, GAME_RESOURCES};
+
 // AVATAR
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct AvatarJson {
@@ -29,6 +31,7 @@ pub struct AvatarData {
     pub skills: BTreeMap<u32, u32>,
 }
 
+#[allow(dead_code)]
 impl AvatarJson {
     pub fn to_avatar_proto(
         &self,
@@ -195,6 +198,7 @@ pub struct Lightcone {
     pub internal_uid: u32,
 }
 
+#[allow(dead_code)]
 impl Lightcone {
     pub fn to_equipment_proto(&self) -> Equipment {
         Equipment {
@@ -247,6 +251,7 @@ pub struct SubAffix {
     pub step: u32,
 }
 
+#[allow(dead_code)]
 impl Relic {
     pub fn to_relic_proto(&self) -> proto::Relic {
         proto::Relic {
@@ -631,7 +636,25 @@ impl JsonData {
             scene: self.scene.clone()
         }).unwrap().as_bytes()).await;
     }
+    
+    pub async fn get_level_group(
+        &self,
+        entry_id: u32,
+    ) -> Option<(SimpleLevelGroup, MapEntrance, Option<MazePlane>)> {
+        let resources = &GAME_RESOURCES;
+        let enterance = resources.map_entrance.get(&entry_id);
 
-}
+        if let Some(enterance) = enterance {
-
+            let plane = resources.maze_plane.get(&enterance.plane_id);
+            if let Some(level) = resources
+                .level_group
+                .get(&format!("P{}_F{}", enterance.plane_id, enterance.floor_id))
+            {
+                // TODO: use reference somehow, not cloning
+                return Some((level.clone(), enterance.clone(), plane.cloned()));
+            };
+        }
 
+        None
+    }
+}

gameserver/src/net/tools_res.rs

@@ -0,0 +1,288 @@
+use std::collections::HashMap;
+use lazy_static::lazy_static;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LevelGroup {
+    #[serde(rename = "GroupGUID")]
+    pub group_guid: String,
+    #[serde(default)]
+    #[serde(rename = "LoadSide")]
+    pub load_side: String,
+    #[serde(default)]
+    #[serde(rename = "LoadOnInitial")]
+    pub load_on_initial: bool,
+
+    // #[serde(rename = "AnchorList")]
+    // pub anchor_list: Vec<LevelAnchor>,
+    #[serde(default)]
+    #[serde(rename = "MonsterList")]
+    pub monster_list: Vec<LevelMonster>,
+    #[serde(default)]
+    #[serde(rename = "PropList")]
+    pub prop_list: Vec<LevelProp>,
+    #[serde(default)]
+    #[serde(rename = "NPCList")]
+    pub npc_list: Vec<LevelNPC>,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LevelProp {
+    #[serde(rename = "ID")]
+    pub id: i64,
+    #[serde(default)]
+    #[serde(rename = "Category")]
+    pub category: String,
+    #[serde(default)]
+    #[serde(rename = "GroupName")]
+    pub group_name: String,
+    #[serde(default)]
+    #[serde(rename = "LoadSide")]
+    pub load_side: String,
+    #[serde(default)]
+    #[serde(rename = "PosX")]
+    pub pos_x: f64,
+    #[serde(default)]
+    #[serde(rename = "PosY")]
+    pub pos_y: f64,
+    #[serde(default)]
+    #[serde(rename = "PosZ")]
+    pub pos_z: f64,
+    #[serde(default)]
+    #[serde(rename = "RotY")]
+    pub rot_y: f64,
+    #[serde(rename = "PropID")]
+    pub prop_id: u32,
+    #[serde(rename = "AnchorID")]
+    pub anchor_id: Option<u32>,
+    #[serde(rename = "AnchorGroupID")]
+    pub anchor_group_id: Option<u32>,
+    #[serde(rename = "MappingInfoID")]
+    pub mapping_info_id: Option<u32>,
+
+    #[serde(default)]
+    pub prop_state_list: Vec<PropState>,
+    #[serde(default)]
+    pub group_id: u32,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LevelAnchor {
+    #[serde(rename = "ID")]
+    pub id: i64,
+    #[serde(default)]
+    #[serde(rename = "PosX")]
+    pub pos_x: f64,
+    #[serde(default)]
+    #[serde(rename = "PosY")]
+    pub pos_y: f64,
+    #[serde(default)]
+    #[serde(rename = "PosZ")]
+    pub pos_z: f64,
+    #[serde(default)]
+    #[serde(rename = "RotY")]
+    pub rot_y: f64,
+    #[serde(default)]
+    pub group_id: u32,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LevelNPC {
+    #[serde(rename = "ID")]
+    pub id: i64,
+    #[serde(default)]
+    #[serde(rename = "PosX")]
+    pub pos_x: f64,
+    #[serde(default)]
+    #[serde(rename = "PosY")]
+    pub pos_y: f64,
+    #[serde(default)]
+    #[serde(rename = "PosZ")]
+    pub pos_z: f64,
+    #[serde(rename = "Name")]
+    pub name: String,
+    #[serde(default)]
+    #[serde(rename = "RotY")]
+    pub rot_y: f64,
+    #[serde(rename = "NPCID")]
+    pub npcid: i64,
+    #[serde(default)]
+    pub group_id: u32,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LevelMonster {
+    #[serde(rename = "ID")]
+    pub id: i64,
+    #[serde(default)]
+    #[serde(rename = "RotY")]
+    pub rot_y: f64,
+    #[serde(default)]
+    #[serde(rename = "PosX")]
+    pub pos_x: f64,
+    #[serde(default)]
+    #[serde(rename = "PosY")]
+    pub pos_y: f64,
+    #[serde(default)]
+    #[serde(rename = "PosZ")]
+    pub pos_z: f64,
+    #[serde(rename = "NPCMonsterID")]
+    pub npcmonster_id: i64,
+    #[serde(default)]
+    #[serde(rename = "EventID")]
+    pub event_id: i64,
+    #[serde(default)]
+    pub group_id: u32,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MapEntrance {
+    #[serde(rename = "ID")]
+    pub id: u32,
+    #[serde(default)]
+    #[serde(rename = "EntranceType")]
+    pub entrance_type: PlaneType,
+    #[serde(rename = "PlaneID")]
+    pub plane_id: u32,
+    #[serde(rename = "FloorID")]
+    pub floor_id: u32,
+    #[serde(rename = "BeginMainMissionList")]
+    pub begin_main_mission_list: Vec<Value>,
+    #[serde(rename = "FinishMainMissionList")]
+    pub finish_main_mission_list: Vec<Value>,
+    #[serde(rename = "FinishSubMissionList")]
+    pub finish_sub_mission_list: Vec<Value>,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MazePlane {
+    #[serde(rename = "PlaneID")]
+    pub plane_id: u32,
+    #[serde(rename = "PlaneType")]
+    pub plane_type: PlaneType,
+    #[serde(rename = "SubType")]
+    pub sub_type: u32,
+    #[serde(rename = "MazePoolType")]
+    pub maze_pool_type: u32,
+    #[serde(rename = "WorldID")]
+    pub world_id: u32,
+    #[serde(rename = "StartFloorID")]
+    pub start_floor_id: u32,
+    #[serde(rename = "FloorIDList")]
+    pub floor_idlist: Vec<u32>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Copy)]
+pub enum PlaneType {
+    Unknown = 0,
+    Maze = 2,
+    Train = 3,
+    Challenge = 4,
+    Rogue = 5,
+    Raid = 6,
+    AetherDivide = 7,
+    TrialActivity = 8,
+    #[serde(other)]
+    Town = 1,
+}
+
+impl Default for PlaneType {
+    fn default() -> Self {
+        Self::Maze
+    }
+}
+
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MazeProp {
+    #[serde(rename = "ID")]
+    pub id: i64,
+    #[serde(rename = "PropType")]
+    pub prop_type: String,
+    #[serde(rename = "PropStateList")]
+    pub prop_state_list: Vec<PropState>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub enum PropState {
+    Closed = 0,
+    Open = 1,
+    Locked = 2,
+    BridgeState1 = 3,
+    BridgeState2 = 4,
+    BridgeState3 = 5,
+    BridgeState4 = 6,
+    CheckPointDisable = 7,
+    CheckPointEnable = 8,
+    TriggerDisable = 9,
+    TriggerEnable = 10,
+    ChestLocked = 11,
+    ChestClosed = 12,
+    ChestUsed = 13,
+    Elevator1 = 14,
+    Elevator2 = 15,
+    Elevator3 = 16,
+    WaitActive = 17,
+    EventClose = 18,
+    EventOpen = 19,
+    Hidden = 20,
+    TeleportGate0 = 21,
+    TeleportGate1 = 22,
+    TeleportGate2 = 23,
+    TeleportGate3 = 24,
+    Destructed = 25,
+    CustomState01 = 101,
+    CustomState02 = 102,
+    CustomState03 = 103,
+    CustomState04 = 104,
+    CustomState05 = 105,
+    CustomState06 = 106,
+    CustomState07 = 107,
+    CustomState08 = 108,
+    CustomState09 = 109,
+}
+
+pub type IntMap<T> = HashMap<u32, T>;
+pub type StringMap<T> = HashMap<String, T>;
+
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct SimpleLevelGroup {
+    pub teleports: IntMap<LevelProp>,
+    pub props: Vec<LevelProp>,
+    pub npcs: Vec<LevelNPC>,
+    pub monsters: Vec<LevelMonster>,
+    // pub level_group: IntMap<LevelGroup>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct GameResources {
+    pub map_entrance: IntMap<MapEntrance>,
+    /// Key is P{PLANE_ID}_F{FLOOR_ID}
+    pub level_group: StringMap<SimpleLevelGroup>,
+    pub maze_prop: IntMap<MazeProp>,
+    pub maze_plane: IntMap<MazePlane>,
+}
+
+impl GameResources {
+    pub fn new() -> Self {
+        let str = std::fs::read_to_string("./resources.json").unwrap();
+        let res: Self = serde_json::from_str(&str).unwrap();
+        res
+    }
+}
+
+lazy_static! {
+    pub static ref GAME_RESOURCES: GameResources = {
+        GameResources::new()
+    };
+}