diff --git a/cmake/FindMySQL.cmake b/cmake/FindMySQL.cmake
index e629b8ae3..d15f7abde 100644
--- a/cmake/FindMySQL.cmake
+++ b/cmake/FindMySQL.cmake
@@ -18,28 +18,39 @@ if( UNIX )
     "preferred path to MySQL (mysql_config)"
   )
 
-  find_program(MYSQL_CONFIG mysql_config
+  # try mariadb first
+  find_program(MYSQL_CONFIG mariadb_config
     ${MYSQL_CONFIG_PREFER_PATH}
     /usr/local/mysql/bin/
     /usr/local/bin/
     /usr/bin/
   )
 
+  if( NOT MYSQL_CONFIG )
+    # fallback to mysql
+    find_program(MYSQL_CONFIG mysql_config
+      ${MYSQL_CONFIG_PREFER_PATH}
+      /usr/local/mysql/bin/
+      /usr/local/bin/
+      /usr/bin/
+    )
+  endif()
+
   if( MYSQL_CONFIG )
     message(STATUS "Using mysql-config: ${MYSQL_CONFIG}")
     # set INCLUDE_DIR
-    exec_program(${MYSQL_CONFIG}
-      ARGS --include
+    execute_process(COMMAND ${MYSQL_CONFIG} --include
       OUTPUT_VARIABLE MY_TMP
+      OUTPUT_STRIP_TRAILING_WHITESPACE
     )
 
     string(REGEX REPLACE "-I([^ ]*)( .*)?" "\\1" MY_TMP "${MY_TMP}")
     set(MYSQL_ADD_INCLUDE_PATH ${MY_TMP} CACHE FILEPATH INTERNAL)
     #message("[DEBUG] MYSQL ADD_INCLUDE_PATH : ${MYSQL_ADD_INCLUDE_PATH}")
     # set LIBRARY_DIR
-    exec_program(${MYSQL_CONFIG}
-      ARGS --libs_r
+    execute_process(COMMAND ${MYSQL_CONFIG} --libs_r
       OUTPUT_VARIABLE MY_TMP
+      OUTPUT_STRIP_TRAILING_WHITESPACE
     )
     set(MYSQL_ADD_LIBRARIES "")
     string(REGEX MATCHALL "-l[^ ]*" MYSQL_LIB_LIST "${MY_TMP}")
diff --git a/data/EncounterTimelines/IfritNormal.json b/data/EncounterTimelines/IfritNormal.json
new file mode 100644
index 000000000..f78401f86
--- /dev/null
+++ b/data/EncounterTimelines/IfritNormal.json
@@ -0,0 +1,1082 @@
+{
+  "actors": [
+    {
+      "hp": 13884,
+      "id": 1,
+      "layoutId": 4126276,
+      "name": "Ifrit",
+      "phases": [
+        {
+          "description": "",
+          "id": 1,
+          "name": "Auto-attack",
+          "timepoints": [
+            {
+              "data": {
+                "actionId": 872,
+                "selectorIndex": 0,
+                "selectorName": "<unset>",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit",
+                "targetType": "target"
+              },
+              "description": "Auto attack",
+              "duration": 2500,
+              "type": "castAction"
+            }
+          ]
+        },
+        {
+          "description": "",
+          "id": 2,
+          "name": "Phase 1",
+          "timepoints": [
+            {
+              "data": {
+                "actionId": 453,
+                "selectorIndex": 0,
+                "selectorName": "<unset>",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit",
+                "targetType": "target"
+              },
+              "description": "Incinerate > VB > Incinerate > Incinerate",
+              "duration": 8000,
+              "type": "castAction"
+            },
+            {
+              "data": {
+                "actionId": 454,
+                "selectorIndex": 0,
+                "selectorName": "Vulcan Burst",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit",
+                "targetType": "self"
+              },
+              "description": "VB",
+              "duration": 8000,
+              "type": "castAction"
+            },
+            {
+              "data": {
+                "actionId": 453,
+                "selectorIndex": 0,
+                "selectorName": "<unset>",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit",
+                "targetType": "target"
+              },
+              "description": "Incinerate",
+              "duration": 8000,
+              "type": "castAction"
+            },
+            {
+              "data": {
+                "actionId": 453,
+                "selectorIndex": 0,
+                "selectorName": "<unset>",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit",
+                "targetType": "target"
+              },
+              "description": "Incinerate",
+              "duration": 8000,
+              "type": "castAction"
+            }
+          ]
+        },
+        {
+          "description": "",
+          "id": 3,
+          "name": "Phase 2 Start",
+          "timepoints": [
+            {
+              "data": {
+                "bgmId": 163
+              },
+              "description": "",
+              "duration": 0,
+              "type": "setBGM"
+            },
+            {
+              "data": {
+                "battleTalkId": 2939,
+                "handlerActorName": "Ifrit",
+                "kind": 1,
+                "nameId": 2961,
+                "params": [
+                  0
+                ],
+                "talkerActorName": "Ifrit"
+              },
+              "description": "Succumb to the inferno",
+              "duration": 1500,
+              "type": "battleTalk"
+            },
+            {
+              "data": {
+                "actionId": 453,
+                "selectorIndex": 0,
+                "selectorName": "<unset>",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit",
+                "targetType": "target"
+              },
+              "description": "Incinerate",
+              "duration": 8000,
+              "type": "castAction"
+            },
+            {
+              "data": {
+                "actionId": 454,
+                "selectorIndex": 0,
+                "selectorName": "<unset>",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit",
+                "targetType": "self"
+              },
+              "description": "Vulcan Burst",
+              "duration": 8000,
+              "type": "castAction"
+            },
+            {
+              "data": {
+                "conditionId": 4,
+                "conditionStr": "If Ifrit has 51% < HP < 70%, loop Ifrit->Phase 2 Main",
+                "enabled": true
+              },
+              "description": "",
+              "duration": 5000,
+              "type": "setCondition"
+            }
+          ]
+        },
+        {
+          "description": "",
+          "id": 4,
+          "name": "Phase 2 Main",
+          "timepoints": [
+            {
+              "data": {
+                "actionId": 453,
+                "selectorIndex": 0,
+                "selectorName": "<unset>",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit",
+                "targetType": "target"
+              },
+              "description": "Incinerate",
+              "duration": 8000,
+              "type": "castAction"
+            },
+            {
+              "data": {
+                "selectorName": "Eruption",
+                "sourceActor": "Ifrit"
+              },
+              "description": "",
+              "duration": 0,
+              "type": "snapshot"
+            },
+            {
+              "data": {
+                "actionId": 455,
+                "selectorIndex": 0,
+                "selectorName": "Eruption",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit",
+                "targetType": "self"
+              },
+              "description": "Eruption",
+              "duration": 0,
+              "type": "castAction"
+            },
+            {
+              "data": {
+                "conditionId": 11,
+                "conditionStr": "If Ifrit casts Action#455, loop Ifrit Control->Eruption",
+                "enabled": true
+              },
+              "description": "",
+              "duration": 8000,
+              "type": "setCondition"
+            }
+          ]
+        },
+        {
+          "description": "",
+          "id": 5,
+          "name": "Nail Spawn",
+          "timepoints": [
+            {
+              "data": {
+                "battleTalkId": 2939,
+                "handlerActorName": "Ifrit",
+                "kind": 1,
+                "nameId": 2961,
+                "params": [
+                  0
+                ],
+                "talkerActorName": "Ifrit"
+              },
+              "description": "Surrender thyself to the fires of judgment",
+              "duration": 5000,
+              "type": "battleTalk"
+            },
+            {
+              "data": {
+                "flags": 19,
+                "hateSource": {
+                  "hateType": "<to-be-defined>",
+                  "source": "<to-de-befined>"
+                },
+                "spawnActor": "Ifrit Nail 1"
+              },
+              "description": "",
+              "duration": 1500,
+              "type": "bNpcSpawn"
+            },
+            {
+              "data": {
+                "conditionId": 6,
+                "conditionStr": "If Ifrit state is Combat, loop Ifrit->Phase 1",
+                "enabled": true
+              },
+              "description": "",
+              "duration": 0,
+              "type": "setCondition"
+            },
+            {
+              "data": {},
+              "description": "",
+              "duration": 36000,
+              "type": "idle"
+            },
+            {
+              "data": {
+                "conditionId": 8,
+                "conditionStr": "If Ifrit state is Combat, push Ifrit->Hellfire",
+                "enabled": true
+              },
+              "description": "",
+              "duration": 0,
+              "type": "setCondition"
+            }
+          ]
+        },
+        {
+          "description": "",
+          "id": 7,
+          "name": "Hellfire",
+          "timepoints": [
+            {
+              "data": {
+                "despawnActor": "Ifrit Nail 1"
+              },
+              "description": "Despawn nail if up",
+              "duration": 0,
+              "type": "bNpcDespawn"
+            },
+            {
+              "data": {
+                "conditionId": 7,
+                "conditionStr": "If Ifrit Nail 1 state is Dead, push Ifrit->Hellfire",
+                "enabled": false
+              },
+              "description": "",
+              "duration": 0,
+              "type": "setCondition"
+            },
+            {
+              "data": {
+                "conditionId": 6,
+                "conditionStr": "If Ifrit state is Combat, loop Ifrit->Phase 1",
+                "enabled": false
+              },
+              "description": "",
+              "duration": 0,
+              "type": "setCondition"
+            },
+            {
+              "data": {
+                "actorName": "Ifrit",
+                "pos": [
+                  0,
+                  0,
+                  0
+                ],
+                "rot": 0
+              },
+              "description": "",
+              "duration": 2000,
+              "type": "setPos"
+            },
+            {
+              "data": {
+                "flags": 119,
+                "targetActor": ""
+              },
+              "description": "",
+              "duration": 3000,
+              "type": "bNpcFlags"
+            },
+            {
+              "data": {
+                "actionId": 458,
+                "selectorIndex": 0,
+                "selectorName": "<unset>",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit",
+                "targetType": "self"
+              },
+              "description": "",
+              "duration": 2500,
+              "type": "castAction"
+            },
+            {
+              "data": {
+                "actorName": "Ifrit",
+                "pos": [
+                  0,
+                  -10,
+                  0
+                ],
+                "rot": 0
+              },
+              "description": "",
+              "duration": 8000,
+              "type": "setPos"
+            },
+            {
+              "data": {
+                "flags": 16,
+                "targetActor": ""
+              },
+              "description": "",
+              "duration": 0,
+              "type": "bNpcFlags"
+            },
+            {
+              "data": {
+                "conditionId": 9,
+                "conditionStr": "If Ifrit state is Combat, loop Ifrit->Final Phase",
+                "enabled": true
+              },
+              "description": "Enable final phase",
+              "duration": 0,
+              "type": "setCondition"
+            }
+          ]
+        },
+        {
+          "description": "",
+          "id": 6,
+          "name": "Final Phase",
+          "timepoints": [
+            {
+              "data": {
+                "actionId": 455,
+                "selectorIndex": 0,
+                "selectorName": "<unset>",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit",
+                "targetType": "self"
+              },
+              "description": "Eruption telegraph",
+              "duration": 8000,
+              "type": "castAction"
+            },
+            {
+              "data": {
+                "actionId": 453,
+                "selectorIndex": 0,
+                "selectorName": "<unset>",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit",
+                "targetType": "target"
+              },
+              "description": "Incinerate Final Phase",
+              "duration": 8000,
+              "type": "castAction"
+            },
+            {
+              "data": {
+                "actionId": 456,
+                "selectorIndex": 0,
+                "selectorName": "<unset>",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit",
+                "targetType": "self"
+              },
+              "description": "Plumes telegraph",
+              "duration": 0,
+              "type": "castAction"
+            },
+            {
+              "data": {
+                "conditionId": 12,
+                "conditionStr": "If Ifrit->Final Phase is active, push Ifrit Control->Plumes Loop",
+                "enabled": true
+              },
+              "description": "",
+              "duration": 16000,
+              "type": "setCondition"
+            }
+          ]
+        },
+        {
+          "description": "",
+          "id": 8,
+          "name": "Reset",
+          "timepoints": [
+            {
+              "data": {
+                "flags": 16,
+                "targetActor": ""
+              },
+              "description": "",
+              "duration": 0,
+              "type": "bNpcFlags"
+            },
+            {
+              "data": {},
+              "description": "todo: despawn subactors and anything else spawned in phases",
+              "duration": 5000,
+              "type": "idle"
+            }
+          ]
+        }
+      ],
+      "subactors": [],
+      "type": "bnpc"
+    },
+    {
+      "hp": 445,
+      "id": 2,
+      "layoutId": 4126284,
+      "name": "Ifrit Control",
+      "phases": [
+        {
+          "description": "",
+          "id": 1,
+          "name": "Eruption",
+          "timepoints": [
+            {
+              "data": {
+                "selectorName": "Eruption",
+                "sourceActor": "Ifrit Control <subactor 1>"
+              },
+              "description": "",
+              "duration": 0,
+              "type": "snapshot"
+            },
+            {
+              "data": {
+                "actionId": 733,
+                "selectorIndex": 0,
+                "selectorName": "Eruption",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit Control <subactor 1>",
+                "targetType": "selector"
+              },
+              "description": "Subactor 1 Eruption",
+              "duration": 8000,
+              "type": "castAction"
+            }
+          ]
+        },
+        {
+          "description": "",
+          "id": 2,
+          "name": "Plumes Loop",
+          "timepoints": [
+            {
+              "data": {
+                "actorName": "Ifrit Control <subactor 1>",
+                "pos": [
+                  -10,
+                  0,
+                  10
+                ],
+                "rot": 0
+              },
+              "description": "Move plumes",
+              "duration": 0,
+              "type": "setPos"
+            },
+            {
+              "data": {
+                "actorName": "Ifrit Control <subactor 2>",
+                "pos": [
+                  -10,
+                  0,
+                  -10
+                ],
+                "rot": 0
+              },
+              "description": "",
+              "duration": 0,
+              "type": "setPos"
+            },
+            {
+              "data": {
+                "actorName": "Ifrit Control <subactor 3>",
+                "pos": [
+                  10,
+                  0,
+                  10
+                ],
+                "rot": 0
+              },
+              "description": "",
+              "duration": 0,
+              "type": "setPos"
+            },
+            {
+              "data": {
+                "actorName": "Ifrit Control <subactor 4>",
+                "pos": [
+                  10,
+                  0,
+                  -10
+                ],
+                "rot": 0
+              },
+              "description": "",
+              "duration": 0,
+              "type": "setPos"
+            },
+            {
+              "data": {
+                "actionId": 734,
+                "selectorIndex": 0,
+                "selectorName": "<unset>",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit Control <subactor 1>",
+                "targetType": "self"
+              },
+              "description": "Cast plumes",
+              "duration": 0,
+              "type": "castAction"
+            },
+            {
+              "data": {
+                "actionId": 734,
+                "selectorIndex": 0,
+                "selectorName": "<unset>",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit Control <subactor 2>",
+                "targetType": "self"
+              },
+              "description": "",
+              "duration": 0,
+              "type": "castAction"
+            },
+            {
+              "data": {
+                "actionId": 734,
+                "selectorIndex": 0,
+                "selectorName": "<unset>",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit Control <subactor 3>",
+                "targetType": "self"
+              },
+              "description": "",
+              "duration": 0,
+              "type": "castAction"
+            },
+            {
+              "data": {
+                "actionId": 734,
+                "selectorIndex": 0,
+                "selectorName": "<unset>",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit Control <subactor 4>",
+                "targetType": "self"
+              },
+              "description": "",
+              "duration": 4000,
+              "type": "castAction"
+            },
+            {
+              "data": {
+                "actorName": "Ifrit Control <subactor 1>",
+                "pos": [
+                  0,
+                  0,
+                  -20
+                ],
+                "rot": 0
+              },
+              "description": "Move plumes out",
+              "duration": 0,
+              "type": "setPos"
+            },
+            {
+              "data": {
+                "actorName": "Ifrit Control <subactor 2>",
+                "pos": [
+                  0,
+                  0,
+                  20
+                ],
+                "rot": 0
+              },
+              "description": "",
+              "duration": 0,
+              "type": "setPos"
+            },
+            {
+              "data": {
+                "actorName": "Ifrit Control <subactor 3>",
+                "pos": [
+                  -20,
+                  0,
+                  0
+                ],
+                "rot": 0
+              },
+              "description": "",
+              "duration": 0,
+              "type": "setPos"
+            },
+            {
+              "data": {
+                "actorName": "Ifrit Control <subactor 4>",
+                "pos": [
+                  -20,
+                  0,
+                  20
+                ],
+                "rot": 0
+              },
+              "description": "",
+              "duration": 0,
+              "type": "setPos"
+            },
+            {
+              "data": {
+                "actorName": "Ifrit Control <subactor 5>",
+                "pos": [
+                  -15,
+                  0,
+                  15
+                ],
+                "rot": 0
+              },
+              "description": "",
+              "duration": 0,
+              "type": "setPos"
+            },
+            {
+              "data": {
+                "actorName": "Ifrit Control <subactor 6>",
+                "pos": [
+                  -15,
+                  0,
+                  -15
+                ],
+                "rot": 0
+              },
+              "description": "",
+              "duration": 0,
+              "type": "setPos"
+            },
+            {
+              "data": {
+                "actorName": "Ifrit Control <subactor 7>",
+                "pos": [
+                  15,
+                  0,
+                  -15
+                ],
+                "rot": 0
+              },
+              "description": "",
+              "duration": 0,
+              "type": "setPos"
+            },
+            {
+              "data": {
+                "actorName": "Ifrit Control <subactor 8>",
+                "pos": [
+                  15,
+                  0,
+                  15
+                ],
+                "rot": 0
+              },
+              "description": "",
+              "duration": 200,
+              "type": "setPos"
+            },
+            {
+              "data": {
+                "actionId": 734,
+                "selectorIndex": 0,
+                "selectorName": "<unset>",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit Control <subactor 1>",
+                "targetType": "self"
+              },
+              "description": "Cast plumes out",
+              "duration": 0,
+              "type": "castAction"
+            },
+            {
+              "data": {
+                "actionId": 734,
+                "selectorIndex": 0,
+                "selectorName": "<unset>",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit Control <subactor 2>",
+                "targetType": "self"
+              },
+              "description": "",
+              "duration": 0,
+              "type": "castAction"
+            },
+            {
+              "data": {
+                "actionId": 734,
+                "selectorIndex": 0,
+                "selectorName": "<unset>",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit Control <subactor 3>",
+                "targetType": "self"
+              },
+              "description": "",
+              "duration": 0,
+              "type": "castAction"
+            },
+            {
+              "data": {
+                "actionId": 734,
+                "selectorIndex": 0,
+                "selectorName": "<unset>",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit Control <subactor 4>",
+                "targetType": "self"
+              },
+              "description": "",
+              "duration": 0,
+              "type": "castAction"
+            },
+            {
+              "data": {
+                "actionId": 734,
+                "selectorIndex": 0,
+                "selectorName": "<unset>",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit Control <subactor 5>",
+                "targetType": "self"
+              },
+              "description": "",
+              "duration": 0,
+              "type": "castAction"
+            },
+            {
+              "data": {
+                "actionId": 734,
+                "selectorIndex": 0,
+                "selectorName": "<unset>",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit Control <subactor 6>",
+                "targetType": "self"
+              },
+              "description": "",
+              "duration": 0,
+              "type": "castAction"
+            },
+            {
+              "data": {
+                "actionId": 734,
+                "selectorIndex": 0,
+                "selectorName": "<unset>",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit Control <subactor 7>",
+                "targetType": "self"
+              },
+              "description": "",
+              "duration": 0,
+              "type": "castAction"
+            },
+            {
+              "data": {
+                "actionId": 734,
+                "selectorIndex": 0,
+                "selectorName": "<unset>",
+                "snapshot": false,
+                "snapshotTime": 0,
+                "sourceActor": "Ifrit Control <subactor 8>",
+                "targetType": "self"
+              },
+              "description": "",
+              "duration": 0,
+              "type": "castAction"
+            }
+          ]
+        },
+        {
+          "description": "",
+          "id": 3,
+          "name": "Setup",
+          "timepoints": [
+            {
+              "data": {},
+              "description": "",
+              "duration": 5000,
+              "type": "idle"
+            }
+          ]
+        }
+      ],
+      "subactors": [
+        "Ifrit Control <subactor 1>",
+        "Ifrit Control <subactor 2>",
+        "Ifrit Control <subactor 3>",
+        "Ifrit Control <subactor 4>",
+        "Ifrit Control <subactor 5>",
+        "Ifrit Control <subactor 6>",
+        "Ifrit Control <subactor 7>",
+        "Ifrit Control <subactor 8>"
+      ],
+      "type": "bnpc"
+    },
+    {
+      "hp": 445,
+      "id": 3,
+      "layoutId": 4126281,
+      "name": "Ifrit Nail 1",
+      "phases": [
+        {
+          "description": "",
+          "id": 1,
+          "name": "Phase 1",
+          "timepoints": []
+        }
+      ],
+      "subactors": [],
+      "type": "bnpc"
+    }
+  ],
+  "conditions": [
+    {
+      "condition": "combatState",
+      "description": "",
+      "enabled": true,
+      "id": 10,
+      "loop": false,
+      "paramData": {
+        "combatState": 0,
+        "sourceActor": "Ifrit"
+      },
+      "targetActor": "Ifrit",
+      "targetPhase": "Reset"
+    },
+    {
+      "condition": "combatState",
+      "description": "",
+      "enabled": false,
+      "id": 1,
+      "loop": true,
+      "paramData": {
+        "combatState": 1,
+        "sourceActor": "Ifrit"
+      },
+      "targetActor": "Ifrit",
+      "targetPhase": "Auto-attack"
+    },
+    {
+      "condition": "hpPctBetween",
+      "description": "",
+      "enabled": true,
+      "id": 2,
+      "loop": true,
+      "paramData": {
+        "hpMax": 100,
+        "hpMin": 71,
+        "sourceActor": "Ifrit"
+      },
+      "targetActor": "Ifrit",
+      "targetPhase": "Phase 1"
+    },
+    {
+      "condition": "hpPctBetween",
+      "description": "",
+      "enabled": true,
+      "id": 3,
+      "loop": false,
+      "paramData": {
+        "hpMax": 71,
+        "hpMin": 50,
+        "sourceActor": "Ifrit"
+      },
+      "targetActor": "Ifrit",
+      "targetPhase": "Phase 2 Start"
+    },
+    {
+      "condition": "hpPctBetween",
+      "description": "",
+      "enabled": false,
+      "id": 4,
+      "loop": true,
+      "paramData": {
+        "hpMax": 70,
+        "hpMin": 50,
+        "sourceActor": "Ifrit"
+      },
+      "targetActor": "Ifrit",
+      "targetPhase": "Phase 2 Main"
+    },
+    {
+      "condition": "hpPctBetween",
+      "description": "",
+      "enabled": true,
+      "id": 5,
+      "loop": false,
+      "paramData": {
+        "hpMax": 50,
+        "hpMin": 0,
+        "sourceActor": "Ifrit"
+      },
+      "targetActor": "Ifrit",
+      "targetPhase": "Nail Spawn"
+    },
+    {
+      "condition": "combatState",
+      "description": "",
+      "enabled": false,
+      "id": 6,
+      "loop": true,
+      "paramData": {
+        "combatState": 1,
+        "sourceActor": "Ifrit"
+      },
+      "targetActor": "Ifrit",
+      "targetPhase": "Phase 1"
+    },
+    {
+      "condition": "combatState",
+      "description": "",
+      "enabled": true,
+      "id": 7,
+      "loop": false,
+      "paramData": {
+        "combatState": 5,
+        "sourceActor": "Ifrit Nail 1"
+      },
+      "targetActor": "Ifrit",
+      "targetPhase": "Hellfire"
+    },
+    {
+      "condition": "combatState",
+      "description": "",
+      "enabled": false,
+      "id": 8,
+      "loop": false,
+      "paramData": {
+        "combatState": 1,
+        "sourceActor": "Ifrit"
+      },
+      "targetActor": "Ifrit",
+      "targetPhase": "Hellfire"
+    },
+    {
+      "condition": "combatState",
+      "description": "",
+      "enabled": false,
+      "id": 9,
+      "loop": true,
+      "paramData": {
+        "combatState": 1,
+        "sourceActor": "Ifrit"
+      },
+      "targetActor": "Ifrit",
+      "targetPhase": "Final Phase"
+    },
+    {
+      "condition": "getAction",
+      "description": "",
+      "enabled": true,
+      "id": 11,
+      "loop": true,
+      "paramData": {
+        "actionId": 455,
+        "sourceActor": "Ifrit"
+      },
+      "targetActor": "Ifrit Control",
+      "targetPhase": "Eruption"
+    },
+    {
+      "condition": "phaseActive",
+      "description": "",
+      "enabled": false,
+      "id": 12,
+      "loop": false,
+      "paramData": {
+        "phaseName": "Final Phase",
+        "sourceActor": "Ifrit"
+      },
+      "targetActor": "Ifrit Control",
+      "targetPhase": "Plumes Loop"
+    },
+    {
+      "condition": "combatState",
+      "description": "",
+      "enabled": true,
+      "id": 13,
+      "loop": false,
+      "paramData": {
+        "combatState": 1,
+        "sourceActor": "Ifrit"
+      },
+      "targetActor": "Ifrit Control",
+      "targetPhase": "Setup"
+    }
+  ],
+  "name": "Brand new timeline",
+  "selectors": [
+    {
+      "count": 1,
+      "description": "",
+      "excludeSelectorName": "",
+      "fillRandomEntries": true,
+      "filters": [
+        {
+          "negate": true,
+          "param": 0,
+          "type": "topAggro"
+        }
+      ],
+      "id": 1,
+      "name": "Eruption"
+    }
+  ],
+  "version": 8
+}
\ No newline at end of file
diff --git a/data/actions/IfritNormal.json b/data/actions/IfritNormal.json
new file mode 100644
index 000000000..c611f6596
--- /dev/null
+++ b/data/actions/IfritNormal.json
@@ -0,0 +1,104 @@
+{
+  "872": {
+    "name": "Auto Attack",
+    "potency": 100,
+    "comboPotency": 0,
+    "flankPotency": 0,
+    "frontPotency": 0,
+    "rearPotency": 0,
+    "curePotency": 0,
+    "restorePercentage": 0,
+    "nextCombo": [],
+    "statuses": {
+      "caster": [],
+      "target": []
+    }
+  },
+  "453": {
+    "name": "Incinerate",
+    "potency": 100,
+    "comboPotency": 0,
+    "flankPotency": 0,
+    "frontPotency": 0,
+    "rearPotency": 0,
+    "curePotency": 0,
+    "restorePercentage": 0,
+    "nextCombo": [],
+    "statuses": {
+      "caster": [],
+      "target": []
+    }
+  },
+  "454": {
+    "name": "Vulcan Burst",
+    "potency": 100,
+    "comboPotency": 0,
+    "flankPotency": 0,
+    "frontPotency": 0,
+    "rearPotency": 0,
+    "curePotency": 0,
+    "restorePercentage": 0,
+    "nextCombo": [],
+    "statuses": {
+      "caster": [],
+      "target": []
+    }
+  },
+  "458": {
+    "name": "Hellfire",
+    "potency": 400,
+    "comboPotency": 0,
+    "flankPotency": 0,
+    "frontPotency": 0,
+    "rearPotency": 0,
+    "curePotency": 0,
+    "restorePercentage": 0,
+    "nextCombo": [],
+    "statuses": {
+      "caster": [
+        {
+          "id": 394,
+          "duration": 8000,
+          "modifiers": [
+            {
+              "modifier": "DamageTakenPercent",
+              "value": -100
+            }
+          ]
+        }
+      ],
+      "target": []
+    }
+  },
+  "733": {
+    "name": "Eruption",
+    "potency": 200,
+    "comboPotency": 0,
+    "flankPotency": 0,
+    "frontPotency": 0,
+    "rearPotency": 0,
+    "curePotency": 0,
+    "restorePercentage": 0,
+    "nextCombo": [],
+    "statuses": {
+      "caster": [],
+      "target": []
+    }
+  },
+  "734": {
+    "name": "Radiant Plume",
+    "potency": 200,
+    "comboPotency": 0,
+    "flankPotency": 0,
+    "frontPotency": 0,
+    "rearPotency": 0,
+    "curePotency": 0,
+    "restorePercentage": 0,
+    "nextCombo": [],
+    "statuses": {
+      "caster": [],
+      "target": []
+    }
+  }
+
+}
\ No newline at end of file
diff --git a/data/actions/player.json b/data/actions/player.json
index 149d05aae..c266e805b 100644
--- a/data/actions/player.json
+++ b/data/actions/player.json
@@ -1,7 +1,7 @@
 {
   "7": {
     "name": "Attack",
-    "potency": 0,
+    "potency": 110,
     "comboPotency": 0,
     "flankPotency": 0,
     "frontPotency": 0,
@@ -16,7 +16,7 @@
   },
   "8": {
     "name": "Shot",
-    "potency": 0,
+    "potency": 100,
     "comboPotency": 0,
     "flankPotency": 0,
     "frontPotency": 0,
@@ -398,7 +398,18 @@
     "restorePercentage": 0,
     "nextCombo": [],
     "statuses": {
-      "caster": [],
+      "caster": [
+        {
+          "id": 83,
+          "duration": 20000,
+          "modifiers": [
+            {
+              "modifier": "DefensePercent",
+              "value": 20
+            }
+          ]
+        }
+      ],
       "target": []
     }
   },
@@ -414,7 +425,18 @@
     "nextCombo": [],
     "statuses": {
       "caster": [],
-      "target": []
+      "target": [
+        {
+          "id": 244,
+          "duration": 30000,
+          "modifiers": [
+            {
+              "modifier": "TickDamage",
+              "value": 20
+            }
+          ]
+        }
+      ]
     }
   },
   "34": {
@@ -478,7 +500,18 @@
       45
     ],
     "statuses": {
-      "caster": [],
+      "caster": [
+        {
+          "id": 85,
+          "duration": 24000,
+          "modifiers": [
+            {
+              "modifier": "DamageDealtPercent",
+              "value": 20
+            }
+          ]
+        }
+      ],
       "target": []
     }
   },
@@ -493,7 +526,18 @@
     "restorePercentage": 0,
     "nextCombo": [],
     "statuses": {
-      "caster": [],
+      "caster": [
+        {
+          "id": 86,
+          "duration": 20000,
+          "modifiers": [
+            {
+              "modifier": "AttackPowerPercent",
+              "value": 50
+            }
+          ]
+        }
+      ],
       "target": []
     }
   },
@@ -523,7 +567,18 @@
     "restorePercentage": 0,
     "nextCombo": [],
     "statuses": {
-      "caster": [],
+      "caster": [
+        {
+          "id": 87,
+          "duration": 20000,
+          "modifiers": [
+            {
+              "modifier": "HPPercent",
+              "value": 20
+            }
+          ]
+        }
+      ],
       "target": []
     }
   },
@@ -574,7 +629,7 @@
   },
   "44": {
     "name": "Vengeance",
-    "potency": 50,
+    "potency": 0,
     "comboPotency": 0,
     "flankPotency": 0,
     "frontPotency": 0,
@@ -583,7 +638,18 @@
     "restorePercentage": 0,
     "nextCombo": [],
     "statuses": {
-      "caster": [],
+      "caster": [
+        {
+          "id": 89,
+          "duration": 20000,
+          "modifiers": [
+            {
+              "modifier": "ReflectPhysical",
+              "value": 50
+            }
+          ]
+        }
+      ],
       "target": []
     }
   },
@@ -643,7 +709,34 @@
     "restorePercentage": 0,
     "nextCombo": [],
     "statuses": {
-      "caster": [],
+      "caster": [
+        {
+          "id": 91,
+          "duration": 0,
+          "modifiers": [
+            {
+              "modifier": "HPPercent",
+              "value": 25
+            },
+            {
+              "modifier": "DamageDealtPercent",
+              "value": -25
+            },
+            {
+              "modifier": "HealingMagicRecoveryPercent",
+              "value": 20
+            },
+            {
+              "modifier": "AccuracyPercent",
+              "value": 5
+            },
+            {
+              "modifier": "EnmityPercent",
+              "value": 20
+            }
+          ]
+        }
+      ],
       "target": []
     }
   },
@@ -703,7 +796,12 @@
     "restorePercentage": 0,
     "nextCombo": [],
     "statuses": {
-      "caster": [],
+      "caster": [
+        {
+          "id": 97,
+          "duration": 30000
+        }
+      ],
       "target": []
     }
   },
@@ -1176,7 +1274,19 @@
     "restorePercentage": 0,
     "nextCombo": [],
     "statuses": {
-      "caster": [],
+      "caster": [
+        {
+          "id": 116,
+          "duration": 10000,
+          "flag": 4096,
+          "modifiers": [
+            {
+              "modifier": "CriticalHitPercent",
+              "value": 100
+            }
+          ]
+        }
+      ],
       "target": []
     }
   },
@@ -2454,7 +2564,38 @@
     "nextCombo": [],
     "statuses": {
       "caster": [],
-      "target": []
+      "target": [
+        {
+          "id": 180,
+          "duration": 24000,
+          "modifiers": [
+            {
+              "modifier": "TickDamage",
+              "value": 35
+            }
+          ]
+        },
+        {
+          "id": 191,
+          "duration": 24000,
+          "modifiers": [
+            {
+              "modifier": "HealingRecoveryPercent",
+              "value": -20
+            }
+          ]
+        },
+        {
+          "id": 240,
+          "duration": 24000,
+          "modifiers": [
+            {
+              "modifier": "HeavyPercent",
+              "value": 40
+            }
+          ]
+        }
+      ]
     }
   },
   "169": {
diff --git a/deps/datReader/DatCategories/bg/lgb.h b/deps/datReader/DatCategories/bg/lgb.h
index c5c99f11f..d0c3f29bd 100644
--- a/deps/datReader/DatCategories/bg/lgb.h
+++ b/deps/datReader/DatCategories/bg/lgb.h
@@ -227,6 +227,8 @@ struct LGB_GROUP
       memcpy( (char*)&refs[0], buf + offset + header.LayerSetRef + layerSetReferencedList.LayerSets, layerSetReferencedList.LayerSetCount * sizeof( LayerSetReferenced ) );
     }
 
+    entries.reserve( header.entryCount );
+
     const auto entriesOffset = offset + header.entriesOffset;
     for( auto i = 0; i < header.entryCount; ++i )
     {
@@ -235,41 +237,53 @@ struct LGB_GROUP
       try
       {
         const auto type = *reinterpret_cast< LgbEntryType* >( buf + entryOffset );
-        if( type == LgbEntryType::BgParts )
-        {
-          entries.push_back( std::make_shared< LGB_BGPARTS_ENTRY >( buf, entryOffset ) );
-        }
-        else if( type == LgbEntryType::Gimmick )
-        {
-          entries.push_back( std::make_shared< LGB_GIMMICK_ENTRY >( buf, entryOffset ) );
-        }
-        else if( type == LgbEntryType::EventNpc )
-        {
-          entries.push_back( std::make_shared< LGB_ENPC_ENTRY >( buf, entryOffset ) );
-        }
-        else if( type == LgbEntryType::EventObject )
-        {
-          entries.push_back( std::make_shared< LGB_EOBJ_ENTRY >( buf, entryOffset ) );
-        }
-        else if( type == LgbEntryType::ExitRange )
-        {
-          entries.push_back( std::make_shared< LGB_EXIT_RANGE_ENTRY >( buf, entryOffset ) );
-        }
-        else if( type == LgbEntryType::EventRange )
-        {
-          entries.push_back( std::make_shared< LGB_EVENT_RANGE_ENTRY >( buf, entryOffset ) );
-        }
-        else if( type == LgbEntryType::PopRange )
-        {
-          entries.push_back( std::make_shared< LGB_POP_RANGE_ENTRY >( buf, entryOffset ) );
-        }
-        else if( type == LgbEntryType::MapRange )
-        {
-          entries.push_back( std::make_shared< LGB_MAP_RANGE_ENTRY >( buf, entryOffset ) );
-        }
-        else
+        switch( type )
         {
-          entries.push_back( std::make_shared< LgbEntry >( buf, entryOffset ) );
+          case LgbEntryType::BgParts:
+          {
+            entries.emplace_back( std::make_shared< LGB_BGPARTS_ENTRY >( buf, entryOffset ) );
+            break;
+          }
+          case LgbEntryType::Gimmick:
+          {
+            entries.emplace_back( std::make_shared< LGB_GIMMICK_ENTRY >( buf, entryOffset ) );
+            break;
+          }
+          case LgbEntryType::EventNpc:
+          {
+            entries.emplace_back( std::make_shared< LGB_ENPC_ENTRY >( buf, entryOffset ) );
+            break;
+          }
+          case LgbEntryType::EventObject:
+          {
+            entries.emplace_back( std::make_shared< LGB_EOBJ_ENTRY >( buf, entryOffset ) );
+            break;
+          }
+          case LgbEntryType::ExitRange:
+          {
+            entries.emplace_back( std::make_shared< LGB_EXIT_RANGE_ENTRY >( buf, entryOffset ) );
+            break;
+          }
+          case LgbEntryType::EventRange:
+          {
+            entries.emplace_back( std::make_shared< LGB_EVENT_RANGE_ENTRY >( buf, entryOffset ) );
+            break;
+          }
+          case LgbEntryType::PopRange:
+          {
+            entries.emplace_back( std::make_shared< LGB_POP_RANGE_ENTRY >( buf, entryOffset ) );
+            break;
+          }
+          case LgbEntryType::MapRange:
+          {
+            entries.emplace_back( std::make_shared< LGB_MAP_RANGE_ENTRY >( buf, entryOffset ) );
+            break;
+          }
+          default:
+          {
+            entries.emplace_back( std::make_shared< LgbEntry >( buf, entryOffset ) );
+            break;
+          }
         }
       }
       catch( std::exception& e )
diff --git a/deps/datReader/Exd.cpp b/deps/datReader/Exd.cpp
index 74aae36e0..b1a2a2b5f 100644
--- a/deps/datReader/Exd.cpp
+++ b/deps/datReader/Exd.cpp
@@ -7,50 +7,6 @@
 
 using xiv::utils::bparse::extract;
 
-
-namespace xiv::exd
-{
-  struct ExdHeader
-  {
-    char magic[0x4];
-    uint16_t unknown;
-    uint16_t unknown2;
-    uint32_t index_size;
-  };
-
-  struct ExdRecordIndex
-  {
-    uint32_t id;
-    uint32_t offset;
-  };
-}
-
-namespace xiv::utils::bparse {
-template<>
-  inline void reorder< xiv::exd::ExdHeader >( xiv::exd::ExdHeader& i_struct )
-  {
-    for( int32_t i = 0; i < 0x4; ++i )
-    {
-      xiv::utils::bparse::reorder( i_struct.magic[ i ] );
-    }
-    i_struct.unknown = xiv::utils::bparse::byteswap( i_struct.unknown );
-    xiv::utils::bparse::reorder( i_struct.unknown );
-    i_struct.unknown2 = xiv::utils::bparse::byteswap( i_struct.unknown2 );
-    xiv::utils::bparse::reorder( i_struct.unknown2 );
-    i_struct.index_size = xiv::utils::bparse::byteswap( i_struct.index_size );
-    xiv::utils::bparse::reorder( i_struct.index_size );
-  }
-
-  template<>
-  inline void reorder< xiv::exd::ExdRecordIndex >( xiv::exd::ExdRecordIndex& i_struct )
-  {
-    i_struct.id = xiv::utils::bparse::byteswap( i_struct.id );
-    xiv::utils::bparse::reorder( i_struct.id );
-    i_struct.offset = xiv::utils::bparse::byteswap( i_struct.offset );
-    xiv::utils::bparse::reorder( i_struct.offset );
-  }
-};
-
 namespace xiv::exd
 {
   Exd::Exd( std::shared_ptr< Exh > i_exh, const std::vector< std::shared_ptr< dat::File>>& i_files )
@@ -68,16 +24,16 @@ namespace xiv::exd
       std::istringstream iss( std::string( dataCpy.begin(), dataCpy.end() ) );
 
       // Extract the header and skip to the record indices
-      auto exd_header = extract< ExdHeader >( iss );
+      auto exd_header = extract< ExdHeaderMinimal >( iss );
       iss.seekg( 0x20 );
 
       // Preallocate and extract the record_indices
-      const uint32_t record_count = exd_header.index_size / sizeof( ExdRecordIndex );
-      std::vector< ExdRecordIndex > record_indices;
+      const uint32_t record_count = exd_header.index_size / sizeof( ExdRecordIndexData );
+      std::vector< ExdRecordIndexData > record_indices;
       record_indices.reserve( record_count );
       for( uint32_t i = 0; i < record_count; ++i )
       {
-        auto recordIndex = extract< ExdRecordIndex >( iss );
+        auto recordIndex = extract< ExdRecordIndexData >( iss );
         _idCache[ recordIndex.id ] = ExdCacheEntry{ file_ptr, recordIndex.offset };
       }
     }
@@ -290,16 +246,16 @@ namespace xiv::exd
       std::istringstream iss( std::string( dataCpy.begin(), dataCpy.end() ) );
 
       // Extract the header and skip to the record indices
-      auto exd_header = extract< ExdHeader >( iss );
+      auto exd_header = extract< ExdHeaderMinimal >( iss );
       iss.seekg( 0x20 );
 
       // Preallocate and extract the record_indices
-      const uint32_t record_count = exd_header.index_size / sizeof( ExdRecordIndex );
-      std::vector< ExdRecordIndex > record_indices;
+      const uint32_t record_count = exd_header.index_size / sizeof( ExdRecordIndexData );
+      std::vector< ExdRecordIndexData > record_indices;
       record_indices.reserve( record_count );
       for( uint32_t i = 0; i < record_count; ++i )
       {
-        record_indices.emplace_back( extract< ExdRecordIndex >( iss ) );
+        record_indices.emplace_back( extract< ExdRecordIndexData >( iss ) );
       }
 
       for( auto& record_index : record_indices )
diff --git a/deps/datReader/Exd.h b/deps/datReader/Exd.h
index 8cf406589..e08f6e54b 100644
--- a/deps/datReader/Exd.h
+++ b/deps/datReader/Exd.h
@@ -2,6 +2,7 @@
 
 #include <memory>
 #include <map>
+#include <unordered_map>
 
 #include <variant>
 
@@ -12,6 +13,49 @@
 #include <fstream>
 #include "Exh.h"
 #include "bparse.h"
+
+namespace xiv::exd
+{
+  struct ExdHeaderMinimal {
+    char magic[ 0x4 ];
+    uint16_t unknown;
+    uint16_t unknown2;
+    uint32_t index_size;
+  };
+
+  struct ExdRecordIndexData {
+    uint32_t id;
+    uint32_t offset;
+  };
+}
+
+namespace xiv::utils::bparse
+{
+  template<>
+  inline void reorder< xiv::exd::ExdHeaderMinimal >( xiv::exd::ExdHeaderMinimal& i_struct )
+  {
+    for( int32_t i = 0; i < 0x4; ++i )
+    {
+      xiv::utils::bparse::reorder( i_struct.magic[ i ] );
+    }
+    i_struct.unknown = xiv::utils::bparse::byteswap( i_struct.unknown );
+    xiv::utils::bparse::reorder( i_struct.unknown );
+    i_struct.unknown2 = xiv::utils::bparse::byteswap( i_struct.unknown2 );
+    xiv::utils::bparse::reorder( i_struct.unknown2 );
+    i_struct.index_size = xiv::utils::bparse::byteswap( i_struct.index_size );
+    xiv::utils::bparse::reorder( i_struct.index_size );
+  }
+
+  template<>
+  inline void reorder< xiv::exd::ExdRecordIndexData >( xiv::exd::ExdRecordIndexData& i_struct )
+  {
+    i_struct.id = xiv::utils::bparse::byteswap( i_struct.id );
+    xiv::utils::bparse::reorder( i_struct.id );
+    i_struct.offset = xiv::utils::bparse::byteswap( i_struct.offset );
+    xiv::utils::bparse::reorder( i_struct.offset );
+  }
+};// namespace xiv::utils::bparse
+
 namespace xiv::exd
 {
 
@@ -184,12 +228,153 @@ namespace xiv::exd
     const std::vector< Field > get_row( uint32_t id, uint32_t subRow );
 
     // Get all rows
-    const std::map< uint32_t, std::vector< Field>>& get_rows();
+    const std::map< uint32_t, std::vector< Field > >& get_rows();
+
+    // Get all rows
+    template< typename T >
+    const std::unordered_map< uint32_t, std::shared_ptr< Excel::ExcelStruct< T > > > get_sheet_rows()
+    {
+      std::unordered_map< uint32_t, std::shared_ptr< Excel::ExcelStruct< T > > > sheets;
+
+      // Iterates over all the files
+      const uint32_t member_count =  static_cast< uint32_t >( _exh->get_members().size() );
+      for( auto& file_ptr : _files )
+      {
+        // Get a stream
+        std::vector< char > dataCpy = file_ptr->get_data_sections().front();
+        std::istringstream iss( std::string( dataCpy.begin(), dataCpy.end() ) );
+
+        // Extract the header and skip to the record indices
+        auto exd_header = xiv::utils::bparse::extract< ExdHeaderMinimal >( iss );
+        iss.seekg( 0x20 );
+
+        // Preallocate and extract the record_indices
+        const uint32_t record_count = exd_header.index_size / sizeof( ExdRecordIndexData );
+        std::vector< ExdRecordIndexData > record_indices;
+        record_indices.reserve( record_count );
+        for( uint32_t i = 0; i < record_count; ++i )
+        {
+          record_indices.emplace_back( xiv::utils::bparse::extract< ExdRecordIndexData >( iss ) );
+        }
+
+        for( auto& record_index : record_indices )
+        {
+          auto cacheEntryIt = _idCache.find( record_index.id );
+          if( cacheEntryIt == _idCache.end() )
+            throw std::out_of_range( "Id not found: " + std::to_string( record_index.id ) );
+
+          auto pSheet = std::make_shared< Excel::ExcelStruct< T > >();
+
+          // Get the vector fields for the given record and preallocate it
+          auto fields = _data[ record_index.id ];
+          fields.reserve( member_count );
+          iss.seekg( cacheEntryIt->second.offset + 6 );
+
+          iss.read( reinterpret_cast<char*>( &pSheet.get()->_data ), sizeof( T ) );
+
+          int stringCount = 0;
+          for( auto& member_entry : _exh->get_exh_members() )
+          {
+
+            // Seek to the position of the member to extract.
+            // 6 is because we have uint32_t/uint16_t at the start of each record
+            iss.seekg( cacheEntryIt->second.offset + 6 + member_entry.offset );
+
+            // Switch depending on the type to extract
+            switch( member_entry.type )
+            {
+              case DataType::string:
+                // Extract the offset to the actual string
+                // Seek to it then extract the actual string
+                {
+                  auto string_offset = xiv::utils::bparse::extract< uint32_t >( iss, "string_offset", false );
+                  iss.seekg( cacheEntryIt->second.offset + 6 + _exh->get_header().data_offset + string_offset );
+                  std::string value = xiv::utils::bparse::extract_cstring( iss, "string" );
+                  auto it = pSheet->_strings.insert( pSheet->_strings.end(), value );
+                  *reinterpret_cast< uint32_t* >( pSheet->ptr() + member_entry.offset ) =
+                    static_cast< uint32_t >( std::distance( pSheet->_strings.begin(), it ) );
+                }
+                break;
+
+              case DataType::boolean:
+                xiv::utils::bparse::extract< bool >( iss, "bool" );
+                break;
+
+              case DataType::int8:
+                xiv::utils::bparse::extract< int8_t >( iss, "int8_t" );
+                break;
+
+              case DataType::uint8:
+                xiv::utils::bparse::extract< uint8_t >( iss, "uint8_t" );
+                break;
+
+
+              case DataType::int16:
+                {
+                  int16_t value = xiv::utils::bparse::extract< int16_t >( iss, "int16_t", false );
+                  *reinterpret_cast< int16_t* >( pSheet->ptr() + member_entry.offset ) = value;
+                }
+                break;
+
+              case DataType::uint16:
+                {
+                  uint16_t value = xiv::utils::bparse::extract< uint16_t >( iss, "uint16_t", false );
+                  *reinterpret_cast< uint16_t* >( pSheet->ptr() + member_entry.offset ) = value;
+                }
+                break;
+
+              case DataType::int32:
+                {
+                  int32_t value = xiv::utils::bparse::extract< int32_t >( iss, "int32_t", false );
+                  *reinterpret_cast< int32_t* >( pSheet->ptr() + member_entry.offset ) = value;
+                }
+                break;
+
+              case DataType::uint32:
+                {
+                  uint32_t value = xiv::utils::bparse::extract< uint32_t >( iss, "uint32_t", false );
+                  *reinterpret_cast< uint32_t* >( pSheet->ptr() + member_entry.offset ) = value;
+                }
+                break;
+
+              case DataType::float32:
+                {
+                  float value = xiv::utils::bparse::extract< float >( iss, "float", false );
+                  *reinterpret_cast< float* >( pSheet->ptr() + member_entry.offset ) = value;
+                }
+                break;
+
+              case DataType::uint64:
+                {
+                  uint64_t value = xiv::utils::bparse::extract< uint64_t >( iss, "uint64_t", false );
+                  *reinterpret_cast< uint64_t* >( pSheet->ptr() + member_entry.offset ) = value;
+                }
+                break;
+
+              default:
+                auto type = static_cast< uint16_t >( member_entry.type );
+                if( type < 0x19 || type > 0x20 )
+                  throw std::runtime_error( "Unknown DataType: " + std::to_string( type ) );
+                uint64_t val = xiv::utils::bparse::extract< uint64_t >( iss, "bool" );
+                int32_t shift = type - 0x19;
+                int32_t i = 1 << shift;
+                val &= i;
+                fields.emplace_back( ( val & i ) == i );
+                break;
+            }
+          }
+
+          sheets[ record_index.id ] = pSheet;
+        }
+      }
+
+      return sheets;
+    }
 
   protected:
     // Data indexed by the ID of the row, the vector is field with the same order as exh.members
-    std::map< uint32_t, std::vector< Field>> _data;
-    std::vector< std::shared_ptr< dat::File>> _files;
+    std::map< uint32_t, std::vector< Field > > _data;
+    std::vector< std::shared_ptr< dat::File > > _files;
     std::shared_ptr< Exh > _exh;
     std::map< uint32_t, ExdCacheEntry > _idCache;
   };
diff --git a/deps/datReader/Exd/Structs.h b/deps/datReader/Exd/Structs.h
index 078d26fa4..e8a9b1ad7 100644
--- a/deps/datReader/Exd/Structs.h
+++ b/deps/datReader/Exd/Structs.h
@@ -302,18 +302,18 @@ namespace Excel
     uint16_t LimitBreakAction[3];
     uint16_t PvpLimitBreakAction[3];
     uint8_t Kind;
-    uint8_t UIPriority;
     uint8_t Unknown6;
+    uint8_t JobIndex;
     uint8_t MainClass;
     uint8_t Role;
     uint8_t Town;
-    int8_t MonsterNote;
+    int8_t UIPriority;
     int8_t StartingLevel;
     uint8_t PartyBuff;
     int8_t WorkIndex;
     int8_t BattleClassIndex;
     int8_t CraftingClassIndex;
-    int8_t Unknown7;
+    int8_t MonsterNote;
   };
 
   /* 63507 */
@@ -392,12 +392,13 @@ namespace Excel
     uint8_t CostType;
     uint8_t Cond;
     uint8_t RecastGroup;
-    uint8_t Element;
     uint8_t ProcStatus;
-    uint8_t UseClassJob;
+    uint8_t Unknown1; // todo: possibly cost type? tp etc?
+    uint8_t ClassJobCategory; // recastgroup
     uint8_t Init;
     uint8_t Omen;
-    int8_t Learn;
+    uint8_t Learn;
+    int8_t UseClassJob;
     int8_t SelectRange;
     int8_t SelectCorpse;
     int8_t AttackType;
@@ -429,7 +430,7 @@ namespace Excel
     uint8_t HideCastBar : 1;
     uint8_t IsTargetLine : 1;
 
-    int8_t padding0;
+    int8_t unknown;
   };
 
   /* 75653 */
@@ -2053,7 +2054,8 @@ namespace Excel
     uint8_t NotControl : 1;
     uint8_t NotAction : 1;
     uint8_t NotMove : 1;
-    uint8_t padding0 : 6;
+    uint8_t padding0 : 5;
+    uint8_t CanOff : 1;
     uint8_t SemiTransparent : 1;
     uint8_t FcAction : 1;
     int8_t padding1[2];
diff --git a/deps/datReader/bparse.h b/deps/datReader/bparse.h
index 6c722126d..8d3be519f 100644
--- a/deps/datReader/bparse.h
+++ b/deps/datReader/bparse.h
@@ -3,6 +3,7 @@
 #include <iomanip>
 #include <sstream>
 #include <vector>
+#include <cstdint>
 
 namespace xiv::utils::bparse
 {
diff --git a/deps/datReaderPs3/bparse.h b/deps/datReaderPs3/bparse.h
index 71535263f..398638955 100644
--- a/deps/datReaderPs3/bparse.h
+++ b/deps/datReaderPs3/bparse.h
@@ -5,6 +5,7 @@
 #include <iomanip>
 #include <sstream>
 #include <vector>
+#include <cstdint>
 
 namespace xivps3::utils::bparse
 {
diff --git a/deps/mysqlConnector/ResultSetBase.h b/deps/mysqlConnector/ResultSetBase.h
index 235d85117..210924e09 100644
--- a/deps/mysqlConnector/ResultSetBase.h
+++ b/deps/mysqlConnector/ResultSetBase.h
@@ -4,6 +4,7 @@
 #include <list>
 #include <map>
 #include <iostream>
+#include <cstdint>
 
 namespace Mysql
 {
diff --git a/deps/mysqlConnector/mysql_util.h b/deps/mysqlConnector/mysql_util.h
index e43a373bb..028cf1eef 100644
--- a/deps/mysqlConnector/mysql_util.h
+++ b/deps/mysqlConnector/mysql_util.h
@@ -27,6 +27,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 #include <iostream>
 #include <sstream>
+#include <cstdint>
 #include <mysql.h>
 
 //using  MYSQL_FIELD = st_mysql_field;
diff --git a/deps/watchdog/Watchdog.h b/deps/watchdog/Watchdog.h
index 08cc06788..7d5e98037 100644
--- a/deps/watchdog/Watchdog.h
+++ b/deps/watchdog/Watchdog.h
@@ -32,14 +32,8 @@
 
 #include <functional>
 
- // fucking filesystem
-#if _MSC_VER >= 1925
 #include <filesystem>
 namespace ci { namespace fs = std::filesystem; }
-#else
-#include <experimental/filesystem>
-namespace ci { namespace fs = std::experimental::filesystem; }
-#endif
 
 //! Exception for when Watchdog can't locate a file or parse the wildcard
 class WatchedFileSystemExc : public std::exception {
diff --git a/sql/migrations/20230309164293_AddBorrowAction.sql b/sql/migrations/20230309164293_AddBorrowAction.sql
new file mode 100644
index 000000000..1cdc3f22a
--- /dev/null
+++ b/sql/migrations/20230309164293_AddBorrowAction.sql
@@ -0,0 +1 @@
+ALTER TABLE `characlass` ADD `BorrowAction` binary(40) DEFAULT NULL NULL AFTER `Lvl`;
\ No newline at end of file
diff --git a/src/api/PlayerMinimal.cpp b/src/api/PlayerMinimal.cpp
index c761ac043..f383a96d1 100644
--- a/src/api/PlayerMinimal.cpp
+++ b/src/api/PlayerMinimal.cpp
@@ -256,12 +256,14 @@ void PlayerMinimal::saveAsNew()
       break;
   }
 
-  // CharacterId, ClassIdx, Exp, Lvl
+  // CharacterId, ClassIdx, Exp, Lvl, BorrowAction
   auto stmtClass = g_charaDb.getPreparedStatement( Db::ZoneDbStatements::CHARA_CLASS_INS );
   stmtClass->setUInt64( 1, m_characterId );
   stmtClass->setInt( 2, g_exdData.getRow< Excel::ClassJob >( m_class )->data().WorkIndex );
   stmtClass->setInt( 3, 0 );
   stmtClass->setInt( 4, 1 );
+  std::vector< uint8_t > borrowActionVec( Common::ARRSIZE_BORROWACTION * 4 );
+  stmtClass->setBinary( 5, borrowActionVec );
   g_charaDb.directExecute( stmtClass );
 
   auto stmtSearchInfo = g_charaDb.getPreparedStatement( Db::ZoneDbStatements::CHARA_SEARCHINFO_INS );
diff --git a/src/api/main.cpp b/src/api/main.cpp
index d0c231ce0..c1697b23b 100644
--- a/src/api/main.cpp
+++ b/src/api/main.cpp
@@ -31,14 +31,8 @@
 #include <Util/CrashHandler.h>
 
 
-// fucking filesystem
-#if _MSC_VER >= 1925
 #include <filesystem>
 namespace fs = std::filesystem;
-#else
-#include <experimental/filesystem>
-namespace fs = std::experimental::filesystem;
-#endif
 
 
 Sapphire::Common::Util::CrashHandler crashHandler;
@@ -244,12 +238,14 @@ void createAccount( shared_ptr< HttpServer::Response > response, shared_ptr< Htt
     std::string sId;
     if( g_sapphireAPI.createAccount( user, pass, sId ) )
     {
-      // todo: construct proper json object here
-      std::string json_string = "{\"sId\":\"" + sId +
-                                "\", \"lobbyHost\":\"" +
-                                m_config.global.network.lobbyHost +
-                                "\", \"frontierHost\":\"" +
-                                m_config.global.network.restHost + "\"}";
+      nlohmann::json response_json = {
+              {"sId", sId},
+              {"lobbyHost", m_config.global.network.lobbyHost},
+              {"frontierHost", m_config.global.network.restHost},
+              {"lobbyPort", m_config.global.network.lobbyPort}
+      };
+
+      std::string json_string = response_json.dump();
       *response << buildHttpResponse( 200, json_string, JSON );
     }
     else
@@ -277,12 +273,15 @@ void login( shared_ptr< HttpServer::Response > response, shared_ptr< HttpServer:
     // reloadConfig();
     if( g_sapphireAPI.login( user, pass, sId ) )
     {
-      // todo: build proper json object and stringify it
-      std::string json_string = "{\"sId\":\"" + sId +
-                                "\", \"lobbyHost\":\"" +
-                                m_config.global.network.lobbyHost +
-                                "\", \"frontierHost\":\"" +
-                                m_config.global.network.restHost + "\"}";
+      nlohmann::json response_json = {
+              {"sId", sId},
+              {"lobbyHost", m_config.global.network.lobbyHost},
+              {"frontierHost", m_config.global.network.restHost},
+              {"lobbyPort", m_config.global.network.lobbyPort}
+      };
+
+      std::string json_string = response_json.dump();
+
       *response << buildHttpResponse( 200, json_string, JSON );
     }
     else
@@ -294,7 +293,6 @@ void login( shared_ptr< HttpServer::Response > response, shared_ptr< HttpServer:
     *response << buildHttpResponse( 500 );
     Logger::error( e.what() );
   }
-
 }
 
 void deleteCharacter( shared_ptr< HttpServer::Response > response, shared_ptr< HttpServer::Request > request )
diff --git a/src/common/Common.h b/src/common/Common.h
index 72e14d21f..32d29b7a2 100644
--- a/src/common/Common.h
+++ b/src/common/Common.h
@@ -37,6 +37,8 @@ namespace Sapphire::Common
   const uint16_t ARRSIZE_UNLOCKS = 64u;
   const uint16_t ARRSIZE_ORCHESTRION = 40u;
   const uint16_t ARRSIZE_MONSTERNOTE = 12u;
+  const uint16_t ARRSIZE_BORROWACTION = 10u;
+  const uint16_t ARRSIZE_CONDITION = 12u;
 
   const uint8_t TOWN_COUNT = 6;
 
@@ -887,22 +889,55 @@ namespace Sapphire::Common
     Perception = 73,
 
     // Unique modifiers
-    HPPercent = 1000,
-    MPPercent = 1001,
-    TPPercent = 1002,
-    GPPercent = 1003,
-    CPPercent = 1004,
-    PhysicalDamagePercent = 1005,
-    MagicDamagePercent = 1006,
-    AttackPowerPercent = 1007,
-    DefensePercent = 1008,
-    AccuracyPercent = 1009,
-    EvasionPercent = 1010,
-    MagicDefensePercent = 1011,
-    CriticalHitPowerPercent = 1012,
-    CriticalHitResiliencePercent = 1013,
-    CriticalHitPercent = 1014,
-    EnmityPercent = 1015
+    TickHeal = 1000,
+    TickDamage = 1001,
+    StrengthPercent = 1002,
+    DexterityPercent = 1003,
+    VitalityPercent = 1004,
+    IntelligencePercent = 1005,
+    MindPercent = 1006,
+    PietyPercent = 1007,
+    HPPercent = 1008,
+    MPPercent = 1009,
+    TPPercent = 1010,
+    GPPercent = 1011,
+    CPPercent = 1012,
+    PhysicalDamagePercent = 1013,
+    MagicDamagePercent = 1014,
+    AttackPowerPercent = 1015,
+    DefensePercent = 1016,
+    AccuracyPercent = 1017,
+    EvasionPercent = 1018,
+    MagicDefensePercent = 1019,
+    CriticalHitPowerPercent = 1020,
+    CriticalHitResiliencePercent = 1021,
+    CriticalHitPercent = 1022,
+    EnmityPercent = 1023,
+    DamageDealtPercent = 1024,
+    DamageTakenPercent = 1025,
+    HealingMagicRecoveryPercent = 1026,
+    SlashingResistancePercent = 1027,
+    PiercingResistancePercent = 1028,
+    BluntResistancePercent = 1029,
+    ProjectileResistancePercent = 1030,
+    ParryPercent = 1031
+  };
+
+  enum class StatusEffectFlag : uint32_t
+  {
+    BuffCategory = 1,
+    DebuffCategory = 2,
+    Permanent = 4,
+    IsGaze = 8,
+    Transfiguration = 16,
+    CanDispel = 32,
+    LockActions = 64,
+    LockControl = 128,
+    LockMovement = 256,
+    Invisibilty = 512,
+    CanStatusOff = 1024,
+    FcBuff = 2048,
+    RemoveOnSuccessfulHit = 4096
   };
 
   enum struct ActionAspect : uint8_t
@@ -923,6 +958,7 @@ namespace Sapphire::Common
     MagicPoints = 3,
     TacticsPoints = 5,
     TacticsPoints1 = 6,
+    StatusEffect = 10,
     Sprint = 18,
 //    WARGauge = 22,
 //    DRKGauge = 25,
@@ -948,77 +984,67 @@ namespace Sapphire::Common
     LimitBreak = 8,
   };
 
-  enum ActionEffectType : uint8_t
-  {
-    CALC_RESULT_TYPE_NONE = 0x0,
-    CALC_RESULT_TYPE_MISS = 0x1,
-    CALC_RESULT_TYPE_RESIST = 0x2,
-    CALC_RESULT_TYPE_DAMAGE_HP = 0x3,
-    CALC_RESULT_TYPE_RECOVER_HP = 0x4,
-    CALC_RESULT_TYPE_CRITICAL_DAMAGE_HP = 0x5,
-    CALC_RESULT_TYPE_CRITICAL_RECOVER_HP = 0x6,
-    CALC_RESULT_TYPE_GUARD = 0x7,
-    CALC_RESULT_TYPE_PARRY = 0x8,
-    CALC_RESULT_TYPE_INVALID = 0x9,
-    CALC_RESULT_TYPE_UNEFFECTIVE = 0xA,
-    CALC_RESULT_TYPE_NEGLECT = 0xB,
-    CALC_RESULT_TYPE_DAMAGE_MP = 0xC,
-    CALC_RESULT_TYPE_RECOVER_MP = 0xD,
-    CALC_RESULT_TYPE_DAMAGE_TP = 0xE,
-    CALC_RESULT_TYPE_RECOVER_TP = 0xF,
-    CALC_RESULT_TYPE_RECOVER_GP = 0x10,
-    CALC_RESULT_TYPE_SET_STATUS = 0x11,
-    CALC_RESULT_TYPE_SET_STATUS_ME = 0x12,
-    CALC_RESULT_TYPE_RESET_STATUS = 0x13,
-    CALC_RESULT_TYPE_RESET_STATUS_ME = 0x14,
-    CALC_RESULT_TYPE_RESET_BAD_STATUS = 0x15,
-    CALC_RESULT_TYPE_UNEFFECTIVE_STATUS = 0x16,
-    CALC_RESULT_TYPE_HALF_GOOD_STATUS = 0x17,
-    CALC_RESULT_TYPE_HATE_DIRECT = 0x18,
-    CALC_RESULT_TYPE_HATE_INDIRECTION = 0x19,
-    CALC_RESULT_TYPE_HATE_TOP = 0x1A,
-    CALC_RESULT_TYPE_HATE_ADD = 0x1B,
-    CALC_RESULT_TYPE_HATE_MULT = 0x1C,
-    CALC_RESULT_TYPE_COMBO = 0x1D,
-    CALC_RESULT_TYPE_COMBO_HIT = 0x1E,
-    CALC_RESULT_TYPE_COUNTER = 0x1F,
-    CALC_RESULT_TYPE_DESTRUCT = 0x20,
-    CALC_RESULT_TYPE_PARALYSIS = 0x21,
-    CALC_RESULT_TYPE_KNOCK_BACK = 0x22,
-    CALC_RESULT_TYPE_DRAW_UP_CHAIRS = 0x23,
-    CALC_RESULT_TYPE_SUCKED = 0x24,
-    CALC_RESULT_TYPE_CT_DRAW_UP_CHAIRS = 0x25,
-    CALC_RESULT_TYPE_LIVE_CALLBACK = 0x26,
-    CALC_RESULT_TYPE_MOUNT = 0x27,
-    CALC_RESULT_ARCHER_DOT = 0x28,
-    CALC_RESULT_MASTER_DOT = 0x29,
-    CALC_RESULT_BLESSINGS_OF_GODDESS = 0x2A,
-    CALC_RESULT_BAD_BREATH = 0x2B,
-    CALC_RESULT_REVIVAL = 0x2C,
-    CALC_RESULT_PET = 0x2D,
-    CALC_RESULT_TYPE_BLOW = 0x2E,
-    CALC_RESULT_TYPE_STATUS_RESIST = 0x2F,
-    CALC_RESULT_TYPE_CLEAR_PHYSICAL = 0x30,
-    CALC_RESULT_BNPC_STATE = 0x31,
-    CALC_RESULT_TYPE_VFX = 0x32,
-    CALC_RESULT_TYPE_HARD_CODE = 0x33,
-    CALC_RESULT_CALC_ID = 0x34,
-    CALC_RESULT_TYPE_CLEAR_PVP_POINT = 0x35,
-    CALC_RESULT_TYPE_CHECK_BARRIER = 0x36,
-    CALC_RESULT_TYPE_REFLEC = 0x37,
-  };
-
-  enum class ActionHitSeverityType : uint8_t
-  {
-    NormalDamage = 0,
-    CritHeal = 0,
-    CritDamage = 1,
-    NormalHeal = 1,
-    DirectHitDamage = 2,
-    CritDirectHitDamage = 3
-  };
-
-  enum class ActionEffectResultFlag : uint8_t
+  enum CalcResultType : uint8_t
+  {
+    TypeNone = 0x0,
+    TypeMiss = 0x1,
+    TypeResist = 0x2,
+    TypeDamageHp = 0x3,
+    TypeRecoverHp = 0x4,
+    TypeCriticalDamageHp = 0x5,
+    TypeCriticalRecoverHp = 0x6,
+    TypeGuard = 0x7,
+    TypeParry = 0x8,
+    TypeInvalid = 0x9,
+    TypeUneffective = 0xA,
+    TypeNeglect = 0xB,
+    TypeDamageMp = 0xC,
+    TypeRecoverMp = 0xD,
+    TypeDamageTp = 0xE,
+    TypeRecoverTp = 0xF,
+    TypeRecoverGp = 0x10,
+    TypeSetStatus = 0x11,
+    TypeSetStatusMe = 0x12,
+    TypeResetStatus = 0x13,
+    TypeResetStatusMe = 0x14,
+    TypeResetBadStatus = 0x15,
+    TypeUneffectiveStatus = 0x16,
+    TypeHalfGoodStatus = 0x17,
+    TypeHateDirect = 0x18,
+    TypeHateIndirection = 0x19,
+    TypeHateTop = 0x1A,
+    TypeHateAdd = 0x1B,
+    TypeHateMult = 0x1C,
+    TypeCombo = 0x1D,
+    TypeComboHit = 0x1E,
+    TypeCounter = 0x1F,
+    TypeDestruct = 0x20,
+    TypeParalysis = 0x21,
+    TypeKnockBack = 0x22,
+    TypeDrawUpChairs = 0x23,
+    TypeSucked = 0x24,
+    TypeCtDrawUpChairs = 0x25,
+    TypeLiveCallback = 0x26,
+    TypeMount = 0x27,
+    TypeArcherDot = 0x28,
+    TypeMasterDot = 0x29,
+    TypeBlessingOfGoddess = 0x2A,
+    TypeBadBreath = 0x2B,
+    TypeRevival = 0x2C,
+    TypePet = 0x2D,
+    TypeBlow = 0x2E,
+    TypeStatusResist = 0x2F,
+    TypeClearPhysical = 0x30,
+    TypeBNpcState = 0x31,
+    TypeVfx = 0x32,
+    TypeHardCode = 0x33,
+    TypeCalcId = 0x34,
+    TypeClearPvpPoint = 0x35,
+    TypeCheckBarrier = 0x36,
+    TypeReflect = 0x37,
+  };
+
+  enum class ActionResultFlag : uint8_t
   {
     None = 0,
     Absorbed = 0x04,
@@ -1033,6 +1059,7 @@ namespace Sapphire::Common
     ItemActionCompanion = 853,
     ItemActionVFX2 = 944,
     ItemActionMount = 1322,
+    ItemActionSong = 5845,
   };
 
   enum ActionEffectDisplayType : uint8_t
@@ -1383,9 +1410,10 @@ namespace Sapphire::Common
   {
     None1 = 0,
     HideUILockChar = 1, // as the name suggests, hides the ui and logs the char...
-    InCombat = 2, // in Combat, locks gearchange/return/teleport
-    Casting = 3,
-    InNpcEvent = 6, // when talking to an npc, locks ui giving "occupied" message
+    InCombat = 18, // in Combat, locks gearchange/return/teleport
+    Casting = 19,
+    EventAction = 22,
+    InNpcEvent = 24, // when talking to an npc, locks ui giving "occupied" message
 
  //   InNpcEvent1 = 10, // Sent together with InNpcEvent, when waiting for input? just a guess...
 
@@ -1798,6 +1826,7 @@ namespace Sapphire::Common
   {
     uint16_t targetAetheryte;
     uint16_t cost;
+    bool useAetheryteTicket{ false };
   };
 
   enum EventSceneError : uint8_t
@@ -1833,12 +1862,13 @@ namespace Sapphire::Common
     THREAT
   };
 
+  // todo: fill this out (Action.exd EffectType)
   enum CastType : uint8_t
   {
     SingleTarget = 1,
     CircularAOE = 2,
-    Type3 = 3, // another single target? no idea how to call it
-    RectangularAOE = 4,
+    RectangularAOE = 3,
+    ConeAOE = 4,
     CircularAoEPlaced = 7
   };
 
@@ -1856,6 +1886,7 @@ namespace Sapphire::Common
 
   using PlayerStateFlagList = std::vector< PlayerCondition >;
 
+  // todo: load BNpcBase and other exd data into this struct
   struct BNPCInstanceObject
   {
     uint16_t territoryType;
diff --git a/src/common/Config/ConfigMgr.cpp b/src/common/Config/ConfigMgr.cpp
index 5d95e17f7..52808aac8 100644
--- a/src/common/Config/ConfigMgr.cpp
+++ b/src/common/Config/ConfigMgr.cpp
@@ -2,13 +2,8 @@
 #include <iostream>
 #include <fstream>
 
-#if _MSC_VER >= 1925
 #include <filesystem>
 namespace fs = std::filesystem;
-#else
-#include <experimental/filesystem>
-namespace fs = std::experimental::filesystem;
-#endif
 
 using namespace Sapphire;
 using namespace Sapphire::Common;
@@ -94,4 +89,4 @@ bool ConfigMgr::copyDefaultConfig( const std::string& configName )
   fs::copy_file( configPath.string() + m_configDefaultSuffix, configPath );
 
   return true;
-}
\ No newline at end of file
+}
diff --git a/src/common/Crypt/base64.h b/src/common/Crypt/base64.h
index a627067e7..94d86c3bc 100644
--- a/src/common/Crypt/base64.h
+++ b/src/common/Crypt/base64.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <string>
+#include <cstdint>
 
 namespace Sapphire::Common::Util
 {
diff --git a/src/common/Database/ZoneDbConnection.cpp b/src/common/Database/ZoneDbConnection.cpp
index 10f9f854e..6a0f79a0a 100644
--- a/src/common/Database/ZoneDbConnection.cpp
+++ b/src/common/Database/ZoneDbConnection.cpp
@@ -161,11 +161,11 @@ void Sapphire::Db::ZoneDbConnection::doPrepareStatements()
   prepareStatement( CHARA_SEL_QUEST, "SELECT * FROM charaquest WHERE CharacterId = ?;", CONNECTION_SYNC );
 
   /// CLASS INFO
-  prepareStatement( CHARA_CLASS_SEL, "SELECT ClassIdx, Exp, Lvl FROM characlass WHERE CharacterId = ?;",
+  prepareStatement( CHARA_CLASS_SEL, "SELECT ClassIdx, Exp, Lvl, BorrowAction FROM characlass WHERE CharacterId = ?;",
                     CONNECTION_SYNC );
-  prepareStatement( CHARA_CLASS_INS, "INSERT INTO characlass ( CharacterId, ClassIdx, Exp, Lvl ) VALUES( ?,?,?,? );",
+  prepareStatement( CHARA_CLASS_INS, "INSERT INTO characlass ( CharacterId, ClassIdx, Exp, Lvl, BorrowAction ) VALUES( ?,?,?,?,? );",
                     CONNECTION_BOTH );
-  prepareStatement( CHARA_CLASS_UP, "UPDATE characlass SET Exp = ?, Lvl = ? WHERE CharacterId = ? AND ClassIdx = ?;",
+  prepareStatement( CHARA_CLASS_UP, "UPDATE characlass SET Exp = ?, Lvl = ?, BorrowAction = ? WHERE CharacterId = ? AND ClassIdx = ?;",
                     CONNECTION_ASYNC );
   prepareStatement( CHARA_CLASS_DEL, "DELETE FROM characlass WHERE CharacterId = ?;", CONNECTION_ASYNC );
 
diff --git a/src/common/Exd/ExdData.h b/src/common/Exd/ExdData.h
index 5ba553e5e..a4be91569 100644
--- a/src/common/Exd/ExdData.h
+++ b/src/common/Exd/ExdData.h
@@ -91,6 +91,27 @@ namespace Sapphire::Data
       return ids;
     }
 
+    template< typename T >
+    std::unordered_map< uint32_t, std::shared_ptr< Excel::ExcelStruct< T > > > getRows()
+    {
+      xiv::exd::Exd sheet;
+      auto needle = m_sheets.find( typeid( T ) );
+      if( needle == m_sheets.end() )
+      {
+        auto sheetName = getSheetName< T >();
+
+        // load sheet
+        auto& cat = m_exd_data->get_category( sheetName );
+        m_sheets[ typeid( T ) ] = sheet = static_cast< xiv::exd::Exd >( cat.get_data( xiv::exd::Language::en ) );
+      }
+      else
+      {
+        sheet = needle->second;
+      }
+
+      return sheet.get_sheet_rows< T >();
+    }
+
     std::shared_ptr< xiv::dat::GameData > getGameData()
     {
       return m_data;
diff --git a/src/common/Logging/Logger.cpp b/src/common/Logging/Logger.cpp
index 828671992..9fc6b37bc 100644
--- a/src/common/Logging/Logger.cpp
+++ b/src/common/Logging/Logger.cpp
@@ -8,13 +8,8 @@
 #include <spdlog/sinks/daily_file_sink.h>
 
 // #include <iostream>
-#if _MSC_VER >= 1925
 #include <filesystem>
 namespace fs = std::filesystem;
-#else
-#include <experimental/filesystem>
-namespace fs = std::experimental::filesystem;
-#endif
 
 
 void Sapphire::Logger::init( const std::string& logPath )
diff --git a/src/common/Util/UtilMath.cpp b/src/common/Util/UtilMath.cpp
index 6a162d64f..516c00c7b 100644
--- a/src/common/Util/UtilMath.cpp
+++ b/src/common/Util/UtilMath.cpp
@@ -39,8 +39,12 @@ float Util::distance2D( float x, float y, float x1, float y1 )
 
 float Util::calcAngTo( float x, float y, float x1, float y1 )
 {
-  float dx = x - x1;
-  float dy = y - y1;
+  float dx = x1 - x;
+  float dy = y1 - y;
+
+  if( dx == 0.0f && dy == 0.0f )
+    return 0.0f;
+
   if( dy != 0.0f )
   {
     return atan2( dy, dx );
@@ -55,6 +59,10 @@ float Util::calcAngFrom( float x, float y, float x1, float y1 )
 {
   float dx = x - x1;
   float dy = y - y1;
+
+  if( dx == 0.0f && dy == 0.0f )
+    return 0.0f;
+
   if( dy != 0.0f )
   {
     return atan2( dy, dx );
@@ -80,6 +88,39 @@ uint8_t Util::floatToUInt8Rot( float val )
   return static_cast< uint8_t >( 0x80 * ( ( val + PI ) ) / PI );
 }
 
+FFXIVARR_POSITION3 Util::getOffsettedPosition( const FFXIVARR_POSITION3& pos, float rot, float right, float up, float forward )
+{
+  FFXIVARR_POSITION3 ret{ pos };
+
+  // height
+  ret.y += up;
+
+  // forward
+  float angle = rot + ( PI / 2 );
+  ret.x -= forward * cos( angle );
+  ret.z += forward * sin( angle );
+
+  // side
+  ret.x -= right * cos( rot );
+  ret.z += right * sin( rot );
+
+  return ret;
+}
+
+FFXIVARR_POSITION3 Util::getKnockbackPosition( const FFXIVARR_POSITION3& origin, const FFXIVARR_POSITION3& pos, float distance )
+{
+  FFXIVARR_POSITION3 ret{ pos };
+
+  float from = Common::Util::calcAngFrom( origin.x, origin.z, pos.x, pos.z );
+  float angle = PI - from + ( PI / 2 );
+
+  angle = angle + ( PI / 2 );
+  ret.x -= distance * cos( angle );
+  ret.z += distance * sin( angle );
+
+  return ret;
+}
+
 FFXIVARR_POSITION3 Util::transform( const FFXIVARR_POSITION3& vector, const Matrix33& matrix )
 {
   FFXIVARR_POSITION3 dst{};
@@ -143,3 +184,23 @@ float Util::trunc( float value, uint8_t digitsToRemain )
 
   return std::floor( value * factor ) / factor;
 }
+
+float Util::length( const FFXIVARR_POSITION3& vec ) {
+  return std::sqrt( vec.x * vec.x + vec.y * vec.y + vec.z * vec.z );
+}
+
+FFXIVARR_POSITION3 Util::normalize( const FFXIVARR_POSITION3& vec ) {
+  float len = length( vec );
+  if( len == 0 ) return FFXIVARR_POSITION3();
+  return FFXIVARR_POSITION3{ vec.x / len, vec.y / len, vec.z / len };
+}
+
+float Util::dot( const FFXIVARR_POSITION3& vec1, const FFXIVARR_POSITION3& vec2 )
+{
+  return vec1.x * vec2.x + vec1.y * vec2.y + vec1.z * vec2.z;
+}
+
+FFXIVARR_POSITION3 Util::projectY( const FFXIVARR_POSITION3& vec )
+{
+  return FFXIVARR_POSITION3{ vec.x, 0, vec.z };
+}
\ No newline at end of file
diff --git a/src/common/Util/UtilMath.h b/src/common/Util/UtilMath.h
index 1f6ddd504..9e5f4adca 100644
--- a/src/common/Util/UtilMath.h
+++ b/src/common/Util/UtilMath.h
@@ -29,6 +29,10 @@ namespace Sapphire::Common::Util
 
   uint8_t floatToUInt8Rot( float val );
 
+  FFXIVARR_POSITION3 getOffsettedPosition( const FFXIVARR_POSITION3& pos, float rotation, float right, float up, float forward );
+
+  FFXIVARR_POSITION3 getKnockbackPosition( const FFXIVARR_POSITION3& origin, const FFXIVARR_POSITION3& pos, float distance );
+
   template < typename T >
   T clamp( T val, T minimum, T maximum )
   {
@@ -44,6 +48,14 @@ namespace Sapphire::Common::Util
   FFXIVARR_POSITION3 transform( const FFXIVARR_POSITION3& vector, const Matrix33& matrix );
 
   float eulerToDirection( const FFXIVARR_POSITION3& euler );
+
+  float length( const FFXIVARR_POSITION3& vec );
+
+  FFXIVARR_POSITION3 normalize( const FFXIVARR_POSITION3& vec );
+  
+  float dot( const FFXIVARR_POSITION3& vec1, const FFXIVARR_POSITION3& vec2 );
+
+  FFXIVARR_POSITION3 projectY( const FFXIVARR_POSITION3& vec );
 }
 
 #endif
diff --git a/src/common/Vector3.cpp b/src/common/Vector3.cpp
index a98c4fdeb..7f2bb3940 100644
--- a/src/common/Vector3.cpp
+++ b/src/common/Vector3.cpp
@@ -7,8 +7,17 @@ inline bool FFXIVARR_POSITION3::operator == ( const FFXIVARR_POSITION3& target )
   return x == target.x && y == target.y && z == target.z;
 }
 
+FFXIVARR_POSITION3 FFXIVARR_POSITION3::operator - ( const FFXIVARR_POSITION3& target ) const
+{
+  return FFXIVARR_POSITION3{ x - target.x, y - target.y, z - target.z };
+}
 
 inline bool Vector3::operator == ( const Vector3& target ) const
 {
   return x == target.x && y == target.y && z == target.z && reserve == target.reserve;
-}
\ No newline at end of file
+}
+
+Vector3 Vector3::operator - ( const Vector3& target ) const
+{
+  return Vector3{ x - target.x, y - target.y, z - target.z };
+}
diff --git a/src/common/Vector3.h b/src/common/Vector3.h
index 1658aa76c..539c4e032 100644
--- a/src/common/Vector3.h
+++ b/src/common/Vector3.h
@@ -2,12 +2,14 @@
 
 namespace Sapphire::Common
 {
+  // todo: get rid of this struct and use an actual vector 3 class
   struct FFXIVARR_POSITION3
   {
     float x;
     float y;
     float z;
     inline bool operator == ( const FFXIVARR_POSITION3& target ) const;
+    FFXIVARR_POSITION3 operator - ( const FFXIVARR_POSITION3& target ) const;
   };
 
   struct Vector3
@@ -17,6 +19,8 @@ namespace Sapphire::Common
     float z;
     float reserve;
     inline bool operator == ( const Vector3& target ) const;
+    inline bool operator == ( const FFXIVARR_POSITION3& target ) const;
+    Vector3 operator - ( const Vector3& target ) const;
   };
 
   struct Matrix33
diff --git a/src/dbm/DbManager.cpp b/src/dbm/DbManager.cpp
index 0f7062127..31ef313c3 100644
--- a/src/dbm/DbManager.cpp
+++ b/src/dbm/DbManager.cpp
@@ -11,14 +11,8 @@
 using namespace Sapphire;
 using namespace Sapphire::Common;
 
-// fucking filesystem
-#if _MSC_VER >= 1925
 #include <filesystem>
 namespace fs = std::filesystem;
-#else
-#include <experimental/filesystem>
-namespace fs = std::experimental::filesystem;
-#endif
 
 
 DbManager::DbManager( const std::string& host, const std::string& database, const std::string& user, const std::string& pw, uint16_t port ) :
diff --git a/src/dbm/main.cpp b/src/dbm/main.cpp
index 7eaff9031..dd28ef9f0 100644
--- a/src/dbm/main.cpp
+++ b/src/dbm/main.cpp
@@ -9,14 +9,8 @@
 
 Sapphire::Common::Util::CrashHandler crashHandler;
 
-// fucking filesystem
-#if _MSC_VER >= 1925
 #include <filesystem>
 namespace filesys = std::filesystem;
-#else
-#include <experimental/filesystem>
-namespace filesys = std::experimental::filesystem;
-#endif
 
 #include <fstream>
 #include <streambuf>
diff --git a/src/scripts/action/common/ActionSprint3.cpp b/src/scripts/action/common/ActionSprint3.cpp
index 82bf80fba..929487f93 100644
--- a/src/scripts/action/common/ActionSprint3.cpp
+++ b/src/scripts/action/common/ActionSprint3.cpp
@@ -17,10 +17,7 @@ class ActionSprint3 : public Sapphire::ScriptAPI::ActionScript
       return;
 
     uint32_t duration = ( sourceChara->getAsPlayer()->getTp() / 50 ) * 1000;
-
-    action.getEffectbuilder()->applyStatusEffect( sourceChara, 50, 30 );
-
-    sourceChara->getAsPlayer()->addStatusEffectByIdIfNotExist( 50, duration, *sourceChara, 30 );
+    action.getActionResultBuilder()->applyStatusEffectSelf( 50, duration, 30, false );
     sourceChara->getAsPlayer()->setTp( 0 );
   }
 };
diff --git a/src/scripts/action/common/ActionTeleport5.cpp b/src/scripts/action/common/ActionTeleport5.cpp
index 954ab7465..cbd52078b 100644
--- a/src/scripts/action/common/ActionTeleport5.cpp
+++ b/src/scripts/action/common/ActionTeleport5.cpp
@@ -22,6 +22,7 @@ class ActionTeleport5 : public Sapphire::ScriptAPI::ActionScript
     auto teleportQuery = pPlayer->getTeleportQuery();
 
     if( pPlayer->getCurrency( Common::CurrencyType::Gil ) < teleportQuery.cost ||
+        teleportQuery.useAetheryteTicket && !pPlayer->removeItem( 7569 ) ||
         teleportQuery.targetAetheryte == 0 )
     {
       action.interrupt();
diff --git a/src/scripts/action/war/ActionInnerBeast.cpp b/src/scripts/action/war/ActionInnerBeast.cpp
new file mode 100644
index 000000000..d4193e4d4
--- /dev/null
+++ b/src/scripts/action/war/ActionInnerBeast.cpp
@@ -0,0 +1,47 @@
+#include <Script/NativeScriptApi.h>
+#include <ScriptObject.h>
+#include <Actor/Player.h>
+#include <Action/CommonAction.h>
+#include <Action/Action.h>
+#include <StatusEffect/StatusEffect.h>
+
+using namespace Sapphire;
+using namespace Sapphire::World::Action;
+
+class ActionInnerBeast : public Sapphire::ScriptAPI::ActionScript
+{
+public:
+  ActionInnerBeast() : Sapphire::ScriptAPI::ActionScript( 49 )
+  {
+  }
+
+  static constexpr auto Potency = 300;
+
+  void onExecute( Sapphire::World::Action::Action& action ) override
+  {
+    auto pPlayer = action.getSourceChara()->getAsPlayer();
+    auto pSource = action.getSourceChara();
+    auto pTarget = action.getHitChara();
+    auto pActionBuilder = action.getActionResultBuilder();
+
+    if( !pPlayer || !pActionBuilder )
+      return;
+    
+    if( auto status = pPlayer->getStatusEffectById( Defiance ); status )
+      status->setModifier( Common::ParamModifier::DamageDealtPercent, 0 );
+
+    auto dmg = action.calcDamage( Potency );
+    pActionBuilder->damage( pSource, pTarget, dmg.first, dmg.second );
+    pActionBuilder->heal( pTarget, pSource, dmg.first, Common::CalcResultType::TypeRecoverHp, Common::ActionResultFlag::EffectOnSource );
+
+    pActionBuilder->applyStatusEffectSelf( InnerBeast, 15000, 0, { StatusModifier{ Common::ParamModifier::DamageTakenPercent, -20 } } );
+    
+    if( !pPlayer->hasStatusEffect( Unchained ) )
+    {
+      if( auto status = pPlayer->getStatusEffectById( Defiance ); status )
+        status->setModifier( Common::ParamModifier::DamageDealtPercent, -25 );
+    }
+  }
+};
+
+EXPOSE_SCRIPT( ActionInnerBeast );
\ No newline at end of file
diff --git a/src/scripts/action/war/ActionUnchained.cpp b/src/scripts/action/war/ActionUnchained.cpp
new file mode 100644
index 000000000..640f024a2
--- /dev/null
+++ b/src/scripts/action/war/ActionUnchained.cpp
@@ -0,0 +1,33 @@
+#include <Script/NativeScriptApi.h>
+#include <ScriptObject.h>
+#include <Actor/Player.h>
+#include <Action/CommonAction.h>
+#include <Action/Action.h>
+#include <StatusEffect/StatusEffect.h>
+
+using namespace Sapphire;
+using namespace Sapphire::World::Action;
+
+class ActionUnchained : public Sapphire::ScriptAPI::ActionScript
+{
+public:
+  ActionUnchained() : Sapphire::ScriptAPI::ActionScript( 50 )
+  {
+  }
+
+  void onExecute( Sapphire::World::Action::Action& action ) override
+  {
+    auto pPlayer = action.getSourceChara()->getAsPlayer();
+    auto pActionBuilder = action.getActionResultBuilder();
+
+    if( !pPlayer || !pActionBuilder )
+      return;
+
+    if( auto status = pPlayer->getStatusEffectById( Defiance ); status )
+      status->setModifier( Common::ParamModifier::DamageDealtPercent, 0 );
+
+    pActionBuilder->applyStatusEffectSelf( Unchained, 20000, 0 );
+  }
+};
+
+EXPOSE_SCRIPT( ActionUnchained );
\ No newline at end of file
diff --git a/src/scripts/common/aethernet/Aetheryte.cpp b/src/scripts/common/aethernet/Aetheryte.cpp
index 2af4abef6..b02dbe77f 100644
--- a/src/scripts/common/aethernet/Aetheryte.cpp
+++ b/src/scripts/common/aethernet/Aetheryte.cpp
@@ -62,10 +62,18 @@ class Aetheryte :
       // eventParam4 (or params[1] if using EventPlay8, which is actually used on retail) anything bigger than 1 will show select instance menu item
       eventMgr().playScene( player, eventId, 0, 1, { 1, 2 }, [ this ]( Entity::Player& player, const Event::SceneResult& result )
       {
-        if( result.numOfResults == 1 ) // set homepoint
+        if( result.numOfResults == 1 )
         {
-          player.setHomepoint( result.eventId & 0xFFFF );
-          eventMgr().sendEventNotice( player, result.eventId, 2, 0xEA, 0, 0 );
+          auto cmd = result.getResult( 0 );
+          if( cmd == 1 ) // set homepoint
+          {
+            player.setHomepoint( result.eventId & 0xFFFF );
+            eventMgr().sendEventNotice( player, result.eventId, 2, 0xEA, 0, 0 );
+          }
+          else if( cmd == 5 )
+          {
+            //TODO: Housing teleport selection
+          }
         }
         else if( result.numOfResults == 2 ) // aethernet access
         {
diff --git a/src/scripts/common/eobj/InstanceExit.cpp b/src/scripts/common/eobj/InstanceExit.cpp
index fae2b0dea..d95d5cd2c 100644
--- a/src/scripts/common/eobj/InstanceExit.cpp
+++ b/src/scripts/common/eobj/InstanceExit.cpp
@@ -26,7 +26,7 @@ class InstanceExit :
     eventMgr().playScene( player, eventId, 1, 0, [this, eobj]( Entity::Player& player, const Event::SceneResult& result )
     {
       if( result.getResult( 0 ) != 1 )
-        player.exitInstance();
+        playerMgr().onExitInstance( player );
     } );
   }
 };
diff --git a/src/scripts/instances/questbattles/UnderneaththeSultantree.cpp b/src/scripts/instances/questbattles/UnderneaththeSultantree.cpp
index f5dc332f4..135be4b5a 100644
--- a/src/scripts/instances/questbattles/UnderneaththeSultantree.cpp
+++ b/src/scripts/instances/questbattles/UnderneaththeSultantree.cpp
@@ -1,5 +1,8 @@
 #include <ScriptObject.h>
 #include <Territory/QuestBattle.h>
+#include <Actor/Player.h>
+#include <Actor/GameObject.h>
+#include <Actor/BNpc.h>
 
 using namespace Sapphire;
 
@@ -100,15 +103,126 @@ class UnderneaththeSultantree : public Sapphire::ScriptAPI::QuestBattleScript
     instance.addEObj( "Millioncornseedling", 2001255, 0, 3927161, 4, { -320.576813f, 25.833500f, -527.550171f }, 0.961304f, -0.384837f, 0); 
 
   }
+  enum vars
+  {
+    SET_1_SPAWNED,
+    SET_2_SPAWNED,
+    SUCCESS_CALLED,
+  };
+
+  void onPlayerSetup( Sapphire::QuestBattle& instance, Entity::Player& player ) override
+  {
+    player.setRot( -71.03f );
+    player.setPos( { 198.303f, 14.244f, 538.248f } );
+  }
 
   void onUpdate( QuestBattle& instance, uint64_t tickCount ) override
   {
+    auto pair1Spawnd = instance.getDirectorVar( SET_1_SPAWNED );
+    auto pair2Spawnd = instance.getDirectorVar( SET_2_SPAWNED );
+    auto successCalled = instance.getDirectorVar( SUCCESS_CALLED );
+
+    auto boss = instance.getActiveBNpcByLayoutId( INIT_POP_BOSS );
+    auto thancred = instance.getActiveBNpcByLayoutId( INIT_P_POP_01 );
+    auto pPlayer = instance.getPlayerPtr();
+
+    uint32_t bossHpPercent = 0;
+    if( boss )
+      bossHpPercent = boss->getHpPercent();
+
+    if( pPlayer && !pPlayer->isAlive() )
+    {
+      instance.fail();
+      return;
+    }
+
+    if (!thancred)
+      return;
+
+    if( pair1Spawnd == 0 && bossHpPercent <= 70 )
+    {
+      instance.setDirectorVar( SET_1_SPAWNED, 1 );
+      auto a2 = instance.createBNpcFromLayoutId( INIT_POP_01_01, 1440 /*TODO: Find the right value*/, Common::BNpcType::Enemy );
+      auto a3 = instance.createBNpcFromLayoutId( INIT_POP_01_02, 1440 /*TODO: Find the right value*/, Common::BNpcType::Enemy );
+      a2->setFlag( Entity::NoDeaggro );
+      a3->setFlag( Entity::NoDeaggro );
+
+      auto pPlayer = instance.getPlayerPtr();
+      a2->hateListAdd( pPlayer, 1 );
+      a3->hateListAdd( pPlayer, 1 );
+
+      thancred->hateListAdd( a2, 9999 );
+      thancred->hateListAdd( a3, 9999 );
+    }
+
+    if( pair2Spawnd == 0 && bossHpPercent <= 40 )
+    {
+      instance.setDirectorVar( SET_2_SPAWNED, 1 );
+      auto a2 = instance.createBNpcFromLayoutId( INIT_POP_02_01, 1440 /*TODO: Find the right value*/, Common::BNpcType::Enemy );
+      auto a3 = instance.createBNpcFromLayoutId( INIT_POP_02_02, 1440 /*TODO: Find the right value*/, Common::BNpcType::Enemy );
+      auto a4 = instance.createBNpcFromLayoutId( INIT_POP_02_03, 1440 /*TODO: Find the right value*/, Common::BNpcType::Enemy );
+      auto a5 = instance.createBNpcFromLayoutId( INIT_POP_02_04, 1440 /*TODO: Find the right value*/, Common::BNpcType::Enemy );
+      a2->setFlag( Entity::NoDeaggro );
+      a3->setFlag( Entity::NoDeaggro );
+      a4->setFlag( Entity::NoDeaggro );
+      a5->setFlag( Entity::NoDeaggro );
+
+      auto pPlayer = instance.getPlayerPtr();
+      a2->hateListAdd( pPlayer, 1 );
+      a3->hateListAdd( pPlayer, 1 );
+      a4->hateListAdd( pPlayer, 1 );
+      a5->hateListAdd( pPlayer, 1 );
+
+      thancred->hateListAdd( a2, 9999 );
+      thancred->hateListAdd( a3, 9999 );
+      thancred->hateListAdd( a4, 9999 );
+      thancred->hateListAdd( a5, 9999 );
+    }
+
+    if( instance.getCountEnemyBNpc() == 0 && successCalled == 0 )
+    {
+      instance.setDirectorVar( SUCCESS_CALLED, 1 );
+      instance.success();
+      return;
+    }
 
   }
 
   void onEnterTerritory( QuestBattle& instance, Entity::Player& player, uint32_t eventId, uint16_t param1,
                          uint16_t param2 ) override
   {
+    eventMgr().playScene( player, instance.getDirectorId(), 1,
+                          NO_DEFAULT_CAMERA | CONDITION_CUTSCENE | SILENT_ENTER_TERRI_ENV |
+                          HIDE_HOTBAR | SILENT_ENTER_TERRI_BGM | SILENT_ENTER_TERRI_SE |
+                          DISABLE_STEALTH | 0x00100000 | LOCK_HUD | LOCK_HOTBAR |
+                          // todo: wtf is 0x00100000
+                          DISABLE_CANCEL_EMOTE, [ & ]( Entity::Player& player, const Event::SceneResult& result ) {
+                            player.setOnEnterEventDone( true );
+                          } );
+  }
+
+  void onDutyComplete( QuestBattle& instance, Entity::Player& player ) override
+  {
+    auto idx = player.getQuestIndex( instance.getQuestId() );
+    if( idx == -1 )
+      return;
+    auto& quest = player.getQuestByIndex( idx );
+    quest.setSeq( 2 );
+  }
+
+  void onDutyCommence( QuestBattle& instance, Entity::Player& player ) override
+  {
+    // TODO: Change to correct HP values
+    auto boss = instance.createBNpcFromLayoutId( INIT_POP_BOSS, 10571 /*TODO: Find the right value*/, Common::BNpcType::Enemy );
+    auto thancred = instance.createBNpcFromLayoutId( INIT_P_POP_01, 27780 /*TODO: Find the right value*/, Common::BNpcType::Friendly );
+
+    boss->setFlag( Entity::NoDeaggro );
+    thancred->setFlag( Entity::NoDeaggro );
+
+    boss->hateListAdd( thancred, 10000 );
+    boss->hateListAdd( player.getAsPlayer(), 1 );
+
+    thancred->hateListAdd( boss, 10000 );
 
   }
 
diff --git a/src/scripts/quest/ManFst407.cpp b/src/scripts/quest/ManFst407.cpp
index 0eb4c3763..59f77027e 100644
--- a/src/scripts/quest/ManFst407.cpp
+++ b/src/scripts/quest/ManFst407.cpp
@@ -823,7 +823,7 @@ class ManFst407 : public Sapphire::ScriptAPI::QuestScript
     quest.setSeq( Seq6 );
     eventMgr().sendEventNotice( player, getId(), 4, 0 );
     playerMgr().sendUrgent( player, "QuestBattle Unimplemented, skipping..." );
-    player.exitInstance();
+    playerMgr().onExitInstance( player );
     travelToPoprange( player, Poprange3, false );
   }
 
diff --git a/src/scripts/quest/ManWil005.cpp b/src/scripts/quest/ManWil005.cpp
new file mode 100644
index 000000000..75ab8a97a
--- /dev/null
+++ b/src/scripts/quest/ManWil005.cpp
@@ -0,0 +1,318 @@
+// This is an automatically generated C++ script template
+// Content needs to be added by hand to make it function
+// In order for this script to be loaded, move it to the correct folder in <root>/scripts/
+
+#include <Actor/Player.h>
+#include "Manager/EventMgr.h"
+#include <ScriptObject.h>
+#include <Service.h>
+
+// Quest Script: ManWil005_00550
+// Quest Name: Underneath the Sultantree
+// Quest ID: 66086
+// Start NPC: 1003995 (Papashan)
+// End NPC: 1003995 (Papashan)
+
+using namespace Sapphire;
+
+class ManWil005 : public Sapphire::ScriptAPI::QuestScript
+{
+  private:
+    // Basic quest information  
+    // Quest vars / flags used
+    // BitFlag8
+    // UI8AL
+
+    /// Countable Num: 1 Seq: 1 Event: 1 Listener: 1003996
+    /// Countable Num: 1 Seq: 2 Event: 1 Listener: 2001853
+    /// Countable Num: 0 Seq: 255 Event: 15 Listener: 5020000
+    // Steps in this quest ( 0 is before accepting, 
+    // 1 is first, 255 means ready for turning it in
+    enum Sequence : uint8_t
+    {
+      Seq0 = 0,
+      Seq1 = 1,
+      Seq2 = 2,
+      SeqFinish = 255,
+    };
+
+    // Entities found in the script data of the quest
+    static constexpr auto Actor0 = 1003995; // Papashan ( Pos: 75.338402 2.138110 316.362000  Teri: 141 )
+    static constexpr auto Actor1 = 1003996; // Hooded Lalafell ( Pos: 202.662994 14.104900 536.909973  Teri: 141 )
+    static constexpr auto Actor2 = 1003997; // ×次女a ( Pos: 76.674599 2.137120 317.433014  Teri: 141 )
+    static constexpr auto Actor3 = 1003998; // ×近衛a ( Pos: 77.176598 2.137340 315.631989  Teri: 141 )
+    static constexpr auto Actor4 = 1003999; // ×近衛b ( Pos: 77.310501 2.136910 316.973999  Teri: 141 )
+    static constexpr auto Actor5 = 1004000; // ×近衛c ( Pos: 78.402603 2.136520 316.269012  Teri: 141 )
+    static constexpr auto Actor6 = 1004001; // Lilira ( Pos: 76.643402 2.136930 318.191010  Teri: 141 )
+    static constexpr auto Actor20 = 1006171; // Lilira
+    static constexpr auto Actor30 = 1006167; // 侍女a
+    static constexpr auto Actor40 = 1006168; // 近衛a
+    static constexpr auto Actor50 = 1006169; // 近衛b
+    static constexpr auto Actor60 = 1006170; // 近衛c
+    static constexpr auto CutScene02 = 141;
+    static constexpr auto CutScene03 = 56;
+    static constexpr auto CutScene04 = 142;
+    static constexpr auto Eobject0 = 2001853; //  ( Pos: 202.638000 14.137900 536.905029  Teri: 141 )
+    static constexpr auto EventActionSearch = 1; // Interaction
+    static constexpr auto Questbattle0 = 37;
+    static constexpr auto Seq0Actor0Lq = 50; // Goblin Thug
+    static constexpr auto Territorytype0 = 270;
+    static constexpr auto Territorytype1 = 141;
+
+  public:
+    ManWil005() : Sapphire::ScriptAPI::QuestScript( 66086 ){}; 
+    ~ManWil005() = default; 
+
+  //////////////////////////////////////////////////////////////////////
+  // Event Handlers
+  void onTalk( World::Quest& quest, Entity::Player& player, uint64_t actorId ) override
+  {
+    switch( actorId )
+    {
+      case Actor0:
+      {
+        if (quest.getSeq() == Seq0)
+        {
+          Scene00000( quest, player );
+        }
+        else if (quest.getSeq() == SeqFinish)
+        {
+         Scene00006( quest, player );
+        }
+          
+        break;
+      }
+      case Actor1:
+      {
+        if( quest.getSeq() == Seq1 )
+          Scene00002( quest, player );
+        break;
+      }
+      case Actor2:
+      {
+        break;
+      }
+      case Actor3:
+      {
+        break;
+      }
+      case Actor4:
+      {
+        break;
+      }
+      case Actor5:
+      {
+        break;
+      }
+      case Actor6:
+      {
+        break;
+      }
+      case Actor20:
+      {
+        break;
+      }
+      case Actor30:
+      {
+        break;
+      }
+      case Actor40:
+      {
+        break;
+      }
+      case Actor50:
+      {
+        break;
+      }
+      case Actor60:
+      {
+        break;
+      }
+    }
+  }
+
+  void onEnterTerritory( World::Quest& quest, Entity::Player& player, uint16_t param1, uint16_t param2 ) override
+  {
+    if( quest.getSeq() == Seq2 )
+    {
+      Scene00005( quest, player );
+    }
+  }
+
+
+  private:
+  //////////////////////////////////////////////////////////////////////
+  // Available Scenes in this quest, not necessarly all are used
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00000( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 0, HIDE_HOTBAR, bindSceneReturn( &ManWil005::Scene00000Return ) );
+  }
+
+  void Scene00000Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    if( result.getResult( 0 ) == 1 ) // accept quest
+    {
+      Scene00001( quest, player );
+    }
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00001( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 1, FADE_OUT | CONDITION_CUTSCENE | HIDE_UI, bindSceneReturn( &ManWil005::Scene00001Return ) );
+  }
+
+  void Scene00001Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    quest.setSeq( Seq1 );
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00002( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 2, NONE, bindSceneReturn( &ManWil005::Scene00002Return ) );
+  }
+
+  void Scene00002Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    if( result.getResult( 0 ) == 1 )
+    {
+      auto& pTeriMgr = Common::Service< Sapphire::World::Manager::TerritoryMgr >::ref();
+
+      eventMgr().eventFinish( player, result.eventId, 0 );
+      pTeriMgr.createAndJoinQuestBattle( player, Questbattle0 );
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00003( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 3, NONE, bindSceneReturn( &ManWil005::Scene00003Return ) );
+  }
+
+  void Scene00003Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00004( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 4, NONE, bindSceneReturn( &ManWil005::Scene00004Return ) );
+  }
+
+  void Scene00004Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00005( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 5, NO_DEFAULT_CAMERA | CONDITION_CUTSCENE | SILENT_ENTER_TERRI_ENV | HIDE_HOTBAR | SILENT_ENTER_TERRI_BGM | SILENT_ENTER_TERRI_SE | DISABLE_STEALTH | 0x00100000 | LOCK_HUD | LOCK_HOTBAR |
+                                                           // todo: wtf is 0x00100000
+                                                           DISABLE_CANCEL_EMOTE,
+                               bindSceneReturn( &ManWil005::Scene00005Return ) );
+  }
+
+  void Scene00005Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    quest.setSeq( SeqFinish );
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00006( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 6, FADE_OUT | HIDE_HOTBAR | CONDITION_CUTSCENE | HIDE_UI, bindSceneReturn( &ManWil005::Scene00006Return ) );
+  }
+
+  void Scene00006Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+    if( result.getResult( 0 ) == 1 )
+    {
+      player.finishQuest( getId(), result.getResult( 1 ) );
+    }
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00007( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 7, NONE, bindSceneReturn( &ManWil005::Scene00007Return ) );
+  }
+
+  void Scene00007Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00008( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 8, NONE, bindSceneReturn( &ManWil005::Scene00008Return ) );
+  }
+
+  void Scene00008Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00009( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 9, NONE, bindSceneReturn( &ManWil005::Scene00009Return ) );
+  }
+
+  void Scene00009Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00010( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 10, NONE, bindSceneReturn( &ManWil005::Scene00010Return ) );
+  }
+
+  void Scene00010Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00011( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 11, NONE, bindSceneReturn( &ManWil005::Scene00011Return ) );
+  }
+
+  void Scene00011Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+};
+
+EXPOSE_SCRIPT( ManWil005 );
\ No newline at end of file
diff --git a/src/scripts/quest/classquest/CNJ/ClsCnj998.cpp b/src/scripts/quest/classquest/CNJ/ClsCnj998.cpp
new file mode 100644
index 000000000..4789e5d6b
--- /dev/null
+++ b/src/scripts/quest/classquest/CNJ/ClsCnj998.cpp
@@ -0,0 +1,105 @@
+// This is an automatically generated C++ script template
+// Content needs to be added by hand to make it function
+// In order for this script to be loaded, move it to the correct folder in <root>/scripts/
+
+#include "Manager/EventMgr.h"
+#include <Actor/Player.h>
+#include <ScriptObject.h>
+#include <Service.h>
+
+// Quest Script: ClsCnj998_00133
+// Quest Name: Way of the Conjurer
+// Quest ID: 65669
+// Start NPC: 1000323 (Madelle)
+// End NPC: 1000692 (E-Sumi-Yan)
+
+using namespace Sapphire;
+
+class ClsCnj998 : public Sapphire::ScriptAPI::QuestScript
+{
+private:
+  // Basic quest information
+  // Quest vars / flags used
+  // UI8AL
+
+  /// Countable Num: 1 Seq: 255 Event: 1 Listener: 1000692
+  // Steps in this quest ( 0 is before accepting,
+  // 1 is first, 255 means ready for turning it in
+  enum Sequence : uint8_t
+  {
+    Seq0 = 0,
+    SeqFinish = 255,
+  };
+
+  // Entities found in the script data of the quest
+  static constexpr auto Actor0 = 1000323;// Madelle ( Pos: -234.028000 -4.000220 -11.062800  Teri: 133 )
+  static constexpr auto Actor1 = 1000692;// E-sumi-yan ( Pos: -258.808014 -5.773500 -27.237400  Teri: 133 )
+  static constexpr auto Classjob = 6;
+  static constexpr auto GearsetUnlock = 1905;
+  static constexpr auto LogmessageMonsterNotePageUnlock = 1009;
+  static constexpr auto UnlockImageClassCnj = 25;
+
+public:
+  ClsCnj998() : Sapphire::ScriptAPI::QuestScript( 65669 ){};
+  ~ClsCnj998() = default;
+
+  //////////////////////////////////////////////////////////////////////
+  // Event Handlers
+  void onTalk( World::Quest& quest, Entity::Player& player, uint64_t actorId ) override
+  {
+    switch( actorId )
+    {
+      case Actor0:
+      {
+        if( quest.getSeq() == Seq0 )
+          Scene00000( quest, player );
+        break;
+      }
+      case Actor1:
+      {
+        if( quest.getSeq() == SeqFinish )
+          Scene00001( quest, player );
+        break;
+      }
+    }
+  }
+
+
+private:
+  //////////////////////////////////////////////////////////////////////
+  // Available Scenes in this quest, not necessarly all are used
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00000( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 0, HIDE_HOTBAR, bindSceneReturn( &ClsCnj998::Scene00000Return ) );
+  }
+
+  void Scene00000Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    if( result.getResult( 0 ) == 1 )// accept quest
+    {
+      quest.setSeq( SeqFinish );
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00001( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 1, FADE_OUT | HIDE_UI, bindSceneReturn( &ClsCnj998::Scene00001Return ) );
+  }
+
+  void Scene00001Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+    if( result.getResult( 0 ) == 1 )
+    {
+      player.finishQuest( getId() );
+      player.setLevelForClass( 1, Sapphire::Common::ClassJob::Conjurer );
+      player.addGearSet();
+    }
+  }
+};
+
+EXPOSE_SCRIPT( ClsCnj998 );
\ No newline at end of file
diff --git a/src/scripts/quest/classquest/CNJ/ClsCnj999.cpp b/src/scripts/quest/classquest/CNJ/ClsCnj999.cpp
new file mode 100644
index 000000000..abd19e3e5
--- /dev/null
+++ b/src/scripts/quest/classquest/CNJ/ClsCnj999.cpp
@@ -0,0 +1,72 @@
+// This is an automatically generated C++ script template
+// Content needs to be added by hand to make it function
+// In order for this script to be loaded, move it to the correct folder in <root>/scripts/
+
+#include "Manager/EventMgr.h"
+#include <Actor/Player.h>
+#include <ScriptObject.h>
+#include <Service.h>
+
+// Quest Script: ClsCnj999_00182
+// Quest Name: So You Want to Be a Conjurer
+// Quest ID: 65718
+// Start NPC: 1000323 (Madelle)
+// End NPC: 1000323 (Madelle)
+
+using namespace Sapphire;
+
+class ClsCnj999 : public Sapphire::ScriptAPI::QuestScript
+{
+private:
+  // Basic quest information
+  // Quest vars / flags used
+
+  // Steps in this quest ( 0 is before accepting,
+  // 1 is first, 255 means ready for turning it in
+  enum Sequence : uint8_t
+  {
+  };
+  static constexpr auto Actor0 = 1000323;
+
+
+  // Entities found in the script data of the quest
+
+public:
+  ClsCnj999() : Sapphire::ScriptAPI::QuestScript( 65718 ){};
+  ~ClsCnj999() = default;
+
+  //////////////////////////////////////////////////////////////////////
+  // Event Handlers
+  void onTalk( World::Quest& quest, Entity::Player& player, uint64_t actorId ) override
+  {
+    switch( actorId )
+    {
+      case Actor0:
+      {
+        Scene00000( quest, player );
+        break;
+      }
+    }
+  }
+
+
+private:
+  //////////////////////////////////////////////////////////////////////
+  // Available Scenes in this quest, not necessarly all are used
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00000( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 0, HIDE_HOTBAR, bindSceneReturn( &ClsCnj999::Scene00000Return ) );
+  }
+
+  void Scene00000Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    if( result.getResult( 0 ) == 1 )
+    {
+      player.finishQuest( getId(), 0 );
+    }
+  }
+};
+
+EXPOSE_SCRIPT( ClsCnj999 );
\ No newline at end of file
diff --git a/src/scripts/quest/classquest/MIN/ClsMin502.cpp b/src/scripts/quest/classquest/MIN/ClsMin502.cpp
index ee1238597..05505cdf3 100644
--- a/src/scripts/quest/classquest/MIN/ClsMin502.cpp
+++ b/src/scripts/quest/classquest/MIN/ClsMin502.cpp
@@ -45,6 +45,7 @@ class ClsMin502 : public Sapphire::ScriptAPI::QuestScript
   static constexpr auto Actor4 = 1013231;//Hatchling
   static constexpr auto BindActor1 = 5896086;
   static constexpr auto Item0 = 2001726;
+  static constexpr auto Item0Icon = 26177;
   static constexpr auto LocBgm1 = 313;
 
 public:
@@ -137,7 +138,7 @@ class ClsMin502 : public Sapphire::ScriptAPI::QuestScript
   void Scene00002Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
   {
     quest.setUI8BH( 1 );
-    eventMgr().sendEventNotice( player, getId(), 0, 0 );//TODO: Item Icon, probably
+    eventMgr().sendNotice( player, getId(), 0, { Item0Icon } );
     quest.setSeq( Seq2 );
   }
 
diff --git a/src/scripts/quest/classquest/MIN/ClsMin580.cpp b/src/scripts/quest/classquest/MIN/ClsMin580.cpp
index 9505ca2f9..716fc9515 100644
--- a/src/scripts/quest/classquest/MIN/ClsMin580.cpp
+++ b/src/scripts/quest/classquest/MIN/ClsMin580.cpp
@@ -64,6 +64,7 @@ class ClsMin580 : public Sapphire::ScriptAPI::QuestScript
   static constexpr auto Eobject2 = 2005950;
   static constexpr auto EventActionGatherMiddle = 7;
   static constexpr auto Item0 = 2001728;
+  static constexpr auto Item0Icon = 21223;
   static constexpr auto LocActor1 = 1013860;
   static constexpr auto LocActor2 = 1013870;
   static constexpr auto LocActor3 = 1013871;
@@ -207,7 +208,7 @@ class ClsMin580 : public Sapphire::ScriptAPI::QuestScript
 private:
   void checkQuestCompletion( World::Quest& quest, Entity::Player& player )
   {
-    eventMgr().sendEventNotice( player, getId(), 1, 2, quest.getUI8AL(), 3 );//TODO: Item Icon, probably
+    eventMgr().sendNotice( player, getId(), 1, { quest.getUI8AL(), 3, Item0Icon } );
 
     if( quest.getUI8AL() >= 3 )
     {
diff --git a/src/scripts/quest/classquest/MIN/ClsMin600.cpp b/src/scripts/quest/classquest/MIN/ClsMin600.cpp
index 7e733494a..df5fd18f0 100644
--- a/src/scripts/quest/classquest/MIN/ClsMin600.cpp
+++ b/src/scripts/quest/classquest/MIN/ClsMin600.cpp
@@ -56,6 +56,7 @@ class ClsMin600 : public Sapphire::ScriptAPI::QuestScript
   static constexpr auto Actor7 = 1013961;//Goblin Trader (Seq5)
   static constexpr auto BindActor1 = 5896328;
   static constexpr auto Item0 = 2001729;
+  static constexpr auto Item0Icon = 25919;
   static constexpr auto LocActor1 = 1013954;
   static constexpr auto LocActor2 = 1013955;
   static constexpr auto LocBgm1 = 313;
@@ -390,7 +391,7 @@ class ClsMin600 : public Sapphire::ScriptAPI::QuestScript
 
   void Scene00019Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
   {
-    eventMgr().sendEventNotice( player, getId(), 5, 0 );//TODO: Item Icon?
+    eventMgr().sendNotice( player, getId(), 5, { Item0Icon } );
     quest.setSeq( SeqFinish );
     quest.setUI8BH( 0 );
   }
diff --git a/src/scripts/quest/classquest/WHM/JobWhm001.cpp b/src/scripts/quest/classquest/WHM/JobWhm001.cpp
index 4a809993e..4fb8ad996 100644
--- a/src/scripts/quest/classquest/WHM/JobWhm001.cpp
+++ b/src/scripts/quest/classquest/WHM/JobWhm001.cpp
@@ -101,6 +101,8 @@ class JobWhm001 : public Sapphire::ScriptAPI::QuestScript
   static constexpr auto Item4 = 2001029;
   static constexpr auto Item5 = 2001038;
   static constexpr auto Item6 = 2001047;
+  static constexpr auto Item0Icon = 21003;
+  static constexpr auto Item3Icon = 26002;
   static constexpr auto LocAction0 = 858;
   static constexpr auto LocAction1 = 995;
   static constexpr auto LocAction2 = 936;
@@ -109,6 +111,7 @@ class JobWhm001 : public Sapphire::ScriptAPI::QuestScript
   static constexpr auto Ritem0 = 2049;//Madman's Whispering Rod
   static constexpr auto Ritem1 = 2046;//Unfinished Thyrus
   static constexpr auto Ritem2 = 6267;//Radz-at-Han Quenching Oil
+  static constexpr auto Ritem1Icon = 32627;
 
 public:
   JobWhm001() : Sapphire::ScriptAPI::QuestScript( 66660 ){};
@@ -327,7 +330,7 @@ class JobWhm001 : public Sapphire::ScriptAPI::QuestScript
   void Scene00002Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
   {
     quest.setUI8BH( 1 );
-    eventMgr().sendEventNotice( player, getId(), 0, 0 );//TODO:Item Icon
+    eventMgr().sendNotice( player, getId(), 0, { Item0Icon } );
     quest.setSeq( Seq2 );
   }
 
@@ -469,7 +472,7 @@ class JobWhm001 : public Sapphire::ScriptAPI::QuestScript
 
   void Scene00013Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
   {
-    eventMgr().sendEventNotice( player, getId(), 7, 0 );//TODO: Item Icon
+    eventMgr().sendNotice( player, getId(), 7, { Item3Icon } );
     quest.setSeq( Seq9 );
     quest.setUI8BH( 1 );
   }
@@ -497,7 +500,7 @@ class JobWhm001 : public Sapphire::ScriptAPI::QuestScript
   void Scene00015Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
   {
     quest.setUI8BH( 0 );
-    eventMgr().sendEventNotice( player, getId(), 8, 0 );//TODO: Item Icon?
+    eventMgr().sendNotice( player, getId(), 8, { Ritem1Icon } );
     player.addItem( Ritem1 );
     quest.setSeq( Seq10 );
   }
@@ -719,4 +722,4 @@ class JobWhm001 : public Sapphire::ScriptAPI::QuestScript
   }
 };
 
-EXPOSE_SCRIPT( JobWhm001 );
\ No newline at end of file
+EXPOSE_SCRIPT( JobWhm001 );
diff --git a/src/scripts/quest/classquest/WHM/JobWhm450.cpp b/src/scripts/quest/classquest/WHM/JobWhm450.cpp
index 4953a2142..fae06547b 100644
--- a/src/scripts/quest/classquest/WHM/JobWhm450.cpp
+++ b/src/scripts/quest/classquest/WHM/JobWhm450.cpp
@@ -80,6 +80,10 @@ class JobWhm450 : public Sapphire::ScriptAPI::QuestScript
   static constexpr auto Ritem1 = 3894;
   static constexpr auto Ritem2 = 3463;
   static constexpr auto Ritem3 = 2902;
+  static constexpr auto Ritem0Icon = 48242;
+  static constexpr auto Ritem1Icon = 48219;
+  static constexpr auto Ritem2Icon = 45189;
+  static constexpr auto Ritem3Icon = 40616;
   static constexpr auto VfxReaction = 177;
 
 public:
@@ -214,7 +218,7 @@ class JobWhm450 : public Sapphire::ScriptAPI::QuestScript
 
   void Scene00003Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
   {
-    eventMgr().sendEventNotice( player, getId(), 0, 0 );//TODO:Item Icon, Cleric's Gloves
+    eventMgr().sendNotice( player, getId(), 0, { Ritem0Icon } );
     playerMgr().sendLogMessage( player, Logmessage0 );
     quest.setUI8AL( 1 );
     quest.setUI8CH( 0 );
@@ -241,7 +245,7 @@ class JobWhm450 : public Sapphire::ScriptAPI::QuestScript
 
   void Scene00005Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
   {
-    eventMgr().sendEventNotice( player, getId(), 1, 0 );//TODO:Item Icon, Cleric's Culottes
+    eventMgr().sendNotice( player, getId(), 1, { Ritem2Icon } );
     playerMgr().sendLogMessage( player, Logmessage0 );
     quest.setUI8BH( 1 );
     quest.setUI8CL( 0 );
@@ -268,7 +272,7 @@ class JobWhm450 : public Sapphire::ScriptAPI::QuestScript
 
   void Scene00007Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
   {
-    eventMgr().sendEventNotice( player, getId(), 2, 0 );//TODO:Item Icon, Cleric's Boots
+    eventMgr().sendNotice( player, getId(), 2, {Ritem1Icon} );
     playerMgr().sendLogMessage( player, Logmessage0 );
     quest.setUI8BL( 1 );
     quest.setUI8DH( 0 );
@@ -436,7 +440,7 @@ class JobWhm450 : public Sapphire::ScriptAPI::QuestScript
 
   void Scene00021Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
   {
-    eventMgr().sendEventNotice( player, getId(), 6, 0 );//TODO:Item Icon, Cleric's Circlet
+    eventMgr().sendNotice( player, getId(), 6, { Ritem3Icon } );
     playerMgr().sendLogMessage( player, Logmessage0 );
     quest.setSeq( SeqFinish );
     quest.setUI8BH( 0 );
diff --git a/src/scripts/quest/festivalquest/FesEst101.cpp b/src/scripts/quest/festivalquest/FesEst101.cpp
index e72447b7b..32b88a784 100644
--- a/src/scripts/quest/festivalquest/FesEst101.cpp
+++ b/src/scripts/quest/festivalquest/FesEst101.cpp
@@ -179,7 +179,8 @@ class FesEst101 : public Sapphire::ScriptAPI::QuestScript
 
   void Scene00002Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
   {
-    player.addStatusEffectById( Status0, 0, player, Transformation0 );
+    // todo - fix status effect without action?
+    //player.addStatusEffectById( Status0, 0, player, Transformation0 );
     eventMgr().sendEventNotice( player, getId(), 0, 0 );
     quest.setSeq( Seq2 );
   }
@@ -294,7 +295,7 @@ class FesEst101 : public Sapphire::ScriptAPI::QuestScript
 
   void Scene00010Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
   {
-    player.addStatusEffectById( Status0, 0, player, Transformation0 );
+  //  player.addStatusEffectById( Status0, 0, player, Transformation0 );
   }
 
   //////////////////////////////////////////////////////////////////////
diff --git a/src/scripts/quest/subquest/blackshroud_central/SubFst033.cpp b/src/scripts/quest/subquest/blackshroud_central/SubFst033.cpp
index 05dafa7b2..eb6b8abb6 100644
--- a/src/scripts/quest/subquest/blackshroud_central/SubFst033.cpp
+++ b/src/scripts/quest/subquest/blackshroud_central/SubFst033.cpp
@@ -54,6 +54,7 @@ class SubFst033 : public Sapphire::ScriptAPI::QuestScript
   static constexpr auto Eobject1 = 2000017;//Decaying Tree (South)
   static constexpr auto Eobject2 = 2000018;//Decaying Tree (East)
   static constexpr auto Item0 = 2000061;
+  static constexpr auto Item0Icon = 20661;
   static constexpr auto Seq0Actor0 = 0;
   static constexpr auto Seq1Eobject0 = 1;
   static constexpr auto Seq1Eobject0Useitemno = 99;
@@ -184,7 +185,7 @@ class SubFst033 : public Sapphire::ScriptAPI::QuestScript
 private:
   void checkQuestCompletion( World::Quest& quest, Entity::Player& player )
   {
-    eventMgr().sendEventNotice( player, getId(), 0, 2, quest.getUI8AH(), 3 );//TODO: Probably needs item icon
+    eventMgr().sendNotice( player, getId(), 0, { quest.getUI8AH(), 3, Item0Icon } );
 
     if( quest.getUI8AH() >= 3 )
     {
diff --git a/src/scripts/quest/subquest/blackshroud_central/SubFst052.cpp b/src/scripts/quest/subquest/blackshroud_central/SubFst052.cpp
index ed0a3e022..f91b170a9 100644
--- a/src/scripts/quest/subquest/blackshroud_central/SubFst052.cpp
+++ b/src/scripts/quest/subquest/blackshroud_central/SubFst052.cpp
@@ -45,6 +45,8 @@ class SubFst052 : public Sapphire::ScriptAPI::QuestScript
   static constexpr auto Enemy0 = 54;//Hornet Swarm (INCORRECT: 57)
   static constexpr auto Item0 = 2000099;
   static constexpr auto Item1 = 2000094;
+  static constexpr auto Item0Icon = 22623;
+  static constexpr auto Item1Icon = 24403;
   static constexpr auto Seq0Actor0 = 0;
   static constexpr auto Seq2Actor0 = 1;
   static constexpr auto Seq2Actor0Npctradeno = 99;
@@ -88,7 +90,7 @@ class SubFst052 : public Sapphire::ScriptAPI::QuestScript
       {
         quest.setUI8BH( quest.getUI8BH() + 1 );
         quest.setUI8AL( quest.getUI8AL() + 1 );
-        eventMgr().sendEventNotice( player, getId(), 0, 2, quest.getUI8AL(), 4 );//TODO: Probably needs item icon
+        eventMgr().sendNotice( player, getId(), 0, { quest.getUI8AL(), 4, Item0Icon } ); // item Icon 2 missing
 
         if( quest.getUI8AL() >= 4 )
         {
diff --git a/src/scripts/quest/subquest/blackshroud_central/SubFst067.cpp b/src/scripts/quest/subquest/blackshroud_central/SubFst067.cpp
index 6433ed1d3..a8c3da0fe 100644
--- a/src/scripts/quest/subquest/blackshroud_central/SubFst067.cpp
+++ b/src/scripts/quest/subquest/blackshroud_central/SubFst067.cpp
@@ -53,6 +53,7 @@ class SubFst067 : public Sapphire::ScriptAPI::QuestScript
   static constexpr auto Eventrange0 = 3841476;
   static constexpr auto EventActionSearch = 1;
   static constexpr auto Item0 = 2000192;
+  static constexpr auto Item0Icon = 22627;
 
 public:
   SubFst067() : Sapphire::ScriptAPI::QuestScript( 65919 ){};
@@ -182,7 +183,7 @@ class SubFst067 : public Sapphire::ScriptAPI::QuestScript
 private:
   void checkQuestCompletion( World::Quest& quest, Entity::Player& player )
   {
-    eventMgr().sendEventNotice( player, getId(), 1, 2, quest.getUI8AL(), 3 );//TODO: Item Icon
+    eventMgr().sendNotice( player, getId(), 1, { quest.getUI8AL(), 3, Item0Icon } );
     if( quest.getUI8AL() >= 3 )
     {
       quest.setUI8AL( 0 );
diff --git a/src/scripts/quest/subquest/blackshroud_central/SubFst069.cpp b/src/scripts/quest/subquest/blackshroud_central/SubFst069.cpp
index 855624f10..14a68e7b4 100644
--- a/src/scripts/quest/subquest/blackshroud_central/SubFst069.cpp
+++ b/src/scripts/quest/subquest/blackshroud_central/SubFst069.cpp
@@ -39,6 +39,7 @@ class SubFst069 : public Sapphire::ScriptAPI::QuestScript
   static constexpr auto Eobject0 = 2000685;//Well-worn Fishing Rod
   static constexpr auto EventActionSearch = 1;
   static constexpr auto Item0 = 2000185;
+  static constexpr auto Item0Icon = 38201;
   static constexpr auto Seq0Actor0 = 0;
   static constexpr auto Seq1Eobject0 = 1;
   static constexpr auto Seq1Eobject0Eventactionno = 99;
@@ -169,7 +170,7 @@ class SubFst069 : public Sapphire::ScriptAPI::QuestScript
 
   void Scene00100Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
   {
-    eventMgr().sendEventNotice( player, getId(), 0, 0 );//TODO: Probably Item Icon
+    eventMgr().sendNotice( player, getId(), 0, { Item0Icon } );
     quest.setUI8BH( 1 );
     quest.setSeq( SeqFinish );
   }
diff --git a/src/scripts/quest/subquest/blackshroud_north/GaiUsa803.cpp b/src/scripts/quest/subquest/blackshroud_north/GaiUsa803.cpp
index 15fcf1da9..341a8e8b5 100644
--- a/src/scripts/quest/subquest/blackshroud_north/GaiUsa803.cpp
+++ b/src/scripts/quest/subquest/blackshroud_north/GaiUsa803.cpp
@@ -55,6 +55,7 @@ class GaiUsa803 : public Sapphire::ScriptAPI::QuestScript
   static constexpr auto EventActionSearchMiddle = 3;
   static constexpr auto Item0 = 2000616;
   static constexpr auto Item1 = 2000617;
+  static constexpr auto Item1Icon = 20005;
 
 public:
   GaiUsa803() : Sapphire::ScriptAPI::QuestScript( 66323 ){};
@@ -140,7 +141,7 @@ class GaiUsa803 : public Sapphire::ScriptAPI::QuestScript
 private:
   void checkQuestCompletion( World::Quest& quest, Entity::Player& player )
   {
-    eventMgr().sendEventNotice( player, getId(), 1, 2, quest.getUI8AH(), 5 );//TODO:Show Item Icon
+    eventMgr().sendNotice( player, getId(), 1, { quest.getUI8AH(), 5, Item1Icon } );
     if( quest.getUI8AH() >= 5 )
     {
       quest.setUI8BH( quest.getUI8DH() );
diff --git a/src/scripts/quest/subquest/coerthas_central/GaiUsb808.cpp b/src/scripts/quest/subquest/coerthas_central/GaiUsb808.cpp
index 5ef10f234..3630fb8f4 100644
--- a/src/scripts/quest/subquest/coerthas_central/GaiUsb808.cpp
+++ b/src/scripts/quest/subquest/coerthas_central/GaiUsb808.cpp
@@ -55,6 +55,7 @@ class GaiUsb808 : public Sapphire::ScriptAPI::QuestScript
   static constexpr auto Item0 = 2000720;
   static constexpr auto Item1 = 2000721;
   static constexpr auto Item2 = 2000722;
+  static constexpr auto Item0Icon = 26002;
 
 public:
   GaiUsb808() : Sapphire::ScriptAPI::QuestScript( 66453 ){};
@@ -162,7 +163,7 @@ class GaiUsb808 : public Sapphire::ScriptAPI::QuestScript
 
   void Scene00003Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
   {
-    eventMgr().sendEventNotice( player, getId(), 1, 0 );//TODO:Show Item Icon (Needs func update)
+    eventMgr().sendNotice( player, getId(), 1, { Item0Icon } );
     quest.setUI8BH( 1 );
     quest.setSeq( Seq3 );
   }
diff --git a/src/scripts/quest/subquest/gridania/GaiUsc609.cpp b/src/scripts/quest/subquest/gridania/GaiUsc609.cpp
index 7b1b10471..a5cff6f2d 100644
--- a/src/scripts/quest/subquest/gridania/GaiUsc609.cpp
+++ b/src/scripts/quest/subquest/gridania/GaiUsc609.cpp
@@ -61,6 +61,8 @@ class GaiUsc609 : public Sapphire::ScriptAPI::QuestScript
   static constexpr auto EventActionSearch = 1;
   static constexpr auto Item0 = 2000963;
   static constexpr auto Item1 = 2000965;
+  static constexpr auto Item0Icon = 22614;
+  static constexpr auto Item1Icon = 21452;
   static constexpr auto Poprange0 = 3884000;
   static constexpr auto Territorytype0 = 204;
 
@@ -263,7 +265,7 @@ class GaiUsc609 : public Sapphire::ScriptAPI::QuestScript
 
   void Scene00003Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
   {
-    eventMgr().sendEventNotice( player, getId(), 0, 0 );
+    eventMgr().sendNotice( player, getId(), 0, { Item0Icon } );
     quest.setUI8BH( 1 );
     quest.setSeq( Seq2 );
   }
@@ -393,7 +395,7 @@ class GaiUsc609 : public Sapphire::ScriptAPI::QuestScript
   {
     quest.setSeq( Seq4 );
     quest.setUI8BH( 1 );
-    eventMgr().sendEventNotice( player, getId(), 2, 0 /*1, Item1*/ );//TODO:Item Icon Event Notice
+    eventMgr().sendNotice( player, getId(), 2, { Item1Icon } );
   }
 
   //////////////////////////////////////////////////////////////////////
diff --git a/src/scripts/quest/subquest/gridania/SubFst009.cpp b/src/scripts/quest/subquest/gridania/SubFst009.cpp
index 6d1a63c0a..a61e2e8c2 100644
--- a/src/scripts/quest/subquest/gridania/SubFst009.cpp
+++ b/src/scripts/quest/subquest/gridania/SubFst009.cpp
@@ -96,8 +96,6 @@ class SubFst009 : public Sapphire::ScriptAPI::QuestScript
   {
     if (result.getResult(0) == 1)
       Scene00100(quest, player);
-    else
-      Scene00099(quest, player);
   }
 
   //////////////////////////////////////////////////////////////////////
diff --git a/src/scripts/quest/subquest/gridania/SubFst011.cpp b/src/scripts/quest/subquest/gridania/SubFst011.cpp
index 5c7286b68..dfda7acca 100644
--- a/src/scripts/quest/subquest/gridania/SubFst011.cpp
+++ b/src/scripts/quest/subquest/gridania/SubFst011.cpp
@@ -67,8 +67,11 @@ class SubFst011 : public Sapphire::ScriptAPI::QuestScript
       case Enemy0:
       {
         auto currentKC = quest.getUI8AL();
-        quest.setUI8AL( currentKC + 1 );
-        eventMgr().sendEventNotice( player, getId(), 0, 2, currentKC + 1, 6 );
+        if( currentKC < 6 )
+        {
+          quest.setUI8AL( currentKC + 1 );
+          eventMgr().sendEventNotice( player, getId(), 0, 2, currentKC + 1, 6 );
+        }
 
         if( currentKC + 1 >= 6 )
           quest.setSeq( SeqFinish );
diff --git a/src/scripts/quest/subquest/lanoscea_outer/GaiUsb406.cpp b/src/scripts/quest/subquest/lanoscea_outer/GaiUsb406.cpp
index 176978e3f..179139672 100644
--- a/src/scripts/quest/subquest/lanoscea_outer/GaiUsb406.cpp
+++ b/src/scripts/quest/subquest/lanoscea_outer/GaiUsb406.cpp
@@ -55,6 +55,8 @@ class GaiUsb406 : public Sapphire::ScriptAPI::QuestScript
   static constexpr auto EventActionSearch = 1;
   static constexpr auto Item0 = 2000669;
   static constexpr auto Item1 = 2000929;
+  static constexpr auto Item0Icon = 27241;
+  static constexpr auto Item1Icon = 22301;
 
 public:
   GaiUsb406() : Sapphire::ScriptAPI::QuestScript( 66398 ){};
@@ -143,7 +145,11 @@ class GaiUsb406 : public Sapphire::ScriptAPI::QuestScript
   {
     if( quest.getSeq() == Seq1 )
     {
-      eventMgr().sendEventNotice( player, getId(), type, 2, ( type == 0 ) ? quest.getUI8AL() : quest.getUI8BH(), 3 ); //TODO: Item Icons
+      if( type == 0 )
+        eventMgr().sendNotice( player, getId(), type, { quest.getUI8AL(), 3, Item1Icon } );
+      else
+        eventMgr().sendNotice( player, getId(), type, { quest.getUI8BH(), 3, Item0Icon } );
+
       if( quest.getUI8BL() >= 3 && quest.getUI8CH() >= 3 )
       {
         quest.setUI8BH( quest.getUI8BL() );
diff --git a/src/scripts/quest/subquest/limsa/SubSea002.cpp b/src/scripts/quest/subquest/limsa/SubSea002.cpp
index 406c22d5b..9ec722922 100644
--- a/src/scripts/quest/subquest/limsa/SubSea002.cpp
+++ b/src/scripts/quest/subquest/limsa/SubSea002.cpp
@@ -8,7 +8,7 @@
 #include <Service.h>
 
 // Quest Script: SubSea002_00112
-// Quest Name: Suspiciously SoberF
+// Quest Name: Suspiciously Sober
 // Quest ID: 65648
 // Start NPC: 1003604 (Ahldskyf)
 // End NPC: 1003275 (Frydwyb)
diff --git a/src/scripts/quest/subquest/limsa/SubSea004.cpp b/src/scripts/quest/subquest/limsa/SubSea004.cpp
index 6b08ea21d..b3e3ccf6b 100644
--- a/src/scripts/quest/subquest/limsa/SubSea004.cpp
+++ b/src/scripts/quest/subquest/limsa/SubSea004.cpp
@@ -145,6 +145,7 @@ class SubSea004 : public Sapphire::ScriptAPI::QuestScript
   {
     eventMgr().sendEventNotice( player, getId(), 0, 0 );
     quest.setUI8AL( 1 );
+    quest.setBitFlag8( 1, true );
     checkQuestCompletion( quest, player, 1 );
   }
 
@@ -159,6 +160,7 @@ class SubSea004 : public Sapphire::ScriptAPI::QuestScript
   {
     eventMgr().sendEventNotice( player, getId(), 1, 0 );
     quest.setUI8BH( 1 );
+    quest.setBitFlag8( 2, true );
     checkQuestCompletion( quest, player, 1 );
   }
 
@@ -173,6 +175,7 @@ class SubSea004 : public Sapphire::ScriptAPI::QuestScript
   {
     eventMgr().sendEventNotice( player, getId(), 2, 0 );
     quest.setUI8BL( 1 );
+    quest.setBitFlag8( 3, true );
     checkQuestCompletion( quest, player, 1 );
   }
 
diff --git a/src/scripts/quest/subquest/limsa/SubSea007.cpp b/src/scripts/quest/subquest/limsa/SubSea007.cpp
index 26feaf983..4475010a8 100644
--- a/src/scripts/quest/subquest/limsa/SubSea007.cpp
+++ b/src/scripts/quest/subquest/limsa/SubSea007.cpp
@@ -41,6 +41,7 @@ class SubSea007 : public Sapphire::ScriptAPI::QuestScript
     static constexpr auto Actor1 = 1000957; // R'sushmo ( Pos: -49.240898 43.991699 -146.380005  Teri: 128 )
     static constexpr auto Actor2 = 1000937; // Godebert ( Pos: -12.222500 44.998798 -251.850006  Teri: 128 )
     static constexpr auto Item0 = 2000455;
+    static constexpr auto Item0Icon = 25906;
 
   public:
     SubSea007() : Sapphire::ScriptAPI::QuestScript( 65653 ){}; 
@@ -117,7 +118,7 @@ class SubSea007 : public Sapphire::ScriptAPI::QuestScript
 
   void Scene00002Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
   {
-    eventMgr().sendEventNotice( player, getId(), 0, 0 ); // TODO: Show item icon
+    eventMgr().sendNotice( player, getId(), 0, { Item0Icon } );
     quest.setUI8BH( 1 );
     quest.setSeq( Seq2 );
   }
diff --git a/src/scripts/quest/subquest/limsa/SubSea008.cpp b/src/scripts/quest/subquest/limsa/SubSea008.cpp
index 6e7c013ea..6a220f83c 100644
--- a/src/scripts/quest/subquest/limsa/SubSea008.cpp
+++ b/src/scripts/quest/subquest/limsa/SubSea008.cpp
@@ -45,6 +45,7 @@ class SubSea008 : public Sapphire::ScriptAPI::QuestScript
     static constexpr auto Actor2 = 1000938; // Ginnade ( Pos: -4.651690 45.018398 -241.815002  Teri: 128 )
     static constexpr auto Actor3 = 1000947; // Lyngsath ( Pos: -54.642601 43.991699 -151.201996  Teri: 128 )
     static constexpr auto Item0 = 2000451;
+    static constexpr auto Item0Icon = 25919;
 
   public:
     SubSea008() : Sapphire::ScriptAPI::QuestScript( 65654 ){}; 
@@ -58,7 +59,8 @@ class SubSea008 : public Sapphire::ScriptAPI::QuestScript
     {
       case Actor0:
       {
-        Scene00000( quest, player );
+        if( quest.getSeq() == Seq0 )
+          Scene00000( quest, player );
         break;
       }
       case Actor1:
@@ -71,12 +73,14 @@ class SubSea008 : public Sapphire::ScriptAPI::QuestScript
       }
       case Actor2:
       {
-        Scene00003( quest, player );
+        if( quest.getSeq() == Seq2 )
+          Scene00003( quest, player );
         break;
       }
       case Actor3:
       {
-        Scene00005( quest, player );
+        if( quest.getSeq() == Seq2 )
+          Scene00005( quest, player );
         break;
       }
     }
@@ -137,7 +141,7 @@ class SubSea008 : public Sapphire::ScriptAPI::QuestScript
   void Scene00002Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
   {
     quest.setUI8BL( 1 );
-    eventMgr().sendEventNotice( player, getId(), 0, 0 ); //TODO: add item icon
+    eventMgr().sendNotice( player, getId(), 0, { Item0Icon } );
     quest.setSeq( Seq2 );
   }
 
@@ -167,6 +171,7 @@ class SubSea008 : public Sapphire::ScriptAPI::QuestScript
   {
     eventMgr().sendEventNotice( player, getId(), 1, 0 );
     quest.setUI8AL( 1 );
+    quest.setBitFlag8( 1, true );
     checkQuestCompletion( quest, player, 1 );
 
   }
@@ -197,6 +202,7 @@ class SubSea008 : public Sapphire::ScriptAPI::QuestScript
   {
     eventMgr().sendEventNotice( player, getId(), 2, 0 );
     quest.setUI8BH( 1 );
+    quest.setBitFlag8( 2, true );
     checkQuestCompletion( quest, player, 1 );
   }
 
diff --git a/src/scripts/quest/subquest/limsa/SubSea016.cpp b/src/scripts/quest/subquest/limsa/SubSea016.cpp
index bd263eea7..48d8d5c34 100644
--- a/src/scripts/quest/subquest/limsa/SubSea016.cpp
+++ b/src/scripts/quest/subquest/limsa/SubSea016.cpp
@@ -64,7 +64,8 @@ class SubSea016 : public Sapphire::ScriptAPI::QuestScript
       }
       case Actor1:
       {
-        Scene00002( quest, player );
+        if( quest.getSeq() == Seq1 )
+          Scene00002( quest, player );
         break;
       }
     }
@@ -131,6 +132,7 @@ class SubSea016 : public Sapphire::ScriptAPI::QuestScript
   void Scene00003Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
   {
     eventMgr().sendEventNotice( player, getId(), 0, 0 );
+    quest.setBitFlag8( 1, true );
     quest.setSeq( SeqFinish );
   }
 
diff --git a/src/scripts/quest/subquest/thanalan_central/SubWil025.cpp b/src/scripts/quest/subquest/thanalan_central/SubWil025.cpp
new file mode 100644
index 000000000..aba1d54dd
--- /dev/null
+++ b/src/scripts/quest/subquest/thanalan_central/SubWil025.cpp
@@ -0,0 +1,324 @@
+// This is an automatically generated C++ script template
+// Content needs to be added by hand to make it function
+// In order for this script to be loaded, move it to the correct folder in <root>/scripts/
+
+#include "Manager/EventMgr.h"
+#include <Actor/Player.h>
+#include <ScriptObject.h>
+#include <Service.h>
+
+// Quest Script: SubWil025_00671
+// Quest Name: Nothing to See Here
+// Quest ID: 66207
+// Start NPC: 1003995 (Papashan)
+// End NPC: 1003995 (Papashan)
+
+using namespace Sapphire;
+
+class SubWil025 : public Sapphire::ScriptAPI::QuestScript
+{
+private:
+  // Basic quest information
+  // Quest vars / flags used
+  // BitFlag8
+  // UI8AH
+  // UI8AL
+  // UI8BH
+  // UI8BL
+  // UI8CH
+  // UI8CL
+
+  /// Countable Num: 0 Seq: 1 Event: 1 Listener: 1004599
+  /// Countable Num: 0 Seq: 255 Event: 1 Listener: 1004600
+  // Steps in this quest ( 0 is before accepting,
+  // 1 is first, 255 means ready for turning it in
+  enum Sequence : uint8_t
+  {
+    Seq0 = 0,
+    Seq1 = 1,
+    SeqFinish = 255,
+  };
+
+  // Entities found in the script data of the quest
+  static constexpr auto Actor0 = 1003995;// Papashan ( Pos: 75.338402 2.138110 316.362000  Teri: 141 )
+  static constexpr auto Actor1 = 1004599;// Stern Sultansworn ( Pos: 89.876198 4.633540 425.415009  Teri: 141 )
+  static constexpr auto Actor2 = 1004600;// Serious Sultansworn ( Pos: 126.024002 14.465300 278.462006  Teri: 141 )
+  static constexpr auto Actor3 = 1004601;// Servile Sultansworn ( Pos: -62.415001 4.641350 261.281006  Teri: 141 )
+  static constexpr auto Item0 = 2000463;
+
+public:
+  SubWil025() : Sapphire::ScriptAPI::QuestScript( 66207 ){};
+  ~SubWil025() = default;
+
+  //////////////////////////////////////////////////////////////////////
+  // Event Handlers
+  void onTalk( World::Quest& quest, Entity::Player& player, uint64_t actorId ) override
+  {
+    switch( actorId )
+    {
+      case Actor0:
+      {
+        if( quest.getSeq() == Seq0 )
+          Scene00000( quest, player );
+        else if( quest.getSeq() == SeqFinish )
+          Scene00010( quest, player );
+        break;
+      }
+
+      case Actor1:
+      {
+        if( quest.getSeq() == Seq1 )
+        {
+          if( quest.getUI8AL() == 0 )
+            Scene00001( quest, player );
+          else
+            Scene00003( quest, player );
+        }
+        else if( quest.getSeq() == SeqFinish )
+        {
+          Scene00011( quest, player );
+        }
+        break;
+      }
+
+      case Actor2:
+      {
+        if( quest.getSeq() == Seq1 )
+        {
+          if( quest.getUI8BH() == 0 )
+            Scene00004( quest, player );
+          else
+            Scene00006( quest, player );
+        }
+        else if( quest.getSeq() == SeqFinish )
+        {
+          Scene00012( quest, player );
+        }
+        break;
+      }
+
+      case Actor3:
+      {
+        if( quest.getSeq() == Seq1 )
+        {
+          if( quest.getUI8BL() == 0 )
+            Scene00007( quest, player );
+          else
+            Scene00009( quest, player );
+        }
+        break;
+      }
+    }
+  }
+
+  void onEventItem( World::Quest& quest, Entity::Player& player, uint64_t actorId ) override
+  {
+  }
+
+
+private:
+  void checkQuestCompletion( World::Quest& quest, Entity::Player& player, uint32_t varIdx )
+  {
+    if( varIdx == 1 )
+    {
+      quest.setUI8AH( quest.getUI8AH() + 1 );
+      quest.setUI8CH( quest.getUI8CH() - 1 );
+      auto actor1Talked = quest.getUI8AL();
+      auto actor2Talked = quest.getUI8BH();
+      auto actor3Talked = quest.getUI8BL();
+      if( actor1Talked && actor2Talked && actor3Talked )
+      {
+        quest.setSeq( SeqFinish );
+      }
+      eventMgr().sendEventNotice( player, getId(), 0, 2, quest.getUI8AH(), 3 );
+    }
+  }
+  //////////////////////////////////////////////////////////////////////
+  // Available Scenes in this quest, not necessarly all are used
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00000( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 0, HIDE_HOTBAR, bindSceneReturn( &SubWil025::Scene00000Return ) );
+  }
+
+  void Scene00000Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    if( result.getResult( 0 ) == 1 )// accept quest
+    {
+      quest.setSeq( Seq1 );
+      quest.setUI8CH( 3 );
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00001( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 1, HIDE_HOTBAR, bindSceneReturn( &SubWil025::Scene00001Return ) );
+  }
+
+  void Scene00001Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    if( result.getResult( 0 ) == 1 )
+    {
+      Scene00002( quest, player );
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00002( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 2, HIDE_HOTBAR, bindSceneReturn( &SubWil025::Scene00002Return ) );
+  }
+
+  void Scene00002Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    quest.setUI8AL( 1 );
+    quest.setBitFlag8( 1, true );
+    checkQuestCompletion( quest, player, 1 );
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00003( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 3, HIDE_HOTBAR, bindSceneReturn( &SubWil025::Scene00003Return ) );
+  }
+
+  void Scene00003Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00004( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 4, HIDE_HOTBAR, bindSceneReturn( &SubWil025::Scene00004Return ) );
+  }
+
+  void Scene00004Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    if( result.getResult( 0 ) == 1 )
+    {
+      Scene00005( quest, player );
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00005( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 5, HIDE_HOTBAR, bindSceneReturn( &SubWil025::Scene00005Return ) );
+  }
+
+  void Scene00005Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    quest.setUI8BH( 1 );
+    quest.setBitFlag8( 2, true );
+    checkQuestCompletion( quest, player, 1 );
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00006( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 6, HIDE_HOTBAR, bindSceneReturn( &SubWil025::Scene00006Return ) );
+  }
+
+  void Scene00006Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00007( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 7, HIDE_HOTBAR, bindSceneReturn( &SubWil025::Scene00007Return ) );
+  }
+
+  void Scene00007Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    if( result.getResult( 0 ) == 1 )
+    {
+      Scene00008( quest, player );
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00008( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 8, HIDE_HOTBAR, bindSceneReturn( &SubWil025::Scene00008Return ) );
+  }
+
+  void Scene00008Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    quest.setUI8BL( 1 );
+    quest.setBitFlag8( 3, true );
+    checkQuestCompletion( quest, player, 1 );
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00009( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 9, HIDE_HOTBAR, bindSceneReturn( &SubWil025::Scene00009Return ) );
+  }
+
+  void Scene00009Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00010( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 10, HIDE_HOTBAR, bindSceneReturn( &SubWil025::Scene00010Return ) );
+  }
+
+  void Scene00010Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+    if( result.getResult( 0 ) == 1 )
+    {
+      player.finishQuest( getId(), result.getResult( 1 ) );
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00011( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 11, HIDE_HOTBAR, bindSceneReturn( &SubWil025::Scene00011Return ) );
+  }
+
+  void Scene00011Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00012( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 12, HIDE_HOTBAR, bindSceneReturn( &SubWil025::Scene00012Return ) );
+  }
+
+  void Scene00012Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00013( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 13, HIDE_HOTBAR, bindSceneReturn( &SubWil025::Scene00013Return ) );
+  }
+
+  void Scene00013Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+  }
+};
+
+EXPOSE_SCRIPT( SubWil025 );
\ No newline at end of file
diff --git a/src/scripts/quest/subquest/thanalan_central/SubWil026.cpp b/src/scripts/quest/subquest/thanalan_central/SubWil026.cpp
new file mode 100644
index 000000000..5ae382c0b
--- /dev/null
+++ b/src/scripts/quest/subquest/thanalan_central/SubWil026.cpp
@@ -0,0 +1,117 @@
+// This is an automatically generated C++ script template
+// Content needs to be added by hand to make it function
+// In order for this script to be loaded, move it to the correct folder in <root>/scripts/
+
+#include <Actor/Player.h>
+#include "Manager/EventMgr.h"
+#include <ScriptObject.h>
+#include <Service.h>
+
+// Quest Script: SubWil026_00623
+// Quest Name: Takin' What They're Givin'
+// Quest ID: 66159
+// Start NPC: 1001353 (Momodi)
+// End NPC: 1002065 (Dadanen)
+
+using namespace Sapphire;
+
+class SubWil026 : public Sapphire::ScriptAPI::QuestScript
+{
+  private:
+    // Basic quest information 
+    // Quest vars / flags used
+    // UI8AL
+
+    /// Countable Num: 1 Seq: 255 Event: 1 Listener: 1002065
+    // Steps in this quest ( 0 is before accepting, 
+    // 1 is first, 255 means ready for turning it in
+    enum Sequence : uint8_t
+    {
+      Seq0 = 0,
+      SeqFinish = 255,
+    };
+
+    // Entities found in the script data of the quest
+    static constexpr auto Actor0 = 1001353; // Momodi ( Pos: 21.072599 7.450000 -78.782303  Teri: 130 )
+    static constexpr auto Actor1 = 1002065; // Dadanen ( Pos: 60.946701 45.145302 -204.985992  Teri: 140 )
+
+  public:
+    SubWil026() : Sapphire::ScriptAPI::QuestScript( 66159 ){}; 
+    ~SubWil026() = default; 
+
+  //////////////////////////////////////////////////////////////////////
+  // Event Handlers
+  void onTalk( World::Quest& quest, Entity::Player& player, uint64_t actorId ) override
+  {
+    switch( actorId )
+    {
+      case Actor0:
+      {
+        if( quest.getSeq() == Seq0 )
+          Scene00000( quest, player );
+        break;
+      }
+      case Actor1:
+      {
+        if( quest.getSeq() == SeqFinish )
+          Scene00001( quest, player );
+        break;
+      }
+    }
+  }
+
+  void onEventItem( World::Quest& quest, Entity::Player& player, uint64_t actorId ) override
+  {
+  }
+
+
+  private:
+  //////////////////////////////////////////////////////////////////////
+  // Available Scenes in this quest, not necessarly all are used
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00000( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 0, HIDE_HOTBAR, bindSceneReturn( &SubWil026::Scene00000Return ) );
+  }
+
+  void Scene00000Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    if( result.getResult( 0 ) == 1 ) // accept quest
+    {
+      quest.setUI8AL( 1 );
+      quest.setSeq( SeqFinish );
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00001( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 1, FADE_OUT | CONDITION_CUTSCENE | HIDE_UI, bindSceneReturn( &SubWil026::Scene00001Return ) );
+  }
+
+  void Scene00001Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    Scene00002( quest, player );
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00002( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 2, HIDE_HOTBAR, bindSceneReturn( &SubWil026::Scene00002Return ) );
+  }
+
+  void Scene00002Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+    if( result.getResult( 0 ) == 1 )
+    {
+      player.finishQuest( getId(), result.getResult( 1 ) );
+    }
+  }
+
+};
+
+EXPOSE_SCRIPT( SubWil026 );
\ No newline at end of file
diff --git a/src/scripts/quest/subquest/thanalan_central/SubWil060.cpp b/src/scripts/quest/subquest/thanalan_central/SubWil060.cpp
new file mode 100644
index 000000000..7d04b507a
--- /dev/null
+++ b/src/scripts/quest/subquest/thanalan_central/SubWil060.cpp
@@ -0,0 +1,194 @@
+// This is an automatically generated C++ script template
+// Content needs to be added by hand to make it function
+// In order for this script to be loaded, move it to the correct folder in <root>/scripts/
+
+#include <Actor/Player.h>
+#include "Manager/EventMgr.h"
+#include <ScriptObject.h>
+#include <Service.h>
+
+// Quest Script: SubWil060_00303
+// Quest Name: Step Nine
+// Quest ID: 65839
+// Start NPC: 1001500 (Cicidoa)
+// End NPC: 1001541 (Roger)
+
+using namespace Sapphire;
+
+class SubWil060 : public Sapphire::ScriptAPI::QuestScript
+{
+  private:
+    // Basic quest information 
+    // Quest vars / flags used
+    // UI8AL
+    // UI8BH
+    // UI8BL
+
+    /// Countable Num: 1 Seq: 1 Event: 1 Listener: 1001455
+    /// Countable Num: 1 Seq: 255 Event: 1 Listener: 1001541
+    // Steps in this quest ( 0 is before accepting, 
+    // 1 is first, 255 means ready for turning it in
+    enum Sequence : uint8_t
+    {
+      Seq0 = 0,
+      Seq1 = 1,
+      SeqFinish = 255,
+    };
+
+    // Entities found in the script data of the quest
+    static constexpr auto Actor0 = 1001500; // Cicidoa ( Pos: 81.792099 1.050750 311.240997  Teri: 141 )
+    static constexpr auto Actor1 = 1001455; // Gagari ( Pos: 59.952599 0.999894 255.863998  Teri: 141 )
+    static constexpr auto Actor2 = 1001541; // Roger ( Pos: -99.395401 -11.380900 -41.723999  Teri: 141 )
+    static constexpr auto Item0 = 2000199;
+    static constexpr auto Item1 = 2000238;
+    static constexpr auto Item1Icon = 25210;
+
+  public:
+    SubWil060() : Sapphire::ScriptAPI::QuestScript( 65839 ){}; 
+    ~SubWil060() = default; 
+
+  //////////////////////////////////////////////////////////////////////
+  // Event Handlers
+  void onTalk( World::Quest& quest, Entity::Player& player, uint64_t actorId ) override
+  {
+    switch( actorId )
+    {
+      case Actor0:
+      {
+        if( quest.getSeq() == Seq0 )
+          Scene00000( quest, player );
+        break;
+      }
+      case Actor1:
+      {
+        if( quest.getSeq() == Seq1 )
+          Scene00001( quest, player );
+        break;
+      }
+      case Actor2:
+      {
+        if( quest.getSeq() == SeqFinish )
+          Scene00004( quest, player );
+        break;
+      }
+    }
+  }
+
+  void onEventItem( World::Quest& quest, Entity::Player& player, uint64_t actorId ) override
+  {
+  }
+
+
+  private:
+  //////////////////////////////////////////////////////////////////////
+  // Available Scenes in this quest, not necessarly all are used
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00000( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 0, HIDE_HOTBAR, bindSceneReturn( &SubWil060::Scene00000Return ) );
+  }
+
+  void Scene00000Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    if( result.getResult( 0 ) == 1 ) // accept quest
+    {
+      quest.setUI8BH( 1 );
+      quest.setSeq( Seq1 );
+    }
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00001( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 1, HIDE_HOTBAR, bindSceneReturn( &SubWil060::Scene00001Return ) );
+  }
+
+  void Scene00001Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    if( result.getResult( 0 ) == 1 )
+    {
+      Scene00002( quest, player );
+    }
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00002( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 2, HIDE_HOTBAR, bindSceneReturn( &SubWil060::Scene00002Return ) );
+  }
+
+  void Scene00002Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    quest.setUI8BH( 0 );
+    quest.setUI8BL( 1 );
+    eventMgr().sendNotice( player, getId(), 0, { Item1Icon } );
+    quest.setSeq( SeqFinish );
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00003( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 3, NONE, bindSceneReturn( &SubWil060::Scene00003Return ) );
+  }
+
+  void Scene00003Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00004( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 4, HIDE_HOTBAR, bindSceneReturn( &SubWil060::Scene00004Return ) );
+  }
+
+  void Scene00004Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    if( result.getResult( 0 ) == 1 )
+    {
+      Scene00005( quest, player );
+    }
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00005( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 5, HIDE_HOTBAR, bindSceneReturn( &SubWil060::Scene00005Return ) );
+  }
+
+  void Scene00005Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+    if( result.getResult( 0 ) == 1 )
+    {
+        player.finishQuest( getId(), result.getResult( 1 ) );
+    }
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00006( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 6, NONE, bindSceneReturn( &SubWil060::Scene00006Return ) );
+  }
+
+  void Scene00006Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+};
+
+EXPOSE_SCRIPT( SubWil060 );
\ No newline at end of file
diff --git a/src/scripts/quest/subquest/thanalan_central/SubWil062.cpp b/src/scripts/quest/subquest/thanalan_central/SubWil062.cpp
new file mode 100644
index 000000000..ce041da38
--- /dev/null
+++ b/src/scripts/quest/subquest/thanalan_central/SubWil062.cpp
@@ -0,0 +1,169 @@
+// This is an automatically generated C++ script template
+// Content needs to be added by hand to make it function
+// In order for this script to be loaded, move it to the correct folder in <root>/scripts/
+
+#include "Manager/EventMgr.h"
+#include <Actor/Player.h>
+#include <Actor/BNpc.h>
+#include <ScriptObject.h>
+#include <Service.h>
+
+// Quest Script: SubWil062_00305
+// Quest Name: Until a Quieter Time
+// Quest ID: 65841
+// Start NPC: 1001541 (Roger)
+// End NPC: 1001447 (Warin)
+
+using namespace Sapphire;
+
+class SubWil062 : public Sapphire::ScriptAPI::QuestScript
+{
+  private:
+    // Basic quest information 
+    // Quest vars / flags used
+    // UI8AL
+    // UI8BH
+
+    /// Countable Num: 8 Seq: 1 Event: 9 Listener: 432
+    /// Countable Num: 1 Seq: 255 Event: 1 Listener: 1001447
+    // Steps in this quest ( 0 is before accepting, 
+    // 1 is first, 255 means ready for turning it in
+    enum Sequence : uint8_t
+    {
+      Seq0 = 0,
+      Seq1 = 1,
+      SeqFinish = 255,
+    };
+
+    // Entities found in the script data of the quest
+    static constexpr auto Actor0 = 1001541; // Roger ( Pos: -99.395401 -11.380900 -41.723999  Teri: 141 )
+    static constexpr auto Actor1 = 1001447; // Warin ( Pos: -32.639099 -1.033260 -148.485992  Teri: 141 )
+    static constexpr auto Enemy0 = 294; // Antling Worker
+    static constexpr auto Item0 = 2000168;
+    static constexpr auto Item0Icon = 22205;
+
+  public:
+    SubWil062() : Sapphire::ScriptAPI::QuestScript( 65841 ){}; 
+    ~SubWil062() = default; 
+
+  //////////////////////////////////////////////////////////////////////
+  // Event Handlers
+  void onTalk( World::Quest& quest, Entity::Player& player, uint64_t actorId ) override
+  {
+    switch( actorId )
+    {
+      case Actor0:
+      {
+        if( quest.getSeq() == Seq0 )
+          Scene00000( quest, player );
+        break;
+      }
+      case Actor1:
+      {
+        if( quest.getSeq() == SeqFinish )
+          Scene00002( quest, player );
+        break;
+      }
+    }
+  }
+
+  void onEventItem( World::Quest& quest, Entity::Player& player, uint64_t actorId ) override
+  {
+  }
+
+  void onBNpcKill( World::Quest& quest, Entity::BNpc& bnpc, Entity::Player& player ) override
+  {
+    if( bnpc.getBNpcNameId() != Enemy0 )
+      return;
+
+    unsigned currentKC = quest.getUI8AL() + 1;
+    quest.setUI8BH( currentKC );
+    quest.setUI8AL( currentKC );
+
+    if( currentKC >= 5 )
+      quest.setSeq( SeqFinish );
+
+    eventMgr().sendNotice( player, getId(), 0, { currentKC, 5, Item0Icon } );
+  }
+
+  private:
+  //////////////////////////////////////////////////////////////////////
+  // Available Scenes in this quest, not necessarly all are used
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00000( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 0, HIDE_HOTBAR, bindSceneReturn( &SubWil062::Scene00000Return ) );
+  }
+
+  void Scene00000Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    if( result.getResult( 0 ) == 1 ) // accept quest
+    {
+      quest.setUI8AL( 0 );
+      quest.setSeq( Seq1 );
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00001( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 1, NONE, bindSceneReturn( &SubWil062::Scene00001Return ) );
+  }
+
+  void Scene00001Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00002( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 2, HIDE_HOTBAR, bindSceneReturn( &SubWil062::Scene00002Return ) );
+  }
+
+  void Scene00002Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    if( result.getResult( 0 ) == 1 )
+    {
+      quest.setUI8BH( 0 );
+      Scene00003( quest, player );
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00003( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 3, HIDE_HOTBAR, bindSceneReturn( &SubWil062::Scene00003Return ) );
+  }
+
+  void Scene00003Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+    if( result.getResult( 0 ) == 1 )
+    {
+      player.finishQuest( getId(), result.getResult( 1 ) );
+    }
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00004( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 4, NONE, bindSceneReturn( &SubWil062::Scene00004Return ) );
+  }
+
+  void Scene00004Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+};
+
+EXPOSE_SCRIPT( SubWil062 );
\ No newline at end of file
diff --git a/src/scripts/quest/subquest/thanalan_central/SubWil063.cpp b/src/scripts/quest/subquest/thanalan_central/SubWil063.cpp
new file mode 100644
index 000000000..e1fec0289
--- /dev/null
+++ b/src/scripts/quest/subquest/thanalan_central/SubWil063.cpp
@@ -0,0 +1,103 @@
+// This is an automatically generated C++ script template
+// Content needs to be added by hand to make it function
+// In order for this script to be loaded, move it to the correct folder in <root>/scripts/
+
+#include <Actor/Player.h>
+#include "Manager/EventMgr.h"
+#include <ScriptObject.h>
+#include <Service.h>
+
+// Quest Script: SubWil063_00306
+// Quest Name: Prudence at This Junction
+// Quest ID: 65842
+// Start NPC: 1001447 (Warin)
+// End NPC: 1001447 (Warin)
+
+using namespace Sapphire;
+
+class SubWil063 : public Sapphire::ScriptAPI::QuestScript
+{
+  private:
+    // Basic quest information 
+    // Quest vars / flags used
+    // UI8AL
+
+    /// Countable Num: 1 Seq: 255 Event: 1 Listener: 1001447
+    // Steps in this quest ( 0 is before accepting, 
+    // 1 is first, 255 means ready for turning it in
+    enum Sequence : uint8_t
+    {
+      Seq0 = 0,
+      SeqFinish = 255,
+    };
+
+    // Entities found in the script data of the quest
+    static constexpr auto Actor0 = 1001447; // Warin ( Pos: -32.639099 -1.033260 -148.485992  Teri: 141 )
+    static constexpr auto Seq0Actor0 = 0; // 
+    static constexpr auto Seq1Actor0 = 1; // 
+
+  public:
+    SubWil063() : Sapphire::ScriptAPI::QuestScript( 65842 ){}; 
+    ~SubWil063() = default; 
+
+  //////////////////////////////////////////////////////////////////////
+  // Event Handlers
+  void onTalk( World::Quest& quest, Entity::Player& player, uint64_t actorId ) override
+  {
+    switch( actorId )
+    {
+      case Actor0:
+      {
+        if( quest.getSeq() == Seq0 )
+          Scene00000( quest, player );
+        else if( quest.getSeq() == SeqFinish )
+          Scene00001( quest, player );
+        break;
+      }
+    }
+  }
+
+  void onEventItem( World::Quest& quest, Entity::Player& player, uint64_t actorId ) override
+  {
+  }
+
+
+  private:
+  //////////////////////////////////////////////////////////////////////
+  // Available Scenes in this quest, not necessarly all are used
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00000( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 0, HIDE_HOTBAR, bindSceneReturn( &SubWil063::Scene00000Return ) );
+  }
+
+  void Scene00000Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    if( result.getResult( 0 ) == 1 ) // accept quest
+    {
+      quest.setSeq( SeqFinish );
+      eventMgr().sendNotice( player, getId(), 0, {} );
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00001( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 1, HIDE_HOTBAR, bindSceneReturn( &SubWil063::Scene00001Return ) );
+  }
+
+  void Scene00001Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+    if( result.getResult( 0 ) == 1 )
+    {
+      player.finishQuest( getId(), result.getResult( 1 ) );
+    }
+
+  }
+
+};
+
+EXPOSE_SCRIPT( SubWil063 );
\ No newline at end of file
diff --git a/src/scripts/quest/subquest/thanalan_central/SubWil064.cpp b/src/scripts/quest/subquest/thanalan_central/SubWil064.cpp
new file mode 100644
index 000000000..c614aa306
--- /dev/null
+++ b/src/scripts/quest/subquest/thanalan_central/SubWil064.cpp
@@ -0,0 +1,315 @@
+// This is an automatically generated C++ script template
+// Content needs to be added by hand to make it function
+// In order for this script to be loaded, move it to the correct folder in <root>/scripts/
+
+#include "Manager/EventMgr.h"
+#include <Actor/Player.h>
+#include <Actor/BNpc.h>
+#include <ScriptObject.h>
+#include <Service.h>
+
+#include "Actor/BNpc.h"
+#include "Manager/TerritoryMgr.h"
+#include "Territory/Territory.h"
+
+// Quest Script: SubWil064_00307
+// Quest Name: Out of House and Home
+// Quest ID: 65843
+// Start NPC: 1001447 (Warin)
+// End NPC: 1001447 (Warin)
+
+using namespace Sapphire;
+
+class SubWil064 : public Sapphire::ScriptAPI::QuestScript
+{
+private:
+    // Basic quest information 
+    // Quest vars / flags used
+    // BitFlag8
+    // UI8AL
+    // UI8BH
+
+    /// Countable Num: 0 Seq: 1 Event: 1 Listener: 2000268
+    /// Countable Num: 1 Seq: 255 Event: 8 Listener: 2000268
+    // Steps in this quest ( 0 is before accepting, 
+    // 1 is first, 255 means ready for turning it in
+    enum Sequence : uint8_t
+    {
+      Seq0 = 0,
+      Seq1 = 1,
+      SeqFinish = 255,
+    };
+
+    // Entities found in the script data of the quest
+    static constexpr auto Actor0 = 1001447; // Warin ( Pos: -32.639099 -1.033260 -148.485992  Teri: 141 )
+    static constexpr auto Enemy0 = 3785130; // 
+    static constexpr auto Enemy1 = 3785131; // 
+    static constexpr auto Enemy2 = 3785134; // 
+    static constexpr auto Eobject0 = 2000268; // Narrow Fissure ( Pos: 25.690800 13.106300 47.828999  Teri: 141 )
+    static constexpr auto Item0 = 2000212;
+
+  public:
+    SubWil064() : Sapphire::ScriptAPI::QuestScript( 65843 ){}; 
+    ~SubWil064() = default; 
+
+  //////////////////////////////////////////////////////////////////////
+  // Event Handlers
+  void onTalk( World::Quest& quest, Entity::Player& player, uint64_t actorId ) override
+  {
+    switch( actorId )
+    {
+      case Actor0:
+      {
+        if( quest.getSeq() == Seq0 )
+        {
+          Scene00000( quest, player );
+        }
+        else if( quest.getSeq() == SeqFinish )
+        {
+          Scene00013( quest,player );
+        }
+        break;
+      }
+    }
+  }
+
+  void onEventItem( World::Quest& quest, Entity::Player& player, uint64_t actorId ) override
+  {
+    if (actorId == Eobject0)
+    {
+      Scene00002( quest, player );
+    }
+  }
+
+  void onBNpcKill( World::Quest& quest, Entity::BNpc& bnpc, Entity::Player& player ) override
+  {
+    switch( bnpc.getLayoutId() )
+    {
+      case Enemy0:
+      {
+        auto instance = teriMgr().getTerritoryByGuId( player.getTerritoryId() );
+        auto enemy1 = instance->createBNpcFromLayoutId( Enemy1, 1220 /*Find the right value*/, Common::BNpcType::Enemy );
+        auto enemy2 = instance->createBNpcFromLayoutId( Enemy2, 1220 /*Find the right value*/, Common::BNpcType::Enemy );
+
+        enemy1->setTriggerOwnerId( player.getId() );
+        enemy2->setTriggerOwnerId( player.getId() );
+        enemy1->hateListAddDelayed( player.getAsPlayer(), 1 );
+        enemy2->hateListAddDelayed( player.getAsPlayer(), 1 );
+        quest.setUI8AL( 1 );
+        break;
+      }
+      case Enemy1:
+      case Enemy2:
+      {
+        quest.setUI8AL( quest.getUI8AL() + 1 );
+        if( quest.getUI8AL() >= 4 )
+        {
+          quest.setUI8BH( 0 );
+          quest.setUI8AL( 0 );
+          quest.setSeq( SeqFinish );
+          eventMgr().sendNotice( player, getId(), 0, {} );
+        }
+        break;
+      }
+    }
+  }
+
+  private:
+  //////////////////////////////////////////////////////////////////////
+  // Available Scenes in this quest, not necessarly all are used
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00000( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 0, NONE, bindSceneReturn( &SubWil064::Scene00000Return ) );
+  }
+
+  void Scene00000Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    if( result.getResult( 0 ) == 1 ) // accept quest
+    {
+      Scene00001( quest, player );
+    }
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00001( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 1, NONE, bindSceneReturn( &SubWil064::Scene00001Return ) );
+  }
+
+  void Scene00001Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    quest.setUI8BH( 1 );
+    quest.setSeq( Seq1 );
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00002( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 2, NONE, bindSceneReturn( &SubWil064::Scene00002Return ) );
+  }
+
+  void Scene00002Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    quest.setBitFlag8( 1, true );
+    auto instance = teriMgr().getTerritoryByGuId( player.getTerritoryId() );
+    auto enemy0 = instance->createBNpcFromLayoutId( Enemy0, 1220 /*Find the right value*/, Common::BNpcType::Enemy );
+    enemy0->setTriggerOwnerId( player.getId() );
+    enemy0->hateListAddDelayed( player.getAsPlayer(), 1 );
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00003( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 3, NONE, bindSceneReturn( &SubWil064::Scene00003Return ) );
+  }
+
+  void Scene00003Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00004( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 4, NONE, bindSceneReturn( &SubWil064::Scene00004Return ) );
+  }
+
+  void Scene00004Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00005( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 5, NONE, bindSceneReturn( &SubWil064::Scene00005Return ) );
+  }
+
+  void Scene00005Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00006( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 6, NONE, bindSceneReturn( &SubWil064::Scene00006Return ) );
+  }
+
+  void Scene00006Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00007( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 7, NONE, bindSceneReturn( &SubWil064::Scene00007Return ) );
+  }
+
+  void Scene00007Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00008( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 8, NONE, bindSceneReturn( &SubWil064::Scene00008Return ) );
+  }
+
+  void Scene00008Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00009( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 9, NONE, bindSceneReturn( &SubWil064::Scene00009Return ) );
+  }
+
+  void Scene00009Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00010( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 10, NONE, bindSceneReturn( &SubWil064::Scene00010Return ) );
+  }
+
+  void Scene00010Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00011( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 11, NONE, bindSceneReturn( &SubWil064::Scene00011Return ) );
+  }
+
+  void Scene00011Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00012( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 12, NONE, bindSceneReturn( &SubWil064::Scene00012Return ) );
+  }
+
+  void Scene00012Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00013( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 13, NONE, bindSceneReturn( &SubWil064::Scene00013Return ) );
+  }
+
+  void Scene00013Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+    if( result.getResult( 0 ) == 1 )
+    {
+      player.finishQuest( getId(), result.getResult( 1 ) );
+    }
+
+  }
+
+};
+
+EXPOSE_SCRIPT( SubWil064 );
\ No newline at end of file
diff --git a/src/scripts/quest/subquest/thanalan_central/SubWil070.cpp b/src/scripts/quest/subquest/thanalan_central/SubWil070.cpp
new file mode 100644
index 000000000..92b693132
--- /dev/null
+++ b/src/scripts/quest/subquest/thanalan_central/SubWil070.cpp
@@ -0,0 +1,234 @@
+// This is an automatically generated C++ script template
+// Content needs to be added by hand to make it function
+// In order for this script to be loaded, move it to the correct folder in <root>/scripts/
+
+#include <Actor/Player.h>
+#include "Manager/EventMgr.h"
+#include <ScriptObject.h>
+#include <Service.h>
+
+// Quest Script: SubWil070_00324
+// Quest Name: Disorderly Conduct
+// Quest ID: 65860
+// Start NPC: 1001541 (Roger)
+// End NPC: 1001541 (Roger)
+
+using namespace Sapphire;
+
+class SubWil070 : public Sapphire::ScriptAPI::QuestScript
+{
+  private:
+    // Basic quest information 
+    // Quest vars / flags used
+    // BitFlag8
+    // UI8AL
+    // UI8BH
+
+    /// Countable Num: 4 Seq: 1 Event: 1 Listener: 1001462
+    /// Countable Num: 1 Seq: 255 Event: 1 Listener: 1001463
+    // Steps in this quest ( 0 is before accepting, 
+    // 1 is first, 255 means ready for turning it in
+    enum Sequence : uint8_t
+    {
+      Seq0 = 0,
+      Seq1 = 1,
+      SeqFinish = 255,
+    };
+
+    // Entities found in the script data of the quest
+    static constexpr auto Actor0 = 1001541; // Roger ( Pos: -99.395401 -11.380900 -41.723999  Teri: 141 )
+    static constexpr auto Actor1 = 1001462; // Roundelph ( Pos: -93.339500 -11.350300 -41.367199  Teri: 141 )
+    static constexpr auto Actor2 = 1001463; // Adalfuns ( Pos: -72.826401 -12.667800 -54.076199  Teri: 141 )
+    static constexpr auto Actor3 = 1001465; // Solid Trunk ( Pos: -90.043503 -11.398500 -53.666000  Teri: 141 )
+    static constexpr auto Actor4 = 1001466; // Ricard ( Pos: -89.735001 -11.350000 -51.539902  Teri: 141 )
+    static constexpr auto Item0 = 2000234;
+    static constexpr auto Item0Icon = 26153;
+    static constexpr auto Seq0Actor0 = 0;
+    static constexpr auto Seq1Actor1 = 1;
+    static constexpr auto Seq1Actor2 = 2;
+    static constexpr auto Seq1Actor3 = 3; 
+    static constexpr auto Seq1Actor4 = 4; 
+    static constexpr auto Seq2Actor0 = 5; 
+    static constexpr auto Seq2Actor0Npctradeno = 99;
+    static constexpr auto Seq2Actor0Npctradeok = 100;
+
+  public:
+    SubWil070() : Sapphire::ScriptAPI::QuestScript( 65860 ){}; 
+    ~SubWil070() = default; 
+
+  //////////////////////////////////////////////////////////////////////
+  // Event Handlers
+  void onTalk( World::Quest& quest, Entity::Player& player, uint64_t actorId ) override
+  {
+    switch( actorId )
+    {
+      case Actor0:
+      {
+        if( quest.getSeq() == 0 )
+          Scene00000( quest, player );
+        else if( quest.getSeq() == SeqFinish )
+          Scene00005( quest, player );
+        break;
+      }
+      case Actor1:
+      {
+        if( quest.getSeq() == 1 )
+          Scene00001( quest, player );
+        break;
+      }
+      case Actor2:
+      {
+        if( quest.getSeq() == 1 )
+          Scene00002( quest, player );
+        break;
+      }
+      case Actor3:
+      {
+        if( quest.getSeq() == 1 )
+          Scene00003( quest, player );
+        break;
+      }
+      case Actor4:
+      {
+        if( quest.getSeq() == 1 )
+          Scene00004( quest, player );
+        break;
+      }
+    }
+  }
+
+  void onEventItem( World::Quest& quest, Entity::Player& player, uint64_t actorId ) override
+  {
+  }
+
+
+  private:
+    void checkQuestCompletion( World::Quest& quest, Entity::Player& player, uint32_t varIdx )
+    {
+      if( varIdx == 1 )
+      {
+      quest.setUI8AL( quest.getUI8AL() + 1 );
+      if (quest.getUI8AL() == 4)
+        quest.setSeq( SeqFinish );
+      }
+      eventMgr().sendNotice( player, getId(), 0, { quest.getUI8AL(), 4, Item0Icon } );
+    }
+  //////////////////////////////////////////////////////////////////////
+  // Available Scenes in this quest, not necessarly all are used
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00000( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 0, HIDE_HOTBAR, bindSceneReturn( &SubWil070::Scene00000Return ) );
+  }
+
+  void Scene00000Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    if( result.getResult( 0 ) == 1 ) // accept quest
+    {
+      quest.setUI8BH( 1 );
+      quest.setSeq( Seq1 );
+    }
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00001( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 1, HIDE_HOTBAR, bindSceneReturn( &SubWil070::Scene00001Return ) );
+  }
+
+  void Scene00001Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    checkQuestCompletion( quest, player, 1 );
+    quest.setBitFlag8( 1, true );
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00002( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 2, HIDE_HOTBAR, bindSceneReturn( &SubWil070::Scene00002Return ) );
+  }
+
+  void Scene00002Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    checkQuestCompletion( quest, player, 1 );
+    quest.setBitFlag8( 2, true );
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00003( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 3, HIDE_HOTBAR, bindSceneReturn( &SubWil070::Scene00003Return ) );
+  }
+
+  void Scene00003Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    checkQuestCompletion( quest, player, 1 );
+    quest.setBitFlag8( 3, true );
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00004( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 4, HIDE_HOTBAR, bindSceneReturn( &SubWil070::Scene00004Return ) );
+  }
+
+  void Scene00004Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    checkQuestCompletion( quest, player, 1 );
+    quest.setBitFlag8( 4, true );
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00005( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 5, NONE, bindSceneReturn( &SubWil070::Scene00005Return ) );
+  }
+
+  void Scene00005Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    if( result.getResult( 0 ) == 1 )
+    {
+      Scene00100( quest, player );
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00099( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 99, NONE, bindSceneReturn( &SubWil070::Scene00099Return ) );
+  }
+
+  void Scene00099Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00100( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 100, HIDE_HOTBAR, bindSceneReturn( &SubWil070::Scene00100Return ) );
+  }
+
+  void Scene00100Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+    if( result.getResult( 0 ) == 1 )
+    {
+      player.finishQuest( getId(), result.getResult( 1 ) );
+    }
+
+  }
+
+};
+
+EXPOSE_SCRIPT( SubWil070 );
\ No newline at end of file
diff --git a/src/scripts/quest/subquest/thanalan_central/SubWil073.cpp b/src/scripts/quest/subquest/thanalan_central/SubWil073.cpp
new file mode 100644
index 000000000..857f5c213
--- /dev/null
+++ b/src/scripts/quest/subquest/thanalan_central/SubWil073.cpp
@@ -0,0 +1,415 @@
+// This is an automatically generated C++ script template
+// Content needs to be added by hand to make it function
+// In order for this script to be loaded, move it to the correct folder in <root>/scripts/
+
+#include "Manager/EventMgr.h"
+#include <Actor/Player.h>
+#include <Actor/BNpc.h>
+#include <ScriptObject.h>
+#include <Service.h>
+
+#include "Actor/BNpc.h"
+#include "Manager/TerritoryMgr.h"
+#include "Territory/Territory.h"
+
+// Quest Script: SubWil073_00327
+// Quest Name: Spriggan Cleaning
+// Quest ID: 65863
+// Start NPC: 1001447 (Warin)
+// End NPC: 1001447 (Warin)
+
+using namespace Sapphire;
+
+class SubWil073 : public Sapphire::ScriptAPI::QuestScript
+{
+  private:
+    // Basic quest information 
+    // Quest vars / flags used
+    // BitFlag8
+    // UI8AH
+    // UI8AL
+    // UI8BH
+    // UI8BL
+    // UI8CH
+    // UI8CL
+    // UI8DH
+    // UI8DL
+    // UI8EH
+
+    /// Countable Num: 4 Seq: 1 Event: 1 Listener: 2000377
+    /// Countable Num: 1 Seq: 255 Event: 5 Listener: 100
+    // Steps in this quest ( 0 is before accepting, 
+    // 1 is first, 255 means ready for turning it in
+    enum Sequence : uint8_t
+    {
+      Seq0 = 0,
+      Seq1 = 1,
+      SeqFinish = 255,
+    };
+
+    // Entities found in the script data of the quest
+    static constexpr auto Actor0 = 1001447; // Warin ( Pos: -32.639099 -1.033260 -148.485992  Teri: 141 )
+    static constexpr auto Enemy0 = 3742257; // 
+    static constexpr auto Enemy1 = 3742258; // 
+    static constexpr auto Enemy2 = 3742259; // 
+    static constexpr auto Enemy3 = 3742261; // 
+    static constexpr auto Eobject0 = 2000377; // Pockmarked Silver Ore ( Pos: -134.695999 6.168210 -116.594002  Teri: 141 )
+    static constexpr auto Eobject1 = 2000378; // Pockmarked Silver Ore ( Pos: -95.958298 -1.021940 -163.731003  Teri: 141 )
+    static constexpr auto Eobject2 = 2000379; // Pockmarked Silver Ore ( Pos: -103.938004 0.491295 -213.695007  Teri: 141 )
+    static constexpr auto Eobject3 = 2000380; // Pockmarked Silver Ore ( Pos: -1.174590 -1.322410 -111.265999  Teri: 141 )
+    static constexpr auto EventActionSearch = 1;
+    static constexpr auto Seq0Actor0 = 0; // 
+    static constexpr auto Seq1Eobject0 = 1; // 
+    static constexpr auto Seq1Eobject0Eventactionno = 99; // Hecatoncheir Piledriver
+    static constexpr auto Seq1Eobject0Eventactionok = 100; // Hecatoncheir Blastmaster ( Pos: -135.210007 5.708900 -117.417999  Teri: 141 )
+    static constexpr auto Seq1Eobject1 = 2; // Ruins Runner ( Pos: -5.462710 -1.142520 27.215000  Teri: 5 )
+    static constexpr auto Seq1Eobject1Eventactionno = 97; // Hecatoncheir Stonehauler
+    static constexpr auto Seq1Eobject1Eventactionok = 98; // Hecatoncheir Shockblocker
+    static constexpr auto Seq1Eobject2 = 3; // Antelope Doe
+    static constexpr auto Seq1Eobject2Eventactionno = 95; // Flux Flan
+    static constexpr auto Seq1Eobject2Eventactionok = 96; // Hecatoncheir Overseer
+    static constexpr auto Seq1Eobject3 = 4; // Antelope Stag
+    static constexpr auto Seq1Eobject3Eventactionno = 93; // Sargas
+    static constexpr auto Seq1Eobject3Eventactionok = 94; // Shaula
+    static constexpr auto Seq2Actor0 = 5; // Opo-opo
+
+  public:
+    SubWil073() : Sapphire::ScriptAPI::QuestScript( 65863 ){}; 
+    ~SubWil073() = default; 
+
+  //////////////////////////////////////////////////////////////////////
+  // Event Handlers
+  void onTalk( World::Quest& quest, Entity::Player& player, uint64_t actorId ) override
+  {
+    switch( actorId )
+    {
+      case Actor0:
+      {
+        if( quest.getSeq() == Seq0 )
+          Scene00000( quest, player );
+        else if( quest.getSeq() == SeqFinish )
+          Scene00005( quest, player );
+        break;
+      }
+      case Eobject0:
+      {
+        eventMgr().eventActionStart(
+                player, getId(), EventActionSearch,
+                [ & ]( Entity::Player& player, uint32_t eventId, uint64_t additional ) {
+                  Scene00094( quest, player );
+                },
+                nullptr, 0 );
+        break;
+
+      }
+      case Eobject1:
+      {
+        eventMgr().eventActionStart(
+                player, getId(), EventActionSearch,
+                [ & ]( Entity::Player& player, uint32_t eventId, uint64_t additional ) {
+                  Scene00095( quest, player );
+                },
+                nullptr, 0 );
+        break;
+      }
+      case Eobject2:
+      {
+        eventMgr().eventActionStart(
+                player, getId(), EventActionSearch,
+                [ & ]( Entity::Player& player, uint32_t eventId, uint64_t additional ) {
+                  Scene00096( quest, player );
+                },
+                nullptr, 0 );
+        break;
+      }
+      case Eobject3:
+      {
+        eventMgr().eventActionStart(
+                player, getId(), EventActionSearch,
+                [ & ]( Entity::Player& player, uint32_t eventId, uint64_t additional ) {
+                  Scene00097( quest, player );
+                },
+                nullptr, 0 );
+        break;
+      }
+    }
+  }
+
+  void onEventItem( World::Quest& quest, Entity::Player& player, uint64_t actorId ) override
+  {
+  }
+
+  void onBNpcKill( World::Quest& quest, Entity::BNpc& bnpc, Entity::Player& player ) override
+  {
+    switch (bnpc.getLayoutId())
+    {
+      case Enemy0:
+      {
+        quest.setUI8AL( 1 );
+        quest.setUI8BH( 1 );
+        checkQuestCompletion( quest, player );
+        break;
+      }
+      case Enemy1:
+      {
+        quest.setUI8BL( 1 );
+        quest.setUI8CH( 1 );
+        checkQuestCompletion( quest, player );
+        break;
+      }
+      case Enemy2:
+      {
+        quest.setUI8CL( 1 );
+        quest.setUI8DH( 1 );
+        checkQuestCompletion( quest, player );
+        break;
+      }
+      case Enemy3:
+      {
+        quest.setUI8DL( 1 );
+        quest.setUI8EH( 1 );
+        checkQuestCompletion( quest, player );
+        break;
+      }
+    }
+  }
+
+  private:
+    void checkQuestCompletion( World::Quest& quest, Entity::Player& player )
+    {
+      quest.setUI8AH( quest.getUI8AH() + 1 );
+      eventMgr().sendEventNotice( player, getId(), 0, 2, quest.getUI8AH(), 4 );
+
+      if( quest.getUI8AH() >= 4 )
+      {
+        quest.setUI8AL( 0 );
+        quest.setUI8BH( 0 );
+        quest.setUI8BL( 0 );
+        quest.setUI8CH( 0 );
+        quest.setUI8CL( 0 );
+        quest.setUI8DH( 0 );
+        quest.setUI8DL( 0 );
+        quest.setUI8EH( 0 );
+        quest.setUI8AH( 0 );
+        quest.setBitFlag8( 1, false );
+        quest.setBitFlag8( 2, false );
+        quest.setBitFlag8( 3, false );
+        quest.setBitFlag8( 4, false );
+        quest.setSeq( SeqFinish );
+      }
+    }
+  //////////////////////////////////////////////////////////////////////
+  // Available Scenes in this quest, not necessarly all are used
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00000( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 0, HIDE_HOTBAR, bindSceneReturn( &SubWil073::Scene00000Return ) );
+  }
+
+  void Scene00000Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    if( result.getResult( 0 ) == 1 ) // accept quest
+    {
+      Scene00001( quest, player );
+    }
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00001( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 1, HIDE_HOTBAR, bindSceneReturn( &SubWil073::Scene00001Return ) );
+  }
+
+  void Scene00001Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    quest.setSeq( Seq1 );
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00002( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 2, NONE, bindSceneReturn( &SubWil073::Scene00002Return ) );
+  }
+
+  void Scene00002Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00003( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 3, NONE, bindSceneReturn( &SubWil073::Scene00003Return ) );
+  }
+
+  void Scene00003Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00004( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 4, NONE, bindSceneReturn( &SubWil073::Scene00004Return ) );
+  }
+
+  void Scene00004Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00005( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 5, HIDE_HOTBAR, bindSceneReturn( &SubWil073::Scene00005Return ) );
+  }
+
+  void Scene00005Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+    if( result.getResult( 0 ) == 1 )
+    {
+      player.finishQuest( getId(), result.getResult( 1 ) );
+    }
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00093( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 93, NONE, bindSceneReturn( &SubWil073::Scene00093Return ) );
+  }
+
+  void Scene00093Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00094( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 94, NONE, bindSceneReturn( &SubWil073::Scene00094Return ) );
+  }
+
+  void Scene00094Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    auto instance = teriMgr().getTerritoryByGuId( player.getTerritoryId() );
+    auto enemy = instance->createBNpcFromLayoutId( Enemy0, 1220 /*Find the right value*/, Common::BNpcType::Enemy );
+
+    enemy->setTriggerOwnerId( player.getId() );
+    enemy->hateListAddDelayed( player.getAsPlayer(), 1 );
+    quest.setBitFlag8( 1, true );
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00095( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 95, NONE, bindSceneReturn( &SubWil073::Scene00095Return ) );
+  }
+
+  void Scene00095Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    auto instance = teriMgr().getTerritoryByGuId( player.getTerritoryId() );
+    auto enemy = instance->createBNpcFromLayoutId( Enemy1, 1220 /*Find the right value*/, Common::BNpcType::Enemy );
+
+    enemy->setTriggerOwnerId( player.getId() );
+    enemy->hateListAddDelayed( player.getAsPlayer(), 1 );
+    quest.setBitFlag8( 2, true );
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00096( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 96, NONE, bindSceneReturn( &SubWil073::Scene00096Return ) );
+  }
+
+  void Scene00096Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    auto instance = teriMgr().getTerritoryByGuId( player.getTerritoryId() );
+    auto enemy = instance->createBNpcFromLayoutId( Enemy2, 1220 /*Find the right value*/, Common::BNpcType::Enemy );
+
+    enemy->setTriggerOwnerId( player.getId() );
+    enemy->hateListAddDelayed( player.getAsPlayer(), 1 );
+    quest.setBitFlag8( 3, true );
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00097( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 97, NONE, bindSceneReturn( &SubWil073::Scene00097Return ) );
+  }
+
+  void Scene00097Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    auto instance = teriMgr().getTerritoryByGuId( player.getTerritoryId() );
+    auto enemy = instance->createBNpcFromLayoutId( Enemy3, 1220 /*Find the right value*/, Common::BNpcType::Enemy );
+
+    enemy->setTriggerOwnerId( player.getId() );
+    enemy->hateListAddDelayed( player.getAsPlayer(), 1 );
+    quest.setBitFlag8( 4, true );
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00098( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 98, NONE, bindSceneReturn( &SubWil073::Scene00098Return ) );
+  }
+
+  void Scene00098Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00099( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 99, NONE, bindSceneReturn( &SubWil073::Scene00099Return ) );
+  }
+
+  void Scene00099Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00100( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 100, NONE, bindSceneReturn( &SubWil073::Scene00100Return ) );
+  }
+
+  void Scene00100Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+
+  }
+
+};
+
+EXPOSE_SCRIPT( SubWil073 );
\ No newline at end of file
diff --git a/src/scripts/quest/subquest/thanalan_central/SubWil080.cpp b/src/scripts/quest/subquest/thanalan_central/SubWil080.cpp
new file mode 100644
index 000000000..9619e8fe8
--- /dev/null
+++ b/src/scripts/quest/subquest/thanalan_central/SubWil080.cpp
@@ -0,0 +1,136 @@
+// This is an automatically generated C++ script template
+// Content needs to be added by hand to make it function
+// In order for this script to be loaded, move it to the correct folder in <root>/scripts/
+
+#include <Actor/Player.h>
+#include "Manager/EventMgr.h"
+#include <ScriptObject.h>
+#include <Service.h>
+
+// Quest Script: SubWil080_00328
+// Quest Name: Supply and Demands
+// Quest ID: 65864
+// Start NPC: 1002065 (Dadanen)
+// End NPC: 1002061 (Drunken Stag)
+
+using namespace Sapphire;
+
+class SubWil080 : public Sapphire::ScriptAPI::QuestScript
+{
+  private:
+    // Basic quest information 
+    // Quest vars / flags used
+    // UI8AL
+    // UI8BH
+
+    /// Countable Num: 1 Seq: 255 Event: 1 Listener: 1002061
+    // Steps in this quest ( 0 is before accepting, 
+    // 1 is first, 255 means ready for turning it in
+    enum Sequence : uint8_t
+    {
+      Seq0 = 0,
+      SeqFinish = 255,
+    };
+
+    // Entities found in the script data of the quest
+    static constexpr auto Actor0 = 1002065; // Dadanen ( Pos: 60.946701 45.145302 -204.985992  Teri: 140 )
+    static constexpr auto Actor1 = 1002061; // Drunken Stag ( Pos: 240.998993 58.318298 -160.998001  Teri: 140 )
+    static constexpr auto Item0 = 2000368;
+
+  public:
+    SubWil080() : Sapphire::ScriptAPI::QuestScript( 65864 ){}; 
+    ~SubWil080() = default; 
+
+  //////////////////////////////////////////////////////////////////////
+  // Event Handlers
+  void onTalk( World::Quest& quest, Entity::Player& player, uint64_t actorId ) override
+  {
+    switch( actorId )
+    {
+      case Actor0:
+      {
+        if( quest.getSeq() == Seq0 )
+          Scene00000( quest, player );
+        break;
+      }
+      case Actor1:
+      {
+        if( quest.getSeq() == SeqFinish )
+          Scene00001( quest, player );
+        break;
+      }
+    }
+  }
+
+  void onEventItem( World::Quest& quest, Entity::Player& player, uint64_t actorId ) override
+  {
+  }
+
+
+  private:
+  //////////////////////////////////////////////////////////////////////
+  // Available Scenes in this quest, not necessarly all are used
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00000( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 0, HIDE_HOTBAR, bindSceneReturn( &SubWil080::Scene00000Return ) );
+  }
+
+  void Scene00000Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    if( result.getResult( 0 ) == 1 ) // accept quest
+    {
+      quest.setUI8BH( 1 );
+      quest.setSeq( SeqFinish );
+    }
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00001( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 1, HIDE_HOTBAR, bindSceneReturn( &SubWil080::Scene00001Return ) );
+  }
+
+  void Scene00001Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+    if (result.getResult(0) == 1)
+    {
+      Scene00002( quest, player );
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00002( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 2, NONE, bindSceneReturn( &SubWil080::Scene00002Return ) );
+  }
+
+  void Scene00002Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+    if( result.getResult( 0 ) == 1 )
+    {
+      player.finishQuest( getId(), result.getResult( 1 ) );
+    }
+
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  void Scene00003( World::Quest& quest, Entity::Player& player )
+  {
+    eventMgr().playQuestScene( player, getId(), 3, NONE, bindSceneReturn( &SubWil080::Scene00003Return ) );
+  }
+
+  void Scene00003Return( World::Quest& quest, Entity::Player& player, const Event::SceneResult& result )
+  {
+
+  }
+
+};
+
+EXPOSE_SCRIPT( SubWil080 );
\ No newline at end of file
diff --git a/src/scripts/statuseffect/StatusEffectDefiance.cpp b/src/scripts/statuseffect/StatusEffectDefiance.cpp
new file mode 100644
index 000000000..207ccec01
--- /dev/null
+++ b/src/scripts/statuseffect/StatusEffectDefiance.cpp
@@ -0,0 +1,22 @@
+#include <Script/NativeScriptApi.h>
+#include <ScriptObject.h>
+#include <Actor/Player.h>
+#include <Action/CommonAction.h>
+
+using namespace Sapphire;
+using namespace Sapphire::World::Action;
+
+class StatusEffectDefiance : public Sapphire::ScriptAPI::StatusEffectScript
+{
+public:
+  StatusEffectDefiance() : Sapphire::ScriptAPI::StatusEffectScript( 91 )
+  {
+  }
+
+  void onExpire( Entity::Chara& actor ) override
+  {
+    actor.removeStatusEffectById( { Unchained, Wrath, WrathII, WrathIII, WrathIV, Infuriated } );
+  }
+};
+
+EXPOSE_SCRIPT( StatusEffectDefiance );
\ No newline at end of file
diff --git a/src/scripts/statuseffect/StatusEffectUnchained.cpp b/src/scripts/statuseffect/StatusEffectUnchained.cpp
new file mode 100644
index 000000000..3a5f991e6
--- /dev/null
+++ b/src/scripts/statuseffect/StatusEffectUnchained.cpp
@@ -0,0 +1,24 @@
+#include <Script/NativeScriptApi.h>
+#include <ScriptObject.h>
+#include <Actor/Player.h>
+#include <Action/CommonAction.h>
+#include <StatusEffect/StatusEffect.h>
+
+using namespace Sapphire;
+using namespace Sapphire::World::Action;
+
+class StatusEffectUnchained : public Sapphire::ScriptAPI::StatusEffectScript
+{
+public:
+  StatusEffectUnchained() : Sapphire::ScriptAPI::StatusEffectScript( 92 )
+  {
+  }
+
+  void onExpire( Entity::Chara& actor ) override
+  {
+    if( auto status = actor.getStatusEffectById( Defiance ); status )
+      status->setModifier( Common::ParamModifier::DamageDealtPercent, -25 );
+  }
+};
+
+EXPOSE_SCRIPT( StatusEffectUnchained );
\ No newline at end of file
diff --git a/src/tools/action_parse/actions/player.json b/src/tools/action_parse/actions/player.json
index 149d05aae..e6c9cb3e7 100644
--- a/src/tools/action_parse/actions/player.json
+++ b/src/tools/action_parse/actions/player.json
@@ -1,7 +1,7 @@
 {
   "7": {
     "name": "Attack",
-    "potency": 0,
+    "potency": 110,
     "comboPotency": 0,
     "flankPotency": 0,
     "frontPotency": 0,
@@ -16,7 +16,7 @@
   },
   "8": {
     "name": "Shot",
-    "potency": 0,
+    "potency": 100,
     "comboPotency": 0,
     "flankPotency": 0,
     "frontPotency": 0,
diff --git a/src/tools/action_parse/main.cpp b/src/tools/action_parse/main.cpp
index c542eae7f..1f07de8fa 100644
--- a/src/tools/action_parse/main.cpp
+++ b/src/tools/action_parse/main.cpp
@@ -40,6 +40,8 @@ struct StatusModifier
 struct StatusEntry
 {
   uint16_t id;
+  uint32_t duration;
+  uint32_t flag;
   std::vector< StatusModifier > modifiers;
 };
 
@@ -76,6 +78,8 @@ void to_json( nlohmann::ordered_json& j, const StatusEntry& statusEntry )
 {
   j = nlohmann::ordered_json{
     { "id", statusEntry.id },
+    { "duration", statusEntry.duration },
+    { "flag", statusEntry.flag },
     { "modifiers", statusEntry.modifiers }
   };
 }
@@ -157,22 +161,20 @@ int main( int argc, char* argv[] )
     Logger::fatal( "Error setting up EXD data " );
     return 0;
   }
-  auto idList = g_exdDataGen.getIdList< Excel::Action >();
+  auto actionList = g_exdDataGen.getRows< Excel::Action >();
 
   std::map< uint32_t, ActionEntry > actions;
   std::map< uint32_t, std::vector< uint32_t > > traversedCombos;
 
-  auto total = idList.size();
+  auto total = actionList.size();
   int cursor = 0;
 
-  for( auto id : idList )
+  for( const auto& [ id, action ] : actionList )
   {
     auto done = ( cursor++ / static_cast< float >( total ) ) * 100.f;
     if( cursor % 50 == 0 && cursor > 0 )
       Logger::info( "Processing {} actions of {} ({:.2f}%)", cursor, total, done );
 
-    auto action = g_exdDataGen.getRow< Excel::Action >( id );
-
     //auto actionTransient = g_exdData.get< Sapphire::Data::ActionTransient >( id );
     if( action )
     {
diff --git a/src/tools/wiki_parse/main.cpp b/src/tools/wiki_parse/main.cpp
index 914e79831..ca12c46d7 100644
--- a/src/tools/wiki_parse/main.cpp
+++ b/src/tools/wiki_parse/main.cpp
@@ -89,11 +89,11 @@ int main( int argc, char* argv[] )
   // CFC list
   {
 
-    auto idList = g_exdDataGen.getIdList< Excel::ContentFinderCondition >();
+    auto cfcList = g_exdDataGen.getRows< Excel::ContentFinderCondition >();
 
     std::stringstream cfcOutputStream;
 
-    auto total = idList.size();
+    auto total = cfcList.size();
     int cursor = 0;
 
     std::map< uint8_t, std::string > instanceContentTypeMap;
@@ -118,7 +118,7 @@ int main( int argc, char* argv[] )
     cfcOutputStream << "| ID | Instance | Territory | Name | Type |" << std::endl
                     << "| --- | --- | --- | --- | --- |" << std::endl;
 
-    for( auto id : idList )
+    for( const auto& [ id, cfc ] : cfcList )
     {
       auto done = ( cursor++ / static_cast< float >( total ) ) * 100.f;
       if( cursor % 50 == 0 && cursor > 0 )
@@ -127,8 +127,6 @@ int main( int argc, char* argv[] )
       if( id == 0 )
         continue;
 
-      auto cfc = g_exdDataGen.getRow< Excel::ContentFinderCondition >( id );
-
       if( cfc )
       {
         auto& cfcData = cfc->data();
@@ -234,24 +232,22 @@ int main( int argc, char* argv[] )
     teriTypeIntendedUseMap[ TheFeastArea ] = "TheFeastArea";
     teriTypeIntendedUseMap[ PrivateEventArea ] = "PrivateEventArea";
 
-    auto idList = g_exdDataGen.getIdList< Excel::TerritoryType >();
+    auto teriList = g_exdDataGen.getRows< Excel::TerritoryType >();
 
     std::stringstream teritypeOutputStream;
 
     teritypeOutputStream << "| ID | Place Name | Name | Intended Use |" << std::endl
                          << "| --- | --- | --- | --- |" << std::endl;
 
-    auto total = idList.size();
+    auto total = teriList.size();
     int cursor = 0;
 
-    for( auto id : idList )
+    for( const auto& [ id, teriType ] : teriList )
     {
       auto done = ( cursor++ / static_cast< float >( total ) ) * 100.f;
       if( cursor % 50 == 0 && cursor > 0 )
         Logger::info( "Processing {} teritypes of {} ({:.2f}%)", cursor, total, done );
 
-      auto teriType = g_exdDataGen.getRow< Excel::TerritoryType >( id );
-
       if( teriType )
       {
         auto& teriTypeData = teriType->data();
@@ -291,24 +287,22 @@ int main( int argc, char* argv[] )
 
   // class/job list
   {
-    auto idList = g_exdDataGen.getIdList< Excel::ClassJob >();
+    auto classJobList = g_exdDataGen.getRows< Excel::ClassJob >();
 
     std::stringstream classjobOutputStream;
 
     classjobOutputStream << "| ID | Name | Short | Main Class |" << std::endl
                          << "| --- | --- | --- | --- |" << std::endl;
 
-    auto total = idList.size();
+    auto total = classJobList.size();
     int cursor = 0;
 
-    for( auto id : idList )
+    for( const auto& [ id, classJob ] : classJobList )
     {
       auto done = ( cursor++ / static_cast< float >( total ) ) * 100.f;
       if( cursor % 50 == 0 && cursor > 0 )
         Logger::info( "Processing {} classjobs of {} ({:.2f}%)", cursor, total, done );
 
-      auto classJob = g_exdDataGen.getRow< Excel::ClassJob >( id );
-
       if( classJob )
       {
         auto& classJobData = classJob->data();
@@ -338,7 +332,7 @@ int main( int argc, char* argv[] )
 
   // achievement list
   {
-    auto idList = g_exdDataGen.getIdList< Excel::Achievement >();
+    auto achvList = g_exdDataGen.getRows< Excel::Achievement >();
 
     enum class Type : uint8_t
     {
@@ -394,17 +388,15 @@ int main( int argc, char* argv[] )
     achvOutputStream << "| ID | Name | Type (Subtype) | Description |" << std::endl
                          << "| --- | --- | --- | --- |" << std::endl;
 
-    auto total = idList.size();
+    auto total = achvList.size();
     int cursor = 0;
 
-    for( auto id : idList )
+    for( const auto& [ id, pAchv ] : achvList )
     {
       auto done = ( cursor++ / static_cast< float >( total ) ) * 100.f;
       if( cursor % 50 == 0 && cursor > 0 )
         Logger::info( "Processing {} achievements of {} ({:.2f}%)", cursor, total, done );
 
-      auto pAchv = g_exdDataGen.getRow< Excel::Achievement >( id );
-
       if( pAchv )
       {
         auto& achvData = pAchv->data();
diff --git a/src/world/AI/Fsm/Condition.h b/src/world/AI/Fsm/Condition.h
new file mode 100644
index 000000000..11fb48046
--- /dev/null
+++ b/src/world/AI/Fsm/Condition.h
@@ -0,0 +1,95 @@
+#include <cstdint>
+#include "ForwardsZone.h"
+#include "Actor/BNpc.h"
+#include <Util/Util.h>
+#include <Util/UtilMath.h>
+
+#pragma once
+
+namespace Sapphire::World::AI::Fsm
+{
+  class Condition
+  {
+  public:
+    Condition() = default;
+    virtual ~Condition() = default;
+
+    virtual bool isConditionMet( Sapphire::Entity::BNpc& src ) const = 0;
+    virtual bool update( Sapphire::Entity::BNpc& src, float time )
+    {
+      if( isConditionMet( src ) )
+        return true;
+      return false;
+    };
+  };
+
+  class RoamNextTimeReachedCondition : public Condition
+  {
+  public:
+    bool isConditionMet( Sapphire::Entity::BNpc& src ) const override
+    {
+      if( ( Common::Util::getTimeSeconds() - src.getLastRoamTargetReachedTime() ) > 20 )
+        return true;
+      return false;
+    }
+  };
+
+  class RoamTargetReachedCondition : public Condition
+  {
+  public:
+    bool isConditionMet( Sapphire::Entity::BNpc& src ) const override
+    {
+      if( src.isRoamTargetReached() )
+        return true;
+      return false;
+    }
+  };
+
+  class HateListEmptyCondition : public Condition
+  {
+  public:
+    bool isConditionMet( Sapphire::Entity::BNpc& src ) const override
+    {
+      if( src.hateListGetHighest() )
+        return false;
+      return true;
+    }
+  };
+
+  class HateListHasEntriesCondition : public Condition
+  {
+  public:
+    bool isConditionMet( Sapphire::Entity::BNpc& src ) const override
+    {
+      if( src.hateListGetHighest() )
+        return true;
+      return false;
+    }
+  };
+
+  class SpawnPointDistanceGtMaxDistanceCondition : public Condition
+  {
+  public:
+    bool isConditionMet( Sapphire::Entity::BNpc& src ) const override
+    {
+      auto distanceOrig = Common::Util::distance( src.getPos(), src.getSpawnPos() );
+      if( distanceOrig > 40 )
+        return true;
+
+      return false;
+    }
+  };
+
+  class IsDeadCondition : public Condition
+  {
+  public:
+    bool isConditionMet( Sapphire::Entity::BNpc& src ) const override
+    {
+      if( !src.isAlive() )
+        return true;
+
+      return false;
+    }
+  };
+
+}
\ No newline at end of file
diff --git a/src/world/AI/Fsm/State.h b/src/world/AI/Fsm/State.h
new file mode 100644
index 000000000..d5739e038
--- /dev/null
+++ b/src/world/AI/Fsm/State.h
@@ -0,0 +1,43 @@
+#include <cstdint>
+#include "ForwardsZone.h"
+#include "Actor/BNpc.h"
+#include "Transition.h"
+
+#pragma once
+
+namespace Sapphire::World::AI::Fsm
+{
+  class State
+  {
+  public:
+    virtual ~State() = default;
+
+    virtual void onUpdate( Entity::BNpc& bnpc, uint64_t tickCount ) = 0;
+    virtual void onEnter( Entity::BNpc& bnpc ) { }
+    virtual void onExit( Entity::BNpc& bnpc ) { }
+
+    void addTransition( TransitionPtr transition )
+    {
+      m_transitions.push_back( transition );
+    }
+
+    void addTransition( StatePtr targetState, ConditionPtr condition )
+    {
+      m_transitions.push_back( make_Transition( targetState, condition ) );
+    }
+
+
+    TransitionPtr getTriggeredTransition( Entity::BNpc& bnpc )
+    {
+      for( auto transition : m_transitions )
+      {
+        if( transition->hasTriggered( bnpc ) )
+          return transition;
+      }
+      return nullptr;
+    }
+
+  private:
+    std::vector< TransitionPtr > m_transitions;
+  };
+}
\ No newline at end of file
diff --git a/src/world/AI/Fsm/StateCombat.cpp b/src/world/AI/Fsm/StateCombat.cpp
new file mode 100644
index 000000000..85bb4ca58
--- /dev/null
+++ b/src/world/AI/Fsm/StateCombat.cpp
@@ -0,0 +1,80 @@
+#include "StateCombat.h"
+#include "Actor/BNpc.h"
+#include "Logging/Logger.h"
+#include <Service.h>
+
+#include <Manager/TerritoryMgr.h>
+#include <Territory/Territory.h>
+#include <Navi/NaviProvider.h>
+
+using namespace Sapphire::World;
+
+void AI::Fsm::StateCombat::onUpdate( Entity::BNpc& bnpc, uint64_t tickCount )
+{
+
+  auto& teriMgr = Common::Service< World::Manager::TerritoryMgr >::ref();
+  auto pZone = teriMgr.getTerritoryByGuId( bnpc.getTerritoryId() );
+  auto pNaviProvider = pZone->getNaviProvider();
+
+  auto pHatedActor = bnpc.hateListGetHighest();
+  if( !pHatedActor )
+    return;
+
+  pNaviProvider->updateAgentParameters( bnpc );
+
+  auto distanceOrig = Common::Util::distance( bnpc.getPos(), bnpc.getSpawnPos() );
+
+  if( !pHatedActor->isAlive() || bnpc.getTerritoryId() != pHatedActor->getTerritoryId() )
+  {
+    bnpc.hateListRemove( pHatedActor );
+    pHatedActor = bnpc.hateListGetHighest();
+  }
+
+  if( !pHatedActor )
+    return;
+
+  auto distance = Common::Util::distance( bnpc.getPos(), pHatedActor->getPos() );
+
+  if( !bnpc.hasFlag( Entity::NoDeaggro ) )
+  {
+
+  }
+
+  if( !bnpc.hasFlag( Entity::Immobile ) && distance > ( bnpc.getNaviTargetReachedDistance() + pHatedActor->getRadius() ) )
+  {
+    if( pNaviProvider )
+      pNaviProvider->setMoveTarget( bnpc, pHatedActor->getPos() );
+
+    bnpc.moveTo( *pHatedActor );
+  }
+
+  pNaviProvider->syncPosToChara( bnpc );
+
+  if( distance < ( bnpc.getNaviTargetReachedDistance() + pHatedActor->getRadius() ) )
+  {
+    // todo: dont turn if facing
+    if( !bnpc.hasFlag( Entity::TurningDisabled ) )
+      bnpc.face( pHatedActor->getPos() );
+
+    if( !bnpc.checkAction() )
+      bnpc.processGambits( tickCount );
+
+    // in combat range. ATTACK!
+    if( !bnpc.hasFlag( Entity::BNpcFlag::AutoAttackDisabled ) )
+      bnpc.autoAttack( pHatedActor );
+  }
+
+}
+
+void AI::Fsm::StateCombat::onEnter( Entity::BNpc& bnpc )
+{
+}
+
+void AI::Fsm::StateCombat::onExit( Entity::BNpc& bnpc )
+{
+  bnpc.hateListClear();
+  bnpc.changeTarget( Common::INVALID_GAME_OBJECT_ID64 );
+  bnpc.setStance( Common::Stance::Passive );
+  bnpc.setOwner( nullptr );
+}
+
diff --git a/src/world/AI/Fsm/StateCombat.h b/src/world/AI/Fsm/StateCombat.h
new file mode 100644
index 000000000..9030331c9
--- /dev/null
+++ b/src/world/AI/Fsm/StateCombat.h
@@ -0,0 +1,20 @@
+#include <cstdint>
+#include "ForwardsZone.h"
+#include "Actor/BNpc.h"
+#include "State.h"
+
+#pragma once
+
+namespace Sapphire::World::AI::Fsm
+{
+  class StateCombat : public State
+  {
+  public:
+    virtual ~StateCombat() = default;
+
+    void onUpdate( Entity::BNpc& bnpc, uint64_t tickCount );
+    void onEnter( Entity::BNpc& bnpc );
+    void onExit( Entity::BNpc& bnpc );
+
+  };
+}
\ No newline at end of file
diff --git a/src/world/AI/Fsm/StateDead.cpp b/src/world/AI/Fsm/StateDead.cpp
new file mode 100644
index 000000000..15b3a6656
--- /dev/null
+++ b/src/world/AI/Fsm/StateDead.cpp
@@ -0,0 +1,26 @@
+#include "StateDead.h"
+#include "Actor/BNpc.h"
+#include "Logging/Logger.h"
+#include <Service.h>
+#include <Manager/TerritoryMgr.h>
+
+#include <Territory/Territory.h>
+#include <Navi/NaviProvider.h>
+
+using namespace Sapphire::World;
+
+void AI::Fsm::StateDead::onUpdate( Entity::BNpc& bnpc, uint64_t tickCount )
+{
+
+}
+
+void AI::Fsm::StateDead::onEnter( Entity::BNpc& bnpc )
+{
+
+}
+
+void AI::Fsm::StateDead::onExit( Entity::BNpc& bnpc )
+{
+
+}
+
diff --git a/src/world/AI/Fsm/StateDead.h b/src/world/AI/Fsm/StateDead.h
new file mode 100644
index 000000000..9051288a2
--- /dev/null
+++ b/src/world/AI/Fsm/StateDead.h
@@ -0,0 +1,20 @@
+#include <cstdint>
+#include "ForwardsZone.h"
+#include "Actor/BNpc.h"
+#include "State.h"
+
+#pragma once
+
+namespace Sapphire::World::AI::Fsm
+{
+  class StateDead : public State
+  {
+  public:
+    virtual ~StateDead() = default;
+
+    void onUpdate( Entity::BNpc& bnpc, uint64_t tickCount );
+    void onEnter( Entity::BNpc& bnpc );
+    void onExit( Entity::BNpc& bnpc );
+
+  };
+}
\ No newline at end of file
diff --git a/src/world/AI/Fsm/StateIdle.cpp b/src/world/AI/Fsm/StateIdle.cpp
new file mode 100644
index 000000000..957e4c885
--- /dev/null
+++ b/src/world/AI/Fsm/StateIdle.cpp
@@ -0,0 +1,20 @@
+#include "StateIdle.h"
+#include "Actor/BNpc.h"
+#include "Logging/Logger.h"
+
+using namespace Sapphire::World;
+
+void AI::Fsm::StateIdle::onUpdate( Entity::BNpc& bnpc, uint64_t tickCount )
+{
+
+}
+
+void AI::Fsm::StateIdle::onEnter( Entity::BNpc& bnpc )
+{
+  bnpc.setLastRoamTargetReachedTime( Common::Util::getTimeSeconds() );
+}
+
+void AI::Fsm::StateIdle::onExit( Entity::BNpc& bnpc )
+{
+}
+
diff --git a/src/world/AI/Fsm/StateIdle.h b/src/world/AI/Fsm/StateIdle.h
new file mode 100644
index 000000000..fe145bfe8
--- /dev/null
+++ b/src/world/AI/Fsm/StateIdle.h
@@ -0,0 +1,20 @@
+#include <cstdint>
+#include "ForwardsZone.h"
+#include "Actor/BNpc.h"
+#include "State.h"
+
+#pragma once
+
+namespace Sapphire::World::AI::Fsm
+{
+  class StateIdle : public State
+  {
+  public:
+    virtual ~StateIdle() = default;
+
+    void onUpdate( Entity::BNpc& bnpc, uint64_t tickCount );
+    void onEnter( Entity::BNpc& bnpc );
+    void onExit( Entity::BNpc& bnpc );
+
+  };
+}
\ No newline at end of file
diff --git a/src/world/AI/Fsm/StateMachine.cpp b/src/world/AI/Fsm/StateMachine.cpp
new file mode 100644
index 000000000..ac67ab860
--- /dev/null
+++ b/src/world/AI/Fsm/StateMachine.cpp
@@ -0,0 +1,38 @@
+#include <cstdint>
+#include "ForwardsZone.h"
+#include "Actor/BNpc.h"
+#include "StateMachine.h"
+#include "State.h"
+
+#pragma once
+
+using namespace Sapphire;
+using namespace Sapphire::World;
+
+AI::Fsm::StatePtr AI::Fsm::StateMachine::addState( Fsm::StatePtr state )
+{
+  m_states.push_back( state );
+  return state;
+}
+
+void AI::Fsm::StateMachine::setCurrentState( Fsm::StatePtr state )
+{
+  m_pCurrentState = state;
+}
+
+void AI::Fsm::StateMachine::update( Entity::BNpc& bnpc, uint64_t tickCount )
+{
+  if( !m_pCurrentState )
+    return;
+
+  TransitionPtr transition = m_pCurrentState->getTriggeredTransition( bnpc );
+
+  if( transition )
+  {
+    m_pCurrentState->onExit( bnpc );
+    m_pCurrentState = transition->getTargetState();
+    m_pCurrentState->onEnter( bnpc );
+  }
+
+  m_pCurrentState->onUpdate( bnpc, tickCount );
+}
diff --git a/src/world/AI/Fsm/StateMachine.h b/src/world/AI/Fsm/StateMachine.h
new file mode 100644
index 000000000..3156b846c
--- /dev/null
+++ b/src/world/AI/Fsm/StateMachine.h
@@ -0,0 +1,23 @@
+#include <cstdint>
+#include "ForwardsZone.h"
+#include "Actor/BNpc.h"
+
+#pragma once
+
+namespace Sapphire::World::AI::Fsm
+{
+  class StateMachine
+  {
+  public:
+    StateMachine() = default;
+    ~StateMachine() = default;
+
+    StatePtr addState( StatePtr state );
+    void setCurrentState( StatePtr state );
+    virtual void update( Entity::BNpc& bnpc, uint64_t tickCount );
+
+  protected:
+    std::vector< StatePtr > m_states;
+    StatePtr m_pCurrentState;
+  };
+}
\ No newline at end of file
diff --git a/src/world/AI/Fsm/StateRetreat.cpp b/src/world/AI/Fsm/StateRetreat.cpp
new file mode 100644
index 000000000..1f1e937da
--- /dev/null
+++ b/src/world/AI/Fsm/StateRetreat.cpp
@@ -0,0 +1,41 @@
+#include "StateRetreat.h"
+#include "Actor/BNpc.h"
+#include "Logging/Logger.h"
+#include <Service.h>
+#include <Manager/TerritoryMgr.h>
+
+#include <Territory/Territory.h>
+#include <Navi/NaviProvider.h>
+
+using namespace Sapphire::World;
+
+void AI::Fsm::StateRetreat::onUpdate( Entity::BNpc& bnpc, uint64_t tickCount )
+{
+  if( bnpc.moveTo( bnpc.getSpawnPos() ) )
+  {
+    bnpc.setRoamTargetReached( true );
+    bnpc.setLastRoamTargetReachedTime( Common::Util::getTimeSeconds() );
+  }
+}
+
+void AI::Fsm::StateRetreat::onEnter( Entity::BNpc& bnpc )
+{
+  bnpc.setRoamTargetReached( false );
+
+  auto& teriMgr = Common::Service< World::Manager::TerritoryMgr >::ref();
+  auto pZone = teriMgr.getTerritoryByGuId( bnpc.getTerritoryId() );
+  auto pNaviProvider = pZone->getNaviProvider();
+
+  bnpc.setInvincibilityType( Common::InvincibilityType::InvincibilityIgnoreDamage );
+
+  if( pNaviProvider )
+    pNaviProvider->setMoveTarget( bnpc, bnpc.getSpawnPos() );
+}
+
+void AI::Fsm::StateRetreat::onExit( Entity::BNpc& bnpc )
+{
+  bnpc.setOwner( nullptr );
+  bnpc.setRoamTargetReached( false );
+  bnpc.setInvincibilityType( Common::InvincibilityType::InvincibilityNone );
+}
+
diff --git a/src/world/AI/Fsm/StateRetreat.h b/src/world/AI/Fsm/StateRetreat.h
new file mode 100644
index 000000000..00cfe4277
--- /dev/null
+++ b/src/world/AI/Fsm/StateRetreat.h
@@ -0,0 +1,20 @@
+#include <cstdint>
+#include "ForwardsZone.h"
+#include "Actor/BNpc.h"
+#include "State.h"
+
+#pragma once
+
+namespace Sapphire::World::AI::Fsm
+{
+  class StateRetreat : public State
+  {
+  public:
+    virtual ~StateRetreat() = default;
+
+    void onUpdate( Entity::BNpc& bnpc, uint64_t tickCount );
+    void onEnter( Entity::BNpc& bnpc );
+    void onExit( Entity::BNpc& bnpc );
+
+  };
+}
\ No newline at end of file
diff --git a/src/world/AI/Fsm/StateRoam.cpp b/src/world/AI/Fsm/StateRoam.cpp
new file mode 100644
index 000000000..1b6848179
--- /dev/null
+++ b/src/world/AI/Fsm/StateRoam.cpp
@@ -0,0 +1,49 @@
+#include "StateRoam.h"
+#include "Actor/BNpc.h"
+#include "Logging/Logger.h"
+#include <Service.h>
+#include <Manager/TerritoryMgr.h>
+
+#include <Territory/Territory.h>
+#include <Navi/NaviProvider.h>
+
+using namespace Sapphire::World;
+
+void AI::Fsm::StateRoam::onUpdate( Entity::BNpc& bnpc, uint64_t tickCount )
+{
+  auto& teriMgr = Common::Service< World::Manager::TerritoryMgr >::ref();
+  auto pZone = teriMgr.getTerritoryByGuId( bnpc.getTerritoryId() );
+  auto pNaviProvider = pZone->getNaviProvider();
+
+  if( pNaviProvider )
+    pNaviProvider->setMoveTarget( bnpc, bnpc.getRoamTargetPos() );
+
+  if( bnpc.moveTo( bnpc.getRoamTargetPos() ) )
+  {
+    bnpc.setRoamTargetReached( true );
+    bnpc.setLastRoamTargetReachedTime( Common::Util::getTimeSeconds() );
+  }
+
+}
+
+void AI::Fsm::StateRoam::onEnter( Entity::BNpc& bnpc )
+{
+  auto& teriMgr = Common::Service< World::Manager::TerritoryMgr >::ref();
+  auto pZone = teriMgr.getTerritoryByGuId( bnpc.getTerritoryId() );
+  auto pNaviProvider = pZone->getNaviProvider();
+
+  if( !pNaviProvider )
+  {
+    bnpc.setRoamTargetReached( true );
+    return;
+  }
+
+  auto pos = pNaviProvider->findRandomPositionInCircle( bnpc.getSpawnPos(), bnpc.getInstanceObjectInfo()->WanderingRange );
+  bnpc.setRoamTargetPos( pos );
+}
+
+void AI::Fsm::StateRoam::onExit( Entity::BNpc& bnpc )
+{
+  bnpc.setRoamTargetReached( false );
+}
+
diff --git a/src/world/AI/Fsm/StateRoam.h b/src/world/AI/Fsm/StateRoam.h
new file mode 100644
index 000000000..6f9ba3ca9
--- /dev/null
+++ b/src/world/AI/Fsm/StateRoam.h
@@ -0,0 +1,20 @@
+#include <cstdint>
+#include "ForwardsZone.h"
+#include "Actor/BNpc.h"
+#include "State.h"
+
+#pragma once
+
+namespace Sapphire::World::AI::Fsm
+{
+  class StateRoam : public State
+  {
+  public:
+    virtual ~StateRoam() = default;
+
+    void onUpdate( Entity::BNpc& bnpc, uint64_t tickCount );
+    void onEnter( Entity::BNpc& bnpc );
+    void onExit( Entity::BNpc& bnpc );
+
+  };
+}
\ No newline at end of file
diff --git a/src/world/AI/Fsm/Transition.h b/src/world/AI/Fsm/Transition.h
new file mode 100644
index 000000000..f5bd3b2fe
--- /dev/null
+++ b/src/world/AI/Fsm/Transition.h
@@ -0,0 +1,22 @@
+#include <cstdint>
+#include "ForwardsZone.h"
+#include "Actor/BNpc.h"
+#include "AI/Fsm/Condition.h"
+
+#pragma once
+
+namespace Sapphire::World::AI::Fsm
+{
+  class Transition
+  {
+  public:
+    Transition( StatePtr targetState, ConditionPtr condition ) : m_pTargetState( targetState ), m_pCondition( condition ) { }
+    virtual ~Transition() = default;
+
+    StatePtr getTargetState() { return m_pTargetState; }
+    bool hasTriggered( Entity::BNpc& bnpc ) { return m_pCondition->isConditionMet( bnpc ); }
+  private:
+    StatePtr m_pTargetState;
+    ConditionPtr m_pCondition;
+  };
+}
\ No newline at end of file
diff --git a/src/world/AI/GambitPack.cpp b/src/world/AI/GambitPack.cpp
new file mode 100644
index 000000000..03a8e0de5
--- /dev/null
+++ b/src/world/AI/GambitPack.cpp
@@ -0,0 +1,135 @@
+#include <cstdint>
+#include <ForwardsZone.h>
+#include <Service.h>
+#include <Manager/ActionMgr.h>
+#include <Action/Action.h>
+#include "GambitTargetCondition.h"
+#include "GambitRule.h"
+#include "GambitPack.h"
+
+using namespace Sapphire;
+using namespace Sapphire::World;
+
+AI::GambitTimeLinePack::GambitTimeLinePack( int8_t loopCount ) :
+  GambitPack( GambitPackType::TimeLine ),
+  m_loopCount( loopCount ),
+  m_currentIndex( 0 ),
+  m_currentLoop( 0 ),
+  m_startTimeMs( 0 )
+{
+
+}
+
+void AI::GambitTimeLinePack::start()
+{
+  m_startTimeMs = Common::Util::getTimeMs();
+}
+
+void AI::GambitTimeLinePack::addTimeLine( const GambitRulePtr& pRule, uint32_t offsetInSeconds )
+{
+  auto timeLine = std::make_pair( pRule, offsetInSeconds );
+  m_gambits.push_back( timeLine );
+}
+
+void AI::GambitTimeLinePack::addTimeLine( const GambitTargetConditionPtr& targetCondition, const Action::ActionPtr& action, uint32_t offsetInSeconds )
+{
+  auto pRule = make_GambitRule( targetCondition, action, 0 );
+  auto timeLine = std::make_pair( pRule, offsetInSeconds );
+  m_gambits.push_back( timeLine );
+}
+
+uint8_t AI::GambitTimeLinePack::getLoopCount() const
+{
+  return m_loopCount;
+}
+
+uint8_t AI::GambitTimeLinePack::getCurrentIndex() const
+{
+  return m_currentIndex;
+}
+
+void AI::GambitTimeLinePack::update( Entity::BNpc& bnpc, uint64_t tickCount )
+{
+  if( m_startTimeMs == 0 || m_gambits.empty() )
+    return;
+
+  auto& actionMgr = Common::Service< World::Manager::ActionMgr >::ref();
+
+  if( m_gambits.size() <= m_currentIndex )
+  {
+    if( m_currentLoop < m_loopCount || m_loopCount == -1 )
+    {
+      m_currentIndex = 0;
+      m_currentLoop++;
+      m_startTimeMs = Common::Util::getTimeMs();
+    }
+    else
+    {
+      m_startTimeMs = 0;
+      m_currentLoop = 0;
+      return;
+    }
+  }
+
+  auto currentTimeLine = m_gambits.at( m_currentIndex );
+  auto& pRule = currentTimeLine.first;
+  auto offset = currentTimeLine.second * 1000;
+
+  if( tickCount - m_startTimeMs >= offset )
+  {
+    if( pRule->getGambitTargetCondition()->isConditionMet( bnpc ) )
+    {
+      pRule->setLastExecutionMs( tickCount );
+      actionMgr.handleTargetedAction( bnpc, pRule->getActionPtr()->getId(), pRule->getGambitTargetCondition()->getTarget()->getId(), 0 );
+    }
+    m_currentIndex++;
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+AI::GambitRuleSetPack::GambitRuleSetPack() : GambitPack( GambitPackType::RuleSetList )
+{
+
+}
+
+void AI::GambitRuleSetPack::addRule( const GambitRulePtr& pRule )
+{
+  m_gambits.push_back( pRule );
+}
+
+void AI::GambitRuleSetPack::addRule( const GambitTargetConditionPtr& targetCondition, const Action::ActionPtr& action, uint32_t coolDown )
+{
+  auto pRule = make_GambitRule( targetCondition, action, coolDown );
+  m_gambits.push_back( pRule );
+}
+
+void AI::GambitRuleSetPack::update( Entity::BNpc& bnpc, uint64_t tickCount )
+{
+  auto& actionMgr = Common::Service< World::Manager::ActionMgr >::ref();
+  for( auto& gambitRule : m_gambits )
+  {
+    if( !gambitRule->isEnabled() )
+      continue;
+
+    if( ( tickCount - gambitRule->getLastExecutionMs() ) > gambitRule->getCoolDown() )
+    {
+      if( !gambitRule->getGambitTargetCondition()->isConditionMet( bnpc ) )
+        continue;
+
+      gambitRule->setLastExecutionMs( tickCount );
+      actionMgr.handleTargetedAction( bnpc, gambitRule->getActionPtr()->getId(), gambitRule->getGambitTargetCondition()->getTarget()->getId(), 0 );
+      break;
+    }
+  }
+}
+
+AI::GambitTimeLinePackPtr AI::GambitPack::getAsTimeLine()
+{
+  return std::dynamic_pointer_cast< GambitTimeLinePack, GambitPack >( shared_from_this() );
+}
+
+AI::GambitRuleSetPackPtr AI::GambitPack::getAsRuleSet()
+{
+  return std::dynamic_pointer_cast< GambitRuleSetPack, GambitPack >( shared_from_this() );
+}
diff --git a/src/world/AI/GambitPack.h b/src/world/AI/GambitPack.h
new file mode 100644
index 000000000..caf62f9c1
--- /dev/null
+++ b/src/world/AI/GambitPack.h
@@ -0,0 +1,60 @@
+#include <cstdint>
+#include <ForwardsZone.h>
+#include "GambitTargetCondition.h"
+#include "GambitRule.h"
+
+#pragma once
+
+namespace Sapphire::World::AI
+{
+  enum class GambitPackType : uint8_t
+  {
+    None,
+    RuleSetList,
+    TimeLine
+  };
+
+  class GambitPack : public std::enable_shared_from_this< GambitPack >
+  {
+  public:
+    GambitPack( GambitPackType type ) : m_type( type ) { };
+    virtual ~GambitPack() = default;
+    GambitPackType getType() const { return m_type; }
+    virtual void update( Entity::BNpc& bnpc, uint64_t tickCount ) = 0;
+    GambitTimeLinePackPtr getAsTimeLine();
+    GambitRuleSetPackPtr getAsRuleSet();
+  private:
+    GambitPackType m_type;
+  };
+
+  class GambitTimeLinePack : public GambitPack
+  {
+  public:
+    GambitTimeLinePack( int8_t loopCount );
+    void update( Entity::BNpc& bnpc, uint64_t tickCount );
+    void addTimeLine( const GambitRulePtr& pRule, uint32_t offsetInSeconds );
+    void addTimeLine( const GambitTargetConditionPtr& targetCondition, const Action::ActionPtr& action, uint32_t offsetInSeconds );
+    uint8_t getLoopCount() const;
+    uint8_t getCurrentIndex() const;
+    void start();
+
+  private:
+    std::vector< std::pair< GambitRulePtr, uint32_t > > m_gambits;
+
+    uint64_t m_startTimeMs;
+    uint8_t m_currentIndex;
+    int8_t m_loopCount;
+    uint8_t m_currentLoop;
+  };
+
+  class GambitRuleSetPack : public GambitPack
+  {
+  public:
+    GambitRuleSetPack();
+    void addRule( const GambitRulePtr& pRule );
+    void addRule( const GambitTargetConditionPtr& targetCondition, const Action::ActionPtr& action, uint32_t coolDown );
+    void update( Entity::BNpc& bnpc, uint64_t tickCount );
+  private:
+    std::vector< GambitRulePtr > m_gambits;
+  };
+}
\ No newline at end of file
diff --git a/src/world/AI/GambitRule.cpp b/src/world/AI/GambitRule.cpp
new file mode 100644
index 000000000..9fb40e63c
--- /dev/null
+++ b/src/world/AI/GambitRule.cpp
@@ -0,0 +1,52 @@
+#include <cstdint>
+#include <ForwardsZone.h>
+#include "GambitTargetCondition.h"
+#include "GambitRule.h"
+
+using namespace Sapphire;
+using namespace Sapphire::World;
+
+AI::GambitRule::GambitRule( const GambitTargetConditionPtr targetCondition, Action::ActionPtr action, uint32_t coolDown ) :
+  m_targetCondition( targetCondition ),
+  m_pAction( std::move( action ) ),
+  m_lastExecutionMs( 0 ),
+  m_coolDownMs( coolDown ),
+  m_isEnabled( true )
+{
+
+}
+
+void AI::GambitRule::toggleEnabled()
+{
+  m_isEnabled = !m_isEnabled;
+}
+
+bool AI::GambitRule::isEnabled() const
+{
+  return m_isEnabled;
+}
+
+uint64_t AI::GambitRule::getLastExecutionMs() const
+{
+  return m_lastExecutionMs;
+}
+
+void AI::GambitRule::setLastExecutionMs( uint64_t lastExecution )
+{
+  m_lastExecutionMs = lastExecution;
+}
+
+uint32_t AI::GambitRule::getCoolDown() const
+{
+  return m_coolDownMs;
+}
+
+AI::GambitTargetConditionPtr AI::GambitRule::getGambitTargetCondition()
+{
+  return m_targetCondition;
+}
+
+Action::ActionPtr AI::GambitRule::getActionPtr()
+{
+  return m_pAction;
+}
\ No newline at end of file
diff --git a/src/world/AI/GambitRule.h b/src/world/AI/GambitRule.h
new file mode 100644
index 000000000..c8a436487
--- /dev/null
+++ b/src/world/AI/GambitRule.h
@@ -0,0 +1,33 @@
+#include <cstdint>
+#include <ForwardsZone.h>
+#include "GambitTargetCondition.h"
+
+#pragma once
+
+namespace Sapphire::World::AI
+{
+  class GambitRule
+  {
+  public:
+    GambitRule( GambitTargetConditionPtr targetCondition, Action::ActionPtr action, uint32_t coolDown );
+    ~GambitRule() = default;
+
+    bool isEnabled() const;
+    void toggleEnabled();
+
+    uint64_t getLastExecutionMs() const;
+    void setLastExecutionMs( uint64_t lastExecution );
+
+    uint32_t getCoolDown() const;
+
+    GambitTargetConditionPtr getGambitTargetCondition();
+
+    Action::ActionPtr getActionPtr();
+  private:
+    GambitTargetConditionPtr m_targetCondition;
+    Action::ActionPtr m_pAction;
+    uint32_t m_coolDownMs;
+    uint64_t m_lastExecutionMs;
+    bool m_isEnabled;
+  };
+}
\ No newline at end of file
diff --git a/src/world/AI/GambitTargetCondition.h b/src/world/AI/GambitTargetCondition.h
new file mode 100644
index 000000000..931b579d6
--- /dev/null
+++ b/src/world/AI/GambitTargetCondition.h
@@ -0,0 +1,65 @@
+#include <cstdint>
+#include <ForwardsZone.h>
+#include <Actor/BNpc.h>
+
+#pragma once
+
+namespace Sapphire::World::AI
+{
+  enum GambitTargetType : uint8_t
+  {
+    Self,
+    Player,
+    PlayerAndAlly,
+    Ally,
+    BNpc
+  };
+
+  class GambitTargetCondition
+  {
+  public:
+    GambitTargetCondition() = default;
+    virtual ~GambitTargetCondition() = default;
+
+    virtual bool isConditionMet( Sapphire::Entity::BNpc& src ) { return false; };
+    Sapphire::Entity::CharaPtr getTarget() const { return m_pTarget; };
+  protected:
+    Sapphire::Entity::CharaPtr m_pTarget;
+  };
+
+  class TopHateTargetCondition : public GambitTargetCondition
+  {
+  public:
+    TopHateTargetCondition() = default;
+
+    bool isConditionMet( Sapphire::Entity::BNpc& src ) override
+    {
+      auto foundChara = src.hateListGetHighest();
+      if( foundChara )
+      {
+        m_pTarget = foundChara;
+        return true;
+      }
+      return false;
+    };
+  };
+
+  class HPSelfPctLessThanTargetCondition : public GambitTargetCondition
+  {
+  public:
+    HPSelfPctLessThanTargetCondition( uint8_t pct ) : m_HpPct( pct ) {};
+
+    bool isConditionMet( Sapphire::Entity::BNpc& src ) override
+    {
+      if( src.getHpPercent() < m_HpPct )
+      {
+        m_pTarget = src.getAsBNpc();
+        return true;
+      }
+      return false;
+    };
+  private:
+    uint8_t m_HpPct;
+  };
+
+}
\ No newline at end of file
diff --git a/src/world/AI/TargetHelper.cpp b/src/world/AI/TargetHelper.cpp
new file mode 100644
index 000000000..aef8433ea
--- /dev/null
+++ b/src/world/AI/TargetHelper.cpp
@@ -0,0 +1,271 @@
+#include "TargetHelper.h"
+
+#include <algorithm>
+
+#include <Actor/BNpc.h>
+#include <Actor/Chara.h>
+#include <Actor/Player.h>
+#include <Manager/PartyMgr.h>
+#include <Manager/RNGMgr.h>
+#include <Util/UtilMath.h>
+#include <Service.h>
+
+namespace Sapphire::World::AI
+{
+
+  bool InsideRadiusFilter::isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const
+  {
+    bool ret = Common::Util::distance( pSrc->getPos(), pTarget->getPos() ) <= m_distance;
+    return m_negate ? !ret : ret;
+  }
+
+  bool OutsideRadiusFilter::isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const
+  {
+    bool ret = Common::Util::distance( pSrc->getPos(), pTarget->getPos() ) >= m_distance;
+    return m_negate ? !ret : ret;
+  }
+
+  bool PlayerFilter::isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const
+  {
+    bool ret = pTarget->isPlayer();
+    return m_negate ? !ret : ret;
+  }
+
+  bool AllyFilter::isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const
+  {
+    bool ret = false;
+    // todo: pets, companions, enpc
+    if( pSrc->isPlayer() )
+    {
+      auto pBNpcTarget = pTarget->getAsBNpc();
+      if( pBNpcTarget && pBNpcTarget->getEnemyType() == 0 )
+        ret = true;
+      else if( pTarget->isPlayer() )
+        ret = true;
+    }
+    else if( pSrc->isBattleNpc() )
+    {
+      auto pBNpcTarget = pTarget->getAsBNpc();
+      if( pBNpcTarget && pBNpcTarget->getEnemyType() == 0 )
+        ret = true;
+      else if( pTarget->isPlayer() )
+        ret = true;
+    }
+
+    return m_negate ? !ret : ret;
+  }
+
+  bool OwnBattalionFilter::isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const
+  {
+    return false;
+  }
+
+  bool TankFilter::isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const
+  {
+    bool ret = pTarget->getRole() == Common::Role::Tank;
+    return m_negate ? !ret : ret;
+  }
+
+  bool HealerFilter::isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const
+  {
+    bool ret = pTarget->getRole() == Common::Role::Healer;
+    return m_negate ? !ret : ret;
+  }
+
+  bool DpsFilter::isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const
+  {
+    bool ret = true;
+    switch( pTarget->getRole() )
+    {
+      case Common::Role::Melee:
+      case Common::Role::RangedMagical:
+      case Common::Role::RangedPhysical:
+        ret = true;
+        break;
+      default:
+        ret = false;
+        break;
+    }
+    return m_negate ? !ret : ret;
+  }
+
+  bool HasStatusEffectFilter::isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const
+  {
+    auto ret = pTarget->hasStatusEffect( m_statusId );
+    return m_negate ? !ret : ret;
+  }
+
+  bool TopAggroFilter::isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const
+  {
+    auto pBNpc = pSrc->getAsBNpc();
+    bool ret = false;
+    if( pBNpc )
+    {
+      ret = pBNpc->hateListGetHighest() == pTarget;
+    }
+    return m_negate ? !ret : ret;
+  }
+
+  bool SecondAggroFilter::isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const
+  {
+    auto pBNpc = pSrc->getAsBNpc();
+    bool ret = false;
+    if( pBNpc )
+    {
+      // todo: this is so dumb
+
+      auto hateList = pBNpc->getHateList();
+      std::vector sorted( hateList.begin(), hateList.end() );
+      std::sort( sorted.begin(), sorted.end(), []( Entity::HateListEntryPtr a, Entity::HateListEntryPtr b ) {
+        return a->m_hateAmount > b->m_hateAmount; } );
+
+      Entity::CharaPtr pChara = nullptr;
+      auto topIt = sorted.begin();
+      if( topIt != sorted.end() && ++topIt != sorted.end() )
+        pChara = topIt->get()->m_pChara;
+
+      ret = pChara == pTarget;
+    }
+    return m_negate ? !ret : ret;
+  }
+
+  bool PartyMemberFilter::isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const
+  {
+    bool ret = false;
+    // todo: pets, companions, enpc
+    if( auto pPlayer = pSrc->getAsPlayer() )
+    {
+      if( auto pTargetPlayer = pTarget->getAsPlayer() )
+      {
+        ret = pPlayer->getPartyId() == pTargetPlayer->getPartyId();
+      }
+      else if( auto pBNpc = pTarget->getAsBNpc() )
+      {
+        ret = pBNpc->getBNpcType() == 0;
+      }
+    }
+    else if( auto pBNpc = pSrc->getAsBNpc() )
+    {
+      if( auto pTargetPlayer = pTarget->getAsPlayer() )
+      {
+        ret = pPlayer->getPartyId() == pTargetPlayer->getPartyId();
+      }
+      else if( auto pTargetBNpc = pTarget->getAsBNpc() )
+      {
+        ret = pBNpc->getBNpcType() == pTargetBNpc->getEnemyType();
+      }
+    }
+    return m_negate ? !ret : ret;
+  }
+
+  void Snapshot::createSnapshot( Entity::CharaPtr pSrc, const std::set< Entity::GameObjectPtr >& inRange,
+                                 uint32_t count, bool fillWithRandom,
+                                 const std::vector< TargetSelectFilterPtr >& filters,
+                                 const std::vector< uint32_t >& exclude )
+  {
+    m_results.clear();
+    m_targetIds.clear();
+
+    auto& RNGMgr = Common::Service< World::Manager::RNGMgr >::ref();
+    for( const auto& pActor : inRange )
+    {
+      auto pChara = pActor->getAsChara();
+      if( pChara == nullptr )
+        continue;
+
+      // exclude this character from the result set
+      auto excludeIt = std::find_if( exclude.begin(), exclude.end(),
+        [ pChara ]( uint32_t id ) { return pChara->getId() == id; }
+      );
+      if( excludeIt != exclude.end() )
+        continue;
+
+      bool matches = true;
+      for( const auto& filter : filters )
+      {
+        if( !filter->isApplicable( pSrc, pChara ) )
+        {
+          matches = false;
+          break;
+        }
+      }
+
+      if( matches )
+      {
+        CharaEntry entry{};
+        entry.m_entityId = pChara->getId();
+        entry.m_pos = pChara->getPos();
+        entry.m_rot = pChara->getRot();
+
+        m_results.push_back( entry );
+        if( m_results.size() == count ) break;
+      }
+    }
+
+    // fallback to fill with random entries if we dont have enough valid results
+    if( fillWithRandom && m_results.size() < count )
+    {
+      std::vector< Entity::CharaPtr > remaining;
+      for( const auto& pActor : inRange )
+      {
+        auto pChara = pActor->getAsChara();
+        if( pChara == nullptr )
+          continue;
+
+        auto excludeIt = std::find_if( exclude.begin(), exclude.end(),
+          [ pChara ]( uint32_t id ) { return pChara->getId() == id; }
+        );
+
+        if( excludeIt == exclude.end() && std::find_if( m_results.begin(), m_results.end(),
+            [ &pChara ]( CharaEntry entry ) { return entry.m_entityId == pChara->getId(); } ) == m_results.end() )
+        {
+          remaining.push_back( pChara );
+        }
+      }
+      while( m_results.size() < count && !remaining.empty() )
+      {
+        // idk
+        std::shuffle( remaining.begin(), remaining.end(), *RNGMgr.getRNGEngine() );
+
+        auto pChara = remaining.back();
+        CharaEntry entry{};
+        entry.m_entityId = pChara->getId();
+        entry.m_pos = pChara->getPos();
+        entry.m_rot = pChara->getRot();
+        m_results.emplace_back( entry );
+        remaining.pop_back();
+      }
+    }
+
+    // sort by distance at the end always
+    const auto& srcPos = pSrc->getPos();
+    std::sort( m_results.begin(), m_results.end(),
+      [ srcPos ]( CharaEntry l, CharaEntry r )
+      {
+        return Common::Util::distance( srcPos, l.m_pos ) < Common::Util::distance( srcPos, r.m_pos );
+      }
+    );
+
+    // we might want the target ids separately
+    m_targetIds.resize( m_results.size() );
+    for( auto i = 0; i < m_results.size(); ++i )
+      m_targetIds[ i ] = m_results[ i ].m_entityId;
+  }
+
+  const std::vector< Snapshot::CharaEntry >& Snapshot::getResults() const
+  {
+    return m_results;
+  }
+
+  const std::vector< uint32_t >& Snapshot::getTargetIds() const
+  {
+    return m_targetIds;
+  }
+
+  void Snapshot::clearResults()
+  {
+    m_results.clear();
+    m_targetIds.clear();
+  }
+
+};// namespace Sapphire::World::AI
\ No newline at end of file
diff --git a/src/world/AI/TargetHelper.h b/src/world/AI/TargetHelper.h
new file mode 100644
index 000000000..772fdc38b
--- /dev/null
+++ b/src/world/AI/TargetHelper.h
@@ -0,0 +1,249 @@
+#ifndef _TARGETHELPER_H
+#define _TARGETHELPER_H
+
+#include <memory>
+#include <unordered_map>
+#include <set>
+#include <vector>
+
+#include <ForwardsZone.h>
+
+namespace Sapphire::World::AI
+{
+  //
+  // Filters
+  //
+  class TargetSelectFilter :
+    public std::enable_shared_from_this< TargetSelectFilter >
+  {
+  public:
+    enum class Type
+    {
+      InsideRadius,
+      OutsideRadius,
+
+      Player,
+      Ally,
+      OwnBattalion,
+
+      Tank,
+      Healer,
+      Dps,
+
+      HasStatusEffect,
+
+      TopAggro,
+      SecondAggro,
+
+      PartyMember,
+
+      AllianceA,
+      AllianceB,
+      AllianceC
+    };
+
+  protected:
+    Type m_type;
+    bool m_negate{ false };
+
+  public:
+    TargetSelectFilter( Type type, bool negate ) :
+      m_type( type ),
+      m_negate( negate )
+    {
+    }
+    virtual ~TargetSelectFilter()
+    {
+    }
+
+    virtual bool isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const
+    {
+      return false;
+    };
+
+    bool isNegate() const
+    {
+      return m_negate;
+    }
+  };
+  using TargetSelectFilterPtr = std::shared_ptr< TargetSelectFilter >;
+
+  class InsideRadiusFilter : public TargetSelectFilter
+  {
+  private:
+    float m_distance{ 0 };
+
+  public:
+    InsideRadiusFilter( float distance, bool negate ) :
+      TargetSelectFilter( Type::InsideRadius, negate ),
+      m_distance( distance )
+    {
+    }
+
+    bool isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const override;
+  };
+
+  class OutsideRadiusFilter : public TargetSelectFilter
+  {
+  private:
+    float m_distance{ 0 };
+  public:
+    OutsideRadiusFilter( float distance, bool negate ) :
+      TargetSelectFilter( Type::OutsideRadius, negate ),
+      m_distance( distance )
+    {
+    }
+
+    bool isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const override;
+  };
+
+  class PlayerFilter : public TargetSelectFilter
+  {
+  public:
+    PlayerFilter( bool negate ) :
+      TargetSelectFilter( Type::Player, negate )
+    {
+    }
+
+    bool isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const override;
+  };
+
+  class AllyFilter : public TargetSelectFilter
+  {
+  public:
+    AllyFilter( bool negate ) :
+      TargetSelectFilter( Type::Ally, negate )
+    {
+    }
+
+    bool isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const override;
+  };
+
+  class OwnBattalionFilter : public TargetSelectFilter
+  {
+  public:
+    OwnBattalionFilter( bool negate ) :
+      TargetSelectFilter( Type::OwnBattalion, negate )
+    {
+    }
+
+    bool isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const override;
+  };
+
+  class TankFilter : public TargetSelectFilter
+  {
+  public:
+    TankFilter( bool negate ) :
+      TargetSelectFilter( Type::Tank, negate )
+    {
+    }
+
+    bool isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const override;
+  };
+
+  class HealerFilter : public TargetSelectFilter
+  {
+  public:
+    HealerFilter( bool negate ) :
+      TargetSelectFilter( Type::Healer, negate )
+    {
+    }
+
+    bool isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const override;
+  };
+
+  class DpsFilter : public TargetSelectFilter
+  {
+  public:
+    DpsFilter( bool negate ) :
+      TargetSelectFilter( Type::Dps, negate )
+    {
+    }
+
+    bool isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const override;
+  };
+
+  class HasStatusEffectFilter : public TargetSelectFilter
+  {
+  private:
+    uint32_t m_statusId{ 0 };
+  public:
+    HasStatusEffectFilter( uint32_t statusId, bool negate ) :
+      TargetSelectFilter( Type::HasStatusEffect, negate ),
+      m_statusId( statusId )
+    {
+    }
+
+    bool isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const override;
+  };
+
+  class TopAggroFilter : public TargetSelectFilter
+  {
+  public:
+    TopAggroFilter( bool negate ) :
+      TargetSelectFilter( Type::TopAggro, negate )
+    {
+    }
+
+    bool isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const override;
+  };
+
+  class SecondAggroFilter : public TargetSelectFilter
+  {
+  public:
+    SecondAggroFilter( bool negate ) :
+      TargetSelectFilter( Type::SecondAggro, negate )
+    {
+    }
+
+    bool isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const override;
+  };
+
+  class PartyMemberFilter : public TargetSelectFilter
+  {
+  public:
+    PartyMemberFilter( bool negate ) :
+      TargetSelectFilter( Type::PartyMember, negate )
+    {
+    }
+
+    bool isApplicable( Entity::CharaPtr& pSrc, Entity::CharaPtr& pTarget ) const override;
+  };
+
+  //
+  // Helpers
+  //
+  class Snapshot :
+    public std::enable_shared_from_this< Snapshot >
+  {
+  public:
+    struct CharaEntry
+    {
+      uint32_t m_entityId;
+      Common::FFXIVARR_POSITION3 m_pos;
+      float m_rot;
+      // todo: status effects?
+    };
+    using Results = std::vector< CharaEntry >;
+    using TargetIds = std::vector< uint32_t >;
+  private:
+    std::vector< CharaEntry > m_results;
+    std::vector< uint32_t > m_targetIds;
+
+  public:
+    Snapshot() {}
+
+    void createSnapshot( Entity::CharaPtr pSrc, const std::set< Entity::GameObjectPtr >& inRange,
+                         uint32_t count, bool fillWithRandom,
+                         const std::vector< TargetSelectFilterPtr >& filters,
+                         const std::vector< uint32_t >& exclude = {} );
+
+    // returns actors sorted by distance
+    const std::vector< CharaEntry >& getResults() const;
+    const std::vector< uint32_t >& getTargetIds() const;
+    void clearResults();
+  };
+  using SnapshotPtr = std::shared_ptr< Snapshot >;
+}// namespace Sapphire::World::AI
+
+#endif
\ No newline at end of file
diff --git a/src/world/Action/Action.cpp b/src/world/Action/Action.cpp
index d78ebe2e6..544d6af44 100644
--- a/src/world/Action/Action.cpp
+++ b/src/world/Action/Action.cpp
@@ -16,6 +16,7 @@
 
 #include "Manager/PlayerMgr.h"
 #include "Manager/MgrUtil.h"
+#include "Manager/TerritoryMgr.h"
 
 #include "Session.h"
 #include "Network/GameConnection.h"
@@ -23,7 +24,7 @@
 #include "Network/PacketWrappers/ActorControlPacket.h"
 #include "Network/PacketWrappers/ActorControlSelfPacket.h"
 #include "Network/PacketWrappers/ActorControlTargetPacket.h"
-#include "Network/Util/PlayerUtil.h"
+#include "Network/Util/PacketUtil.h"
 
 #include <Logging/Logger.h>
 
@@ -31,6 +32,8 @@
 #include <Service.h>
 #include "WorldServer.h"
 
+#include "Job/Warrior.h"
+
 using namespace Sapphire;
 using namespace Sapphire::Common;
 using namespace Sapphire::Network;
@@ -65,6 +68,16 @@ uint32_t Action::Action::getId() const
   return m_id;
 }
 
+uint32_t Action::Action::getResultId() const
+{
+  return m_resultId;
+}
+
+std::shared_ptr< Excel::ExcelStruct< Excel::Action > > Action::Action::getActionData() const
+{
+  return m_actionData;
+}
+
 bool Action::Action::init()
 {
   if( !m_actionData )
@@ -78,14 +91,18 @@ bool Action::Action::init()
 
     m_actionData = actionData;
   }
+  auto teriMgr = Common::Service< Manager::TerritoryMgr >::ref();
+  auto zone = teriMgr.getTerritoryByGuId( m_pSource->getTerritoryId() );
+  m_resultId = zone->getNextActionResultId();
 
-  m_effectBuilder = make_EffectBuilder( m_pSource, getId(), m_requestId );
+  m_actionResultBuilder = make_ActionResultBuilder( m_pSource, getId(), m_resultId, m_requestId );
 
   m_castTimeMs = static_cast< uint32_t >( m_actionData->data().CastTime * 100 );
   m_recastTimeMs = static_cast< uint32_t >( m_actionData->data().RecastTime * 100 );
   m_cooldownGroup = m_actionData->data().RecastGroup;
   m_range = m_actionData->data().SelectRange;
   m_effectRange = m_actionData->data().EffectRange;
+  m_effectWidth = m_actionData->data().EffectWidth;
   m_category = static_cast< Common::ActionCategory >( m_actionData->data().Category );
   m_castType = static_cast< Common::CastType >( m_actionData->data().EffectType );
   m_aspect = static_cast< Common::ActionAspect >( m_actionData->data().AttackType );
@@ -105,9 +122,9 @@ bool Action::Action::init()
     {
       case Common::ClassJob::Bard:
       case Common::ClassJob::Archer:
+      case Common::ClassJob::Machinist:
         m_range = 25;
         break;
-        // anything that isnt ranged
       default:
         m_range = 3;
         break;
@@ -117,7 +134,7 @@ bool Action::Action::init()
   m_primaryCostType = static_cast< Common::ActionPrimaryCostType >( m_actionData->data().CostType );
   m_primaryCost = m_actionData->data().CostValue;
 
-  /*if( !m_actionData->targetArea )
+  if( !m_actionData->data().SelectGround )
   {
     // override pos to target position
     // todo: this is kinda dirty
@@ -129,7 +146,7 @@ bool Action::Action::init()
         break;
       }
     }
-  }*/
+  }
 
   // todo: add missing rows for secondaryCostType/secondaryCostType and rename the current rows to primaryCostX
 
@@ -164,6 +181,16 @@ const Common::FFXIVARR_POSITION3& Action::Action::getPos() const
   return m_pos;
 }
 
+void Action::Action::setRot( float rot )
+{
+  m_rot = rot;
+}
+
+float Action::Action::getRot() const
+{
+  return m_rot;
+}
+
 void Action::Action::setTargetId( uint64_t targetId )
 {
   m_targetId = targetId;
@@ -241,34 +268,34 @@ bool Action::Action::update()
     // todo: check if the target is still in range
   }
 
-  uint64_t tickCount = Common::Util::getTimeMs();
-  uint32_t castTime = m_castTimeMs;
+  auto tickCount = static_cast< time_t >( Common::Util::getTimeMs() );
+  auto startTime = static_cast< time_t >( m_startTime );
+  uint64_t castTime = m_castTimeMs;
 
   if( auto player = m_pSource->getAsPlayer() )
   {
-    uint64_t lastActionTick = player->getLastActionTick();
+    auto lastActionTick = static_cast< time_t >( player->getLastActionTick() );
     uint32_t lastTickMs = 0;
     if( lastActionTick > 0 )
     {
-      lastTickMs = static_cast< uint32_t >( std::difftime( static_cast< time_t >( tickCount ), static_cast< time_t >( lastActionTick ) ) );
+      lastTickMs = static_cast< uint32_t >( std::difftime( tickCount, lastActionTick ) );
       if( lastTickMs > 100 ) //max 100ms
         lastTickMs = 100;
     }
 
     player->setLastActionTick( tickCount );
-    uint32_t delayMs = 100 - lastTickMs;
+    uint64_t delayMs = 100 - lastTickMs;
     castTime = ( m_castTimeMs + delayMs );
-    m_castTimeRestMs = static_cast< uint64_t >( m_castTimeMs ) -
-                       static_cast< uint64_t >( std::difftime( static_cast< time_t >( tickCount ), static_cast< time_t >( m_startTime ) ) );
+    m_castTimeRestMs = static_cast< uint64_t >( m_castTimeMs ) - static_cast< uint64_t >( std::difftime( tickCount, startTime ) );
   }
 
-  if( !hasCastTime() || std::difftime( static_cast< time_t >( tickCount ), static_cast< time_t >( m_startTime ) ) > castTime )
+  if( !hasCastTime() || std::difftime( tickCount, startTime ) > castTime )
   {
     execute();
     return true;
   }
 
-  if( m_pTarget == nullptr && m_targetId != 0 )
+  if( !m_pTarget && m_targetId != 0 )
   {
     // try to search for the target actor
     for( const auto& actor : m_pSource->getInRangeActors( true ) )
@@ -281,7 +308,7 @@ bool Action::Action::update()
     }
   }
 
-  if( m_pTarget != nullptr && !m_pTarget->isAlive() )
+  if( m_pTarget && !m_pTarget->isAlive() )
   {
     // interrupt the cast if target died
     setInterrupted( Common::ActionInterruptType::RegularInterrupt );
@@ -310,25 +337,25 @@ void Action::Action::start()
     data.CastTime = static_cast< float >( m_castTimeMs ) / 1000.f;
     data.Target = static_cast< uint32_t >( m_targetId );
 
-    data.TargetPos[ 0 ] = Common::Util::floatToUInt16( m_pSource->getPos().x );
-    data.TargetPos[ 1 ] = Common::Util::floatToUInt16( m_pSource->getPos().y );
-    data.TargetPos[ 2 ] = Common::Util::floatToUInt16( m_pSource->getPos().z );
-    data.Dir = m_pSource->getRot();
+    data.TargetPos[ 0 ] = Common::Util::floatToUInt16( m_pos.x );
+    data.TargetPos[ 1 ] = Common::Util::floatToUInt16( m_pos.y );
+    data.TargetPos[ 2 ] = Common::Util::floatToUInt16( m_pos.z );
+    data.Dir = m_rot;
 
-    server().queueForPlayers( m_pSource->getInRangePlayerIds( true ), castPacket );
+    server().queueForPlayers( m_pSource->getInRangePlayerIds( m_pSource->isPlayer() ), castPacket );
 
     if( player )
-    {
       player->setCondition( PlayerCondition::Casting );
-    }
   }
   
   // todo: m_recastTimeMs needs to be adjusted for player sks/sps
   auto actionStartPkt = makeActorControlSelf( m_pSource->getId(), ActorControlType::ActionStart, m_cooldownGroup, getId(), m_recastTimeMs / 10 );
 
-  player->setRecastGroup( m_cooldownGroup, static_cast< float >( m_castTimeMs ) / 1000.f );
-
-  server().queueForPlayer( player->getCharacterId(), actionStartPkt );
+  if( player )
+  {
+    player->setRecastGroup( m_cooldownGroup, static_cast< float >( m_castTimeMs ) / 1000.f );
+    server().queueForPlayer( player->getCharacterId(), actionStartPkt );
+  }
 
   onStart();
 
@@ -362,7 +389,6 @@ void Action::Action::onStart()
 void Action::Action::interrupt()
 {
   assert( m_pSource );
-
   // things that aren't players don't care about cooldowns and state flags
   if( m_pSource->isPlayer() )
   {
@@ -402,25 +428,20 @@ void Action::Action::onInterrupt()
 void Action::Action::execute()
 {
   assert( m_pSource );
-
   // subtract costs first, if somehow the caster stops meeting those requirements cancel the cast
-
   if( !consumeResources() )
   {
     interrupt();
     return;
   }
 
-
   auto& scriptMgr = Common::Service< Scripting::ScriptMgr >::ref();
 
-  if( hasCastTime() )
+  if( hasCastTime() && m_pSource->isPlayer() )
   {
-    if( auto pPlayer = m_pSource->getAsPlayer(); pPlayer )
-    {
-      pPlayer->setLastActionTick( 0 );
-      pPlayer->removeCondition( PlayerCondition::Casting );
-    }
+    auto pPlayer = m_pSource->getAsPlayer();
+    pPlayer->setLastActionTick( 0 );
+    pPlayer->removeCondition( PlayerCondition::Casting );
   }
 
   if( isCorrectCombo() )
@@ -430,13 +451,9 @@ void Action::Action::execute()
   }
 
   if( !hasClientsideTarget()  )
-  {
-    buildEffects();
-  }
+    buildActionResults();
   else if( auto player = m_pSource->getAsPlayer() )
-  {
     scriptMgr.onEObjHit( *player, m_targetId, getId() );
-  }
 
   // set currently casted action as the combo action if it interrupts a combo
   // ignore it otherwise (ogcds, etc.)
@@ -444,17 +461,13 @@ void Action::Action::execute()
   {
     // potential combo starter or correct combo from last action, must hit something to progress combo
     if( !m_hitActors.empty() && ( !isComboAction() || isCorrectCombo() ) )
-    {
       m_pSource->setLastComboActionId( getId() );
-    }
     else // clear last combo action if the combo breaks
-    {
       m_pSource->setLastComboActionId( 0 );
-    }
   }
 }
 
-std::pair< uint32_t, Common::ActionHitSeverityType > Action::Action::calcDamage( uint32_t potency )
+std::pair< uint32_t, Common::CalcResultType > Action::Action::calcDamage( uint32_t potency )
 {
   // todo: what do for npcs?
   auto wepDmg = 1.f;
@@ -466,19 +479,19 @@ std::pair< uint32_t, Common::ActionHitSeverityType > Action::Action::calcDamage(
 
     auto role = player->getRole();
     if( role == Common::Role::RangedMagical || role == Common::Role::Healer )
-    {
       wepDmg = item->getMagicalDmg();
-    }
     else
-    {
       wepDmg = item->getPhysicalDmg();
-    }
+
+    // is auto attack
+    if( getId() == 7 || getId() == 8 )
+      return Math::CalcStats::calcAutoAttackDamage( *m_pSource->getAsPlayer() );
   }
 
   return Math::CalcStats::calcActionDamage( *m_pSource, potency, wepDmg );
 }
 
-std::pair< uint32_t, Common::ActionHitSeverityType > Action::Action::calcHealing( uint32_t potency )
+std::pair< uint32_t, Common::CalcResultType > Action::Action::calcHealing( uint32_t potency )
 {
   auto wepDmg = 1.f;
 
@@ -489,41 +502,38 @@ std::pair< uint32_t, Common::ActionHitSeverityType > Action::Action::calcHealing
 
     auto role = player->getRole();
     if( role == Common::Role::RangedMagical || role == Common::Role::Healer )
-    {
       wepDmg = item->getMagicalDmg();
-    }
     else
-    {
       wepDmg = item->getPhysicalDmg();
-    }
   }
 
   return Math::CalcStats::calcActionHealing( *m_pSource, potency, wepDmg );
 }
 
-void Action::Action::buildEffects()
+void Action::Action::buildActionResults()
 {
   snapshotAffectedActors( m_hitActors );
 
   auto& scriptMgr = Common::Service< Scripting::ScriptMgr >::ref();
   auto hasLutEntry = hasValidLutEntry();
+  auto hasScript = scriptMgr.onExecute( *this );
 
-  if( !scriptMgr.onExecute( *this ) && !hasLutEntry )
+  if( !hasScript && !hasLutEntry )
   {
     if( auto player = m_pSource->getAsPlayer() )
-    {
       Manager::PlayerMgr::sendUrgent( *player, "missing lut entry for action#{}", getId() );
-    }
-
     return;
   }
 
-  Network::Util::Player::sendHudParam( *m_pSource->getAsPlayer() );
+  if( !hasScript )
+    m_enableGenericHandler = true;
+
+  Network::Util::Packet::sendHudParam( *m_pSource );
 
-  if( !hasLutEntry || m_hitActors.empty() )
+  if( !m_enableGenericHandler || !hasLutEntry || m_hitActors.empty() )
   {
     // send any effect packet added by script or an empty one just to play animation for other players
-    m_effectBuilder->buildAndSendPackets( m_hitActors );
+    m_actionResultBuilder->sendActionResults( {} );
     return;
   }
 
@@ -544,14 +554,14 @@ void Action::Action::buildEffects()
     if( m_lutEntry.potency > 0 )
     {
       auto dmg = calcDamage( isCorrectCombo() ? m_lutEntry.comboPotency : m_lutEntry.potency );
-      m_effectBuilder->damage( m_pSource, actor, dmg.first, dmg.second );
+      m_actionResultBuilder->damage( m_pSource, actor, dmg.first, dmg.second );
 
       if( dmg.first > 0 )
         actor->onActionHostile( m_pSource );
 
       if( isCorrectCombo() && shouldApplyComboSucceedEffect )
       {
-        m_effectBuilder->comboSucceed( m_pSource );
+        m_actionResultBuilder->comboSucceed( m_pSource );
         shouldApplyComboSucceedEffect = false;
       }
 
@@ -560,46 +570,100 @@ void Action::Action::buildEffects()
         if( m_lutEntry.curePotency > 0 ) // actions with self heal
         {
           auto heal = calcHealing( m_lutEntry.curePotency );
-          m_effectBuilder->heal( actor, m_pSource, heal.first, heal.second, Common::ActionEffectResultFlag::EffectOnSource );
+          m_actionResultBuilder->heal( actor, m_pSource, heal.first, heal.second, Common::ActionResultFlag::EffectOnSource );
         }
 
         if( m_lutEntry.restoreMPPercentage > 0 && shouldRestoreMP )
         {
-          m_effectBuilder->restoreMP( actor, m_pSource, m_pSource->getMaxMp() * m_lutEntry.restoreMPPercentage / 100, Common::ActionEffectResultFlag::EffectOnSource );
+          m_actionResultBuilder->restoreMP( actor, m_pSource, m_pSource->getMaxMp() * m_lutEntry.restoreMPPercentage / 100, Common::ActionResultFlag::EffectOnSource );
           shouldRestoreMP = false;
         }
 
         if( !m_lutEntry.nextCombo.empty() ) // if we have a combo action followup
-        {
-          m_effectBuilder->startCombo( m_pSource, getId() ); // this is on all targets hit
-        }
+          m_actionResultBuilder->startCombo( m_pSource, getId() ); // this is on all targets hit
       }
     }
     else if( m_lutEntry.curePotency > 0 )
     {
       auto heal = calcHealing( m_lutEntry.curePotency );
-      m_effectBuilder->heal( actor, actor, heal.first, heal.second );
+      m_actionResultBuilder->heal( actor, actor, heal.first, heal.second );
 
       if( m_lutEntry.restoreMPPercentage > 0 && shouldRestoreMP )
       {
-        m_effectBuilder->restoreMP( actor, m_pSource, m_pSource->getMaxMp() * m_lutEntry.restoreMPPercentage / 100, Common::ActionEffectResultFlag::EffectOnSource );
+        m_actionResultBuilder->restoreMP( actor, m_pSource, m_pSource->getMaxMp() * m_lutEntry.restoreMPPercentage / 100, Common::ActionResultFlag::EffectOnSource );
         shouldRestoreMP = false;
       }
     }
     else if( m_lutEntry.restoreMPPercentage > 0 && shouldRestoreMP )
     {
-      m_effectBuilder->restoreMP( actor, m_pSource, m_pSource->getMaxMp() * m_lutEntry.restoreMPPercentage / 100, Common::ActionEffectResultFlag::EffectOnSource );
+      m_actionResultBuilder->restoreMP( actor, m_pSource, m_pSource->getMaxMp() * m_lutEntry.restoreMPPercentage / 100, Common::ActionResultFlag::EffectOnSource );
       shouldRestoreMP = false;
     }
   }
 
-  m_effectBuilder->buildAndSendPackets( m_hitActors );
+  // If we hit an enemy
+  if( !m_hitActors.empty() && getHitChara()->getObjKind() != m_pSource->getObjKind() )
+  {
+    m_pSource->removeStatusEffectByFlag( Common::StatusEffectFlag::RemoveOnSuccessfulHit );
+  }
+
+  handleJobAction();
+  handleStatusEffects();
+
+  m_actionResultBuilder->sendActionResults( m_hitActors );
 
   // TODO: disabled, reset kills our queued actions
   // at this point we're done with it and no longer need it
   // m_effectBuilder.reset();
 }
 
+void Action::Action::handleStatusEffects()
+{
+  auto pActionBuilder = getActionResultBuilder();
+
+  if( !pActionBuilder )
+    return;
+
+  if( isComboAction() && !isCorrectCombo() )
+    return;
+
+  // handle caster statuses
+  if( !m_lutEntry.statuses.caster.empty() )
+  {
+    for( auto& status : m_lutEntry.statuses.caster )
+    {
+      pActionBuilder->applyStatusEffectSelf( status.id, status.duration, 0, std::move( status.modifiers ), status.flag, true );
+    }
+  }
+
+  // handle hit actor statuses
+  if( !m_lutEntry.statuses.target.empty() && !m_hitActors.empty() )
+  {
+    for( auto& actor : m_hitActors )
+    {
+      for( auto& status : m_lutEntry.statuses.target )
+      {
+        pActionBuilder->applyStatusEffect( actor, status.id, status.duration, 0, std::move( status.modifiers ), status.flag, true );
+      }
+
+      if( !actor->getStatusEffectMap().empty() )
+        actor->onActionHostile( m_pSource );
+    }
+  }
+}
+
+void Action::Action::handleJobAction()
+{
+  switch( m_pSource->getClass() )
+  {
+    case ClassJob::Warrior:
+    {
+      Warrior::onAction( *m_pSource->getAsPlayer(), *this );
+      break;
+    }
+  }
+}
+
 bool Action::Action::preCheck()
 {
   if( auto player = m_pSource->getAsPlayer() )
@@ -678,9 +742,7 @@ bool Action::Action::isCorrectCombo() const
   auto lastActionId = m_pSource->getLastComboActionId();
 
   if( lastActionId == 0 )
-  {
     return false;
-  }
 
   return m_actionData->data().ComboParent == lastActionId;
 }
@@ -724,6 +786,17 @@ bool Action::Action::primaryCostCheck( bool subtractCosts )
       return true;
     }
 
+    case Common::ActionPrimaryCostType::StatusEffect:
+    {
+      if( !m_pSource->hasStatusEffect( m_primaryCost ) )
+        return false;
+
+      if( subtractCosts )
+        m_pSource->removeSingleStatusEffectById( m_primaryCost );
+
+      return true;
+    }
+
     // free casts, likely just pure ogcds
     case Common::ActionPrimaryCostType::None:
     {
@@ -791,8 +864,10 @@ void Action::Action::addDefaultActorFilters()
 {
   switch( m_castType )
   {
+    // todo: figure these out and remove 5/RectangularAOE to own handler
+    case( Common::CastType ) 5:
+    case Common::CastType::RectangularAOE:
     case Common::CastType::SingleTarget:
-    case Common::CastType::Type3:
     {
       auto filter = std::make_shared< World::Util::ActorFilterSingleTarget >( static_cast< uint32_t >( m_targetId ) );
       addActorFilter( filter );
@@ -854,22 +929,20 @@ std::vector< Entity::CharaPtr >& Action::Action::getHitCharas()
 Entity::CharaPtr Action::Action::getHitChara()
 {
   if( !m_hitActors.empty() )
-  {
     return m_hitActors.at( 0 );
-  }
-
   return nullptr;
 }
 
 bool Action::Action::hasValidLutEntry() const
 {
   return m_lutEntry.potency != 0 || m_lutEntry.comboPotency != 0 || m_lutEntry.flankPotency != 0 || m_lutEntry.frontPotency != 0 ||
-    m_lutEntry.rearPotency != 0 || m_lutEntry.curePotency != 0 || m_lutEntry.restoreMPPercentage != 0;
+    m_lutEntry.rearPotency != 0 || m_lutEntry.curePotency != 0 || m_lutEntry.restoreMPPercentage != 0 ||
+    m_lutEntry.statuses.caster.size() > 0 || m_lutEntry.statuses.target.size() > 0;
 }
 
-Action::EffectBuilderPtr Action::Action::getEffectbuilder()
+Action::ActionResultBuilderPtr Action::Action::getActionResultBuilder()
 {
-  return m_effectBuilder;
+  return m_actionResultBuilder;
 }
 
 uint8_t Action::Action::getActionKind() const
@@ -891,3 +964,8 @@ uint64_t Action::Action::getCastTimeRest() const
 {
   return m_castTimeRestMs;
 }
+
+void Action::Action::enableGenericHandler()
+{
+  m_enableGenericHandler = true;
+}
\ No newline at end of file
diff --git a/src/world/Action/Action.h b/src/world/Action/Action.h
index 044681155..ea55ab1f7 100644
--- a/src/world/Action/Action.h
+++ b/src/world/Action/Action.h
@@ -4,7 +4,7 @@
 #include "ActionLut.h"
 #include "Util/ActorFilter.h"
 #include "ForwardsZone.h"
-#include "EffectBuilder.h"
+#include "ActionResultBuilder.h"
 #include "Exd/Structs.h"
 
 namespace Sapphire::World::Action
@@ -23,11 +23,16 @@ namespace Sapphire::World::Action
 
     uint32_t getId() const;
 
+    uint32_t getResultId() const;
+
     bool init();
 
     void setPos( const Common::FFXIVARR_POSITION3& pos );
     const Common::FFXIVARR_POSITION3& getPos() const;
 
+    void setRot( float rot );
+    float getRot() const;
+
     void setTargetId( uint64_t targetId );
     uint64_t getTargetId() const;
     Entity::CharaPtr getSourceChara() const;
@@ -53,6 +58,10 @@ namespace Sapphire::World::Action
 
     uint64_t getCastTimeRest() const;
 
+    void enableGenericHandler();
+    
+    std::shared_ptr< Excel::ExcelStruct< Excel::Action > > getActionData() const;
+
     /*!
      * @brief Checks if a chara has enough resources available to cast the action (tp/mp/etc)
      * @return true if they have the required resources
@@ -103,9 +112,13 @@ namespace Sapphire::World::Action
      */
     bool snapshotAffectedActors( std::vector< Entity::CharaPtr >& actors );
 
-    EffectBuilderPtr getEffectbuilder();
+    ActionResultBuilderPtr getActionResultBuilder();
+
+    void buildActionResults();
+
+    void handleStatusEffects();
 
-    void buildEffects();
+    void handleJobAction();
 
     /*!
      * @brief Adds an actor filter to this action.
@@ -118,9 +131,9 @@ namespace Sapphire::World::Action
      */
     void addDefaultActorFilters();
 
-    std::pair< uint32_t, Common::ActionHitSeverityType > calcDamage( uint32_t potency );
+    std::pair< uint32_t, Common::CalcResultType > calcDamage( uint32_t potency );
 
-    std::pair< uint32_t, Common::ActionHitSeverityType > calcHealing( uint32_t potency );
+    std::pair< uint32_t, Common::CalcResultType > calcHealing( uint32_t potency );
 
 
     std::vector< Entity::CharaPtr >& getHitCharas();
@@ -172,6 +185,7 @@ namespace Sapphire::World::Action
     uint8_t m_actionKind{};
 
     uint16_t m_requestId{};
+    uint32_t m_resultId{};
 
     Common::ActionPrimaryCostType m_primaryCostType;
     uint16_t m_primaryCost{};
@@ -185,6 +199,7 @@ namespace Sapphire::World::Action
     uint8_t m_cooldownGroup{};
     int8_t m_range{};
     uint8_t m_effectRange{};
+    uint8_t m_effectWidth{};
     uint8_t m_xAxisModifier{};
     Common::ActionAspect m_aspect;
     Common::CastType m_castType;
@@ -201,14 +216,16 @@ namespace Sapphire::World::Action
     bool m_canTargetFriendly{};
     bool m_canTargetHostile{};
     bool m_canTargetDead{};
+    bool m_enableGenericHandler{};
 
     Common::ActionInterruptType m_interruptType;
 
     std::shared_ptr< Excel::ExcelStruct< Excel::Action > > m_actionData;
 
     Common::FFXIVARR_POSITION3 m_pos{};
+    float m_rot{};
 
-    EffectBuilderPtr m_effectBuilder;
+    ActionResultBuilderPtr m_actionResultBuilder;
 
     std::vector< World::Util::ActorFilterPtr > m_actorFilters;
     std::vector< Entity::CharaPtr > m_hitActors;
diff --git a/src/world/Action/ActionLut.cpp b/src/world/Action/ActionLut.cpp
index 38746ca9d..69824c431 100644
--- a/src/world/Action/ActionLut.cpp
+++ b/src/world/Action/ActionLut.cpp
@@ -15,7 +15,8 @@ bool ActionLut::validEntryExists( uint16_t actionId )
 
   // if all of the fields are 0, it's not 'valid' due to parse error or no useful data in the tooltip
   return entry.potency != 0 || entry.comboPotency != 0 || entry.flankPotency != 0 || entry.frontPotency != 0 ||
-         entry.rearPotency != 0 || entry.curePotency != 0;
+         entry.rearPotency != 0 || entry.curePotency != 0 ||
+         entry.statuses.caster.size() > 0 || entry.statuses.target.size() > 0;
 }
 
 const ActionEntry& ActionLut::getEntry( uint16_t actionId )
diff --git a/src/world/Action/ActionLut.h b/src/world/Action/ActionLut.h
index 3ea20cdba..0b86013ee 100644
--- a/src/world/Action/ActionLut.h
+++ b/src/world/Action/ActionLut.h
@@ -17,6 +17,8 @@ namespace Sapphire::World::Action
   struct StatusEntry
   {
     uint16_t id;
+    uint32_t duration;
+    uint32_t flag;
     std::vector< StatusModifier > modifiers;
   };
 
diff --git a/src/world/Action/ActionLutData.cpp b/src/world/Action/ActionLutData.cpp
index 99ee9b738..108f0b775 100644
--- a/src/world/Action/ActionLutData.cpp
+++ b/src/world/Action/ActionLutData.cpp
@@ -3,6 +3,7 @@
 #include <fstream>
 #include <filesystem>
 #include <iostream>
+#include <Logging/Logger.h>
 
 using namespace Sapphire;
 using namespace Sapphire::World::Action;
@@ -85,6 +86,14 @@ std::unordered_map< std::string, Common::ParamModifier > ActionLutData::m_modifi
   { "Control", Common::ParamModifier::Control },
   { "Gathering", Common::ParamModifier::Gathering },
   { "Perception", Common::ParamModifier::Perception },
+  { "TickHeal", Common::ParamModifier::TickHeal },
+  { "TickDamage", Common::ParamModifier::TickDamage },
+  { "StrengthPercent", Common::ParamModifier::StrengthPercent },
+  { "DexterityPercent", Common::ParamModifier::DexterityPercent },
+  { "VitalityPercent", Common::ParamModifier::VitalityPercent },
+  { "IntelligencePercent", Common::ParamModifier::IntelligencePercent },
+  { "MindPercent", Common::ParamModifier::MindPercent },
+  { "PietyPercent", Common::ParamModifier::PietyPercent },
   { "HPPercent", Common::ParamModifier::HPPercent },
   { "MPPercent", Common::ParamModifier::MPPercent },
   { "TPPercent", Common::ParamModifier::TPPercent },
@@ -100,7 +109,15 @@ std::unordered_map< std::string, Common::ParamModifier > ActionLutData::m_modifi
   { "CriticalHitPowerPercent", Common::ParamModifier::CriticalHitPowerPercent },
   { "CriticalHitResiliencePercent", Common::ParamModifier::CriticalHitResiliencePercent },
   { "CriticalHitPercent", Common::ParamModifier::CriticalHitPercent },
-  { "EnmityPercent", Common::ParamModifier::EnmityPercent }
+  { "EnmityPercent", Common::ParamModifier::EnmityPercent },
+  { "DamageDealtPercent", Common::ParamModifier::DamageDealtPercent },
+  { "DamageTakenPercent", Common::ParamModifier::DamageTakenPercent },
+  { "HealingMagicRecoveryPercent", Common::ParamModifier::HealingMagicRecoveryPercent },
+  { "SlashingResistancePercent", Common::ParamModifier::SlashingResistancePercent },
+  { "PiercingResistancePercent", Common::ParamModifier::PiercingResistancePercent },
+  { "BluntResistancePercent", Common::ParamModifier::BluntResistancePercent },
+  { "ProjectileResistancePercent", Common::ParamModifier::ProjectileResistancePercent },
+  { "ParryPercent", Common::ParamModifier::ParryPercent }
 };
 
 bool ActionLutData::cacheActions()
@@ -122,6 +139,10 @@ bool ActionLutData::cacheActions()
       {
         auto id = std::stoi( i.key() );
         auto action = i.value().get< ActionEntry >();
+
+        if( ActionLut::m_actionLut.count( id ) > 0 )
+          throw std::runtime_error( fmt::format( "Action with ID {} cannot be defined more than once (defined again in {})", i.key(), p.path().string() ) );
+
         ActionLut::m_actionLut.try_emplace( id, action );
       }
 
diff --git a/src/world/Action/ActionLutData.h b/src/world/Action/ActionLutData.h
index 61225af68..22cf62bf2 100644
--- a/src/world/Action/ActionLutData.h
+++ b/src/world/Action/ActionLutData.h
@@ -32,6 +32,9 @@ namespace Sapphire::World::Action
   inline void from_json( const nlohmann::json& j, StatusEntry& statusEntry )
   {
     j.at( "id" ).get_to( statusEntry.id );
+    j.at( "duration" ).get_to( statusEntry.duration );
+    if( j.contains( "flag" ) )
+      j.at( "flag" ).get_to( statusEntry.flag );
     if( j.contains( "modifiers" ) )
       j.at( "modifiers" ).get_to( statusEntry.modifiers );
   }
diff --git a/src/world/Action/ActionResult.cpp b/src/world/Action/ActionResult.cpp
new file mode 100644
index 000000000..13b8d99eb
--- /dev/null
+++ b/src/world/Action/ActionResult.cpp
@@ -0,0 +1,181 @@
+#include "ActionResult.h"
+
+#include <Util/Util.h>
+
+#include <Service.h>
+#include <Manager/PlayerMgr.h>
+
+#include "Actor/Chara.h"
+#include "Actor/Player.h"
+#include "StatusEffect/StatusEffect.h"
+
+using namespace Sapphire;
+using namespace Sapphire::Common;
+using namespace Sapphire::World::Action;
+
+
+ActionResult::ActionResult( Entity::CharaPtr target ) :
+  m_target( std::move( target ) )
+{
+  m_result.Arg0 = 0;
+  m_result.Arg1 = 0;
+  m_result.Arg2 = 0;
+  m_result.Value = 0;
+  m_result.Flag = static_cast< uint8_t >( ActionResultFlag::None );
+  m_result.Type = CalcResultType::TypeNone;
+}
+
+Entity::CharaPtr ActionResult::getTarget() const
+{
+  return m_target;
+}
+
+void ActionResult::damage( uint32_t amount, CalcResultType hitType, uint8_t hitEffect, ActionResultFlag flag )
+{
+  m_result.Arg0 = hitEffect;
+  m_result.Value = static_cast< int16_t >( amount );
+  m_result.Flag = static_cast< uint8_t >( flag );
+  m_result.Type = hitType;
+}
+
+void ActionResult::heal( uint32_t amount, CalcResultType hitType, uint8_t hitEffect, ActionResultFlag flag )
+{
+  m_result.Arg0 = hitEffect;
+  m_result.Value = static_cast< int16_t >( amount );
+  m_result.Flag = static_cast< uint8_t >( flag );
+  m_result.Type = hitType;
+}
+
+void ActionResult::restoreMP( uint32_t amount, ActionResultFlag flag )
+{
+  m_result.Value = static_cast< int16_t >( amount );
+  m_result.Flag = static_cast< uint8_t >( flag );
+  m_result.Type = CalcResultType::TypeRecoverMp;
+}
+
+void ActionResult::startCombo( uint16_t actionId )
+{
+  m_result.Value = static_cast< int16_t >( actionId );
+  m_result.Flag = static_cast< uint8_t >( ActionResultFlag::EffectOnSource );
+  m_result.Type = CalcResultType::TypeCombo;
+}
+
+void ActionResult::comboSucceed()
+{
+  // no EffectOnSource flag on this
+  m_result.Type = CalcResultType::TypeComboHit;
+}
+
+void ActionResult::applyStatusEffect( uint32_t id, int32_t duration, Entity::Chara& source, uint8_t param, bool shouldOverride )
+{
+  m_result.Value = static_cast< int16_t >( id );
+  m_result.Arg2 = param;
+  m_result.Type = CalcResultType::TypeSetStatus;
+
+  m_bOverrideStatus = shouldOverride;
+  m_pStatus = Sapphire::StatusEffect::make_StatusEffect( id, source.getAsChara(), m_target, duration, 3000 );
+  m_pStatus->setParam( param );
+}
+
+void ActionResult::applyStatusEffect( uint32_t id, int32_t duration, Entity::Chara& source, uint8_t param,
+                                      const std::vector< StatusModifier >& modifiers, uint32_t flag, bool shouldOverride )
+{
+  m_result.Value = static_cast< int16_t >( id );
+  m_result.Arg2 = param;
+  m_result.Type = CalcResultType::TypeSetStatus;
+
+  m_bOverrideStatus = shouldOverride;
+  m_pStatus = Sapphire::StatusEffect::make_StatusEffect( id, source.getAsChara(), m_target, duration, modifiers, flag, 3000 );
+  m_pStatus->setParam( param );
+}
+
+void ActionResult::applyStatusEffectSelf( uint32_t id, int32_t duration, uint8_t param, bool shouldOverride )
+{
+  m_result.Value = static_cast< int16_t >( id );
+  m_result.Arg2 = param;
+  m_result.Type = CalcResultType::TypeSetStatusMe;
+  m_result.Flag = static_cast< uint8_t >( ActionResultFlag::EffectOnSource );
+
+  m_bOverrideStatus = shouldOverride;
+  m_pStatus = Sapphire::StatusEffect::make_StatusEffect( id, m_target, m_target, duration, 3000 );
+  m_pStatus->setParam( param );
+}
+
+void ActionResult::applyStatusEffectSelf( uint32_t id, int32_t duration, uint8_t param, const std::vector< World::Action::StatusModifier >& modifiers,
+                                          uint32_t flag, bool shouldOverride )
+{
+  m_result.Value = static_cast< int16_t >( id );
+  m_result.Arg2 = param;
+  m_result.Type = CalcResultType::TypeSetStatusMe;
+  m_result.Flag = static_cast< uint8_t >( Common::ActionResultFlag::EffectOnSource );
+
+  m_bOverrideStatus = shouldOverride;
+  m_pStatus = Sapphire::StatusEffect::make_StatusEffect( id, m_target, m_target, duration, modifiers, flag, 3000 );
+  m_pStatus->setParam( param );
+}
+
+void ActionResult::mount( uint16_t mountId )
+{
+  m_result.Value = static_cast< int16_t >( mountId );
+  m_result.Arg0 = 1;
+  m_result.Type = CalcResultType::TypeMount;
+}
+
+const Common::CalcResultParam& ActionResult::getCalcResultParam() const
+{
+  return m_result;
+}
+
+const Sapphire::StatusEffect::StatusEffectPtr ActionResult::getStatusEffect() const
+{
+  return m_pStatus;
+}
+
+void ActionResult::execute()
+{
+  if( !m_target )
+    return;
+
+  switch( m_result.Type )
+  {
+    case CalcResultType::TypeDamageHp:
+    case CalcResultType::TypeCriticalDamageHp:
+    {
+      m_target->takeDamage( m_result.Value );
+      break;
+    }
+
+    case CalcResultType::TypeRecoverHp:
+    case CalcResultType::TypeCriticalRecoverHp:
+    {
+      m_target->heal( m_result.Value );
+      break;
+    }
+
+    case CalcResultType::TypeRecoverMp:
+    {
+      m_target->restoreMP( m_result.Value );
+      break;
+    }
+
+    case CalcResultType::TypeSetStatus:
+    case CalcResultType::TypeSetStatusMe:
+    {
+      if( !m_bOverrideStatus )
+        m_target->addStatusEffectByIdIfNotExist( m_pStatus );
+      else
+        m_target->addStatusEffectById( m_pStatus );
+      break;
+    }
+
+    case CalcResultType::TypeMount:
+    {
+      auto pPlayer = m_target->getAsPlayer();
+      pPlayer->setMount( m_result.Value );
+      break;
+    }
+
+    default:
+      break;
+  }
+}
\ No newline at end of file
diff --git a/src/world/Action/ActionResult.h b/src/world/Action/ActionResult.h
new file mode 100644
index 000000000..3a10b4abc
--- /dev/null
+++ b/src/world/Action/ActionResult.h
@@ -0,0 +1,49 @@
+#pragma once
+
+#include <ForwardsZone.h>
+#include <Common.h>
+#include "ActionLut.h"
+
+namespace Sapphire::World::Action
+{
+  /*!
+   * @brief A container for the computed result of an effect on a single actor. Used to apply damage/healing dealt
+   * at a later point in time.
+   */
+  class ActionResult
+  {
+  public:
+    explicit ActionResult( Entity::CharaPtr target );
+
+    void damage( uint32_t amount, Common::CalcResultType hitType, uint8_t hitEffect, Common::ActionResultFlag flag = Common::ActionResultFlag::None );
+    void heal( uint32_t amount, Common::CalcResultType hitType, uint8_t hitEffect, Common::ActionResultFlag flag = Common::ActionResultFlag::None );
+    void restoreMP( uint32_t amount, Common::ActionResultFlag flag = Common::ActionResultFlag::None );
+    void startCombo( uint16_t actionId );
+    void comboSucceed();
+    void applyStatusEffect( uint32_t id, int32_t duration, Entity::Chara& source, uint8_t param, bool shouldOverride );
+    void applyStatusEffect( uint32_t id, int32_t duration, Entity::Chara& source, uint8_t param,
+                            const std::vector< World::Action::StatusModifier >& modifiers, uint32_t flag, bool shouldOverride );
+    void applyStatusEffectSelf( uint32_t id, int32_t duration, uint8_t param, bool shouldOverride );
+    void applyStatusEffectSelf( uint32_t id, int32_t duration, uint8_t param, const std::vector< World::Action::StatusModifier >& modifiers,
+                                uint32_t flag, bool shouldOverride );
+    void mount( uint16_t mountId );
+
+    Entity::CharaPtr getTarget() const;
+
+    const Common::CalcResultParam& getCalcResultParam() const;
+    const Sapphire::StatusEffect::StatusEffectPtr getStatusEffect() const;
+
+    void execute();
+
+  private:
+    Entity::CharaPtr m_target;
+
+    Common::CalcResultParam m_result;
+
+    bool m_bOverrideStatus { false };
+    Sapphire::StatusEffect::StatusEffectPtr m_pStatus;
+
+  };
+
+  using ActionResultList = std::vector< ActionResultPtr >;
+}
\ No newline at end of file
diff --git a/src/world/Action/ActionResultBuilder.cpp b/src/world/Action/ActionResultBuilder.cpp
new file mode 100644
index 000000000..db0da0cbd
--- /dev/null
+++ b/src/world/Action/ActionResultBuilder.cpp
@@ -0,0 +1,204 @@
+  #include "ActionResultBuilder.h"
+#include "ActionResult.h"
+
+#include <Actor/Player.h>
+
+#include <Network/PacketWrappers/EffectPacket.h>
+#include <Network/PacketWrappers/EffectPacket1.h>
+
+#include <Territory/Territory.h>
+
+#include <Util/Util.h>
+#include <Util/UtilMath.h>
+#include <Exd/ExdData.h>
+
+#include <Logging/Logger.h>
+#include <Manager/TerritoryMgr.h>
+#include <Manager/MgrUtil.h>
+#include <Service.h>
+
+#include <Manager/TaskMgr.h>
+#include <Task/ActionIntegrityTask.h>
+
+using namespace Sapphire;
+using namespace Sapphire::World::Action;
+using namespace Sapphire::World::Manager;
+using namespace Sapphire::Network::Packets;
+using namespace Sapphire::Network::Packets::WorldPackets::Server;
+
+ActionResultBuilder::ActionResultBuilder( Entity::CharaPtr source, uint32_t actionId, uint32_t resultId, uint16_t requestId ) :
+  m_sourceChara( std::move( source ) ),
+  m_actionId( actionId ),
+  m_resultId( resultId ),
+  m_requestId( requestId )
+{
+
+}
+
+void ActionResultBuilder::addResultToActor( Entity::CharaPtr& chara, ActionResultPtr result )
+{
+  auto it = m_actorResultsMap.find( chara );
+  if( it == m_actorResultsMap.end() )
+  {
+    m_actorResultsMap[ chara ].push_back( std::move( result ) );
+    return;
+  }
+
+  it->second.push_back( std::move( result ) );
+}
+
+void ActionResultBuilder::heal( Entity::CharaPtr& effectTarget, Entity::CharaPtr& healingTarget, uint32_t amount, Common::CalcResultType hitType, Common::ActionResultFlag flag )
+{
+  ActionResultPtr nextResult = make_ActionResult( healingTarget );
+  auto& exdData = Common::Service< Data::ExdData >::ref();
+  auto actionData = exdData.getRow< Excel::Action >( m_actionId );
+  nextResult->heal( amount, hitType, std::abs( actionData->data().AttackType ), flag );
+  addResultToActor( effectTarget, nextResult );
+}
+
+void ActionResultBuilder::restoreMP( Entity::CharaPtr& target, Entity::CharaPtr& restoringTarget, uint32_t amount, Common::ActionResultFlag flag )
+{
+  ActionResultPtr nextResult = make_ActionResult( restoringTarget ); // restore mp source actor
+  nextResult->restoreMP( amount, flag );
+  addResultToActor( target, nextResult );
+}
+
+void ActionResultBuilder::damage( Entity::CharaPtr& effectTarget, Entity::CharaPtr& damagingTarget, uint32_t amount, Common::CalcResultType hitType, Common::ActionResultFlag flag )
+{
+  ActionResultPtr nextResult = make_ActionResult( damagingTarget );
+  auto& exdData = Common::Service< Data::ExdData >::ref();
+  auto actionData = exdData.getRow< Excel::Action >( m_actionId );
+  nextResult->damage( amount, hitType, std::abs( actionData->data().AttackType ), flag );
+  addResultToActor( damagingTarget, nextResult );
+}
+
+void ActionResultBuilder::startCombo( Entity::CharaPtr& target, uint16_t actionId )
+{
+  ActionResultPtr nextResult = make_ActionResult( target );
+  nextResult->startCombo( actionId );
+  addResultToActor( target, nextResult );
+}
+
+void ActionResultBuilder::comboSucceed( Entity::CharaPtr& target )
+{
+  ActionResultPtr nextResult = make_ActionResult( target );
+  nextResult->comboSucceed();
+  addResultToActor( target, nextResult );
+}
+
+void ActionResultBuilder::applyStatusEffect( Entity::CharaPtr& target, uint16_t statusId, uint32_t duration, uint8_t param, bool shouldOverride )
+{
+  ActionResultPtr nextResult = make_ActionResult( target );
+  nextResult->applyStatusEffect( statusId, duration, *m_sourceChara, param, shouldOverride );
+  addResultToActor( target, nextResult );
+}
+
+void ActionResultBuilder::applyStatusEffect( Entity::CharaPtr& target, uint16_t statusId, uint32_t duration, uint8_t param,
+                                             const std::vector< World::Action::StatusModifier >& modifiers, uint32_t flag, bool shouldOverride )
+{
+  ActionResultPtr nextResult = make_ActionResult( target );
+  nextResult->applyStatusEffect( statusId, duration, *m_sourceChara, param, modifiers, flag, shouldOverride );
+  addResultToActor( target, nextResult );
+}
+
+void ActionResultBuilder::applyStatusEffectSelf( uint16_t statusId, uint32_t duration, uint8_t param, bool shouldOverride )
+{
+  ActionResultPtr nextResult = make_ActionResult( m_sourceChara );
+  nextResult->applyStatusEffectSelf( statusId, duration, param, shouldOverride );
+  addResultToActor( m_sourceChara, nextResult );
+}
+
+void ActionResultBuilder::applyStatusEffectSelf( uint16_t statusId, uint32_t duration, uint8_t param, const std::vector< World::Action::StatusModifier >& modifiers,
+                                                 uint32_t flag, bool shouldOverride )
+{
+  ActionResultPtr nextResult = make_ActionResult( m_sourceChara );
+  nextResult->applyStatusEffectSelf( statusId, duration, param, modifiers, flag, shouldOverride );
+  addResultToActor( m_sourceChara, nextResult );
+}
+
+void ActionResultBuilder::mount( Entity::CharaPtr& target, uint16_t mountId )
+{
+  ActionResultPtr nextResult = make_ActionResult( target );
+  nextResult->mount( mountId );
+  addResultToActor( target, nextResult );
+}
+
+void ActionResultBuilder::sendActionResults( const std::vector< Entity::CharaPtr >& targetList )
+{
+  Logger::debug( "EffectBuilder result: " );
+  Logger::debug( "Targets afflicted: {}", targetList.size() );
+
+  do // we want to send at least one packet even nothing is hit so other players can see
+  {
+    auto packet = createActionResultPacket( targetList );
+    server().queueForPlayers( m_sourceChara->getInRangePlayerIds( true ), packet );
+  }
+  while( !m_actorResultsMap.empty() );
+}
+
+std::shared_ptr< FFXIVPacketBase > ActionResultBuilder::createActionResultPacket( const std::vector< Entity::CharaPtr >& targetList )
+{
+  auto targetCount = targetList.size();
+  auto& taskMgr = Common::Service< World::Manager::TaskMgr >::ref();
+  auto& teriMgr = Common::Service< Sapphire::World::Manager::TerritoryMgr >::ref();
+  auto zone = teriMgr.getTerritoryByGuId( m_sourceChara->getTerritoryId() );
+
+  if( targetCount > 1 ) // use AoeEffect packets
+  {
+    auto actionResult = makeEffectPacket( m_sourceChara->getId(), targetList[ 0 ]->getId(), m_actionId );
+    actionResult->setRotation( Common::Util::floatToUInt16Rot( m_sourceChara->getRot() ) );
+    actionResult->setRequestId( m_requestId );
+    actionResult->setResultId( m_resultId );
+
+    uint8_t targetIndex = 0;
+    for( auto& [ actor, actorResultList ] : m_actorResultsMap )
+    {
+
+      if( actor )
+        taskMgr.queueTask( World::makeActionIntegrityTask( m_resultId, actor, actorResultList, 300 ) );
+
+      for( auto& result : actorResultList )
+      {
+        auto effect = result->getCalcResultParam();
+        if( result->getTarget() == m_sourceChara )
+          actionResult->addSourceEffect( effect );
+        else
+          actionResult->addTargetEffect( effect, result->getTarget()->getId() );
+      }
+      targetIndex++;
+
+      if( targetIndex == 15 )
+        break;
+    }
+
+    m_actorResultsMap.clear();
+    return actionResult;
+  }
+  else  // use Effect for single target
+  {
+    uint32_t mainTargetId = targetList.empty() ? m_sourceChara->getId() : targetList[ 0 ]->getId();
+    auto actionResult = makeEffectPacket1( m_sourceChara->getId(), mainTargetId, m_actionId );
+    actionResult->setRotation( Common::Util::floatToUInt16Rot( m_sourceChara->getRot() ) );
+    actionResult->setRequestId( m_requestId );
+    actionResult->setResultId( m_resultId );
+
+    for( auto& [ actor, actorResultList ] : m_actorResultsMap )
+    {
+      if( actor )
+        taskMgr.queueTask( World::makeActionIntegrityTask( m_resultId, actor, actorResultList, 300 ) );
+
+      for( auto& result : actorResultList )
+      {
+        auto effect = result->getCalcResultParam();
+        if( result->getTarget() == m_sourceChara &&
+            result->getCalcResultParam().Type != Common::CalcResultType::TypeSetStatusMe )
+          actionResult->addSourceEffect( effect );
+        else
+          actionResult->addTargetEffect( effect );
+      }
+    }
+
+    m_actorResultsMap.clear();
+    return actionResult;
+  }
+}
\ No newline at end of file
diff --git a/src/world/Action/ActionResultBuilder.h b/src/world/Action/ActionResultBuilder.h
new file mode 100644
index 000000000..e2e79747a
--- /dev/null
+++ b/src/world/Action/ActionResultBuilder.h
@@ -0,0 +1,54 @@
+#pragma once
+
+#include <ForwardsZone.h>
+#include <Common.h>
+#include "ActionLut.h"
+
+namespace Sapphire::World::Action
+{
+  class ActionResultBuilder
+  {
+  public:
+    ActionResultBuilder( Entity::CharaPtr source, uint32_t actionId, uint32_t resultId, uint16_t requestId );
+
+    void heal( Entity::CharaPtr& effectTarget, Entity::CharaPtr& healingTarget, uint32_t amount,
+               Common::CalcResultType hitType = Common::CalcResultType::TypeRecoverMp,
+               Common::ActionResultFlag flag = Common::ActionResultFlag::None );
+
+    void restoreMP( Entity::CharaPtr& effectTarget, Entity::CharaPtr& restoringTarget, uint32_t amount,
+                    Common::ActionResultFlag flag = Common::ActionResultFlag::None );
+
+    void damage( Entity::CharaPtr& effectTarget, Entity::CharaPtr& damagingTarget, uint32_t amount,
+                 Common::CalcResultType hitType = Common::CalcResultType::TypeDamageHp,
+                 Common::ActionResultFlag flag = Common::ActionResultFlag::None );
+
+    void startCombo( Entity::CharaPtr& target, uint16_t actionId );
+
+    void comboSucceed( Entity::CharaPtr& target );
+
+    void applyStatusEffect( Entity::CharaPtr& target, uint16_t statusId, uint32_t duration, uint8_t param, bool shouldOverride = false );
+    void applyStatusEffect( Entity::CharaPtr& target, uint16_t statusId, uint32_t duration, uint8_t param,
+                            const std::vector< World::Action::StatusModifier >& modifiers, uint32_t flag = 0, bool shouldOverride = false );
+    void applyStatusEffectSelf( uint16_t statusId, uint32_t duration, uint8_t param, bool shouldOverride = false );
+    void applyStatusEffectSelf( uint16_t statusId, uint32_t duration, uint8_t param, const std::vector< World::Action::StatusModifier >& modifiers,
+                                uint32_t flag = 0, bool shouldOverride = false );
+
+    void mount( Entity::CharaPtr& target, uint16_t mountId );
+
+    void sendActionResults( const std::vector< Entity::CharaPtr >& targetList );
+
+  private:
+    void addResultToActor( Entity::CharaPtr& chara, ActionResultPtr result );
+
+    Network::Packets::FFXIVPacketBasePtr createActionResultPacket( const std::vector< Entity::CharaPtr >& targetList );
+
+  private:
+    uint32_t m_actionId;
+    uint16_t m_requestId;
+    uint32_t m_resultId;
+
+    Entity::CharaPtr m_sourceChara;
+    std::unordered_map< Entity::CharaPtr, std::vector< ActionResultPtr > > m_actorResultsMap;
+  };
+
+}
\ No newline at end of file
diff --git a/src/world/Action/CommonAction.h b/src/world/Action/CommonAction.h
new file mode 100644
index 000000000..e67132b79
--- /dev/null
+++ b/src/world/Action/CommonAction.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <cstdint>
+#include <vector>
+#include <string>
+
+namespace Sapphire::World::Action
+{
+  enum ActionSkill
+  {
+    SkullSunder = 35,
+    Maim = 37,
+    StormsPath = 42,
+    StormsEye = 45,
+    ButchersBlock = 47
+  };
+
+  enum ActionStatus
+  {
+    Defiance = 91,
+    Unchained = 92,
+    Wrath = 93,
+    WrathII = 94,
+    WrathIII = 95,
+    WrathIV = 96,
+    Infuriated = 97,
+    InnerBeast = 411,
+    Deliverance = 729
+  };
+}
\ No newline at end of file
diff --git a/src/world/Action/EffectBuilder.cpp b/src/world/Action/EffectBuilder.cpp
deleted file mode 100644
index 1770e8c68..000000000
--- a/src/world/Action/EffectBuilder.cpp
+++ /dev/null
@@ -1,236 +0,0 @@
-#include "EffectBuilder.h"
-#include "EffectResult.h"
-
-#include <Actor/Player.h>
-
-#include <Network/PacketWrappers/EffectPacket.h>
-#include <Network/PacketWrappers/EffectPacket1.h>
-
-#include <Territory/Territory.h>
-
-#include <Util/Util.h>
-#include <Util/UtilMath.h>
-
-#include <Logging/Logger.h>
-#include <Manager/TerritoryMgr.h>
-#include <Manager/MgrUtil.h>
-#include <Service.h>
-
-#include <Manager/TaskMgr.h>
-#include <Task/ActionIntegrityTask.h>
-
-using namespace Sapphire;
-using namespace Sapphire::World::Action;
-using namespace Sapphire::World::Manager;
-using namespace Sapphire::Network::Packets;
-using namespace Sapphire::Network::Packets::WorldPackets::Server;
-
-EffectBuilder::EffectBuilder( Entity::CharaPtr source, uint32_t actionId, uint16_t requestId ) :
-  m_sourceChara( std::move( source ) ),
-  m_actionId( actionId ),
-  m_requestId( requestId )
-{
-
-}
-
-uint64_t EffectBuilder::getResultDelayMs()
-{
-  // todo: actually figure this retarded shit out
-
-  return Common::Util::getTimeMs() + 850;
-}
-
-void EffectBuilder::addResultToActor( Entity::CharaPtr& chara, EffectResultPtr result )
-{
-  auto it = m_actorEffectsMap.find( chara->getId() );
-  if( it == m_actorEffectsMap.end() )
-  {
-    // create a new one
-    auto resultList = std::vector< EffectResultPtr >();
-
-    resultList.push_back( std::move( result ) );
-
-    m_actorEffectsMap[ chara->getId() ] = resultList;
-
-    return;
-  }
-
-  it->second.push_back( std::move( result ) );
-}
-
-void EffectBuilder::heal( Entity::CharaPtr& effectTarget, Entity::CharaPtr& healingTarget, uint32_t amount, Common::ActionHitSeverityType severity, Common::ActionEffectResultFlag flag )
-{
-  EffectResultPtr nextResult = make_EffectResult( healingTarget, getResultDelayMs() );
-  nextResult->heal( amount, severity, flag );
-  addResultToActor( effectTarget, nextResult );
-}
-
-void EffectBuilder::restoreMP( Entity::CharaPtr& target, Entity::CharaPtr& restoringTarget, uint32_t amount, Common::ActionEffectResultFlag flag )
-{
-  EffectResultPtr nextResult = make_EffectResult( restoringTarget, getResultDelayMs() ); // restore mp source actor
-  nextResult->restoreMP( amount, flag );
-  addResultToActor( target, nextResult );
-}
-
-void EffectBuilder::damage( Entity::CharaPtr& effectTarget, Entity::CharaPtr& damagingTarget, uint32_t amount, Common::ActionHitSeverityType severity, Common::ActionEffectResultFlag flag )
-{
-  EffectResultPtr nextResult = make_EffectResult( damagingTarget, getResultDelayMs() );
-  nextResult->damage( amount, severity, flag );
-  addResultToActor( damagingTarget, nextResult );
-}
-
-void EffectBuilder::startCombo( Entity::CharaPtr& target, uint16_t actionId )
-{
-  EffectResultPtr nextResult = make_EffectResult( target, 0 );
-  nextResult->startCombo( actionId );
-  addResultToActor( target, nextResult );
-}
-
-void EffectBuilder::comboSucceed( Entity::CharaPtr& target )
-{
-  EffectResultPtr nextResult = make_EffectResult( target, 0 );
-  nextResult->comboSucceed();
-  addResultToActor( target, nextResult );
-}
-
-void EffectBuilder::applyStatusEffect( Entity::CharaPtr& target, uint16_t statusId, uint8_t param )
-{
-  EffectResultPtr nextResult = make_EffectResult( target, 0 );
-  nextResult->applyStatusEffect( statusId, param );
-  addResultToActor( target, nextResult );
-}
-
-void EffectBuilder::mount( Entity::CharaPtr& target, uint16_t mountId )
-{
-  EffectResultPtr nextResult = make_EffectResult( target, getResultDelayMs() );
-  nextResult->mount( mountId );
-  addResultToActor( target, nextResult );
-}
-
-void EffectBuilder::buildAndSendPackets( const std::vector< Entity::CharaPtr >& targetList )
-{
-  Logger::debug( "EffectBuilder result: " );
-  Logger::debug( "Targets afflicted: {}", targetList.size() );
-
-  do // we want to send at least one packet even nothing is hit so other players can see
-  {
-    auto packet = buildNextEffectPacket( targetList );
-    server().queueForPlayers( m_sourceChara->getInRangePlayerIds( true ), packet );
-  }
-  while( !m_actorEffectsMap.empty() );
-}
-
-std::shared_ptr< FFXIVPacketBase > EffectBuilder::buildNextEffectPacket( const std::vector< Entity::CharaPtr >& targetList )
-{
-  auto remainingTargetCount = targetList.size();
-  auto& teriMgr = Common::Service< Sapphire::World::Manager::TerritoryMgr >::ref();
-  auto zone = teriMgr.getTerritoryByGuId( m_sourceChara->getTerritoryId() );
-  auto resultId = zone->getNextEffectResultId();
-
-  if( remainingTargetCount > 1 ) // use AoeEffect packets
-  {
-    auto effectPacket = std::make_shared< EffectPacket >( m_sourceChara->getId(), m_actionId );
-    effectPacket->setRotation( Common::Util::floatToUInt16Rot( m_sourceChara->getRot() ) );
-    effectPacket->setRequestId( m_requestId );
-    effectPacket->setResultId( resultId );
-    effectPacket->setTargetActor( targetList[ 0 ]->getId() );
-
-    uint8_t targetIndex = 0;
-    for( auto it = m_actorEffectsMap.begin(); it != m_actorEffectsMap.end(); )
-    {
-      // get all effect results for an actor
-      auto actorResultList = it->second;
-
-      for( auto i = 0; i < actorResultList.size(); ++i )
-      {
-        auto result = actorResultList.data()[ i ];
-        auto effect = result->getCalcResultParam();
-
-        // if effect result is a source/caster effect
-        if( result->getTarget() == m_sourceChara )
-        {
-          effectPacket->addSourceEffect( effect );
-        }
-        else
-        {
-          effectPacket->addTargetEffect( effect, result->getTarget()->getId() );
-          auto& taskMgr = Common::Service< World::Manager::TaskMgr >::ref();
-          taskMgr.queueTask( Sapphire::World::makeActionIntegrityTask( resultId, result->getTarget(), 1000 ) );
-        }
-
-        zone->addEffectResult( std::move( result ) );
-
-      }
-
-      actorResultList.clear();
-      it = m_actorEffectsMap.erase( it );
-      targetIndex++;
-
-      if( targetIndex == 15 )
-        break;
-    }
-
-    return effectPacket;
-  }
-  else if( remainingTargetCount == 1 ) // use Effect for single target
-  {
-
-    Logger::debug( " - id: {}", targetList[0]->getId() );
-    Logger::debug( "------------------------------------------" );
-
-    auto effectPacket = std::make_shared< EffectPacket1 >( m_sourceChara->getId(), targetList[ 0 ]->getId(), m_actionId );
-    effectPacket->setRotation( Common::Util::floatToUInt16Rot( m_sourceChara->getRot() ) );
-    effectPacket->setRequestId( m_requestId );
-    effectPacket->setResultId( resultId );
-
-    for( auto it = m_actorEffectsMap.begin(); it != m_actorEffectsMap.end(); )
-    {
-      // get all effect results for an actor
-      auto actorResultList = it->second;
-
-      for( auto i = 0; i < actorResultList.size(); ++i )
-      {
-        auto result = actorResultList.data()[ i ];
-        auto effect = result->getCalcResultParam();
-
-        // if effect result is a source/caster effect
-        if( result->getTarget() == m_sourceChara )
-        {
-          effectPacket->addSourceEffect( effect );
-        }
-        else
-        {
-          effectPacket->addTargetEffect( effect );
-          auto& taskMgr = Common::Service< World::Manager::TaskMgr >::ref();
-          taskMgr.queueTask( Sapphire::World::makeActionIntegrityTask( resultId, result->getTarget(), 1000 ) );
-        }
-        
-        zone->addEffectResult( std::move( result ) );
-      }
-
-      actorResultList.clear();
-      it = m_actorEffectsMap.erase( it );
-    }
-
-    m_actorEffectsMap.clear();
-
-    return effectPacket;
-  }
-  else // nothing is hit, this only happens when using aoe and AoeEffect8 is used on retail
-  {
-    auto effectPacket = makeZonePacket< FFXIVIpcActionResult1 >( m_sourceChara->getId() );
-
-    effectPacket->data().ActionKey = m_actionId;
-    effectPacket->data().Action = static_cast< uint16_t >( m_actionId );
-    effectPacket->data().Target = m_sourceChara->getId();
-    effectPacket->data().MainTarget = static_cast< uint64_t >( m_sourceChara->getId() );
-    effectPacket->data().DirTarget = Common::Util::floatToUInt16Rot( m_sourceChara->getRot() );
-    effectPacket->data().Flag = Common::ActionEffectDisplayType::HideActionName;
-    effectPacket->data().RequestId = m_requestId;
-    effectPacket->data().ResultId = resultId;
-
-    m_actorEffectsMap.clear();
-
-    return effectPacket;
-  }
-}
\ No newline at end of file
diff --git a/src/world/Action/EffectBuilder.h b/src/world/Action/EffectBuilder.h
deleted file mode 100644
index 705690a81..000000000
--- a/src/world/Action/EffectBuilder.h
+++ /dev/null
@@ -1,49 +0,0 @@
-#pragma once
-
-#include <ForwardsZone.h>
-#include <Common.h>
-
-namespace Sapphire::World::Action
-{
-  class EffectBuilder
-  {
-  public:
-    EffectBuilder( Entity::CharaPtr source, uint32_t actionId, uint16_t requestId );
-
-    void heal( Entity::CharaPtr& effectTarget, Entity::CharaPtr& healingTarget, uint32_t amount,
-               Common::ActionHitSeverityType severity = Common::ActionHitSeverityType::NormalHeal,
-               Common::ActionEffectResultFlag flag = Common::ActionEffectResultFlag::None );
-
-    void restoreMP( Entity::CharaPtr& effectTarget, Entity::CharaPtr& restoringTarget, uint32_t amount,
-                    Common::ActionEffectResultFlag flag = Common::ActionEffectResultFlag::None );
-
-    void damage( Entity::CharaPtr& effectTarget, Entity::CharaPtr& damagingTarget, uint32_t amount,
-                 Common::ActionHitSeverityType severity = Common::ActionHitSeverityType::NormalDamage,
-                 Common::ActionEffectResultFlag flag = Common::ActionEffectResultFlag::None );
-
-    void startCombo( Entity::CharaPtr& target, uint16_t actionId );
-
-    void comboSucceed( Entity::CharaPtr& target );
-
-    void applyStatusEffect( Entity::CharaPtr& target, uint16_t statusId, uint8_t param );
-
-    void mount( Entity::CharaPtr& target, uint16_t mountId );
-
-    void buildAndSendPackets( const std::vector< Entity::CharaPtr >& targetList );
-
-  private:
-    void addResultToActor( Entity::CharaPtr& chara, EffectResultPtr result );
-
-    uint64_t getResultDelayMs();
-
-    Network::Packets::FFXIVPacketBasePtr buildNextEffectPacket( const std::vector< Entity::CharaPtr >& targetList );
-
-  private:
-    uint32_t m_actionId;
-    uint16_t m_requestId;
-
-    Entity::CharaPtr m_sourceChara;
-    std::unordered_map< uint32_t, std::vector< EffectResultPtr > > m_actorEffectsMap;
-  };
-
-}
\ No newline at end of file
diff --git a/src/world/Action/EffectResult.cpp b/src/world/Action/EffectResult.cpp
deleted file mode 100644
index 8ef9d68f6..000000000
--- a/src/world/Action/EffectResult.cpp
+++ /dev/null
@@ -1,124 +0,0 @@
-#include "EffectResult.h"
-
-#include <Util/Util.h>
-
-#include <Service.h>
-#include <Manager/PlayerMgr.h>
-
-#include "Actor/Chara.h"
-#include "Actor/Player.h"
-
-using namespace Sapphire;
-using namespace Sapphire::World::Action;
-
-
-EffectResult::EffectResult( Entity::CharaPtr target, uint64_t runAfter ) :
-  m_target( std::move( target ) ),
-  m_delayMs( runAfter )
-{
-  m_result.Arg0 = 0;
-  m_result.Arg1 = 0;
-  m_result.Arg2 = 0;
-  m_result.Value = 0;
-  m_result.Flag = static_cast< uint8_t >( Common::ActionEffectResultFlag::None );
-  m_result.Type = Common::ActionEffectType::CALC_RESULT_TYPE_NONE;
-}
-
-Entity::CharaPtr EffectResult::getTarget() const
-{
-  return m_target;
-}
-
-uint64_t EffectResult::getDelay()
-{
-  return m_delayMs;
-}
-
-void EffectResult::damage( uint32_t amount, Common::ActionHitSeverityType severity, Common::ActionEffectResultFlag flag )
-{
-  m_result.Arg0 = static_cast< uint8_t >( severity );
-  m_result.Value = static_cast< int16_t >( amount );
-  m_result.Flag = static_cast< uint8_t >( flag );
-  m_result.Type = Common::ActionEffectType::CALC_RESULT_TYPE_DAMAGE_HP;
-}
-
-void EffectResult::heal( uint32_t amount, Common::ActionHitSeverityType severity, Common::ActionEffectResultFlag flag )
-{
-  m_result.Arg1 = static_cast< uint8_t >( severity );
-  m_result.Value = static_cast< int16_t >( amount );
-  m_result.Flag = static_cast< uint8_t >( flag );
-  m_result.Type = Common::ActionEffectType::CALC_RESULT_TYPE_RECOVER_HP;
-}
-
-void EffectResult::restoreMP( uint32_t amount, Common::ActionEffectResultFlag flag )
-{
-  m_result.Value = static_cast< int16_t >( amount );
-  m_result.Flag = static_cast< uint8_t >( flag );
-  m_result.Type = Common::ActionEffectType::CALC_RESULT_TYPE_RECOVER_MP;
-}
-
-void EffectResult::startCombo( uint16_t actionId )
-{
-  m_result.Value = static_cast< int16_t >( actionId );
-  m_result.Flag = static_cast< uint8_t >( Common::ActionEffectResultFlag::EffectOnSource );
-  m_result.Type = Common::ActionEffectType::CALC_RESULT_TYPE_COMBO;
-}
-
-void EffectResult::comboSucceed()
-{
-  // no EffectOnSource flag on this
-  m_result.Type = Common::ActionEffectType::CALC_RESULT_TYPE_COMBO_HIT;
-}
-
-void EffectResult::applyStatusEffect( uint16_t statusId, uint8_t param )
-{
-  m_result.Value = static_cast< int16_t >( statusId );
-  m_result.Arg2 = param;
-  m_result.Type = Common::ActionEffectType::CALC_RESULT_TYPE_SET_STATUS;
-}
-
-void EffectResult::mount( uint16_t mountId )
-{
-  m_result.Value = static_cast< int16_t >( mountId );
-  m_result.Arg0 = 1;
-  m_result.Type = Common::ActionEffectType::CALC_RESULT_TYPE_MOUNT;
-}
-
-const Common::CalcResultParam& EffectResult::getCalcResultParam() const
-{
-  return m_result;
-}
-
-void EffectResult::execute()
-{
-  switch( m_result.Type )
-  {
-    case Common::ActionEffectType::CALC_RESULT_TYPE_DAMAGE_HP:
-    {
-      m_target->takeDamage( m_result.Value );
-      break;
-    }
-
-    case Common::ActionEffectType::CALC_RESULT_TYPE_RECOVER_HP:
-    {
-      m_target->heal( m_result.Value );
-      break;
-    }
-
-    case Common::ActionEffectType::CALC_RESULT_TYPE_RECOVER_MP:
-    {
-      m_target->restoreMP( m_result.Value );
-      break;
-    }
-
-    case Common::ActionEffectType::CALC_RESULT_TYPE_MOUNT:
-    {
-      auto pPlayer = m_target->getAsPlayer();
-      pPlayer->setMount( m_result.Value );
-      break;
-    }
-
-    default:
-      break;
-  }
-}
\ No newline at end of file
diff --git a/src/world/Action/EffectResult.h b/src/world/Action/EffectResult.h
deleted file mode 100644
index 38ca2b7a2..000000000
--- a/src/world/Action/EffectResult.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-
-#include <ForwardsZone.h>
-#include <Common.h>
-
-namespace Sapphire::World::Action
-{
-  /*!
-   * @brief A container for the computed result of an effect on a single actor. Used to apply damage/healing dealt
-   * at a later point in time.
-   */
-  class EffectResult
-  {
-  public:
-    explicit EffectResult( Entity::CharaPtr target, uint64_t delayMs );
-
-    void damage( uint32_t amount, Common::ActionHitSeverityType severity, Common::ActionEffectResultFlag flag = Common::ActionEffectResultFlag::None );
-    void heal( uint32_t amount, Common::ActionHitSeverityType severity, Common::ActionEffectResultFlag flag = Common::ActionEffectResultFlag::None );
-    void restoreMP( uint32_t amount, Common::ActionEffectResultFlag flag = Common::ActionEffectResultFlag::None );
-    void startCombo( uint16_t actionId );
-    void comboSucceed();
-    void applyStatusEffect( uint16_t statusId, uint8_t param );
-    void mount( uint16_t mountId );
-
-    Entity::CharaPtr getTarget() const;
-
-    uint64_t getDelay();
-
-    const Common::CalcResultParam& getCalcResultParam() const;
-
-    void execute();
-
-  private:
-    uint64_t m_delayMs;
-
-    Entity::CharaPtr m_target;
-
-    Common::CalcResultParam m_result;
-
-  };
-}
\ No newline at end of file
diff --git a/src/world/Action/ItemAction.cpp b/src/world/Action/ItemAction.cpp
index 03139e017..462728ccd 100644
--- a/src/world/Action/ItemAction.cpp
+++ b/src/world/Action/ItemAction.cpp
@@ -67,6 +67,13 @@ void ItemAction::execute()
 
       break;
     }
+
+    case Common::ItemActionType::ItemActionSong:
+    {
+      handleSongItem();
+
+      break;
+    }
   }
 }
 
@@ -78,12 +85,11 @@ void ItemAction::interrupt()
 void ItemAction::handleVFXItem()
 {
   Common::CalcResultParam effect{};
-  effect.Type = Common::ActionEffectType::CALC_RESULT_TYPE_CHECK_BARRIER;
+  effect.Type = Common::CalcResultType::TypeCheckBarrier;
   effect.Value = m_itemAction->data().Calcu0Arg[ 0 ];
 
-  auto effectPacket = std::make_shared< EffectPacket >( getSourceChara()->getId(), getId() );
-  effectPacket->setTargetActor( getSourceChara()->getId() );
-  effectPacket->setAnimationId( Common::ItemActionType::ItemActionVFX );
+  auto effectPacket = std::make_shared< EffectPacket >( getSourceChara()->getId(), getSourceChara()->getId(), getId() );
+  effectPacket->setActionId( Common::ItemActionType::ItemActionVFX );
   effectPacket->setDisplayType( Common::ActionEffectDisplayType::ShowItemName );
   effectPacket->addTargetEffect( effect, static_cast< uint64_t >( getSourceChara()->getId() ) );
   server().queueForPlayers( m_pSource->getInRangePlayerIds( true ), effectPacket );
@@ -103,4 +109,12 @@ void ItemAction::handleMountItem()
 
   player->unlockMount( m_itemAction->data().Calcu0Arg[ 0 ] );
   player->dropInventoryItem( static_cast< Common::InventoryType >( m_itemSourceContainer ), static_cast< uint8_t >( m_itemSourceSlot ) );
+}
+
+void ItemAction::handleSongItem()
+{
+  auto player = getSourceChara()->getAsPlayer();
+
+  playerMgr().onSongLearned( *player, m_itemAction->data().Calcu0Arg[ 0 ], m_id );
+  player->dropInventoryItem( static_cast< Common::InventoryType >( m_itemSourceContainer ), static_cast< uint8_t >( m_itemSourceSlot ) );
 }
\ No newline at end of file
diff --git a/src/world/Action/ItemAction.h b/src/world/Action/ItemAction.h
index d1078bd98..9836ca34d 100644
--- a/src/world/Action/ItemAction.h
+++ b/src/world/Action/ItemAction.h
@@ -31,6 +31,8 @@ namespace Sapphire::World::Action
 
     void handleMountItem();
 
+    void handleSongItem();
+
   private:
     std::shared_ptr< Excel::ExcelStruct< Excel::ItemAction > > m_itemAction;
 
diff --git a/src/world/Action/ItemManipulationAction.cpp b/src/world/Action/ItemManipulationAction.cpp
index dc6a95c62..816d691f9 100644
--- a/src/world/Action/ItemManipulationAction.cpp
+++ b/src/world/Action/ItemManipulationAction.cpp
@@ -40,7 +40,7 @@ void ItemManipulationAction::execute()
 {
   assert( m_pSource );
 
-  m_effectBuilder->buildAndSendPackets( m_hitActors );
+  m_actionResultBuilder->sendActionResults( m_hitActors );
 }
 
 void ItemManipulationAction::onFinish()
diff --git a/src/world/Action/Job/Warrior.cpp b/src/world/Action/Job/Warrior.cpp
new file mode 100644
index 000000000..4ee8a485c
--- /dev/null
+++ b/src/world/Action/Job/Warrior.cpp
@@ -0,0 +1,70 @@
+#include "Warrior.h"
+
+#include <Action/CommonAction.h>
+#include <Action/Action.h>
+#include <Actor/Player.h>
+
+using namespace Sapphire;
+using namespace Sapphire::World::Action;
+
+void Warrior::onAction( Entity::Player& player, Action& action )
+{
+  switch( action.getId() )
+  {
+    case Maim:
+    case StormsEye:
+    case StormsPath:
+    case SkullSunder:
+    case ButchersBlock:
+    {
+      if( action.isComboAction() && !action.isCorrectCombo() )
+        break;
+
+      if( player.hasStatusEffect( Defiance ) )
+        handleWrath( player, action );
+      break;
+    }
+  }
+}
+
+void Warrior::handleWrath( Entity::Player& player, Action& action )
+{
+  auto effectToApply = Wrath;
+  auto parry = 2;
+  auto asChara = player.getAsChara();
+
+  auto pActionBuilder = action.getActionResultBuilder();
+    
+  if( !pActionBuilder )
+    return;
+
+  if( player.hasStatusEffect( Wrath ) )
+  {
+    player.replaceSingleStatusEffectById( Wrath );
+    effectToApply = WrathII;
+    parry += 2;
+  }
+  else if( player.hasStatusEffect( WrathII ) )
+  {
+    player.replaceSingleStatusEffectById( WrathII );
+    effectToApply = WrathIII;
+    parry += 2;
+  }
+  else if( player.hasStatusEffect( WrathIII ) )
+  {
+    player.replaceSingleStatusEffectById( WrathIII );
+    effectToApply = WrathIV;
+    parry += 2;
+  }
+  else if( player.hasStatusEffect( WrathIV ) )
+  {
+    player.replaceSingleStatusEffectById( WrathIV );
+    effectToApply = Infuriated;
+    parry += 2;
+  }
+
+  if( !player.hasStatusEffect( Infuriated ) )
+  {    
+    pActionBuilder->applyStatusEffectSelf( effectToApply, 30000, 0, { StatusModifier{ Common::ParamModifier::ParryPercent, parry } }, 0, false );
+  }
+}
\ No newline at end of file
diff --git a/src/world/Action/Job/Warrior.h b/src/world/Action/Job/Warrior.h
new file mode 100644
index 000000000..494743310
--- /dev/null
+++ b/src/world/Action/Job/Warrior.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <Common.h>
+#include "ForwardsZone.h"
+#include <cstdint>
+#include <unordered_map>
+#include <string>
+#include <vector>
+
+namespace Sapphire::World::Action
+{
+  class Warrior
+  {
+    public:
+      static void onAction( Entity::Player& player, Action& action );
+
+    private:
+      static void handleWrath( Entity::Player& player, Action& action );
+  };
+}
\ No newline at end of file
diff --git a/src/world/Action/MountAction.cpp b/src/world/Action/MountAction.cpp
index f8150a27a..0879c651a 100644
--- a/src/world/Action/MountAction.cpp
+++ b/src/world/Action/MountAction.cpp
@@ -69,6 +69,6 @@ void MountAction::execute()
   assert( m_pSource );
 
   m_pSource->getAsPlayer()->removeCondition( Common::PlayerCondition::Casting );
-  m_effectBuilder->mount( m_pSource, m_mountId );
-  m_effectBuilder->buildAndSendPackets( { m_pSource } );
+  m_actionResultBuilder->mount( m_pSource, m_mountId );
+  m_actionResultBuilder->sendActionResults( { m_pSource } );
 }
\ No newline at end of file
diff --git a/src/world/Actor/BNpc.cpp b/src/world/Actor/BNpc.cpp
index 106c50022..bd84aa5c4 100644
--- a/src/world/Actor/BNpc.cpp
+++ b/src/world/Actor/BNpc.cpp
@@ -18,7 +18,7 @@
 #include "Network/PacketWrappers/ActorControlTargetPacket.h"
 #include "Network/PacketWrappers/NpcSpawnPacket.h"
 #include "Network/PacketWrappers/MoveActorPacket.h"
-#include "Network/Util/PlayerUtil.h"
+#include "Network/Util/PacketUtil.h"
 
 #include "Navi/NaviProvider.h"
 
@@ -36,6 +36,7 @@
 #include <Manager/PlayerMgr.h>
 #include <Manager/TaskMgr.h>
 #include <Manager/MgrUtil.h>
+#include <Manager/ActionMgr.h>
 #include <Script/ScriptMgr.h>
 #include <Task/RemoveBNpcTask.h>
 #include <Task/FadeBNpcTask.h>
@@ -43,19 +44,32 @@
 #include <Task/ActionIntegrityTask.h>
 #include <Service.h>
 
+#include <Action/Action.h>
+#include <AI/GambitRule.h>
+#include <AI/GambitPack.h>
+#include <AI/GambitTargetCondition.h>
+#include <AI/Fsm/StateMachine.h>
+#include <AI/Fsm/Condition.h>
+#include <AI/Fsm/StateIdle.h>
+#include <AI/Fsm/StateRoam.h>
+#include <AI/Fsm/StateCombat.h>
+#include <AI/Fsm/StateRetreat.h>
+#include <AI/Fsm/StateDead.h>
+
+using namespace Sapphire;
+using namespace Sapphire::World;
 using namespace Sapphire::Common;
+using namespace Sapphire::Entity;
 using namespace Sapphire::Network::Packets;
 using namespace Sapphire::Network::Packets::WorldPackets::Server;
 using namespace Sapphire::Network::ActorControl;
 using namespace Sapphire::World::Manager;
 
-Sapphire::Entity::BNpc::BNpc() :
-  Npc( ObjKind::BattleNpc )
+BNpc::BNpc() : Npc( ObjKind::BattleNpc )
 {
 }
 
-Sapphire::Entity::BNpc::BNpc( uint32_t id, std::shared_ptr< Common::BNPCInstanceObject > pInfo, const Territory& zone ) :
-  Npc( ObjKind::BattleNpc )
+BNpc::BNpc( uint32_t id, std::shared_ptr< Common::BNPCInstanceObject > pInfo, const Territory& zone ) : Npc( ObjKind::BattleNpc )
 {
   m_id = id;
   m_pInfo = pInfo;
@@ -82,8 +96,7 @@ Sapphire::Entity::BNpc::BNpc( uint32_t id, std::shared_ptr< Common::BNPCInstance
   m_flags = 0;
   m_rank = pInfo->BNPCRankId;
 
-  if( pInfo->WanderingRange == 0 || pInfo->BoundInstanceID != 0 )
-    setFlag( Immobile );
+
 
   // Striking Dummy
   if( pInfo->NameId == 541 )
@@ -101,6 +114,9 @@ Sapphire::Entity::BNpc::BNpc( uint32_t id, std::shared_ptr< Common::BNPCInstance
   m_modelChara = bNpcBaseData->data().Model;
   m_enemyType = bNpcBaseData->data().Battalion;
 
+  if( pInfo->WanderingRange == 0 || pInfo->BoundInstanceID != 0 || m_enemyType == 0 )
+    setFlag( Immobile );
+
   m_class = ClassJob::Gladiator;
 
   m_territoryTypeId = zone.getTerritoryTypeId();
@@ -158,7 +174,7 @@ Sapphire::Entity::BNpc::BNpc( uint32_t id, std::shared_ptr< Common::BNPCInstance
   }
 
   // todo: is this actually good?
-  m_naviTargetReachedDistance = m_radius * 2;
+  m_naviTargetReachedDistance = m_radius;
 
   calculateStats();
 
@@ -167,7 +183,7 @@ Sapphire::Entity::BNpc::BNpc( uint32_t id, std::shared_ptr< Common::BNPCInstance
 
 }
 
-Sapphire::Entity::BNpc::BNpc( uint32_t id, std::shared_ptr< Common::BNPCInstanceObject > pInfo, const Territory& zone, uint32_t hp, Common::BNpcType type ) :
+BNpc::BNpc( uint32_t id, std::shared_ptr< Common::BNPCInstanceObject > pInfo, const Territory& zone, uint32_t hp, Common::BNpcType type ) :
   Npc( ObjKind::BattleNpc )
 {
   m_id = id;
@@ -258,7 +274,7 @@ Sapphire::Entity::BNpc::BNpc( uint32_t id, std::shared_ptr< Common::BNPCInstance
   auto modelChara = exdData.getRow< Excel::ModelChara >( bNpcBaseData->data().Model );
   if( modelChara )
   {
-    auto modelSkeleton = exdData.getRow< Excel::ModelSkeleton >( modelChara->data().ModelType );
+    auto modelSkeleton = exdData.getRow< Excel::ModelSkeleton >( modelChara->data().SkeletonId );
     if( modelSkeleton )
       m_radius *= modelSkeleton->data().Radius;
   }
@@ -269,81 +285,78 @@ Sapphire::Entity::BNpc::BNpc( uint32_t id, std::shared_ptr< Common::BNPCInstance
   calculateStats();
 }
 
-Sapphire::Entity::BNpc::~BNpc() = default;
+BNpc::~BNpc() = default;
 
-uint8_t Sapphire::Entity::BNpc::getAggressionMode() const
+uint8_t BNpc::getAggressionMode() const
 {
   return m_aggressionMode;
 }
 
-float Sapphire::Entity::BNpc::getNaviTargetReachedDistance() const
+float BNpc::getNaviTargetReachedDistance() const
 {
   return m_naviTargetReachedDistance;
 }
 
-uint8_t Sapphire::Entity::BNpc::getEnemyType() const
+uint8_t BNpc::getEnemyType() const
 {
   return m_enemyType;
 }
 
-uint64_t Sapphire::Entity::BNpc::getWeaponMain() const
+uint64_t BNpc::getWeaponMain() const
 {
   return m_weaponMain;
 }
 
-uint64_t Sapphire::Entity::BNpc::getWeaponSub() const
+uint64_t BNpc::getWeaponSub() const
 {
   return m_weaponSub;
 }
 
-uint16_t Sapphire::Entity::BNpc::getModelChara() const
+uint16_t BNpc::getModelChara() const
 {
   return m_modelChara;
 }
 
-uint8_t Sapphire::Entity::BNpc::getLevel() const
+uint8_t BNpc::getLevel() const
 {
   return m_level;
 }
 
-uint32_t Sapphire::Entity::BNpc::getBNpcBaseId() const
+uint32_t BNpc::getBNpcBaseId() const
 {
   return m_bNpcBaseId;
 }
 
-uint32_t Sapphire::Entity::BNpc::getBNpcNameId() const
+uint32_t BNpc::getBNpcNameId() const
 {
   return m_bNpcNameId;
 }
 
-void Sapphire::Entity::BNpc::spawn( PlayerPtr pTarget )
+void BNpc::spawn( PlayerPtr pTarget )
 {
-  m_lastRoamTargetReached = Util::getTimeSeconds();
+  m_lastRoamTargetReachedTime = Common::Util::getTimeSeconds();
 
   auto& server = Common::Service< World::WorldServer >::ref();
   server.queueForPlayer( pTarget->getCharacterId(), std::make_shared< NpcSpawnPacket >( *this, *pTarget ) );
 }
 
-void Sapphire::Entity::BNpc::despawn( PlayerPtr pTarget )
+void BNpc::despawn( PlayerPtr pTarget )
 {
   pTarget->freePlayerSpawnId( getId() );
-
-  auto& server = Common::Service< World::WorldServer >::ref();
-
-  server.queueForPlayer( pTarget->getCharacterId(), makeActorControlSelf( m_id, WarpStart, 0x04, getId(), 0x01 ) );
+  Network::Util::Packet::sendActorControlSelf( *pTarget, getId(), WarpStart, 4, getId(), 1 );
 }
 
-Sapphire::Entity::BNpcState Sapphire::Entity::BNpc::getState() const
+BNpcState BNpc::getState() const
 {
   return m_state;
 }
 
-void Sapphire::Entity::BNpc::setState( BNpcState state )
+void BNpc::setState( BNpcState state )
 {
   m_state = state;
 }
 
-bool Sapphire::Entity::BNpc::moveTo( const FFXIVARR_POSITION3& pos )
+bool BNpc::moveTo( const FFXIVARR_POSITION3& pos )
 {
   auto& teriMgr = Common::Service< World::Manager::TerritoryMgr >::ref();
   auto pZone = teriMgr.getTerritoryByGuId( getTerritoryId() );
@@ -357,14 +370,13 @@ bool Sapphire::Entity::BNpc::moveTo( const FFXIVARR_POSITION3& pos )
   }
 
   auto pos1 = pNaviProvider->getMovePos( *this );
-  auto distance = Util::distance( pos1, pos );
+  auto distance = Common::Util::distance( pos1, pos );
 
   if( distance < getNaviTargetReachedDistance() )
   {
     // Reached destination
     face( pos );
     setPos( pos1 );
-    sendPositionUpdate();
     pNaviProvider->updateAgentPosition( *this );
     return true;
   }
@@ -376,11 +388,10 @@ bool Sapphire::Entity::BNpc::moveTo( const FFXIVARR_POSITION3& pos )
   else
     face( pos );
   setPos( pos1 );
-  sendPositionUpdate();
   return false;
 }
 
-bool Sapphire::Entity::BNpc::moveTo( const Entity::Chara& targetChara )
+bool BNpc::moveTo( const Chara& targetChara )
 {
 
   auto& teriMgr = Common::Service< World::Manager::TerritoryMgr >::ref();
@@ -395,14 +406,13 @@ bool Sapphire::Entity::BNpc::moveTo( const Entity::Chara& targetChara )
   }
 
   auto pos1 = pNaviProvider->getMovePos( *this );
-  auto distance = Util::distance( pos1, targetChara.getPos() );
+  auto distance = Common::Util::distance( pos1, targetChara.getPos() );
 
   if( distance <= ( getNaviTargetReachedDistance() + targetChara.getRadius() ) )
   {
     // Reached destination
     face( targetChara.getPos() );
     setPos( pos1 );
-    sendPositionUpdate();
     pNaviProvider->resetMoveTarget( *this );
     pNaviProvider->updateAgentPosition( *this );
     return true;
@@ -414,11 +424,10 @@ bool Sapphire::Entity::BNpc::moveTo( const Entity::Chara& targetChara )
   else
     face( targetChara.getPos() );
   setPos( pos1 );
-  sendPositionUpdate();
   return false;
 }
 
-void Sapphire::Entity::BNpc::sendPositionUpdate()
+void BNpc::sendPositionUpdate()
 {
   uint8_t animationType = 2;
 
@@ -429,7 +438,12 @@ void Sapphire::Entity::BNpc::sendPositionUpdate()
   server().queueForPlayers( getInRangePlayerIds(), movePacket );
 }
 
-void Sapphire::Entity::BNpc::hateListClear()
+const std::set< std::shared_ptr< HateListEntry > >& BNpc::getHateList() const
+{
+  return m_hateList;
+}
+
+void BNpc::hateListClear()
 {
   for( auto& listEntry : m_hateList )
   {
@@ -439,7 +453,7 @@ void Sapphire::Entity::BNpc::hateListClear()
   m_hateList.clear();
 }
 
-uint32_t Sapphire::Entity::BNpc::hateListGetValue( const Sapphire::Entity::CharaPtr& pChara )
+uint32_t BNpc::hateListGetValue( const Sapphire::Entity::CharaPtr& pChara )
 {
   for( const auto& listEntry : m_hateList )
   {
@@ -452,7 +466,7 @@ uint32_t Sapphire::Entity::BNpc::hateListGetValue( const Sapphire::Entity::Chara
   return 0;
 }
 
-uint32_t Sapphire::Entity::BNpc::hateListGetHighestValue()
+uint32_t BNpc::hateListGetHighestValue()
 {
   auto it = m_hateList.begin();
   uint32_t maxHate = 0;
@@ -473,7 +487,7 @@ uint32_t Sapphire::Entity::BNpc::hateListGetHighestValue()
 }
 
 
-Sapphire::Entity::CharaPtr Sapphire::Entity::BNpc::hateListGetHighest()
+CharaPtr BNpc::hateListGetHighest()
 {
   auto it = m_hateList.begin();
   uint32_t maxHate = 0;
@@ -493,7 +507,7 @@ Sapphire::Entity::CharaPtr Sapphire::Entity::BNpc::hateListGetHighest()
   return nullptr;
 }
 
-void Sapphire::Entity::BNpc::hateListAdd( const Sapphire::Entity::CharaPtr& pChara, int32_t hateAmount )
+void BNpc::hateListAdd( const CharaPtr& pChara, int32_t hateAmount )
 {
   auto hateEntry = std::make_shared< HateListEntry >();
   hateEntry->m_hateAmount = static_cast< uint32_t >( hateAmount );
@@ -507,14 +521,14 @@ void Sapphire::Entity::BNpc::hateListAdd( const Sapphire::Entity::CharaPtr& pCha
   }
 }
 
-void Sapphire::Entity::BNpc::hateListAddDelayed( const Sapphire::Entity::CharaPtr& pChara, int32_t hateAmount )
+void BNpc::hateListAddDelayed( const CharaPtr& pChara, int32_t hateAmount )
 {
   auto& taskMgr = Common::Service< World::Manager::TaskMgr >::ref();
-  auto delayedEmnityTask = std::make_shared< Sapphire::World::DelayedEmnityTask >( 5000, getAsBNpc(), pChara, hateAmount );
+  auto delayedEmnityTask = std::make_shared< World::DelayedEmnityTask >( 5000, getAsBNpc(), pChara, hateAmount );
   taskMgr.queueTask( delayedEmnityTask );
 }
 
-void Sapphire::Entity::BNpc::hateListUpdate( const Sapphire::Entity::CharaPtr& pChara, int32_t hateAmount )
+void BNpc::hateListUpdate( const CharaPtr& pChara, int32_t hateAmount )
 {
   bool hasEntry = false;
 
@@ -542,12 +556,12 @@ void Sapphire::Entity::BNpc::hateListUpdate( const Sapphire::Entity::CharaPtr& p
     if( pChara->isPlayer() )
     {
       auto pPlayer = pChara->getAsPlayer();
-      Network::Util::Player::sendHateList( *pPlayer );
+      Network::Util::Packet::sendHateList( *pPlayer );
     }
   }
 }
 
-void Sapphire::Entity::BNpc::hateListRemove( const Sapphire::Entity::CharaPtr& pChara )
+void BNpc::hateListRemove( const CharaPtr& pChara )
 {
   for( const auto& listEntry : m_hateList )
   {
@@ -565,33 +579,38 @@ void Sapphire::Entity::BNpc::hateListRemove( const Sapphire::Entity::CharaPtr& p
   }
 }
 
-uint32_t Sapphire::Entity::BNpc::getTriggerOwnerId() const
+uint32_t BNpc::getTriggerOwnerId() const
 {
   return m_triggerOwnerId;
 }
 
-void Sapphire::Entity::BNpc::setTriggerOwnerId( uint32_t triggerOwnerId )
+void BNpc::setTriggerOwnerId( uint32_t triggerOwnerId )
 {
   m_triggerOwnerId = triggerOwnerId;
 }
 
-bool Sapphire::Entity::BNpc::hateListHasActor( const Sapphire::Entity::CharaPtr& pChara )
+bool BNpc::hateListHasActor( const Sapphire::Entity::CharaPtr& pChara )
 {
   return std::any_of( m_hateList.begin(), m_hateList.end(),
                       [ pChara ]( const auto& entry ) { return entry->m_pChara == pChara; } );
 }
 
-void Sapphire::Entity::BNpc::aggro( const Sapphire::Entity::CharaPtr& pChara )
+void BNpc::aggro( const Sapphire::Entity::CharaPtr& pChara )
 {
   auto& pRNGMgr = Common::Service< World::Manager::RNGMgr >::ref();
   auto variation = static_cast< uint32_t >( pRNGMgr.getRandGenerator< float >( 500, 1000 ).next() );
 
-  m_lastAttack = Util::getTimeMs() + variation;
+  if( m_pGambitPack && m_pGambitPack->getAsTimeLine() )
+  {
+    m_pGambitPack->getAsTimeLine()->start();
+  }
+
+  m_lastAttack = Common::Util::getTimeMs() + variation;
 
   setStance( Stance::Active );
   m_state = BNpcState::Combat;
 
-  server().queueForPlayers( getInRangePlayerIds(), makeActorControl( getId(), ActorControlType::SetBattle, 1, 0, 0 ) );
+  Network::Util::Packet::sendActorControl( getInRangePlayerIds(), getId(), SetBattle, 1 );
 
   changeTarget( pChara->getId() );
 
@@ -603,7 +622,7 @@ void Sapphire::Entity::BNpc::aggro( const Sapphire::Entity::CharaPtr& pChara )
 
 }
 
-void Sapphire::Entity::BNpc::deaggro( const Sapphire::Entity::CharaPtr& pChara )
+void BNpc::deaggro( const CharaPtr& pChara )
 {
   if( !hateListHasActor( pChara ) )
     hateListRemove( pChara );
@@ -611,8 +630,8 @@ void Sapphire::Entity::BNpc::deaggro( const Sapphire::Entity::CharaPtr& pChara )
   if( pChara->isPlayer() )
   {
     PlayerPtr tmpPlayer = pChara->getAsPlayer();
-    server().queueForPlayers( getInRangePlayerIds(), makeActorControl( getId(), ActorControlType::ToggleWeapon, 0, 1, 1 ) );
-    server().queueForPlayers( getInRangePlayerIds(), makeActorControl( getId(), ActorControlType::SetBattle, 0, 0, 0 ) );
+    Network::Util::Packet::sendActorControl( getInRangePlayerIds(), getId(), ToggleWeapon, 0, 1, 1 );
+    Network::Util::Packet::sendActorControl( getInRangePlayerIds(), getId(), SetBattle );
     tmpPlayer->onMobDeaggro( *this );
 
     if( getTriggerOwnerId() == pChara->getId() )
@@ -624,7 +643,7 @@ void Sapphire::Entity::BNpc::deaggro( const Sapphire::Entity::CharaPtr& pChara )
   }
 }
 
-void Sapphire::Entity::BNpc::onTick()
+void BNpc::onTick()
 {
   Chara::onTick();
   if( m_state == BNpcState::Retreat )
@@ -633,168 +652,17 @@ void Sapphire::Entity::BNpc::onTick()
   }
 }
 
-void Sapphire::Entity::BNpc::update( uint64_t tickCount )
+void BNpc::update( uint64_t tickCount )
 {
-  auto& teriMgr = Common::Service< World::Manager::TerritoryMgr >::ref();
-  auto pZone = teriMgr.getTerritoryByGuId( getTerritoryId() );
-
-  const uint8_t maxDistanceToOrigin = 40;
-  const uint32_t roamTick = 20;
-
-  auto pNaviProvider = pZone->getNaviProvider();
-
-  if( !pNaviProvider )
-    return;
-
-  switch( m_state )
-  {
-    case BNpcState::Dead:
-    case BNpcState::JustDied:
-      return;
-
-    case BNpcState::Retreat:
-    {
-      setInvincibilityType( InvincibilityType::InvincibilityIgnoreDamage );
-
-      if( pNaviProvider )
-        pNaviProvider->setMoveTarget( *this, m_spawnPos );
-
-      if( moveTo( m_spawnPos ) )
-      {
-        setInvincibilityType( InvincibilityType::InvincibilityNone );
-
-        // retail doesn't seem to roam straight after retreating
-        // todo: perhaps requires more investigation?
-        m_lastRoamTargetReached = Util::getTimeSeconds();
-
-        // resetHp
-        setHp( getMaxHp() );
-
-        m_state = BNpcState::Idle;
-        setOwner( nullptr );
-      }
-    }
-    break;
-
-    case BNpcState::Roaming:
-    {
-
-      if( pNaviProvider )
-        pNaviProvider->setMoveTarget( *this, m_roamPos );
-
-      if( moveTo( m_roamPos ) )
-      {
-        m_lastRoamTargetReached = Util::getTimeSeconds();
-        m_state = BNpcState::Idle;
-      }
-
-      checkAggro();
-    }
-    break;
-
-    case BNpcState::Idle:
-    {
-      auto pHatedActor = hateListGetHighest();
-      if( pHatedActor )
-        aggro( pHatedActor );
-
-      if( pNaviProvider->syncPosToChara( *this ) )
-        sendPositionUpdate();
-
-      if( !hasFlag( Immobile ) && ( Util::getTimeSeconds() - m_lastRoamTargetReached > roamTick ) )
-      {
-
-        if( !pNaviProvider )
-        {
-          m_lastRoamTargetReached = Util::getTimeSeconds();
-          break;
-        }
-        if( m_pInfo->WanderingRange != 0 && getEnemyType() != 0 )
-        {
-          m_roamPos = pNaviProvider->findRandomPositionInCircle( m_spawnPos, m_pInfo->WanderingRange );
-        }
-        else
-        {
-          m_roamPos = m_spawnPos;
-        }
-        m_state = BNpcState::Roaming;
-      }
-
-      checkAggro();
-      break;
-    }
-
-    case BNpcState::Combat:
-    {
-      auto pHatedActor = hateListGetHighest();
-      if( !pHatedActor )
-        return;
-
-      pNaviProvider->updateAgentParameters( *this );
-
-      auto distanceOrig = Util::distance( getPos().x, getPos().y, getPos().z, m_spawnPos.x, m_spawnPos.y,  m_spawnPos.z );
-
-      if( pHatedActor && !pHatedActor->isAlive() )
-      {
-        hateListRemove( pHatedActor );
-        pHatedActor = hateListGetHighest();
-      }
-
-      if( pHatedActor )
-      {
-        auto distance = Util::distance( getPos().x, getPos().y, getPos().z,
-                                        pHatedActor->getPos().x, pHatedActor->getPos().y, pHatedActor->getPos().z );
-
-        if( !hasFlag( NoDeaggro ) && ( ( distanceOrig > maxDistanceToOrigin ) || distance > 30.0f ) )
-        {
-          hateListClear();
-          changeTarget( INVALID_GAME_OBJECT_ID64 );
-          setStance( Stance::Passive );
-          setOwner( nullptr );
-          m_state = BNpcState::Retreat;
-          break;
-        }
-
-        if( distance > ( getNaviTargetReachedDistance() + pHatedActor->getRadius() ) )
-        {
-          if( hasFlag( Immobile ) )
-            break;
-
-          if( pNaviProvider )
-            pNaviProvider->setMoveTarget( *this, pHatedActor->getPos() );
-
-          moveTo( *pHatedActor );
-        }
-
-        if( pNaviProvider->syncPosToChara( *this ) )
-          sendPositionUpdate();
-
-        if( distance < ( getNaviTargetReachedDistance() + pHatedActor->getRadius() ) )
-        {
-          if( !hasFlag( TurningDisabled ) && face( pHatedActor->getPos() ) )
-            sendPositionUpdate();
-
-          // in combat range. ATTACK!
-          autoAttack( pHatedActor );
-        }
-      }
-      else
-      {
-        changeTarget( INVALID_GAME_OBJECT_ID64 );
-        setStance( Stance::Passive );
-        //setOwner( nullptr );
-        m_state = BNpcState::Retreat;
-        pNaviProvider->updateAgentParameters( *this );
-      }
-    }
-    break;
-  }
+  Chara::update( tickCount );
 
+  if( m_dirtyFlag & DirtyFlag::Position )
+    sendPositionUpdate();
 
-  Chara::update( tickCount );
+  m_fsm->update( *this, tickCount );
 }
 
-void Sapphire::Entity::BNpc::restHp()
+void BNpc::restHp()
 {
   if( m_hp < getMaxHp() )
   {
@@ -806,10 +674,10 @@ void Sapphire::Entity::BNpc::restHp()
       m_hp = getMaxHp();
   }
 
-  sendHudParam();
+  Network::Util::Packet::sendHudParam( *this );
 }
 
-void Sapphire::Entity::BNpc::onActionHostile( Sapphire::Entity::CharaPtr pSource )
+void BNpc::onActionHostile( CharaPtr pSource )
 {
   if( !hateListGetHighest() )
     aggro( pSource );
@@ -820,7 +688,7 @@ void Sapphire::Entity::BNpc::onActionHostile( Sapphire::Entity::CharaPtr pSource
     setOwner( pSource );
 }
 
-void Sapphire::Entity::BNpc::onDeath()
+void BNpc::onDeath()
 {
   auto& playerMgr = Common::Service< World::Manager::PlayerMgr >::ref();
   auto& taskMgr = Common::Service< World::Manager::TaskMgr >::ref();
@@ -828,7 +696,7 @@ void Sapphire::Entity::BNpc::onDeath()
   setTargetId( INVALID_GAME_OBJECT_ID64 );
   m_currentStance = Stance::Passive;
   m_state = BNpcState::Dead;
-  m_timeOfDeath = Util::getTimeSeconds();
+  m_timeOfDeath = Common::Util::getTimeSeconds();
   setOwner( nullptr );
 
   taskMgr.queueTask( World::makeFadeBNpcTask( 10000, getAsBNpc() ) );
@@ -844,24 +712,24 @@ void Sapphire::Entity::BNpc::onDeath()
     if( pPlayer )
     {
       playerMgr.onMobKill( *pPlayer, *this );
-      pPlayer->gainExp( paramGrowthInfo->data().BaseExp );
+      playerMgr.onGainExp( *pPlayer, paramGrowthInfo->data().BaseExp );
     }
   }
 
   hateListClear();
 }
 
-uint32_t Sapphire::Entity::BNpc::getTimeOfDeath() const
+uint32_t BNpc::getTimeOfDeath() const
 {
   return m_timeOfDeath;
 }
 
-void Sapphire::Entity::BNpc::setTimeOfDeath( uint32_t timeOfDeath )
+void BNpc::setTimeOfDeath( uint32_t timeOfDeath )
 {
   m_timeOfDeath = timeOfDeath;
 }
 
-void Sapphire::Entity::BNpc::checkAggro()
+void BNpc::checkAggro()
 {
   // passive mobs should ignore players unless aggro'd
   if( m_aggressionMode == 1 )
@@ -885,7 +753,7 @@ void Sapphire::Entity::BNpc::checkAggro()
         range = std::max< float >( 0.f, range - std::pow( 1.53f, static_cast< float >( levelDiff ) * 0.6f ) );
     }
 
-    auto distance = Util::distance( getPos(), pClosestChara->getPos() );
+    auto distance = Common::Util::distance( getPos(), pClosestChara->getPos() );
 
     if( distance < range )
     {
@@ -916,7 +784,7 @@ void Sapphire::Entity::BNpc::checkAggro()
         range = std::max< float >( 0.f, range - std::pow( 1.53f, static_cast< float >( levelDiff ) * 0.6f ) );
     }
 
-    auto distance = Util::distance( getPos(), pClosestChara->getPos() );
+    auto distance = Common::Util::distance( getPos(), pClosestChara->getPos() );
 
     if( distance < range )
     {
@@ -925,7 +793,7 @@ void Sapphire::Entity::BNpc::checkAggro()
   }
 }
 
-void Sapphire::Entity::BNpc::setOwner( const Sapphire::Entity::CharaPtr& m_pChara )
+void BNpc::setOwner( const CharaPtr& m_pChara )
 {
   m_pOwner = m_pChara;
   auto targetId = static_cast< uint32_t >( INVALID_GAME_OBJECT_ID );
@@ -937,40 +805,49 @@ void Sapphire::Entity::BNpc::setOwner( const Sapphire::Entity::CharaPtr& m_pChar
   setOwnerPacket->data().Id = targetId;
   server().queueForPlayers( getInRangePlayerIds(), setOwnerPacket );
 
-  if( m_pChara != nullptr && m_pChara->isPlayer() )
-  {
-    auto letter = makeActorControl( getId(), ActorControlType::SetHateLetter, 1, getId(), 0 );
-    server().queueForPlayer( m_pChara->getAsPlayer()->getCharacterId(), letter );
-  }
+  if( m_pChara && m_pChara->isPlayer() )
+    Network::Util::Packet::sendActorControl( *m_pChara->getAsPlayer(), getId(), SetHateLetter, 1, getId(), 0 );
 
 }
 
-void Sapphire::Entity::BNpc::setLevelId( uint32_t levelId )
+void BNpc::setLevelId( uint32_t levelId )
 {
   m_levelId = levelId;
 }
 
-uint32_t Sapphire::Entity::BNpc::getLevelId() const
+uint32_t BNpc::getLevelId() const
 {
   return m_levelId;
 }
 
-bool Sapphire::Entity::BNpc::hasFlag( uint32_t flag ) const
+bool BNpc::hasFlag( uint32_t flag ) const
 {
   return m_flags & flag;
 }
 
-void Sapphire::Entity::BNpc::setFlag( uint32_t flag )
+void BNpc::setFlag( uint32_t flag )
 {
   m_flags |= flag;
 }
 
-void Sapphire::Entity::BNpc::autoAttack( CharaPtr pTarget )
+void BNpc::removeFlag( uint32_t flag )
+{
+  m_flags &= ~flag;
+}
+
+void BNpc::clearFlags()
+{
+  m_flags = 0;
+}
+
+void BNpc::autoAttack( CharaPtr pTarget )
 {
   auto& teriMgr = Common::Service< World::Manager::TerritoryMgr >::ref();
   auto pZone = teriMgr.getTerritoryByGuId( getTerritoryId() );
+  auto& actionMgr = Common::Service< World::Manager::ActionMgr >::ref();
+  auto& exdData = Common::Service< Data::ExdData >::ref();
 
-  uint64_t tick = Util::getTimeMs();
+  uint64_t tick = Common::Util::getTimeMs();
 
   // todo: this needs to use the auto attack delay for the equipped weapon
   if( ( tick - m_lastAttack ) > 2500 )
@@ -978,30 +855,11 @@ void Sapphire::Entity::BNpc::autoAttack( CharaPtr pTarget )
     pTarget->onActionHostile( getAsChara() );
     m_lastAttack = tick;
     srand( static_cast< uint32_t >( tick ) );
-
-    auto damage = Math::CalcStats::calcAutoAttackDamage( *this );
-    //damage.first = 1;
-
-    auto effectPacket = std::make_shared< EffectPacket1 >( getId(), pTarget->getId(), 7 );
-    effectPacket->setRotation( Util::floatToUInt16Rot( getRot() ) );
-    Common::CalcResultParam effectEntry{};
-    effectEntry.Value = static_cast< int16_t >( damage.first );
-    effectEntry.Type = ActionEffectType::CALC_RESULT_TYPE_DAMAGE_HP;
-    effectEntry.Arg0 = 3;
-    effectEntry.Arg1 = 7;
-    auto resultId = pZone->getNextEffectResultId();
-    effectPacket->setResultId( resultId );
-    effectPacket->addTargetEffect( effectEntry );
-    server().queueForPlayers( getInRangePlayerIds(), effectPacket );
-
-    pTarget->takeDamage( static_cast< uint16_t >( damage.first ) );
-
-    auto& taskMgr = Common::Service< World::Manager::TaskMgr >::ref();
-    taskMgr.queueTask( Sapphire::World::makeActionIntegrityTask( resultId, pTarget, 500 ) );
+    actionMgr.handleTargetedAction( *this, 7, pTarget->getId(), 0 );
   }
 }
 
-void Sapphire::Entity::BNpc::calculateStats()
+void BNpc::calculateStats()
 {
   auto level = getLevel();
   auto job = static_cast< uint8_t >( getClass() );
@@ -1044,28 +902,125 @@ void Sapphire::Entity::BNpc::calculateStats()
 
 }
 
-uint32_t Sapphire::Entity::BNpc::getRank() const
+uint32_t BNpc::getRank() const
 {
   return m_rank;
 }
 
-uint32_t Sapphire::Entity::BNpc::getBoundInstanceId() const
+uint32_t BNpc::getBoundInstanceId() const
 {
   return m_boundInstanceId;
 }
 
-BNpcType Sapphire::Entity::BNpc::getBNpcType() const
+BNpcType BNpc::getBNpcType() const
 {
   return m_bnpcType;
 }
 
-uint32_t Sapphire::Entity::BNpc::getLayoutId() const
+uint32_t BNpc::getLayoutId() const
 {
   return m_layoutId;
 }
 
-void Sapphire::Entity::BNpc::init()
+void BNpc::init()
 {
-  m_maxHp = Sapphire::Math::CalcStats::calculateMaxHp( *getAsChara() );
+  m_maxHp = Math::CalcStats::calculateMaxHp( *getAsChara() );
   m_hp = m_maxHp;
+
+  m_lastRoamTargetReachedTime = Common::Util::getTimeSeconds();
+
+  /*
+  //setup a test gambit
+  auto testGambitRule = AI::make_GambitRule( AI::make_TopHateTargetCondition(), Action::make_Action( getAsChara(), 88, 0 ), 5000 );
+  auto testGambitRule1 = AI::make_GambitRule( AI::make_HPSelfPctLessThanTargetCondition( 50 ), Action::make_Action( getAsChara(), 120, 0 ), 5000 );
+
+  auto gambitPack = AI::make_GambitRuleSetPack();
+  gambitPack->addRule( AI::make_TopHateTargetCondition(), Action::make_Action( getAsChara(), 88, 0 ), 5000 );
+  gambitPack->addRule( AI::make_HPSelfPctLessThanTargetCondition( 50 ), Action::make_Action( getAsChara(), 120, 0 ), 10000 );
+  m_pGambitPack = gambitPack;
+
+
+  auto gambitPack = AI::make_GambitTimeLinePack( -1 );
+  gambitPack->addTimeLine( AI::make_TopHateTargetCondition(), Action::make_Action( getAsChara(), 88, 0 ), 2 );
+  gambitPack->addTimeLine( AI::make_TopHateTargetCondition(), Action::make_Action( getAsChara(), 89, 0 ), 4 );
+  gambitPack->addTimeLine( AI::make_TopHateTargetCondition(), Action::make_Action( getAsChara(), 90, 0 ), 6 );
+  gambitPack->addTimeLine( AI::make_TopHateTargetCondition(), Action::make_Action( getAsChara(), 91, 0 ), 8 );
+  gambitPack->addTimeLine( AI::make_TopHateTargetCondition(), Action::make_Action( getAsChara(), 92, 0 ), 10 );
+  gambitPack->addTimeLine( AI::make_TopHateTargetCondition(), Action::make_Action( getAsChara(), 81, 0 ), 12 );
+  gambitPack->addTimeLine( AI::make_TopHateTargetCondition(), Action::make_Action( getAsChara(), 82, 0 ), 14 );
+  m_pGambitPack = gambitPack;
+  */
+  using namespace AI::Fsm;
+  m_fsm = make_StateMachine();
+  auto stateIdle = make_StateIdle();
+  auto stateCombat = make_StateCombat();
+  auto stateDead = make_StateDead();
+  if( !hasFlag( Immobile ) )
+  {
+    auto stateRoam = make_StateRoam();
+    stateIdle->addTransition( stateRoam, make_RoamNextTimeReachedCondition() );
+    stateRoam->addTransition( stateIdle, make_RoamTargetReachedCondition() );
+    stateRoam->addTransition( stateCombat, make_HateListHasEntriesCondition() );
+    stateRoam->addTransition( stateDead, make_IsDeadCondition() );
+    m_fsm->addState( stateRoam );
+  }
+  stateIdle->addTransition( stateCombat, make_HateListHasEntriesCondition() );
+  stateCombat->addTransition( stateIdle, make_HateListEmptyCondition() );
+  stateIdle->addTransition( stateDead, make_IsDeadCondition() );
+  stateCombat->addTransition( stateDead, make_IsDeadCondition() );
+  m_fsm->addState( stateIdle );
+  if( !hasFlag( NoDeaggro ) )
+  {
+    auto stateRetreat = make_StateRetreat();
+    stateCombat->addTransition( stateRetreat, make_SpawnPointDistanceGtMaxDistanceCondition() );
+    stateRetreat->addTransition( stateIdle, make_RoamTargetReachedCondition() );
+  }
+  m_fsm->setCurrentState( stateIdle );
+}
+
+void BNpc::processGambits( uint64_t tickCount )
+{
+  m_tp = 1000;
+  if( m_pGambitPack )
+    m_pGambitPack->update( *this, tickCount );
+}
+
+uint32_t BNpc::getLastRoamTargetReachedTime() const
+{
+  return m_lastRoamTargetReachedTime;
+}
+
+void BNpc::setLastRoamTargetReachedTime( uint32_t time )
+{
+  m_lastRoamTargetReachedTime = time;
+}
+
+std::shared_ptr< Common::BNPCInstanceObject > BNpc::getInstanceObjectInfo() const
+{
+  return m_pInfo;
+}
+
+void BNpc::setRoamTargetReached( bool reached )
+{
+  m_roamTargetReached = reached;
 }
+
+bool BNpc::isRoamTargetReached() const
+{
+  return m_roamTargetReached;
+}
+
+void BNpc::setRoamTargetPos( const FFXIVARR_POSITION3& targetPos )
+{
+  m_roamPos = targetPos;
+}
+
+const Common::FFXIVARR_POSITION3& BNpc::getRoamTargetPos() const
+{
+  return m_roamPos;
+}
+
+const Common::FFXIVARR_POSITION3& BNpc::getSpawnPos() const
+{
+  return m_spawnPos;
+}
\ No newline at end of file
diff --git a/src/world/Actor/BNpc.h b/src/world/Actor/BNpc.h
index 867f18f35..540a624fb 100644
--- a/src/world/Actor/BNpc.h
+++ b/src/world/Actor/BNpc.h
@@ -3,6 +3,7 @@
 #include <Common.h>
 
 #include "Forwards.h"
+#include "ForwardsZone.h"
 #include "Chara.h"
 #include "Npc.h"
 #include <set>
@@ -17,6 +18,7 @@ namespace Sapphire::Entity
     uint32_t m_hateAmount;
     CharaPtr m_pChara;
   };
+  using HateListEntryPtr = std::shared_ptr< HateListEntry >;
 
   enum class BNpcState
   {
@@ -30,13 +32,16 @@ namespace Sapphire::Entity
 
   enum BNpcFlag
   {
-    None = 0,
-    Immobile = 1,
-    TurningDisabled = 2,
-    Invincible = 4,
-    InvincibleRefill = 8,
-    NoDeaggro = 16,
-    Untargetable = 32,
+    Immobile           = 0x01,
+    TurningDisabled    = 0x02,
+    Invincible         = 0x04,
+    StayAlive          = 0x08,
+    NoDeaggro          = 0x10,
+    Untargetable       = 0x20,
+    AutoAttackDisabled = 0x40,
+    Invisible          = 0x80,
+
+    Intermission       = 0x77 // for transition phases to ensure boss only moves/acts when scripted
   };
 
   const std::array< uint32_t, 50 > BnpcBaseHp =
@@ -102,6 +107,7 @@ namespace Sapphire::Entity
     BNpcState getState() const;
     void setState( BNpcState state );
 
+    const std::set< std::shared_ptr< HateListEntry > >& getHateList() const;
     void hateListClear();
     uint32_t hateListGetValue( const Sapphire::Entity::CharaPtr& pChara );
     uint32_t hateListGetHighestValue();
@@ -111,7 +117,7 @@ namespace Sapphire::Entity
     void hateListUpdate( const CharaPtr& pChara, int32_t hateAmount );
     void hateListRemove( const CharaPtr& pChara );
     bool hateListHasActor( const CharaPtr& pChara );
-
+    
     void aggro( const CharaPtr& pChara );
     void deaggro( const CharaPtr& pChara );
 
@@ -139,6 +145,8 @@ namespace Sapphire::Entity
 
     bool hasFlag( uint32_t flag ) const;
     void setFlag( uint32_t flags );
+    void removeFlag( uint32_t flag );
+    void clearFlags();
 
     void calculateStats() override;
 
@@ -148,6 +156,21 @@ namespace Sapphire::Entity
 
     uint32_t getLayoutId() const;
 
+    void processGambits( uint64_t tickCount );
+
+    uint32_t getLastRoamTargetReachedTime() const;
+    void setLastRoamTargetReachedTime( uint32_t time );
+
+    std::shared_ptr< Common::BNPCInstanceObject > getInstanceObjectInfo() const;
+
+    void setRoamTargetReached( bool reached );
+    bool isRoamTargetReached() const;
+
+    void setRoamTargetPos( const Common::FFXIVARR_POSITION3& targetPos );
+
+    const Common::FFXIVARR_POSITION3& getRoamTargetPos() const;
+    const Common::FFXIVARR_POSITION3& getSpawnPos() const;
+
   private:
     uint32_t m_bNpcBaseId;
     uint32_t m_bNpcNameId;
@@ -175,7 +198,8 @@ namespace Sapphire::Entity
     std::shared_ptr< Common::BNPCInstanceObject > m_pInfo;
 
     uint32_t m_timeOfDeath;
-    uint32_t m_lastRoamTargetReached;
+    uint32_t m_lastRoamTargetReachedTime;
+    bool m_roamTargetReached{ false };
 
     Common::FFXIVARR_POSITION3 m_spawnPos;
     Common::FFXIVARR_POSITION3 m_roamPos;
@@ -189,6 +213,9 @@ namespace Sapphire::Entity
     Common::FFXIVARR_POSITION3 m_naviTarget;
 
     CharaPtr m_pOwner;
+    World::AI::GambitPackPtr m_pGambitPack;
+
+    std::shared_ptr< World::AI::Fsm::StateMachine > m_fsm;
 
   };
 
diff --git a/src/world/Actor/Chara.cpp b/src/world/Actor/Chara.cpp
index 23f652b5d..e4f65a026 100644
--- a/src/world/Actor/Chara.cpp
+++ b/src/world/Actor/Chara.cpp
@@ -5,7 +5,6 @@
 #include <Network/CommonActorControl.h>
 #include <Service.h>
 
-
 #include "Forwards.h"
 
 #include "Territory/Territory.h"
@@ -13,11 +12,12 @@
 #include "Network/GameConnection.h"
 #include "Network/PacketWrappers/ActorControlPacket.h"
 #include "Network/PacketWrappers/ActorControlTargetPacket.h"
-#include "Network/PacketWrappers/RestingPacket.h"
 #include "Network/PacketWrappers/EffectPacket1.h"
 #include "Network/PacketWrappers/HudParamPacket.h"
+#include "Network/PacketWrappers/MoveActorPacket.h"
+
+#include "Network/Util/PacketUtil.h"
 
-#include "StatusEffect/StatusEffect.h"
 #include "Action/Action.h"
 #include "WorldServer.h"
 #include "Session.h"
@@ -26,15 +26,20 @@
 #include "Player.h"
 #include "Manager/TerritoryMgr.h"
 #include "Manager/MgrUtil.h"
+#include "Manager/PlayerMgr.h"
+#include "Navi/NaviProvider.h"
 #include "Common.h"
 
+using namespace Sapphire;
 using namespace Sapphire::Common;
+using namespace Sapphire::Entity;
+using namespace Sapphire::World;
 using namespace Sapphire::World::Manager;
 using namespace Sapphire::Network::Packets;
 using namespace Sapphire::Network::Packets::WorldPackets::Server;
 using namespace Sapphire::Network::ActorControl;
 
-Sapphire::Entity::Chara::Chara( ObjKind type ) :
+Chara::Chara( ObjKind type ) :
   GameObject( type ),
   m_pose( 0 ),
   m_targetId( INVALID_GAME_OBJECT_ID64 ),
@@ -44,7 +49,7 @@ Sapphire::Entity::Chara::Chara( ObjKind type ) :
 
   m_lastTickTime = 0;
   m_lastUpdate = 0;
-  m_lastAttack = Util::getTimeMs();
+  m_lastAttack = Common::Util::getTimeMs();
 
   m_bonusStats.fill( 0 );
 
@@ -55,76 +60,75 @@ Sapphire::Entity::Chara::Chara( ObjKind type ) :
   }
 }
 
-Sapphire::Entity::Chara::~Chara()
-= default;
+Chara::~Chara() = default;
 
 /*! \return the actors name */
-std::string Sapphire::Entity::Chara::getName() const
+std::string Chara::getName() const
 {
   return { m_name };
 }
 
 
 /*! \return current stance of the actors */
-Sapphire::Common::Stance Sapphire::Entity::Chara::getStance() const
+Stance Chara::getStance() const
 {
   return m_currentStance;
 }
 
 /*! \return actor stats */
-const Sapphire::Entity::Chara::ActorStatsArray& Sapphire::Entity::Chara::getStats() const
+const Chara::ActorStatsArray& Chara::getStats() const
 {
   return m_baseStats;
 }
 
 /*! \return current HP */
-uint32_t Sapphire::Entity::Chara::getHp() const
+uint32_t Chara::getHp() const
 {
   return m_hp;
 }
 
-uint32_t Sapphire::Entity::Chara::getHpPercent() const
+uint32_t Chara::getHpPercent() const
 {
   return ( m_hp * 100 ) / m_maxHp;
 }
 
 /*! \return current MP */
-uint32_t Sapphire::Entity::Chara::getMp() const
+uint32_t Chara::getMp() const
 {
   return m_mp;
 }
 
 /*! \return current TP */
-uint16_t Sapphire::Entity::Chara::getTp() const
+uint16_t Chara::getTp() const
 {
   return m_tp;
 }
 
 /*! \return current GP */
-uint16_t Sapphire::Entity::Chara::getGp() const
+uint16_t Chara::getGp() const
 {
   return m_gp;
 }
 
 /*! \return current invincibility type */
-InvincibilityType Sapphire::Entity::Chara::getInvincibilityType() const
+InvincibilityType Chara::getInvincibilityType() const
 {
   return m_invincibilityType;
 }
 
 /*! \return current class or job */
-Sapphire::Common::ClassJob Sapphire::Entity::Chara::getClass() const
+ClassJob Chara::getClass() const
 {
   return m_class;
 }
 
 /*! \param ClassJob to set */
-void Sapphire::Entity::Chara::setClass( Common::ClassJob classJob )
+void Chara::setClass( ClassJob classJob )
 {
   m_class = classJob;
 }
 
-Sapphire::Common::Role Sapphire::Entity::Chara::getRole() const
+Role Chara::getRole() const
 {
   switch( getClass() )
   {
@@ -181,67 +185,85 @@ Sapphire::Common::Role Sapphire::Entity::Chara::getRole() const
 }
 
 /*! \param Id of the target to set */
-void Sapphire::Entity::Chara::setTargetId( uint64_t targetId )
+void Chara::setTargetId( uint64_t targetId )
 {
   m_targetId = targetId;
 }
 
 /*! \return Id of the current target */
-uint64_t Sapphire::Entity::Chara::getTargetId() const
+uint64_t Chara::getTargetId() const
 {
   return m_targetId;
 }
 
 /*! \return True if the actor is alive */
-bool Sapphire::Entity::Chara::isAlive() const
+bool Chara::isAlive() const
 {
   return ( m_hp > 0 );
 }
 
+void Chara::setPos( const Common::FFXIVARR_POSITION3& pos, bool broadcastUpdate )
+{
+  GameObject::setPos( pos, broadcastUpdate );
+  m_dirtyFlag |= DirtyFlag::Position;
+}
+
+void Chara::setPos( float x, float y, float z, bool broadcastUpdate )
+{
+  GameObject::setPos( x, y, z, broadcastUpdate );
+  m_dirtyFlag |= DirtyFlag::Position;
+}
+
+void Sapphire::Entity::Chara::setRot( float rot )
+{
+  GameObject::setRot( rot );
+  m_dirtyFlag |= DirtyFlag::Position;
+}
+
 /*! \return max hp for the actor */
-uint32_t Sapphire::Entity::Chara::getMaxHp() const
+uint32_t Chara::getMaxHp() const
 {
   return m_maxHp;
 }
 
 /*! \return max mp for the actor */
-uint32_t Sapphire::Entity::Chara::getMaxMp() const
+uint32_t Chara::getMaxMp() const
 {
   return m_maxMp;
 }
 
 /*! \return reset hp to current max hp */
-void Sapphire::Entity::Chara::resetHp()
+void Chara::resetHp()
 {
   m_hp = getMaxHp();
 }
 
 /*! \return reset mp to current max mp */
-void Sapphire::Entity::Chara::resetMp()
+void Chara::resetMp()
 {
   m_mp = getMaxMp();
 }
 
 /*! \param hp amount to set ( caps to maxHp ) */
-void Sapphire::Entity::Chara::setHp( uint32_t hp )
+void Chara::setHp( uint32_t hp )
 {
   m_hp = hp < getMaxHp() ? hp : getMaxHp();
 }
 
 /*! \param mp amount to set ( caps to maxMp ) */
-void Sapphire::Entity::Chara::setMp( uint32_t mp )
+void Chara::setMp( uint32_t mp )
 {
   m_mp = mp < getMaxMp() ? mp : getMaxMp();
 }
 
 /*! \param gp amount to set*/
-void Sapphire::Entity::Chara::setGp( uint32_t gp )
+void Chara::setGp( uint32_t gp )
 {
   m_gp = static_cast< uint16_t >( gp );
 }
 
 /*! \param tp amount to set*/
-void Sapphire::Entity::Chara::setTp( uint32_t tp )
+void Chara::setTp( uint32_t tp )
 {
   m_tp = static_cast< uint16_t >( tp );
 }
@@ -253,13 +275,13 @@ void Sapphire::Entity::Chara::setInvincibilityType( Common::InvincibilityType ty
 }
 
 /*! \return current status of the actor */
-Sapphire::Common::ActorStatus Sapphire::Entity::Chara::getStatus() const
+ActorStatus Chara::getStatus() const
 {
   return m_status;
 }
 
 /*! \param status to set */
-void Sapphire::Entity::Chara::setStatus( ActorStatus status )
+void Chara::setStatus( ActorStatus status )
 {
   m_status = status;
 }
@@ -268,7 +290,7 @@ void Sapphire::Entity::Chara::setStatus( ActorStatus status )
 Performs necessary steps to mark an actor dead.
 Sets hp/mp/tp, sets status, plays animation and fires onDeath event
 */
-void Sapphire::Entity::Chara::die()
+void Chara::die()
 {
   m_status = ActorStatus::Dead;
   m_hp = 0;
@@ -280,13 +302,18 @@ void Sapphire::Entity::Chara::die()
 
   // if the actor is a player, the update needs to be send to himself too
   bool selfNeedsUpdate = isPlayer();
+  Network::Util::Packet::sendActorControl( getInRangePlayerIds( selfNeedsUpdate ), getId(), SetStatus, static_cast< uint8_t >( ActorStatus::Dead ) );
+  Network::Util::Packet::sendActorControl( getInRangePlayerIds( selfNeedsUpdate ), getId(), DeathAnimation );
+}
 
-  FFXIVPacketBasePtr packet = makeActorControl( m_id, SetStatus, static_cast< uint8_t >( ActorStatus::Dead ) );
-  server().queueForPlayers( getInRangePlayerIds( selfNeedsUpdate ), packet );
-
-  FFXIVPacketBasePtr packet1 = makeActorControl( m_id, DeathAnimation, 0, 0, 0, 0 );
-  server().queueForPlayers( getInRangePlayerIds( selfNeedsUpdate ), packet1 );
+uint64_t Chara::getLastAttack() const
+{
+  return m_lastAttack;
+}
 
+void Chara::setLastAttack( uint64_t tickCount )
+{
+  m_lastAttack = tickCount;
 }
 
 /*!
@@ -295,10 +322,10 @@ position
 
 \param Position to look towards
 */
-bool Sapphire::Entity::Chara::face( const Common::FFXIVARR_POSITION3& p )
+bool Chara::face( const FFXIVARR_POSITION3& p )
 {
   float oldRot = getRot();
-  float rot = Util::calcAngFrom( getPos().x, getPos().z, p.x, p.z );
+  float rot = Common::Util::calcAngFrom( getPos().x, getPos().z, p.x, p.z );
   float newRot = PI - rot + ( PI / 2 );
 
   setRot( newRot );
@@ -312,12 +339,10 @@ Set and propagate the actor stance to in range players
 
 \param stance to set
 */
-void Sapphire::Entity::Chara::setStance( Stance stance )
+void Chara::setStance( Stance stance )
 {
   m_currentStance = stance;
-
-  FFXIVPacketBasePtr packet = makeActorControl( m_id, ToggleWeapon, stance, 1 );
-  server().queueForPlayers( getInRangePlayerIds(), packet );
+  Network::Util::Packet::sendActorControl( getInRangePlayerIds(), getId(), ToggleWeapon, stance, 1 );
 }
 
 /*!
@@ -326,7 +351,7 @@ and if fully performed, clean up again.
 
 \return true if a queued action has been updated
 */
-bool Sapphire::Entity::Chara::checkAction()
+bool Chara::checkAction()
 {
 
   if( m_pCurrentAction == nullptr )
@@ -339,7 +364,7 @@ bool Sapphire::Entity::Chara::checkAction()
 
 }
 
-void Sapphire::Entity::Chara::update( uint64_t tickCount )
+void Chara::update( uint64_t tickCount )
 {
   updateStatusEffects();
 
@@ -358,17 +383,16 @@ Change the current target and propagate to in range players
 
 \param target actor id
 */
-void Sapphire::Entity::Chara::changeTarget( uint64_t targetId )
+void Chara::changeTarget( uint64_t targetId )
 {
   setTargetId( targetId );
-  FFXIVPacketBasePtr packet = makeActorControlTarget( m_id, SetTarget, 0, 0, 0, 0, targetId );
-  server().queueForPlayers( getInRangePlayerIds(), packet );
+  Network::Util::Packet::sendActorControlTarget( getInRangePlayerIds(), getId(), SetTarget, 0, 0, 0, 0, targetId );
 }
 
 /*!
 Dummy function \return 0
 */
-uint8_t Sapphire::Entity::Chara::getLevel() const
+uint8_t Chara::getLevel() const
 {
   return 0;
 }
@@ -382,7 +406,7 @@ magical dmg and take status effects into account
 
 \param amount of damage to be taken
 */
-void Sapphire::Entity::Chara::takeDamage( uint32_t damage )
+void Chara::takeDamage( uint32_t damage )
 {
   if( damage >= m_hp )
   {
@@ -396,7 +420,7 @@ void Sapphire::Entity::Chara::takeDamage( uint32_t damage )
         resetHp();
         break;
       case InvincibilityStayAlive:
-        setHp( 0 );
+        setHp( 1 );
         break;
       case InvincibilityIgnoreDamage:
         break;
@@ -413,7 +437,7 @@ in range
 
 \param amount of hp to be healed
 */
-void Sapphire::Entity::Chara::heal( uint32_t amount )
+void Chara::heal( uint32_t amount )
 {
   if( ( m_hp + amount ) > getMaxHp() )
   {
@@ -423,7 +447,7 @@ void Sapphire::Entity::Chara::heal( uint32_t amount )
     m_hp += amount;
 }
 
-void Sapphire::Entity::Chara::restoreMP( uint32_t amount )
+void Chara::restoreMP( uint32_t amount )
 {
   if( ( m_mp + amount ) > getMaxMp() )
   {
@@ -433,27 +457,14 @@ void Sapphire::Entity::Chara::restoreMP( uint32_t amount )
     m_mp += amount;
 }
 
-/*!
-Send an HpMpTp update to players in range ( and potentially to self )
-TODO: poor naming, should be changed. Status is not HP. Also should be virtual
-so players can have their own version and we can abolish the param.
-
-\param true if the update should also be sent to the actor ( player ) himself
-*/
-void Sapphire::Entity::Chara::sendHudParam()
-{
-  FFXIVPacketBasePtr packet = makeHudParam( *this );
-  server().queueForPlayers( getInRangePlayerIds( isPlayer() ), packet );
-}
-
 /*! \return ActionPtr of the currently registered action, or nullptr */
-Sapphire::World::Action::ActionPtr Sapphire::Entity::Chara::getCurrentAction() const
+Action::ActionPtr Chara::getCurrentAction() const
 {
   return m_pCurrentAction;
 }
 
 /*! \param ActionPtr of the action to be registered */
-void Sapphire::Entity::Chara::setCurrentAction( Sapphire::World::Action::ActionPtr pAction )
+void Chara::setCurrentAction( Action::ActionPtr pAction )
 {
   m_pCurrentAction = std::move( pAction );
 }
@@ -467,9 +478,9 @@ Will have to be extended for ranged attacks.
 
 \param GameObjectPtr the autoAttack is performed on
 */
-void Sapphire::Entity::Chara::autoAttack( CharaPtr pTarget )
+void Chara::autoAttack( CharaPtr pTarget )
 {
-  uint64_t tick = Util::getTimeMs();
+  uint64_t tick = Common::Util::getTimeMs();
 
   // todo: this needs to use the auto attack delay for the equipped weapon
   if( ( tick - m_lastAttack ) > 2500 )
@@ -481,12 +492,12 @@ void Sapphire::Entity::Chara::autoAttack( CharaPtr pTarget )
     auto damage = static_cast< uint16_t >( 10 + rand() % 12 );
 
     auto effectPacket = std::make_shared< EffectPacket1 >( getId(), pTarget->getId(), 7 );
-    effectPacket->setRotation( Util::floatToUInt16Rot( getRot() ) );
+    effectPacket->setRotation( Common::Util::floatToUInt16Rot( getRot() ) );
 
     Common::CalcResultParam effectEntry{};
     effectEntry.Value = static_cast< int16_t >( damage );
-    effectEntry.Type = ActionEffectType::CALC_RESULT_TYPE_DAMAGE_HP;
-    effectEntry.Arg0 = static_cast< uint8_t >( ActionHitSeverityType::NormalDamage );
+    effectEntry.Type = CalcResultType::TypeDamageHp;
+    effectEntry.Arg0 = 1;
     effectEntry.Arg2 = 0x71;
     effectPacket->addTargetEffect( effectEntry );
 
@@ -497,9 +508,9 @@ void Sapphire::Entity::Chara::autoAttack( CharaPtr pTarget )
 }
 
 /*! \param StatusEffectPtr to be applied to the actor */
-void Sapphire::Entity::Chara::addStatusEffect( StatusEffect::StatusEffectPtr pEffect )
+void Chara::addStatusEffect( StatusEffect::StatusEffectPtr pEffect )
 {
-  auto& teriMgr = Common::Service< World::Manager::TerritoryMgr >::ref();
+  auto& teriMgr = Common::Service< Manager::TerritoryMgr >::ref();
   auto pZone = teriMgr.getTerritoryByGuId( getTerritoryId() );
 
   int8_t nextSlot = getStatusEffectFreeSlot();
@@ -507,62 +518,27 @@ void Sapphire::Entity::Chara::addStatusEffect( StatusEffect::StatusEffectPtr pEf
   if( nextSlot == -1 )
     return;
 
-  pEffect->applyStatus();
+  pEffect->setSlot( nextSlot );
   m_statusEffectMap[ nextSlot ] = pEffect;
-
-  auto statusEffectAdd = makeZonePacket< FFXIVIpcActionIntegrity >( getId() );
-
-  statusEffectAdd->data().ResultId = pZone->getNextEffectResultId();
-  statusEffectAdd->data().Target = pEffect->getTargetActorId();
-  statusEffectAdd->data().Hp = getHp();
-  statusEffectAdd->data().Mp = static_cast< uint16_t >( getMp() );
-  statusEffectAdd->data().Tp = static_cast< uint16_t >( getTp() );
-  statusEffectAdd->data().HpMax = getMaxHp();
-  statusEffectAdd->data().MpMax = static_cast< uint16_t >( getMaxMp() );
-  statusEffectAdd->data().ClassJob = static_cast< uint8_t >( getClass() );
-  statusEffectAdd->data().StatusCount = 1;
-  statusEffectAdd->data().unknown_E0 = 0xE0;
-
-  // set all status sources to u32 invalid game obj
-  // todo: chara status effect map should be filled instead, since hudparam also uses invalid gameobj
-  for( int i = 0; i < 4; ++i )
-  {
-    statusEffectAdd->data().Status[ i ].Source = INVALID_GAME_OBJECT_ID;
-  }
-
-  auto& status = statusEffectAdd->data().Status[ 0 ];
-
-  status.Source = pEffect->getSrcActorId();
-  status.Time = static_cast< float >( pEffect->getDuration() ) / 1000;
-  status.Id = static_cast< uint16_t >( pEffect->getId() );
-  status.Slot = static_cast< uint8_t >( nextSlot );
-  status.SystemParam = static_cast< int16_t >( pEffect->getParam() );
-
-  server().queueForPlayers( getInRangePlayerIds( isPlayer() ), statusEffectAdd );
+  pEffect->applyStatus();
 }
 
 /*! \param StatusEffectPtr to be applied to the actor */
-void Sapphire::Entity::Chara::addStatusEffectById( uint32_t id, int32_t duration, Entity::Chara& source, uint16_t param )
+void Chara::addStatusEffectById( StatusEffect::StatusEffectPtr pStatus )
 {
-  auto effect = StatusEffect::make_StatusEffect( id, source.getAsChara(), getAsChara(), duration, 3000 );
-  effect->setParam( param );
-  addStatusEffect( effect );
+  addStatusEffect( pStatus );
 }
 
 /*! \param StatusEffectPtr to be applied to the actor */
-void Sapphire::Entity::Chara::addStatusEffectByIdIfNotExist( uint32_t id, int32_t duration, Entity::Chara& source,
-                                                             uint16_t param )
+void Chara::addStatusEffectByIdIfNotExist( StatusEffect::StatusEffectPtr pStatus )
 {
-  if( hasStatusEffect( id ) )
+  if( hasStatusEffect( pStatus->getId() ) )
     return;
 
-  auto effect = StatusEffect::make_StatusEffect( id, source.getAsChara(), getAsChara(), duration, 3000 );
-  effect->setParam( param );
-  addStatusEffect( effect );
-
+  addStatusEffect( pStatus );
 }
 
-int8_t Sapphire::Entity::Chara::getStatusEffectFreeSlot()
+int8_t Chara::getStatusEffectFreeSlot()
 {
   int8_t freeEffectSlot = -1;
 
@@ -575,12 +551,24 @@ int8_t Sapphire::Entity::Chara::getStatusEffectFreeSlot()
   return freeEffectSlot;
 }
 
-void Sapphire::Entity::Chara::statusEffectFreeSlot( uint8_t slotId )
+void Chara::statusEffectFreeSlot( uint8_t slotId )
 {
   m_statusEffectFreeSlotQueue.push( slotId );
 }
 
-void Sapphire::Entity::Chara::removeSingleStatusEffectById( uint32_t id )
+void Chara::replaceSingleStatusEffectById( uint32_t id )
+{
+  for( const auto& effectIt : m_statusEffectMap )
+  {
+    if( effectIt.second->getId() == id )
+    {
+      removeStatusEffect( effectIt.first, false );
+      break;
+    }
+  }
+}
+
+void Chara::removeSingleStatusEffectById( uint32_t id )
 {
   for( const auto& effectIt : m_statusEffectMap )
   {
@@ -592,7 +580,36 @@ void Sapphire::Entity::Chara::removeSingleStatusEffectById( uint32_t id )
   }
 }
 
-std::map< uint8_t, Sapphire::StatusEffect::StatusEffectPtr >::iterator Sapphire::Entity::Chara::removeStatusEffect( uint8_t effectSlotId )
+void Chara::removeStatusEffectById( std::vector< uint32_t > ids )
+{
+  for( auto effectIt = m_statusEffectMap.begin(); effectIt != m_statusEffectMap.end(); )
+  {
+    auto foundStatus = std::find( ids.begin(), ids.end(), effectIt->second->getId() );
+
+    if( foundStatus != ids.end() )
+    {
+      effectIt = removeStatusEffect( effectIt->first );
+      ids.erase( foundStatus );
+    }
+    else
+    {
+      ++effectIt;
+    }
+  }
+}
+
+void Chara::removeStatusEffectByFlag( Common::StatusEffectFlag flag )
+{
+  for( auto effectIt = m_statusEffectMap.begin(); effectIt != m_statusEffectMap.end(); )
+  {
+    if( effectIt->second->getFlag() & static_cast< uint32_t >( flag ) )
+      effectIt = removeStatusEffect( effectIt->first );
+    else
+      ++effectIt;
+  }
+}
+
+std::map< uint8_t, Sapphire::StatusEffect::StatusEffectPtr >::iterator Chara::removeStatusEffect( uint8_t effectSlotId, bool sendOrder )
 {
   auto pEffectIt = m_statusEffectMap.find( effectSlotId );
   if( pEffectIt == m_statusEffectMap.end() )
@@ -603,47 +620,53 @@ std::map< uint8_t, Sapphire::StatusEffect::StatusEffectPtr >::iterator Sapphire:
   auto pEffect = pEffectIt->second;
   pEffect->removeStatus();
 
-  server().queueForPlayers( getInRangePlayerIds( isPlayer() ), makeActorControl( getId(), StatusEffectLose, pEffect->getId() ) );
+  if( sendOrder )
+    Network::Util::Packet::sendActorControl( getInRangePlayerIds( isPlayer() ), getId(), StatusEffectLose, pEffect->getId() );
 
   auto it = m_statusEffectMap.erase( pEffectIt );
-
-  if( isPlayer() )
-    server().queueForPlayers( getInRangePlayerIds( isPlayer() ), makeHudParam( *getAsPlayer() ) );
-  else if( isBattleNpc() )
-    server().queueForPlayers( getInRangePlayerIds( isPlayer() ), makeHudParam( *getAsBNpc() ) );
-
+  Network::Util::Packet::sendHudParam( *this );
   return it;
 }
 
-std::map< uint8_t, Sapphire::StatusEffect::StatusEffectPtr > Sapphire::Entity::Chara::getStatusEffectMap() const
+std::map< uint8_t, StatusEffect::StatusEffectPtr > Chara::getStatusEffectMap() const
 {
   return m_statusEffectMap;
 }
 
-const uint8_t* Sapphire::Entity::Chara::getLookArray() const
+Sapphire::StatusEffect::StatusEffectPtr Chara::getStatusEffectById( uint32_t id ) const
+{
+  for( const auto& effectIt : m_statusEffectMap )
+  {
+    if( effectIt.second->getId() == id )
+      return effectIt.second;
+  }
+
+  return nullptr;
+}
+
+const uint8_t* Chara::getLookArray() const
 {
   return m_customize;
 }
 
-const uint32_t* Sapphire::Entity::Chara::getModelArray() const
+const uint32_t* Chara::getModelArray() const
 {
   return m_modelEquip;
 }
 
-uint8_t Sapphire::Entity::Chara::getPose() const
+uint8_t Chara::getPose() const
 {
   return m_pose;
 }
 
-void Sapphire::Entity::Chara::setPose( uint8_t pose )
+void Chara::setPose( uint8_t pose )
 {
   m_pose = pose;
 }
 
-void Sapphire::Entity::Chara::sendStatusEffectUpdate()
+void Chara::sendStatusEffectUpdate()
 {
-  uint64_t currentTimeMs = Util::getTimeMs();
-
+  uint64_t currentTimeMs = Common::Util::getTimeMs();
 
   auto statusEffectList = makeZonePacket< FFXIVIpcStatus >( getId() );
   uint8_t slot = 0;
@@ -660,9 +683,9 @@ void Sapphire::Entity::Chara::sendStatusEffectUpdate()
   server().queueForPlayers( getInRangePlayerIds( isPlayer() ), statusEffectList );
 }
 
-void Sapphire::Entity::Chara::updateStatusEffects()
+void Chara::updateStatusEffects()
 {
-  uint64_t currentTimeMs = Util::getTimeMs();
+  uint64_t currentTimeMs = Common::Util::getTimeMs();
 
   for( auto effectIt = m_statusEffectMap.begin(); effectIt != m_statusEffectMap.end(); )
   {
@@ -687,28 +710,34 @@ void Sapphire::Entity::Chara::updateStatusEffects()
   }
 }
 
-bool Sapphire::Entity::Chara::hasStatusEffect( uint32_t id )
+bool Chara::hasStatusEffect( uint32_t id )
 {
-  return m_statusEffectMap.find( id ) != m_statusEffectMap.end();
+  for( const auto& [ key, val ] : m_statusEffectMap )
+  {
+    if( val->getId() == id )
+      return true;
+  }
+
+  return false;
 }
 
-int64_t Sapphire::Entity::Chara::getLastUpdateTime() const
+int64_t Chara::getLastUpdateTime() const
 {
   return m_lastUpdate;
 }
 
-void Sapphire::Entity::Chara::setLastComboActionId( uint32_t actionId )
+void Chara::setLastComboActionId( uint32_t actionId )
 {
   m_lastComboActionId = actionId;
-  m_lastComboActionTime = Util::getTimeMs();
+  m_lastComboActionTime = Common::Util::getTimeMs();
 }
 
-uint32_t Sapphire::Entity::Chara::getLastComboActionId() const
+uint32_t Chara::getLastComboActionId() const
 {
   // initially check for the time passed first, if it's more than the threshold just return 0 for the combo
   // we can hide the implementation detail this way and it just works:tm: for anything that uses it
 
-  if( std::difftime( static_cast< time_t >( Util::getTimeMs() ),
+  if( std::difftime( static_cast< time_t >( Common::Util::getTimeMs() ),
                      static_cast< time_t >( m_lastComboActionTime ) ) > Common::MAX_COMBO_LENGTH )
   {
     return 0;
@@ -717,43 +746,42 @@ uint32_t Sapphire::Entity::Chara::getLastComboActionId() const
   return m_lastComboActionId;
 }
 
-uint32_t Sapphire::Entity::Chara::getDirectorId() const
+uint32_t Chara::getDirectorId() const
 {
   return m_directorId;
 }
 
-void Sapphire::Entity::Chara::setDirectorId( uint32_t directorId )
+void Chara::setDirectorId( uint32_t directorId )
 {
   m_directorId = directorId;
 }
 
-uint32_t Sapphire::Entity::Chara::getAgentId() const
+uint32_t Chara::getAgentId() const
 {
   return m_agentId;
 }
 
-void Sapphire::Entity::Chara::setAgentId( uint32_t agentId )
+void Chara::setAgentId( uint32_t agentId )
 {
   m_agentId = agentId;
 }
 
-
-float Sapphire::Entity::Chara::getRadius() const
+float Chara::getRadius() const
 {
   return m_radius;
 }
 
-Sapphire::Common::BaseParam Sapphire::Entity::Chara::getPrimaryStat() const
+Common::BaseParam Chara::getPrimaryStat() const
 {
   auto& exdData = Common::Service< Data::ExdData >::ref();
 
   auto classJob = exdData.getRow< Excel::ClassJob >( static_cast< uint16_t >( getClass() ) );
   assert( classJob );
 
-  return static_cast< Sapphire::Common::BaseParam >( classJob->data().Role );
+  return static_cast< Common::BaseParam >( classJob->data().Role );
 }
 
-uint32_t Sapphire::Entity::Chara::getStatValue( Sapphire::Common::BaseParam baseParam ) const
+uint32_t Chara::getStatValue( Common::BaseParam baseParam ) const
 {
   auto index = static_cast< uint32_t >( baseParam );
   assert( index < m_baseStats.size() );
@@ -761,7 +789,7 @@ uint32_t Sapphire::Entity::Chara::getStatValue( Sapphire::Common::BaseParam base
   return m_baseStats[ index ] + m_bonusStats[ index ];
 }
 
-float Sapphire::Entity::Chara::getStatValueFloat( Common::BaseParam baseParam ) const
+float Chara::getStatValueFloat( Common::BaseParam baseParam ) const
 {
   auto index = static_cast< uint32_t >( baseParam );
   assert( index < m_baseStats.size() );
@@ -769,7 +797,7 @@ float Sapphire::Entity::Chara::getStatValueFloat( Common::BaseParam baseParam )
   return static_cast< float >( m_baseStats[ index ] + m_bonusStats[ index ] );
 }
 
-uint32_t Sapphire::Entity::Chara::getBonusStat( Sapphire::Common::BaseParam baseParam ) const
+uint32_t Chara::getBonusStat( Common::BaseParam baseParam ) const
 {
   auto index = static_cast< uint32_t >( baseParam );
   assert( index < m_bonusStats.size() );
@@ -777,7 +805,7 @@ uint32_t Sapphire::Entity::Chara::getBonusStat( Sapphire::Common::BaseParam base
   return m_bonusStats[ index ];
 }
 
-void Sapphire::Entity::Chara::setStatValue( Common::BaseParam baseParam, uint32_t value )
+void Chara::setStatValue( Common::BaseParam baseParam, uint32_t value )
 {
   auto index = static_cast< uint32_t >( baseParam );
   assert( index < m_baseStats.size() );
@@ -785,7 +813,48 @@ void Sapphire::Entity::Chara::setStatValue( Common::BaseParam baseParam, uint32_
   m_baseStats[ index ] = value;
 }
 
-void Sapphire::Entity::Chara::onTick()
+float Chara::getModifier( Common::ParamModifier paramModifier ) const
+{
+  auto result = paramModifier >= Common::ParamModifier::StrengthPercent ? 1.0f : 0;
+
+  for( const auto& [ key, status ] : m_statusEffectMap )
+  {
+    for( const auto& [ mod, val ] : status->getModifiers() )
+    {
+      if( mod != paramModifier )
+        continue;
+
+      if( paramModifier >= Common::ParamModifier::StrengthPercent )
+        result *= 1.0f + ( val / 100.0f );
+      else
+        result += val;
+    }
+  }
+
+  return result;
+}
+
+// Compute forward direction based on rotation angle (assuming rotation around Z axis)
+FFXIVARR_POSITION3 Chara::getForwardVector() const {
+  return Common::Util::normalize( FFXIVARR_POSITION3{ std::sin( getRot() ), 0, std::cos( getRot() ) } );
+}
+
+// Function to check if actor is facing target
+bool Chara::isFacingTarget( const Chara& other, float threshold )
+{
+  auto toActor = Common::Util::normalize( Common::Util::projectY( other.getPos() - getPos() ) );
+
+  auto forward = getForwardVector();
+  
+  float dot = Common::Util::dot( forward, toActor );
+  
+  // The threshold is used to determine how closely the actors need to be facing each other
+  // 1.0 means they need to be perfectly facing each other
+  // Lower values allow for some deviation
+  return dot >= threshold;
+}
+
+void Chara::onTick()
 {
   uint32_t thisTickDmg = 0;
   uint32_t thisTickHeal = 0;
@@ -795,13 +864,13 @@ void Sapphire::Entity::Chara::onTick()
     auto thisEffect = effectIt.second->getTickEffect();
     switch( thisEffect.first )
     {
-      case 1:
+      case Common::ParamModifier::TickDamage:
       {
         thisTickDmg += thisEffect.second;
         break;
       }
 
-      case 2:
+      case Common::ParamModifier::TickHeal:
       {
         thisTickHeal += thisEffect.second;
         break;
@@ -809,19 +878,58 @@ void Sapphire::Entity::Chara::onTick()
     }
   }
 
+  // TODO: don't really like how this is handled
+  // TODO: calculate actual damage from potency
   if( thisTickDmg != 0 )
   {
     takeDamage( thisTickDmg );
-    server().queueForPlayers( getInRangePlayerIds( isPlayer() ), makeActorControl( getId(), HPFloatingText, 0,
-                                                                                   static_cast< uint8_t >( ActionEffectType::CALC_RESULT_TYPE_DAMAGE_HP ),
-                                                                                   thisTickDmg ) );
+    Network::Util::Packet::sendActorControl( getInRangePlayerIds( isPlayer() ), getId(), HPFloatingText, 0,
+                                             CalcResultType::TypeDamageHp, thisTickDmg );
+
+    Network::Util::Packet::sendHudParam( *this );
   }
 
   if( thisTickHeal != 0 )
   {
     heal( thisTickHeal );
-    server().queueForPlayers( getInRangePlayerIds( isPlayer() ), makeActorControl( getId(), HPFloatingText, 0,
-                                                                                   static_cast< uint8_t >( ActionEffectType::CALC_RESULT_TYPE_RECOVER_HP ),
-                                                                                   thisTickHeal ) );
+    Network::Util::Packet::sendActorControl( getInRangePlayerIds( isPlayer() ), getId(), HPFloatingText, 0,
+                                             CalcResultType::TypeRecoverMp, thisTickHeal );
+
+    Network::Util::Packet::sendHudParam( *this );
+  }
+}
+
+void Chara::knockback( const FFXIVARR_POSITION3& origin, float distance, bool ignoreNav )
+{
+  auto kbPos = Common::Util::getKnockbackPosition( origin, m_pos, distance );
+  auto& teriMgr = Common::Service< Manager::TerritoryMgr >::ref();
+  auto pTeri = teriMgr.getTerritoryByGuId( getTerritoryId() );
+
+  if( !ignoreNav )
+  {
+    // todo: use agent
+    auto pNav = pTeri->getNaviProvider();
+    auto path = pNav->findFollowPath( m_pos, kbPos );
+
+    FFXIVARR_POSITION3 navPos{origin};
+    float prevDistance{1000.f};
+    for( const auto& point : path )
+    {
+      auto navDist = Common::Util::distance( kbPos, point );  
+      if( navDist < prevDistance )
+      {
+        navPos = point;
+        prevDistance = navDist;
+      }
+    }
+    setPos( navPos );
+    pNav->updateAgentPosition( *this );
   }
+  else
+  {
+    setPos( kbPos );
+  }
+  pTeri->updateActorPosition( *this );
+
+  server().queueForPlayers( getInRangePlayerIds(), std::make_shared< MoveActorPacket >( *this, getRot(), 2, 0, 0, 0x5A / 4 ) );
 }
\ No newline at end of file
diff --git a/src/world/Actor/Chara.h b/src/world/Actor/Chara.h
index 20449f16c..986839524 100644
--- a/src/world/Actor/Chara.h
+++ b/src/world/Actor/Chara.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <Common.h>
+#include "Action/ActionLut.h"
 
 #include "Forwards.h"
 #include "GameObject.h"
@@ -8,9 +9,18 @@
 #include <map>
 #include <queue>
 #include <array>
+#include <numeric>
 
 namespace Sapphire::Entity
 {
+  // todo: probably macro/template operators for enums
+  enum DirtyFlag : uint32_t
+  {
+    Position   = 0x01,
+    HpMpTp     = 0x02,
+    Status     = 0x04,
+    Appearance = 0x08
+  };
 
   /*!
   \class Chara
@@ -94,6 +104,8 @@ namespace Sapphire::Entity
     /*! Detour Crowd actor scale */
     float m_radius;
 
+    uint32_t m_dirtyFlag{};
+
   public:
     Chara( Common::ObjKind type );
 
@@ -106,10 +118,16 @@ namespace Sapphire::Entity
     /// Status effect functions
     void addStatusEffect( StatusEffect::StatusEffectPtr pEffect );
 
-    std::map< uint8_t, StatusEffect::StatusEffectPtr >::iterator removeStatusEffect( uint8_t effectSlotId );
+    std::map< uint8_t, StatusEffect::StatusEffectPtr >::iterator removeStatusEffect( uint8_t effectSlotId, bool sendOrder = true );
+
+    void replaceSingleStatusEffectById( uint32_t id );
 
     void removeSingleStatusEffectById( uint32_t id );
 
+    void removeStatusEffectById( std::vector< uint32_t > ids );
+
+    void removeStatusEffectByFlag( Common::StatusEffectFlag flag );
+
     void updateStatusEffects();
 
     bool hasStatusEffect( uint32_t id );
@@ -124,6 +142,8 @@ namespace Sapphire::Entity
 
     std::map< uint8_t, Sapphire::StatusEffect::StatusEffectPtr > getStatusEffectMap() const;
 
+    Sapphire::StatusEffect::StatusEffectPtr getStatusEffectById( uint32_t id ) const;
+
     void sendStatusEffectUpdate();
 
     /*! return a const pointer to the look array */
@@ -132,10 +152,10 @@ namespace Sapphire::Entity
     const uint32_t* getModelArray() const;
 
     // add a status effect by id
-    void addStatusEffectById( uint32_t id, int32_t duration, Entity::Chara& source, uint16_t param = 0 );
+    void addStatusEffectById( StatusEffect::StatusEffectPtr pStatus );
 
     // add a status effect by id if it doesn't exist
-    void addStatusEffectByIdIfNotExist( uint32_t id, int32_t duration, Entity::Chara& source, uint16_t param = 0 );
+    void addStatusEffectByIdIfNotExist( StatusEffect::StatusEffectPtr pStatus );
 
     // remove a status effect by id
     void removeSingleStatusEffectFromId( uint32_t id );
@@ -159,6 +179,8 @@ namespace Sapphire::Entity
 
     void setStatValue( Common::BaseParam baseParam, uint32_t value );
 
+    float getModifier( Common::ParamModifier paramModifier ) const;
+
     uint32_t getHp() const;
 
     uint32_t getHpPercent() const;
@@ -183,6 +205,12 @@ namespace Sapphire::Entity
 
     bool isAlive() const;
 
+    virtual void setPos( const Common::FFXIVARR_POSITION3& pos, bool broadcastUpdate = true ) override;
+
+    virtual void setPos( float x, float y, float z, bool broadcastUpdate = true ) override;
+
+    virtual void setRot( float rot ) override;
+
     virtual uint32_t getMaxHp() const;
 
     virtual uint32_t getMaxMp() const;
@@ -203,6 +231,10 @@ namespace Sapphire::Entity
 
     void die();
 
+    uint64_t getLastAttack() const;
+
+    void setLastAttack( uint64_t tickCount );
+
     Common::ActorStatus getStatus() const;
 
     void setStatus( Common::ActorStatus status );
@@ -223,8 +255,6 @@ namespace Sapphire::Entity
 
     virtual uint8_t getLevel() const;
 
-    virtual void sendHudParam();
-
     virtual void takeDamage( uint32_t damage );
 
     virtual void heal( uint32_t amount );
@@ -235,6 +265,10 @@ namespace Sapphire::Entity
 
     virtual void update( uint64_t tickCount );
 
+    Common::FFXIVARR_POSITION3 getForwardVector() const;
+
+    bool isFacingTarget( const Chara& other, float threshold = 0.95f );
+
     World::Action::ActionPtr getCurrentAction() const;
 
     void setCurrentAction( World::Action::ActionPtr pAction );
@@ -252,6 +286,8 @@ namespace Sapphire::Entity
 
     Common::BaseParam getPrimaryStat() const;
 
+    void knockback( const Common::FFXIVARR_POSITION3& origin, float distance, bool ignoreNav = false );
+
   };
 
 }
\ No newline at end of file
diff --git a/src/world/Actor/EventObject.cpp b/src/world/Actor/EventObject.cpp
index 7b306511c..b5ada2c1b 100644
--- a/src/world/Actor/EventObject.cpp
+++ b/src/world/Actor/EventObject.cpp
@@ -3,12 +3,10 @@
 #include "Territory/InstanceContent.h"
 #include "Actor/Player.h"
 
-#include "Network/PacketWrappers/ActorControlPacket.h"
-#include "Network/PacketWrappers/ActorControlTargetPacket.h"
-
 #include <Logging/Logger.h>
 #include <Network/PacketDef/Zone/ServerZoneDef.h>
 #include <Network/CommonActorControl.h>
+#include <Network/Util/PacketUtil.h>
 #include <Util/UtilMath.h>
 
 #include <Service.h>
@@ -16,20 +14,19 @@
 #include <utility>
 #include "WorldServer.h"
 #include "Session.h"
-#include "Network/GameConnection.h"
 #include "Manager/MgrUtil.h"
 
-
+using namespace Sapphire;
 using namespace Sapphire::Common;
+using namespace Sapphire::Entity;
 using namespace Sapphire::World::Manager;
 using namespace Sapphire::Network::Packets;
 using namespace Sapphire::Network::Packets::WorldPackets::Server;
 using namespace Sapphire::Network::ActorControl;
 
-Sapphire::Entity::EventObject::EventObject( uint32_t actorId, uint32_t objectId, uint32_t gimmickId, uint32_t instanceId,
-                                            uint8_t initialState, Common::FFXIVARR_POSITION3 pos,
-                                            float rotation, const std::string& givenName, uint8_t permissionInv ) :
-  Sapphire::Entity::GameObject( ObjKind::EventObj ),
+EventObject::EventObject( uint32_t actorId, uint32_t objectId, uint32_t gimmickId, uint32_t instanceId, uint8_t initialState,
+                          FFXIVARR_POSITION3 pos, float rotation, const std::string& givenName, uint8_t permissionInv ) :
+  GameObject( ObjKind::EventObj ),
   m_gimmickId( gimmickId ),
   m_instanceId( instanceId ),
   m_state( initialState ),
@@ -37,7 +34,7 @@ Sapphire::Entity::EventObject::EventObject( uint32_t actorId, uint32_t objectId,
   m_name( givenName ),
   m_housingLink( 0 ),
   m_permissionInvisibility( permissionInv ),
-  m_ownerId( Common::INVALID_GAME_OBJECT_ID )
+  m_ownerId( INVALID_GAME_OBJECT_ID )
 {
   m_id = actorId;
   m_pos.x = pos.x;
@@ -46,78 +43,77 @@ Sapphire::Entity::EventObject::EventObject( uint32_t actorId, uint32_t objectId,
   m_rot = rotation;
 }
 
-uint32_t Sapphire::Entity::EventObject::getGimmickId() const
+uint32_t EventObject::getGimmickId() const
 {
   return m_gimmickId;
 }
 
-uint32_t Sapphire::Entity::EventObject::getObjectId() const
+uint32_t EventObject::getObjectId() const
 {
   return m_objectId;
 }
 
-float Sapphire::Entity::EventObject::getScale() const
+float EventObject::getScale() const
 {
   return m_scale;
 }
 
-void Sapphire::Entity::EventObject::setScale( float scale )
+void EventObject::setScale( float scale )
 {
   m_scale = scale;
 }
 
-Sapphire::Entity::EventObject::OnTalkEventHandler Sapphire::Entity::EventObject::getOnTalkHandler() const
+EventObject::OnTalkEventHandler EventObject::getOnTalkHandler() const
 {
   return m_onTalkEventHandler;
 }
 
-void Sapphire::Entity::EventObject::setOnTalkHandler( Sapphire::Entity::EventObject::OnTalkEventHandler handler )
+void EventObject::setOnTalkHandler( EventObject::OnTalkEventHandler handler )
 {
   m_onTalkEventHandler = std::move( handler );
 }
 
-void Sapphire::Entity::EventObject::setGimmickId( uint32_t gimmickId )
+void EventObject::setGimmickId( uint32_t gimmickId )
 {
   m_gimmickId = gimmickId;
 }
 
-uint8_t Sapphire::Entity::EventObject::getState() const
+uint8_t EventObject::getState() const
 {
   return m_state;
 }
 
-void Sapphire::Entity::EventObject::setState( uint8_t state )
+void EventObject::setState( uint8_t state )
 {
   m_state = state;
 }
 
-void Sapphire::Entity::EventObject::setAnimationFlag( uint32_t flag, uint32_t animationFlag )
+void EventObject::setAnimationFlag( uint32_t flag, uint32_t animationFlag )
 {
-  for( const auto& player : m_inRangePlayers )
-    server().queueForPlayer( player->getCharacterId(), makeActorControl( getId(), EObjAnimation, flag, animationFlag ) );
+  Network::Util::Packet::sendActorControl( getInRangePlayerIds(), getId(), EObjAnimation, flag, animationFlag );
 }
 
-void Sapphire::Entity::EventObject::setHousingLink( uint32_t housingLink )
+void EventObject::setHousingLink( uint32_t housingLink )
 {
   m_housingLink = housingLink;
 }
 
-uint32_t Sapphire::Entity::EventObject::getHousingLink() const
+uint32_t EventObject::getHousingLink() const
 {
   return m_housingLink;
 }
 
-void Sapphire::Entity::EventObject::setParentInstance( Sapphire::TerritoryPtr instance )
+void EventObject::setParentInstance( Sapphire::TerritoryPtr instance )
 {
   m_parentInstance = std::move( instance );
 }
 
-Sapphire::TerritoryPtr Sapphire::Entity::EventObject::getParentInstance() const
+TerritoryPtr EventObject::getParentInstance() const
 {
   return m_parentInstance;
 }
 
-void Sapphire::Entity::EventObject::spawn( Sapphire::Entity::PlayerPtr pTarget )
+void EventObject::spawn( PlayerPtr pTarget )
 {
   auto spawnIndex = pTarget->getNextObjSpawnIndexForActorId( getId() );
   if( !pTarget->isObjSpawnIndexValid( spawnIndex ) )
@@ -149,34 +145,31 @@ void Sapphire::Entity::EventObject::spawn( Sapphire::Entity::PlayerPtr pTarget )
 }
 
 
-void Sapphire::Entity::EventObject::despawn( Sapphire::Entity::PlayerPtr pTarget )
+void EventObject::despawn( PlayerPtr pTarget )
 {
   Logger::debug( "despawn eobj#{0}", getId() );
 
   pTarget->freeObjSpawnIndexForActorId( getId() );
 }
 
-const std::string& Sapphire::Entity::EventObject::getName() const
+const std::string& EventObject::getName() const
 {
   return m_name;
 }
 
-uint32_t Sapphire::Entity::EventObject::getInstanceId() const
+uint32_t EventObject::getInstanceId() const
 {
   return m_instanceId;
 }
 
-uint8_t Sapphire::Entity::EventObject::getPermissionInvisibility() const
+uint8_t EventObject::getPermissionInvisibility() const
 {
   return m_permissionInvisibility;
 }
 
-void Sapphire::Entity::EventObject::setPermissionInvisibility( uint8_t permissionInvisibility )
+void EventObject::setPermissionInvisibility( uint8_t permissionInvisibility )
 {
-  m_permissionInvisibility = permissionInvisibility;
-  auto& server = Common::Service< World::WorldServer >::ref();
-  auto inRangePlayerIds = getInRangePlayerIds();
-  server.queueForPlayers( inRangePlayerIds, makeActorControl( getId(), DirectorEObjMod, permissionInvisibility ) );
+  Network::Util::Packet::sendActorControl( getInRangePlayerIds(), getId(), DirectorEObjMod, permissionInvisibility );
 }
 
 uint32_t Sapphire::Entity::EventObject::getOwnerId() const
diff --git a/src/world/Actor/GameObject.cpp b/src/world/Actor/GameObject.cpp
index 98a337569..721232fe9 100644
--- a/src/world/Actor/GameObject.cpp
+++ b/src/world/Actor/GameObject.cpp
@@ -23,41 +23,42 @@
 #include "StatusEffect/StatusEffect.h"
 
 using namespace Sapphire::Common;
+using namespace Sapphire::Entity;
 using namespace Sapphire::Network::Packets;
 //using namespace Sapphire::Network::Packets::Server;
 
-Sapphire::Entity::GameObject::GameObject( ObjKind type ) :
+GameObject::GameObject( ObjKind type ) :
   m_objKind( type )
 {
 
 }
 
-uint32_t Sapphire::Entity::GameObject::getId() const
+uint32_t GameObject::getId() const
 {
   return m_id;
 }
 
-void Sapphire::Entity::GameObject::setId( uint32_t id )
+void GameObject::setId( uint32_t id )
 {
   m_id = id;
 }
 
-Sapphire::Common::ObjKind Sapphire::Entity::GameObject::getObjKind() const
+ObjKind GameObject::getObjKind() const
 {
   return m_objKind;
 }
 
-Sapphire::Common::FFXIVARR_POSITION3& Sapphire::Entity::GameObject::getPos()
+FFXIVARR_POSITION3& GameObject::getPos()
 {
   return m_pos;
 }
 
-const Sapphire::Common::FFXIVARR_POSITION3& Sapphire::Entity::GameObject::getPos() const
+const FFXIVARR_POSITION3& GameObject::getPos() const
 {
   return m_pos;
 }
 
-void Sapphire::Entity::GameObject::setPos( float x, float y, float z, bool broadcastUpdate )
+void GameObject::setPos( float x, float y, float z, bool broadcastUpdate )
 {
   m_pos.x = x;
   m_pos.y = y;
@@ -72,7 +73,7 @@ void Sapphire::Entity::GameObject::setPos( float x, float y, float z, bool broad
 
 }
 
-void Sapphire::Entity::GameObject::setPos( const Sapphire::Common::FFXIVARR_POSITION3& pos, bool broadcastUpdate )
+void GameObject::setPos( const FFXIVARR_POSITION3& pos, bool broadcastUpdate )
 {
   m_pos = pos;
 
@@ -84,92 +85,92 @@ void Sapphire::Entity::GameObject::setPos( const Sapphire::Common::FFXIVARR_POSI
   }
 }
 
-float Sapphire::Entity::GameObject::getRot() const
+float GameObject::getRot() const
 {
   return m_rot;
 }
 
-void Sapphire::Entity::GameObject::setRot( float rot )
+void GameObject::setRot( float rot )
 {
   m_rot = rot;
 }
 
-bool Sapphire::Entity::GameObject::isChara() const
+bool GameObject::isChara() const
 {
   return isPlayer() || isBattleNpc() || isEventNpc() || isRetainer() || isCompanion();
 }
 
-bool Sapphire::Entity::GameObject::isPlayer() const
+bool GameObject::isPlayer() const
 {
   return m_objKind == ObjKind::Player;
 }
 
-bool Sapphire::Entity::GameObject::isEventNpc() const
+bool GameObject::isEventNpc() const
 {
   return m_objKind == ObjKind::EventNpc;
 }
 
-bool Sapphire::Entity::GameObject::isBattleNpc() const
+bool GameObject::isBattleNpc() const
 {
   return m_objKind == ObjKind::BattleNpc;
 }
 
-bool Sapphire::Entity::GameObject::isRetainer() const
+bool GameObject::isRetainer() const
 {
   return m_objKind == ObjKind::Retainer;
 }
 
-bool Sapphire::Entity::GameObject::isCompanion() const
+bool GameObject::isCompanion() const
 {
   return m_objKind == ObjKind::Companion;
 }
 
-bool Sapphire::Entity::GameObject::isEventObj() const
+bool GameObject::isEventObj() const
 {
   return m_objKind == ObjKind::EventObj;
 }
 
-bool Sapphire::Entity::GameObject::isHousingEventObj() const
+bool GameObject::isHousingEventObj() const
 {
   return m_objKind == ObjKind::Housing;
 }
 
-bool Sapphire::Entity::GameObject::isAetheryte() const
+bool GameObject::isAetheryte() const
 {
   return m_objKind == ObjKind::Aetheryte;
 }
 
 
 /*! \return pointer to this instance as GameObjectPtr */
-Sapphire::Entity::CharaPtr Sapphire::Entity::GameObject::getAsChara()
+CharaPtr GameObject::getAsChara()
 {
   if( !isChara() )
     return nullptr;
-  return std::dynamic_pointer_cast< Entity::Chara, Entity::GameObject >( shared_from_this() );
+  return std::dynamic_pointer_cast< Chara, GameObject >( shared_from_this() );
 }
 
 /*! \return pointer to this instance as PlayerPtr */
-Sapphire::Entity::PlayerPtr Sapphire::Entity::GameObject::getAsPlayer()
+PlayerPtr GameObject::getAsPlayer()
 {
   if( !isPlayer() )
     return nullptr;
-  return std::dynamic_pointer_cast< Entity::Player, Entity::GameObject >( shared_from_this() );
+  return std::dynamic_pointer_cast< Player, GameObject >( shared_from_this() );
 }
 
 /*! \return pointer to this instance as EventObjPtr */
-Sapphire::Entity::EventObjectPtr Sapphire::Entity::GameObject::getAsEventObj()
+EventObjectPtr GameObject::getAsEventObj()
 {
   if( !isEventObj() )
     return nullptr;
-  return std::dynamic_pointer_cast< Entity::EventObject, Entity::GameObject >( shared_from_this() );
+  return std::dynamic_pointer_cast< EventObject, GameObject >( shared_from_this() );
 }
 
 /*! \return pointer to this instance as BNpcPtr */
-Sapphire::Entity::BNpcPtr Sapphire::Entity::GameObject::getAsBNpc()
+BNpcPtr GameObject::getAsBNpc()
 {
   if( !isBattleNpc() )
     return nullptr;
-  return std::dynamic_pointer_cast< Entity::BNpc, Entity::GameObject >( shared_from_this() );
+  return std::dynamic_pointer_cast< BNpc, GameObject >( shared_from_this() );
 }
 
 /*!
@@ -178,7 +179,7 @@ but also to the global actor map
 
 \param GameObjectPtr to add
 */
-void Sapphire::Entity::GameObject::addInRangeActor( GameObjectPtr pActor )
+void GameObject::addInRangeActor( GameObjectPtr pActor )
 {
 
   // if this is null, something went wrong
@@ -211,7 +212,7 @@ but also to the global actor map
 
 \param GameObjectPtr to remove
 */
-void Sapphire::Entity::GameObject::removeInRangeActor( GameObject& actor )
+void GameObject::removeInRangeActor( GameObject& actor )
 {
   // call virtual event
   onRemoveInRangeActor( actor );
@@ -232,12 +233,12 @@ void Sapphire::Entity::GameObject::removeInRangeActor( GameObject& actor )
 }
 
 /*! \return true if there is at least one actor in the in range set */
-bool Sapphire::Entity::GameObject::hasInRangeActor() const
+bool GameObject::hasInRangeActor() const
 {
   return ( !m_inRangeActor.empty() );
 }
 
-void Sapphire::Entity::GameObject::removeFromInRange()
+void GameObject::removeFromInRange()
 {
   if( !hasInRangeActor() )
     return;
@@ -255,14 +256,14 @@ check if a given actor is in the actors in range set
 \param GameObjectPtr to be checked for
 \return true if the actor was found
 */
-bool Sapphire::Entity::GameObject::isInRangeSet( GameObjectPtr pActor ) const
+bool GameObject::isInRangeSet( GameObjectPtr pActor ) const
 {
   return !( m_inRangeActor.find( pActor ) == m_inRangeActor.end() );
 }
 
 
 /*! \return GameObjectPtr of the closest actor in range, if none, nullptr */
-Sapphire::Entity::CharaPtr Sapphire::Entity::GameObject::getClosestChara()
+CharaPtr GameObject::getClosestChara()
 {
   if( m_inRangeActor.empty() )
     // no actors in range, don't bother
@@ -275,8 +276,7 @@ Sapphire::Entity::CharaPtr Sapphire::Entity::GameObject::getClosestChara()
 
   for( const auto& pCurAct : m_inRangeActor )
   {
-    float distance = Util::distance( getPos().x, getPos().y, getPos().z,
-                                     pCurAct->getPos().x, pCurAct->getPos().y, pCurAct->getPos().z );
+    float distance = Util::distance( getPos().x, getPos().y, getPos().z, pCurAct->getPos().x, pCurAct->getPos().y, pCurAct->getPos().z );
 
     if( distance < minDistance )
     {
@@ -289,7 +289,7 @@ Sapphire::Entity::CharaPtr Sapphire::Entity::GameObject::getClosestChara()
 }
 
 /*! Clear the whole in range set, this does no cleanup */
-void Sapphire::Entity::GameObject::clearInRangeSet()
+void GameObject::clearInRangeSet()
 {
   m_inRangeActor.clear();
   m_inRangePlayers.clear();
@@ -297,7 +297,7 @@ void Sapphire::Entity::GameObject::clearInRangeSet()
 }
 
 /*! \return list of actors currently in range */
-std::set< Sapphire::Entity::GameObjectPtr > Sapphire::Entity::GameObject::getInRangeActors( bool includeSelf )
+std::set< GameObjectPtr > GameObject::getInRangeActors( bool includeSelf )
 {
   auto tempInRange = m_inRangeActor;
 
@@ -307,7 +307,7 @@ std::set< Sapphire::Entity::GameObjectPtr > Sapphire::Entity::GameObject::getInR
   return tempInRange;
 }
 
-std::set< uint64_t > Sapphire::Entity::GameObject::getInRangePlayerIds( bool includeSelf )
+std::set< uint64_t > GameObject::getInRangePlayerIds( bool includeSelf )
 {
   std::set< uint64_t > playerIds;
   for( auto& player : m_inRangePlayers )
@@ -319,22 +319,22 @@ std::set< uint64_t > Sapphire::Entity::GameObject::getInRangePlayerIds( bool inc
   return playerIds;
 }
 
-uint32_t Sapphire::Entity::GameObject::getTerritoryTypeId() const
+uint32_t GameObject::getTerritoryTypeId() const
 {
   return m_territoryTypeId;
 }
 
-void Sapphire::Entity::GameObject::setTerritoryTypeId( uint32_t territoryTypeId )
+void GameObject::setTerritoryTypeId( uint32_t territoryTypeId )
 {
   m_territoryTypeId = territoryTypeId;
 }
 
-uint32_t Sapphire::Entity::GameObject::getTerritoryId() const
+uint32_t GameObject::getTerritoryId() const
 {
   return m_territoryId;
 }
 
-void Sapphire::Entity::GameObject::setTerritoryId( uint32_t territoryId )
+void GameObject::setTerritoryId( uint32_t territoryId )
 {
   m_territoryId = territoryId;
 }
@@ -344,7 +344,7 @@ Get the current cellId of a region the actor is in
 
 \return CellId
 */
-Sapphire::Common::CellId Sapphire::Entity::GameObject::getCellId() const
+CellId GameObject::getCellId() const
 {
   return m_cellId;
 }
@@ -354,7 +354,7 @@ Set the current cellId the actor is in
 
 \param CellId for the cell to be set
 */
-void Sapphire::Entity::GameObject::setCellId( Common::CellId cellId )
+void GameObject::setCellId( CellId cellId )
 {
   m_cellId = cellId;
 }
diff --git a/src/world/Actor/GameObject.h b/src/world/Actor/GameObject.h
index db4bb3afd..2d5bd6b31 100644
--- a/src/world/Actor/GameObject.h
+++ b/src/world/Actor/GameObject.h
@@ -10,7 +10,6 @@
 
 namespace Sapphire::Entity
 {
-
   /*!
   \class GameObject
   \brief Base class for all actor/objects
@@ -59,13 +58,13 @@ namespace Sapphire::Entity
     Common::FFXIVARR_POSITION3& getPos();
     const Common::FFXIVARR_POSITION3& getPos() const;
 
-    void setPos( const Common::FFXIVARR_POSITION3& pos, bool broadcastUpdate = true );
+    virtual void setPos( const Common::FFXIVARR_POSITION3& pos, bool broadcastUpdate = true );
 
-    void setPos( float x, float y, float z, bool broadcastUpdate = true );
+    virtual void setPos( float x, float y, float z, bool broadcastUpdate = true );
 
     float getRot() const;
 
-    void setRot( float rot );
+    virtual void setRot( float rot );
 
     bool isChara() const;
 
diff --git a/src/world/Actor/Npc.cpp b/src/world/Actor/Npc.cpp
index 4ff64afaa..e6f63f65d 100644
--- a/src/world/Actor/Npc.cpp
+++ b/src/world/Actor/Npc.cpp
@@ -1,20 +1,14 @@
-#include <Network/PacketContainer.h>
-#include "Action/Action.h"
-#include "Territory/Territory.h"
-
 #include "Player.h"
 #include "Npc.h"
 #include "Common.h"
 
+using namespace Sapphire::Entity;
 using namespace Sapphire::Common;
-using namespace Sapphire::Network::Packets;
-using namespace Sapphire::Network::Packets::WorldPackets::Server;
 
-Sapphire::Entity::Npc::Npc( ObjKind type ) : Chara( type )
+Npc::Npc( ObjKind type ) : Chara( type )
 {
-
 }
 
-Sapphire::Entity::Npc::~Npc()
+Npc::~Npc()
 {
 }
diff --git a/src/world/Actor/Player.cpp b/src/world/Actor/Player.cpp
index 2ce6e2c30..3ef1f5b57 100644
--- a/src/world/Actor/Player.cpp
+++ b/src/world/Actor/Player.cpp
@@ -35,7 +35,7 @@
 #include "Network/PacketWrappers/EffectPacket1.h"
 #include "Network/PacketWrappers/InitZonePacket.h"
 
-#include "Network/Util/PlayerUtil.h"
+#include "Network/Util/PacketUtil.h"
 
 #include "Action/Action.h"
 
@@ -264,7 +264,7 @@ void Player::addOnlineStatus( OnlineStatus status )
 
   setOnlineStatusMask( newFlags );
 
-  Network::Util::Player::sendOnlineStatus( *this );
+  Network::Util::Packet::sendOnlineStatus( *this );
 }
 
 void Player::addOnlineStatus( const std::vector< Common::OnlineStatus >& status )
@@ -278,7 +278,7 @@ void Player::addOnlineStatus( const std::vector< Common::OnlineStatus >& status
 
   setOnlineStatusMask( newFlags );
 
-  Network::Util::Player::sendOnlineStatus( *this );
+  Network::Util::Packet::sendOnlineStatus( *this );
 }
 
 void Player::removeOnlineStatus( OnlineStatus status )
@@ -292,7 +292,7 @@ void Player::removeOnlineStatus( OnlineStatus status )
   setOnlineStatusMask( newFlags );
   setOnlineStatusCustomMask( newFlagsCustom );
 
-  Network::Util::Player::sendOnlineStatus( *this );
+  Network::Util::Packet::sendOnlineStatus( *this );
 }
 
 void Player::removeOnlineStatus( const std::vector< Common::OnlineStatus >& status )
@@ -309,7 +309,7 @@ void Player::removeOnlineStatus( const std::vector< Common::OnlineStatus >& stat
   setOnlineStatusMask( newFlags );
   setOnlineStatusCustomMask( newFlagsCustom );
 
-  Network::Util::Player::sendOnlineStatus( *this );
+  Network::Util::Packet::sendOnlineStatus( *this );
 }
 
 void Player::calculateStats()
@@ -397,18 +397,6 @@ bool Player::isAutoattackOn() const
   return m_bAutoattack;
 }
 
-bool Player::exitInstance()
-{
-  auto& warpMgr = Common::Service< WarpMgr >::ref();
-
-  resetHp();
-  resetMp();
-
-  warpMgr.requestMoveTerritory( *this, WarpType::WARP_TYPE_CONTENT_END_RETURN, getPrevTerritoryId(), getPrevPos(), getPrevRot() );
-
-  return true;
-}
-
 uint32_t Player::getPlayTime() const
 {
   return m_playTime;
@@ -457,7 +445,7 @@ void Player::registerAetheryte( uint8_t aetheryteId )
   Util::valueToFlagByteIndexValue( aetheryteId, value, index );
 
   m_aetheryte[ index ] |= value;
-  Network::Util::Player::sendActorControlSelf( *this, LearnTeleport, aetheryteId, 1 );
+  Network::Util::Packet::sendActorControlSelf( *this, getId(), LearnTeleport, aetheryteId, 1 );
 }
 
 bool Player::isAetheryteRegistered( uint8_t aetheryteId ) const
@@ -474,60 +462,6 @@ Player::Discovery& Player::getDiscoveryBitmask()
   return m_discovery;
 }
 
-void Player::discover( int16_t mapId, int16_t subId )
-{
-  auto& exdData = Common::Service< Data::ExdData >::ref();
-
-  int32_t offset;
-
-  auto info = exdData.getRow< Excel::Map >( mapId );
-  if( !info )
-  {
-    PlayerMgr::sendDebug( *this, "discover(): Could not obtain map data for map_id == {0}", mapId );
-    return;
-  }
-
-  const auto& mapData = info->data();
-
-  if( mapData.IsUint16Discovery )
-    offset = 2 * mapData.DiscoveryIndex;
-  else
-    offset = 320 + 4 * mapData.DiscoveryIndex;
-
-  uint16_t index;
-  uint8_t value;
-  Util::valueToFlagByteIndexValue( subId, value, index );
-
-  m_discovery[ offset + index ] |= value;
-
-  uint16_t level = getLevel();
-
-  uint32_t exp = ( exdData.getRow< Excel::ParamGrow >( level )->data().NextExp * 5 / 100 );
-  gainExp( exp );
-
-  // gain 10x additional EXP if entire map is completed
-  uint32_t mask = mapData.DiscoveryFlag;
-  uint32_t discoveredAreas;
-  if( info->data().IsUint16Discovery )
-  {
-    discoveredAreas = ( m_discovery[ offset + 1 ] << 8 ) | m_discovery[ offset ];
-  }
-  else
-  {
-    discoveredAreas = ( m_discovery[ offset + 3 ] << 24 ) |
-                      ( m_discovery[ offset + 2 ] << 16 ) |
-                      ( m_discovery[ offset + 1 ] << 8  ) |
-                        m_discovery[ offset ];
-  }
-
-  bool allDiscovered = ( ( discoveredAreas & mask ) == mask );
-
-  if( allDiscovered )
-  {
-    gainExp( exp * 10 );
-  }
-}
-
 bool Player::isNewAdventurer() const
 {
   return m_bNewAdventurer;
@@ -560,7 +494,28 @@ void Player::setRewardFlag( Common::UnlockEntry unlockId )
 
   m_unlocks[ index ] |= value;
 
-  Network::Util::Player::sendActorControlSelf( *this, SetRewardFlag, unlock, 1 );
+  Network::Util::Packet::sendActorControlSelf( *this, getId(), SetRewardFlag, unlock, 1 );
+}
+
+void Player::fillRewardFlags()
+{
+  memset( m_unlocks.data(), 0xFF, m_unlocks.size() );
+}
+
+void Player::setBorrowAction( uint8_t slot, uint32_t action )
+{
+  if( slot > Common::ARRSIZE_BORROWACTION )
+    return;
+
+  auto& borrowAction = getBorrowAction();
+  borrowAction[ slot ] = action;
+}
+
+Player::BorrowAction& Player::getBorrowAction()
+{
+  auto& exdData = Common::Service< Data::ExdData >::ref();
+  uint8_t classJobIndex = exdData.getRow< Excel::ClassJob >( static_cast<uint8_t>( getClass() ) )->data().WorkIndex;
+  return m_borrowActions[ classJobIndex ];
 }
 
 void Player::learnSong( uint8_t songId, uint32_t itemId )
@@ -570,8 +525,6 @@ void Player::learnSong( uint8_t songId, uint32_t itemId )
   Util::valueToFlagByteIndexValue( songId, value, index );
 
   m_orchestrion[ index ] |= value;
-
-  Network::Util::Player::sendActorControlSelf( *this, ToggleOrchestrionUnlock, songId, 1, itemId );
 }
 
 bool Player::hasReward( Common::UnlockEntry unlockId ) const
@@ -598,57 +551,6 @@ bool Player::hasMount( uint32_t mountId ) const
   return m_mountGuide[ index ] & value;
 }
 
-void Player::gainExp( uint32_t amount )
-{
-  uint32_t currentExp = getExp();
-  uint16_t level = getLevel();
-  auto currentClass = static_cast< uint8_t >( getClass() );
-
-  if( level >= Common::MAX_PLAYER_LEVEL )
-  {
-    setExp( 0 );
-    if( currentExp != 0 )
-      Network::Util::Player::sendActorControlSelf( *this, UpdateUiExp, currentClass, 0 );
-
-    return;
-  }
-
-  auto& exdData = Common::Service< Data::ExdData >::ref();
-
-  uint32_t neededExpToLevel = exdData.getRow< Excel::ParamGrow >( level )->data().NextExp;
-  uint32_t neededExpToLevelPlus1 = exdData.getRow< Excel::ParamGrow >( level + 1 )->data().NextExp;
-
-  if( ( currentExp + amount ) >= neededExpToLevel )
-  {
-    // levelup
-    amount = ( currentExp + amount - neededExpToLevel ) > neededExpToLevelPlus1 ? neededExpToLevelPlus1 - 1 : ( currentExp + amount - neededExpToLevel );
-
-    if( level + 1 >= Common::MAX_PLAYER_LEVEL )
-      amount = 0;
-
-    setExp( amount );
-    levelUp();
-  }
-  else
-    setExp( currentExp + amount );
-
-  Network::Util::Player::sendActorControlSelf( *this, GainExpMsg, currentClass, amount );
-  Network::Util::Player::sendActorControlSelf( *this, UpdateUiExp, currentClass, getExp() );
-}
-
-void Player::levelUp()
-{
-  m_hp = getMaxHp();
-  m_mp = getMaxMp();
-
-  setLevel( getLevel() + 1 );
-  Network::Util::Player::sendActorControl( getInRangePlayerIds( true ), *this, LevelUpEffect, static_cast< uint8_t >( getClass() ), getLevel(), getLevel() - 1 );
-
-  auto& achvMgr = Common::Service< World::Manager::AchievementMgr >::ref();
-  achvMgr.progressAchievementByType< Common::Achievement::Type::Classjob >( *this, static_cast< uint32_t >( getClass() ) );
-  Service< World::Manager::MapMgr >::ref().updateQuests( *this );
-}
-
 uint8_t Player::getLevel() const
 {
   auto& exdData = Common::Service< Data::ExdData >::ref();
@@ -680,14 +582,14 @@ bool Player::isClassJobUnlocked( Common::ClassJob classJob ) const
   return getLevelForClass( classJob ) != 0;
 }
 
-uint32_t Player::getExp() const
+uint32_t Player::getCurrentExp() const
 {
   auto& exdData = Common::Service< Data::ExdData >::ref();
   uint8_t classJobIndex = exdData.getRow< Excel::ClassJob >( static_cast< uint8_t >( getClass() ) )->data().WorkIndex;
   return m_expArray[ classJobIndex ];
 }
 
-void Player::setExp( uint32_t amount )
+void Player::setCurrentExp( uint32_t amount )
 {
   auto& exdData = Common::Service< Data::ExdData >::ref();
   uint8_t classJobIndex = exdData.getRow< Excel::ClassJob >( static_cast< uint8_t >( getClass() ) )->data().WorkIndex;
@@ -708,19 +610,6 @@ void Player::setInCombat( bool mode )
 void Player::setClassJob( Common::ClassJob classJob )
 {
   m_class = classJob;
-
-  if( getHp() > getMaxHp() )
-    m_hp = getMaxHp();
-
-  if( getMp() > getMaxMp() )
-    m_mp = getMaxMp();
-
-  m_tp = 0;
-
-  Network::Util::Player::sendStatusUpdate( *this );
-  Network::Util::Player::sendActorControl( getInRangePlayerIds( true ), *this, ClassJobChange, 4 );
-  Network::Util::Player::sendHudParam( *this );
-  Service< World::Manager::MapMgr >::ref().updateQuests( *this );
 }
 
 void Player::setLevel( uint8_t level )
@@ -728,11 +617,6 @@ void Player::setLevel( uint8_t level )
   auto& exdData = Common::Service< Data::ExdData >::ref();
   uint8_t classJobIndex = exdData.getRow< Excel::ClassJob >( static_cast< uint8_t >( getClass() ) )->data().WorkIndex;
   m_classArray[ classJobIndex ] = level;
-
-  calculateStats();
-  Network::Util::Player::sendBaseParams( *this );
-  Network::Util::Player::sendHudParam( *this );
-  Network::Util::Player::sendStatusUpdate( *this );
 }
 
 void Player::setLevelForClass( uint8_t level, Common::ClassJob classjob )
@@ -745,7 +629,7 @@ void Player::setLevelForClass( uint8_t level, Common::ClassJob classjob )
 
   m_classArray[ classJobIndex ] = level;
 
-  Network::Util::Player::sendActorControlSelf( *this, ClassJobUpdate, static_cast< uint8_t >( classjob ), getLevelForClass( classjob ) );
+  Network::Util::Packet::sendActorControlSelf( *this, getId(), ClassJobUpdate, static_cast< uint8_t >( classjob ), getLevelForClass( classjob ) );
 
   auto& achvMgr = Common::Service< World::Manager::AchievementMgr >::ref();
   achvMgr.progressAchievementByType< Common::Achievement::Type::Classjob >( *this, static_cast< uint32_t >( classjob ) );
@@ -818,7 +702,7 @@ void Player::despawn( Entity::PlayerPtr pTarget )
   Logger::debug( "Despawning {0} for {1}", getName(), pTarget->getName() );
 
   pPlayer->freePlayerSpawnId( getId() );
-  Network::Util::Player::sendActorControlSelf( *this, WarpStart, 4, getId(), 1 );
+  Network::Util::Packet::sendActorControlSelf( *this, getId(), WarpStart, 4, getId(), 1 );
 }
 
 GameObjectPtr Player::lookupTargetById( uint64_t targetId )
@@ -848,13 +732,13 @@ void Player::setGrandCompany( uint8_t gc )
   m_gc = gc;
   if( m_gcRank[ gc ] == 0 )
     m_gcRank[ gc ] = 1;
-  Network::Util::Player::sendGrandCompany( *this );
+  Network::Util::Packet::sendGrandCompany( *this );
 }
 
 void Player::setGrandCompanyRankAt( uint8_t index, uint8_t rank )
 {
   m_gcRank[ index ] = rank;
-  Network::Util::Player::sendGrandCompany( *this );
+  Network::Util::Packet::sendGrandCompany( *this );
 }
 
 const Player::Condition& Player::getConditions() const
@@ -882,7 +766,7 @@ void Player::setCondition( Common::PlayerCondition flag )
   Util::valueToFlagByteIndexValue( iFlag, value, index );
 
   m_condition[ index ] |= value;
-  Network::Util::Player::sendCondition( *this );
+  Network::Util::Packet::sendCondition( *this );
 }
 
 void Player::setConditions( const std::vector< Common::PlayerCondition >& flags )
@@ -897,7 +781,7 @@ void Player::setConditions( const std::vector< Common::PlayerCondition >& flags
 
     m_condition[ index ] |= value;
   }
-  Network::Util::Player::sendCondition( *this );
+  Network::Util::Packet::sendCondition( *this );
 }
 
 void Player::removeCondition( Common::PlayerCondition flag )
@@ -912,7 +796,7 @@ void Player::removeCondition( Common::PlayerCondition flag )
   Util::valueToFlagByteIndexValue( iFlag, value, index );
 
   m_condition[ index ] ^= value;
-  Network::Util::Player::sendCondition( *this );
+  Network::Util::Packet::sendCondition( *this );
 }
 
 void Player::update( uint64_t tickCount )
@@ -923,16 +807,6 @@ void Player::update( uint64_t tickCount )
   Chara::update( tickCount );
 }
 
-uint64_t Player::getLastAttack() const
-{
-  return m_lastAttack;
-}
-
-void Player::setLastAttack( uint64_t tickCount )
-{
-  m_lastAttack = tickCount;
-}
-
 void Player::freePlayerSpawnId( uint32_t actorId )
 {
   auto spawnId = m_actorSpawnIndexAllocator.freeUsedSpawnIndex( actorId );
@@ -941,7 +815,7 @@ void Player::freePlayerSpawnId( uint32_t actorId )
   if( spawnId == m_actorSpawnIndexAllocator.getAllocFailId() )
     return;
 
-  Network::Util::Player::sendDeletePlayer( *this, actorId, spawnId );
+  Network::Util::Packet::sendDeletePlayer( *this, actorId, spawnId );
 }
 
 Player::AetheryteList& Player::getAetheryteArray()
@@ -953,7 +827,7 @@ Player::AetheryteList& Player::getAetheryteArray()
 void Player::setHomepoint( uint8_t aetheryteId )
 {
   m_homePoint = aetheryteId;
-  Network::Util::Player::sendActorControlSelf( *this, SetHomepoint, aetheryteId );
+  Network::Util::Packet::sendActorControlSelf( *this, getId(), SetHomepoint, aetheryteId );
 }
 
 /*! get homepoint */
@@ -1002,7 +876,7 @@ void Player::unlockMount( uint32_t mountId )
 
   m_mountGuide[ mount->data().MountOrder / 8 ] |= ( 1 << ( mount->data().MountOrder % 8 ) );
 
-  Network::Util::Player::sendActorControlSelf( *this, SetMountBitmask, mount->data().MountOrder, 1 );
+  Network::Util::Packet::sendActorControlSelf( *this, getId(), SetMountBitmask, mount->data().MountOrder, 1 );
 }
 
 void Player::unlockCompanion( uint32_t companionId )
@@ -1019,7 +893,7 @@ void Player::unlockCompanion( uint32_t companionId )
 
   m_minionGuide[ index ] |= value;
 
-  Network::Util::Player::sendActorControlSelf( *this, LearnCompanion, companionId, 1 );
+  Network::Util::Packet::sendActorControlSelf( *this, getId(), LearnCompanion, companionId, 1 );
 }
 
 Player::MinionList& Player::getMinionGuideBitmask()
@@ -1109,7 +983,7 @@ void Player::hateListAdd( const BNpc& bnpc )
     uint8_t hateId = m_freeHateSlotQueue.front();
     m_freeHateSlotQueue.pop();
     m_actorIdTohateSlotMap[ bnpc.getId() ] = hateId;
-    Network::Util::Player::sendHateList( *this );
+    Network::Util::Packet::sendHateList( *this );
   }
 }
 
@@ -1124,7 +998,7 @@ void Player::hateListRemove( const BNpc& bnpc )
       uint8_t hateSlot = it->second;
       m_freeHateSlotQueue.push( hateSlot );
       m_actorIdTohateSlotMap.erase( it );
-      Network::Util::Player::sendHateList( *this );
+      Network::Util::Packet::sendHateList( *this );
       return;
     }
   }
@@ -1144,14 +1018,18 @@ const std::map< uint32_t, uint8_t >& Player::getActorIdToHateSlotMap()
 void Player::onMobAggro( const BNpc& bnpc )
 {
   hateListAdd( bnpc );
-  Network::Util::Player::sendActorControl( *this, SetBattle, 1 );
+  setCondition( PlayerCondition::InCombat );
+  Network::Util::Packet::sendActorControl( *this, getId(), SetBattle, 1 );
 }
 
 void Player::onMobDeaggro( const BNpc& bnpc )
 {
   hateListRemove( bnpc );
   if( m_actorIdTohateSlotMap.empty() )
-    Network::Util::Player::sendActorControl( *this, SetBattle, 0 );
+  {
+    removeCondition( PlayerCondition::InCombat );
+    Network::Util::Packet::sendActorControl( *this, getId(), SetBattle, 0 );
+  }
 }
 
 bool Player::isLogin() const
@@ -1189,11 +1067,11 @@ void Player::setTitle( uint16_t titleId )
   uint8_t value;
   Util::valueToFlagByteIndexValue( titleId, value, index );
 
-  if( ( m_titleList[ index ] & value ) == 0 )   // Player doesn't have title - bail
+  if( ( m_titleList[ index ] & value ) == 0 && titleId != 0 )   // Player doesn't have title and is not "no title" - bail
     return;
 
   m_activeTitle = titleId;
-  Network::Util::Player::sendActorControl( getInRangePlayerIds( true ), *this, SetTitle, titleId );
+  Network::Util::Packet::sendActorControl( getInRangePlayerIds( true ), getId(), SetTitle, titleId );
 }
 
 const Player::AchievementData& Player::getAchievementData() const
@@ -1209,7 +1087,7 @@ void Player::setAchievementData( const Player::AchievementData& achievementData
 void Player::setMaxGearSets( uint8_t amount )
 {
   m_equippedMannequin = amount;
-  Network::Util::Player::sendActorControlSelf( *this, SetMaxGearSets, m_equippedMannequin );
+  Network::Util::Packet::sendActorControlSelf( *this, getId(), SetMaxGearSets, m_equippedMannequin );
 }
 
 void Player::addGearSet()
@@ -1234,7 +1112,7 @@ uint8_t Player::getMaxGearSets() const
 void Player::setConfigFlags( uint16_t state )
 {
   m_configFlags = static_cast< uint8_t >( state );
-  Network::Util::Player::sendConfigFlags( *this );
+  Network::Util::Packet::sendConfigFlags( *this );
 }
 
 uint8_t Player::getConfigFlags() const
@@ -1245,7 +1123,7 @@ uint8_t Player::getConfigFlags() const
 void Player::setMount( uint32_t mountId )
 {
   m_mount = mountId;
-  Network::Util::Player::sendMount( *this );
+  Network::Util::Packet::sendMount( *this );
 }
 
 void Player::setCompanion( uint8_t id )
@@ -1258,7 +1136,7 @@ void Player::setCompanion( uint8_t id )
 
   m_companionId = id;
 
-  Network::Util::Player::sendActorControl( getInRangePlayerIds( true ), *this, ToggleCompanion, id );
+  Network::Util::Packet::sendActorControl( getInRangePlayerIds( true ), getId(), ToggleCompanion, id );
 }
 
 uint8_t Player::getCurrentCompanion() const
@@ -1295,33 +1173,8 @@ void Player::autoAttack( CharaPtr pTarget )
   auto& RNGMgr = Common::Service< World::Manager::RNGMgr >::ref();
   auto variation = static_cast< uint32_t >( RNGMgr.getRandGenerator< float >( 0, 3 ).next() );
 
-  //actionMgr.handleTargetedPlayerAction( *this, 7, exdData.getRow< Excel::Action >( 7 ), pTarget->getId(), 0 );
-
-  auto damage = Math::CalcStats::calcAutoAttackDamage( *this );
-
-  auto effectPacket = std::make_shared< EffectPacket1 >( getId(), pTarget->getId(), 7 );
-
-  Common::CalcResultParam entry{};
-
-  entry.Value = static_cast< int16_t >( damage.first );
-  entry.Type = Common::ActionEffectType::CALC_RESULT_TYPE_DAMAGE_HP;
-  entry.Arg0 = 2;
-  entry.Arg1 = 7;
-
-  if( getClass() == ClassJob::Machinist || getClass() == ClassJob::Bard || getClass() == ClassJob::Archer )
-    effectPacket->setActionId( 8 );
+  actionMgr.handleTargetedAction( *this, 7, pTarget->getId(), 0 );
 
-  auto resultId = pZone->getNextEffectResultId();
-  effectPacket->setResultId( resultId );
-  effectPacket->setRotation( Util::floatToUInt16Rot( getRot() ) );
-  effectPacket->addTargetEffect( entry );
-
-  server().queueForPlayers( getInRangePlayerIds( true ), effectPacket );
-
-  pTarget->takeDamage( static_cast< uint32_t >( damage.first ) );
-
-  auto& taskMgr = Common::Service< TaskMgr >::ref();
-  taskMgr.queueTask( Sapphire::World::makeActionIntegrityTask( resultId, pTarget, 500 ) );
 }
 
 
@@ -1398,7 +1251,7 @@ bool Player::isDirectorInitialized() const
   return m_directorInitialized;
 }
 
-void Player::teleportQuery( uint16_t aetheryteId )
+void Player::teleportQuery( uint16_t aetheryteId, bool useAetheryteTicket )
 {
   auto& exdData = Common::Service< Data::ExdData >::ref();
   // TODO: only register this action if enough gil is in possession
@@ -1409,8 +1262,9 @@ void Player::teleportQuery( uint16_t aetheryteId )
 
   auto fromAetheryte = exdData.getRow< Excel::Aetheryte >( exdData.getRow< Excel::TerritoryType >( getTerritoryTypeId() )->data().Aetheryte );
 
-  // calculate cost - does not apply for favorite points or homepoints neither checks for aether tickets
-  auto cost = static_cast< uint16_t > (
+  // calculate cost - does not apply for favorite points or homepoints
+  // if using aetheryte ticket, cost is 0
+  auto cost = useAetheryteTicket ? 0 : static_cast< uint16_t > (
     ( std::sqrt( std::pow( fromAetheryte->data().CostPosX - targetAetheryte->data().CostPosX, 2 ) +
                  std::pow( fromAetheryte->data().CostPosY - targetAetheryte->data().CostPosY, 2 ) ) / 2 ) + 100 );
 
@@ -1418,12 +1272,13 @@ void Player::teleportQuery( uint16_t aetheryteId )
   cost = std::min< uint16_t >( 999, cost );
 
   bool insufficientGil = getCurrency( Common::CurrencyType::Gil ) < cost;
-  Network::Util::Player::sendActorControlSelf( *this, OnExecuteTelepo, insufficientGil ? 2 : 0, aetheryteId );
+  Network::Util::Packet::sendActorControlSelf( *this, getId(), OnExecuteTelepo, insufficientGil ? 2 : 0, aetheryteId );
 
   if( !insufficientGil )
   {
     m_teleportQuery.targetAetheryte = aetheryteId;
     m_teleportQuery.cost = cost;
+    m_teleportQuery.useAetheryteTicket = useAetheryteTicket;
   }
   else
   {
@@ -1493,7 +1348,7 @@ void Player::dyeItemFromDyeingInfo()
   insertInventoryItem( static_cast< Sapphire::Common::InventoryType >( itemToDyeContainer ), static_cast< uint16_t >( itemToDyeSlot ), itemToDye );
   writeItem( itemToDye );
 
-  Network::Util::Player::sendActorControlSelf( *this, DyeMsg, itemToDye->getId(), shouldDye, invalidateGearSet );
+  Network::Util::Packet::sendActorControlSelf( *this, getId(), DyeMsg, itemToDye->getId(), shouldDye, invalidateGearSet );
 }
 
 void Player::setGlamouringInfo( uint32_t itemToGlamourContainer, uint32_t itemToGlamourSlot, uint32_t glamourBagContainer, uint32_t glamourBagSlot, bool shouldGlamour )
@@ -1515,7 +1370,7 @@ void Player::glamourItemFromGlamouringInfo()
   uint32_t glamourBagSlot = m_glamouringInfo.glamourBagSlot;
   bool shouldGlamour = m_glamouringInfo.shouldGlamour;
 
-  Network::Util::Player::sendCondition( *this );
+  Network::Util::Packet::sendCondition( *this );
 
   auto itemToGlamour = getItemAt( itemToGlamourContainer, itemToGlamourSlot );
   auto glamourToUse = getItemAt( glamourBagContainer, glamourBagSlot );
@@ -1547,9 +1402,9 @@ void Player::glamourItemFromGlamouringInfo()
   writeItem( itemToGlamour );
 
   if( shouldGlamour )
-    Network::Util::Player::sendActorControlSelf( *this, GlamourCastMsg, itemToGlamour->getId(), glamourToUse->getId(), invalidateGearSet );
+    Network::Util::Packet::sendActorControlSelf( *this, getId(), GlamourCastMsg, itemToGlamour->getId(), glamourToUse->getId(), invalidateGearSet );
   else
-    Network::Util::Player::sendActorControlSelf( *this, GlamourRemoveMsg, itemToGlamour->getId(), invalidateGearSet );
+    Network::Util::Packet::sendActorControlSelf( *this, getId(), GlamourRemoveMsg, itemToGlamour->getId(), invalidateGearSet );
 }
 
 void Player::resetObjSpawnIndex()
@@ -1565,7 +1420,7 @@ void Player::freeObjSpawnIndexForActorId( uint32_t actorId )
   if( spawnId == m_objSpawnIndexAllocator.getAllocFailId() )
     return;
 
-  Network::Util::Player::sendDeleteObject( *this, spawnId );
+  Network::Util::Packet::sendDeleteObject( *this, spawnId );
 }
 
 bool Player::isObjSpawnIndexValid( uint8_t index )
@@ -1598,75 +1453,6 @@ Sapphire::Common::HuntingLogEntry& Player::getHuntingLogEntry( uint8_t index )
   return m_huntingLogEntries[ index ];
 }
 
-void Player::updateHuntingLog( uint16_t id )
-{
-  std::vector< uint32_t > rankRewards{ 2500, 10000, 20000, 30000, 40000 };
-  const auto maxRank = 4;
-  auto& pExdData = Common::Service< Data::ExdData >::ref();
-
-  // make sure we get the matching base-class if a job is being used
-  auto classJobInfo = pExdData.getRow< Excel::ClassJob >( static_cast< uint8_t >( getClass() ) );
-  if( !classJobInfo )
-    return;
-
-  auto currentClassId = classJobInfo->data().MainClass;
-
-  auto& logEntry = m_huntingLogEntries[ currentClassId - 1 ];
-
-  bool logChanged = false;
-
-
-  bool allSectionsComplete = true;
-  for( int i = 1; i <= 10; ++i )
-  {
-    bool sectionComplete = true;
-    bool sectionChanged = false;
-    auto monsterNoteId = static_cast< uint32_t >( classJobInfo->data().MainClass * 10000 + logEntry.rank * 10 + i );
-    auto note = pExdData.getRow< Excel::MonsterNote >( monsterNoteId );
-
-    // for classes that don't have entries, if the first fails the rest will fail
-    if( !note )
-      break;
-
-    for( auto x = 0; x < 4; ++x )
-    {
-      auto note1 = pExdData.getRow< Excel::MonsterNoteTarget >( note->data().Target[ x ] );
-      if( note1->data().Monster == id && logEntry.entries[ i - 1 ][ x ] < note->data().NeededKills[ x ] )
-      {
-        logEntry.entries[ i - 1 ][ x ]++;
-        Network::Util::Player::sendActorControlSelf( *this, HuntingLogEntryUpdate, monsterNoteId, x, logEntry.entries[ i - 1 ][ x ] );
-        logChanged = true;
-        sectionChanged = true;
-      }
-      if( logEntry.entries[ i - 1 ][ x ] != note->data().NeededKills[ x ] )
-        sectionComplete = false;
-    }
-    if( logChanged && sectionComplete && sectionChanged )
-    {
-      Network::Util::Player::sendActorControlSelf( *this, HuntingLogSectionFinish, monsterNoteId, i, 0 );
-      gainExp( note->data().RewardExp );
-    }
-    if( !sectionComplete )
-    {
-      allSectionsComplete = false;
-    }
-  }
-  if( logChanged && allSectionsComplete )
-  {
-    Network::Util::Player::sendActorControlSelf( *this, HuntingLogRankFinish, 4 );
-    gainExp( rankRewards[ logEntry.rank ] );
-    if( logEntry.rank < 4 )
-    {
-      logEntry.rank++;
-      memset( logEntry.entries, 0, 40 );
-      Network::Util::Player::sendActorControlSelf( *this, HuntingLogRankUnlock, currentClassId, logEntry.rank + 1, 0 );
-    }
-  }
-
-  if( logChanged )
-    Network::Util::Player::sendHuntingLog( *this );
-}
-
 void Player::setActiveLand( uint8_t land, uint8_t ward )
 {
   m_activeLand.plot = land;
@@ -1727,7 +1513,7 @@ void Player::resetRecastGroups()
     m_recast[ i ] = 0.0f;
     m_recastMax[ i ] = 0.0f;
   }
-  Network::Util::Player::sendRecastGroups( *this );
+  Network::Util::Packet::sendRecastGroups( *this );
 }
 
 bool Player::checkAction()
@@ -1826,7 +1612,10 @@ void Player::setFalling( bool state, const Common::FFXIVARR_POSITION3& pos, bool
         // no mercy on hated players
         takeDamage( damage );
       }
-      Network::Util::Player::sendActorControl( getInRangePlayerIds( true ), *this, SetFallDamage, damage );
+      Network::Util::Packet::sendActorControl( getInRangePlayerIds( true ), getId(), SetFallDamage, damage );
+      // todo: this used to work without refreshing the entire UI state
+      // does 3.x use some sort of fall integrity?
+      Network::Util::Packet::sendHudParam( *this );
     }
   }
 }
diff --git a/src/world/Actor/Player.h b/src/world/Actor/Player.h
index 01202cb63..87db7e184 100644
--- a/src/world/Actor/Player.h
+++ b/src/world/Actor/Player.h
@@ -34,10 +34,11 @@ namespace Sapphire::Entity
     using AetheryteList = std::array< uint8_t, Common::ARRSIZE_AETHERYTES >;
     using UnlockList = std::array< uint8_t, Common::ARRSIZE_UNLOCKS >;
     using OrchestrionList = std::array< uint8_t, Common::ARRSIZE_ORCHESTRION >;
-    using Condition = std::array< uint8_t, 12 >;
+    using Condition = std::array< uint8_t, Common::ARRSIZE_CONDITION >;
 
     using ClassList = std::array< uint16_t, Common::ARRSIZE_CLASSJOB >;
     using ExpList = std::array< uint32_t, Common::ARRSIZE_CLASSJOB >;
+    using BorrowAction = std::array< uint32_t, Common::ARRSIZE_BORROWACTION >;
 
     struct AchievementData {
       std::array< uint8_t, 2048 / 8 > unlockList;
@@ -83,12 +84,6 @@ namespace Sapphire::Entity
     /*! Event called on every session iteration */
     void update( uint64_t tickCount ) override;
 
-    /*! get last attack tick for player */
-    uint64_t getLastAttack() const;
-
-    /*! set last attack tick for player */
-    void setLastAttack( uint64_t tickCount );
-
     // Quest
     //////////////////////////////////////////////////////////////////////////////////////////////////////
     /*! load data for currently active quests */
@@ -220,16 +215,10 @@ namespace Sapphire::Entity
     bool isClassJobUnlocked( Common::ClassJob classJob ) const;
 
     /*! returns the exp of the currently active class / job */
-    uint32_t getExp() const;
+    uint32_t getCurrentExp() const;
 
     /*! sets the exp of the currently active class / job */
-    void setExp( uint32_t amount );
-
-    /*! adds exp to the currently active class / job */
-    void gainExp( uint32_t amount );
-
-    /*! gain a level on the currently active class / job */
-    void levelUp();
+    void setCurrentExp( uint32_t amount );
 
     /*! set level on the currently active class / job to given level */
     void setLevel( uint8_t level );
@@ -299,9 +288,6 @@ namespace Sapphire::Entity
     /*! return current online status depending on current state / activity */
     Common::OnlineStatus getOnlineStatus() const;
 
-    /*! returns the player to their position before zoning into an instance */
-    bool exitInstance();
-
     /*! gets the players territoryTypeId */
     uint32_t getPrevTerritoryTypeId() const;
 
@@ -345,7 +331,7 @@ namespace Sapphire::Entity
     uint64_t getFullOnlineStatusMask() const;
 
     /*! query teleport of a specified type */
-    void teleportQuery( uint16_t aetheryteId );
+    void teleportQuery( uint16_t aetheryteId, bool useAetheryteTicket );
 
     Common::PlayerTeleportQuery getTeleportQuery() const;
 
@@ -428,9 +414,6 @@ namespace Sapphire::Entity
     /*! get homepoint */
     uint8_t getHomepoint() const;
 
-    /*! discover subarea subid fo map map_id, also send udpate packet */
-    void discover( int16_t mapId, int16_t subId );
-
     /*! return a reference to the discovery bitmask array */
     Discovery& getDiscoveryBitmask();
 
@@ -446,6 +429,13 @@ namespace Sapphire::Entity
     /*! learn an action / update the unlock bitmask. */
     void setRewardFlag( Common::UnlockEntry unlockId );
 
+    /*! helper/debug function to fill unlock bitmask */
+    void fillRewardFlags();
+
+    void setBorrowAction( uint8_t slot, uint32_t action );
+
+    BorrowAction& getBorrowAction();
+
     /*! learn a song / update the unlock bitmask. */
     void learnSong( uint8_t songId, uint32_t itemId );
 
@@ -489,8 +479,8 @@ namespace Sapphire::Entity
     void setRecastGroup( uint8_t index, float time );
 
     float getRecastGroup( uint8_t index ) const;
-    const std::array< float, 80 >& Player::getRecastGroups() const;
-    const std::array< float, 80 >& Player::getRecastGroupsMax() const;
+    const std::array< float, 80 >& getRecastGroups() const;
+    const std::array< float, 80 >& getRecastGroupsMax() const;
 
     void resetRecastGroups();
 
@@ -779,8 +769,6 @@ namespace Sapphire::Entity
 
     Common::HuntingLogEntry& getHuntingLogEntry( uint8_t index );
 
-    void updateHuntingLog( uint16_t id );
-
     uint64_t getPartyId() const;
     void setPartyId( uint64_t partyId );
 
@@ -966,6 +954,8 @@ namespace Sapphire::Entity
 
     std::array< Common::HuntingLogEntry, Common::ARRSIZE_MONSTERNOTE > m_huntingLogEntries{};
 
+    std::array< BorrowAction, Common::ARRSIZE_CLASSJOB > m_borrowActions{};
+
     FriendListIDVec m_friendList{};
     FriendListDataVec m_friendInviteList{};
 
diff --git a/src/world/Actor/PlayerEvent.cpp b/src/world/Actor/PlayerEvent.cpp
index aaf2bbc06..54572cff3 100644
--- a/src/world/Actor/PlayerEvent.cpp
+++ b/src/world/Actor/PlayerEvent.cpp
@@ -6,29 +6,30 @@
 #include "Actor/Player.h"
 
 #include "Territory/Territory.h"
-#include "WorldServer.h"
 
 #include "Action/EventAction.h"
 #include "Manager/PlayerMgr.h"
 #include "Service.h"
-#include <Network/PacketWrappers/RestingPacket.h>
+#include <Network/Util/PacketUtil.h>
 
+using namespace Sapphire;
 using namespace Sapphire::Common;
+using namespace Sapphire::Entity;
 using namespace Sapphire::Network::Packets;
 using namespace Sapphire::Network::Packets::WorldPackets::Server;
 using namespace Sapphire::World::Manager;
 
-void Sapphire::Entity::Player::addEvent( Event::EventHandlerPtr pEvent )
+void Player::addEvent( Event::EventHandlerPtr pEvent )
 {
   m_eventHandlerMap[ pEvent->getId() ] = pEvent;
 }
 
-std::map< uint32_t, Sapphire::Event::EventHandlerPtr >& Sapphire::Entity::Player::getEventListRef()
+std::map< uint32_t, Event::EventHandlerPtr >& Player::getEventListRef()
 {
   return m_eventHandlerMap;
 }
 
-Sapphire::Event::EventHandlerPtr Sapphire::Entity::Player::getEvent( uint32_t eventId ) const
+Event::EventHandlerPtr Player::getEvent( uint32_t eventId ) const
 {
   auto it = m_eventHandlerMap.find( eventId );
   if( it != m_eventHandlerMap.end() )
@@ -37,12 +38,12 @@ Sapphire::Event::EventHandlerPtr Sapphire::Entity::Player::getEvent( uint32_t ev
   return nullptr;
 }
 
-size_t Sapphire::Entity::Player::getEventCount()
+size_t Player::getEventCount()
 {
   return m_eventHandlerMap.size();
 }
 
-void Sapphire::Entity::Player::removeEvent( uint32_t eventId )
+void Player::removeEvent( uint32_t eventId )
 {
   auto it = m_eventHandlerMap.find( eventId );
   if( it != m_eventHandlerMap.end() )
@@ -53,13 +54,13 @@ void Sapphire::Entity::Player::removeEvent( uint32_t eventId )
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void Sapphire::Entity::Player::onDeath()
+void Player::onDeath()
 {
   Service< World::Manager::PlayerMgr >::ref().onDeath( *this );
 }
 
 // TODO: slightly ugly here and way too static. Needs too be done properly
-void Sapphire::Entity::Player::onTick()
+void Player::onTick()
 {
   Chara::onTick();
   // add 3 seconds to total play time
@@ -71,10 +72,10 @@ void Sapphire::Entity::Player::onTick()
   bool sendUpdate = performResting();
 
   if( sendUpdate )
-    server().queueForPlayers( getInRangePlayerIds( true ), std::make_shared< RestingPacket >( *this ) );
+    Network::Util::Packet::sendRestingUpdate( *this );
 }
 
-bool Sapphire::Entity::Player::performResting()
+bool Player::performResting()
 {
   bool sendUpdate = false;
   auto addHp = static_cast< uint32_t >( static_cast< float >( getMaxHp() ) * 0.1f + 1 );
diff --git a/src/world/Actor/PlayerInventory.cpp b/src/world/Actor/PlayerInventory.cpp
index ff6ff745d..4d1166296 100644
--- a/src/world/Actor/PlayerInventory.cpp
+++ b/src/world/Actor/PlayerInventory.cpp
@@ -18,7 +18,7 @@
 #include "Network/PacketWrappers/ActorControlSelfPacket.h"
 #include "Network/PacketWrappers/UpdateInventorySlotPacket.h"
 #include <Network/PacketDef/Zone/ServerZoneDef.h>
-#include <Network/Util/PlayerUtil.h>
+#include <Network/Util/PacketUtil.h>
 
 #include "Manager/InventoryMgr.h"
 #include "Manager/ItemMgr.h"
@@ -27,6 +27,9 @@
 
 #include <Service.h>
 
+using namespace Sapphire;
+using namespace Sapphire::Entity;
+using namespace Sapphire::World;
 using namespace Sapphire::Common;
 using namespace Sapphire::World::Manager;
 using namespace Sapphire::Network::Packets;
@@ -34,7 +37,7 @@ using namespace Sapphire::Network::Packets::WorldPackets::Server;
 using namespace Sapphire::Network::ActorControl;
 
 
-void Sapphire::Entity::Player::initInventory()
+void Player::initInventory()
 {
   const uint8_t inventorySize = 25;
   auto setupContainer = [ this ]( InventoryType type, uint8_t maxSize, const std::string& tableName,
@@ -103,9 +106,9 @@ void Sapphire::Entity::Player::initInventory()
   calculateItemLevel();
 }
 
-void Sapphire::Entity::Player::equipWeapon( const Item& item )
+void Player::equipWeapon( const Item& item )
 {
-  auto& exdData = Common::Service< Sapphire::Data::ExdData >::ref();
+  auto& exdData = Common::Service< Data::ExdData >::ref();
 
   auto itemInfo = exdData.getRow< Excel::Item >( item.getId() );
   auto itemClassJob = itemInfo->data().Class;
@@ -115,23 +118,23 @@ void Sapphire::Entity::Player::equipWeapon( const Item& item )
 
   if( ( isClassJobUnlocked( newClassJob ) ) && ( currentParentClass != newClassJob ) )
   {
-    setClassJob( newClassJob );
+    playerMgr().onClassJobChanged( *this, newClassJob );
   }
 }
 
-void Sapphire::Entity::Player::equipSoulCrystal( const Item& item )
+void Player::equipSoulCrystal( const Item& item )
 {
-  auto& exdData = Common::Service< Sapphire::Data::ExdData >::ref();
+  auto& exdData = Common::Service< Data::ExdData >::ref();
 
   auto itemInfo = exdData.getRow< Excel::Item >( item.getId() );
   auto itemClassJob = itemInfo->data().Class;
   auto newClassJob = static_cast< ClassJob >( itemClassJob );
 
   if( isClassJobUnlocked( newClassJob ) )
-    setClassJob( newClassJob );
+    playerMgr().onClassJobChanged( *this, newClassJob );
 }
 
-void Sapphire::Entity::Player::updateModels( GearSetSlot equipSlotId, const Sapphire::Item& item )
+void Player::updateModels( GearSetSlot equipSlotId, const Sapphire::Item& item )
 {
   uint64_t model = item.getModelId1();
   uint64_t model2 = item.getModelId2();
@@ -169,7 +172,7 @@ void Sapphire::Entity::Player::updateModels( GearSetSlot equipSlotId, const Sapp
   }
 }
 
-Sapphire::Common::GearModelSlot Sapphire::Entity::Player::equipSlotToModelSlot( Common::GearSetSlot slot )
+Common::GearModelSlot Player::equipSlotToModelSlot( Common::GearSetSlot slot )
 {
   switch( slot )
   {
@@ -203,7 +206,7 @@ Sapphire::Common::GearModelSlot Sapphire::Entity::Player::equipSlotToModelSlot(
 }
 
 // equip an item
-void Sapphire::Entity::Player::equipItem( Common::GearSetSlot equipSlotId, Item& item, bool sendUpdate )
+void Player::equipItem( Common::GearSetSlot equipSlotId, Item& item, bool sendUpdate )
 {
   switch( equipSlotId )
   {
@@ -225,15 +228,15 @@ void Sapphire::Entity::Player::equipItem( Common::GearSetSlot equipSlotId, Item&
   calculateItemLevel();
   if( sendUpdate )
   {
-    Network::Util::Player::sendEquip( *this );
-    Network::Util::Player::sendActorControl( *this, SetItemLevel, getItemLevel() );
-    Network::Util::Player::sendBaseParams( *this );
-    Network::Util::Player::sendHudParam( *this );
+    Network::Util::Packet::sendEquip( *this );
+    Network::Util::Packet::sendActorControl( *this, getId(), SetItemLevel, getItemLevel() );
+    Network::Util::Packet::sendBaseParams( *this );
+    Network::Util::Packet::sendHudParam( *this );
   }
 }
 
 
-void Sapphire::Entity::Player::unequipItem( Common::GearSetSlot equipSlotId, Item& item, bool sendUpdate )
+void Player::unequipItem( Common::GearSetSlot equipSlotId, Item& item, bool sendUpdate )
 {
   auto modelSlot = equipSlotToModelSlot( equipSlotId );
   if( modelSlot != GearModelSlot::ModelInvalid )
@@ -247,23 +250,23 @@ void Sapphire::Entity::Player::unequipItem( Common::GearSetSlot equipSlotId, Ite
 
   if( sendUpdate )
   {
-    Network::Util::Player::sendEquip( *this );
-    Network::Util::Player::sendActorControl( *this, SetItemLevel, getItemLevel() );
-    Network::Util::Player::sendBaseParams( *this );
-    Network::Util::Player::sendHudParam( *this );
+    Network::Util::Packet::sendEquip( *this );
+    Network::Util::Packet::sendActorControl( *this, getId(), SetItemLevel, getItemLevel() );
+    Network::Util::Packet::sendBaseParams( *this );
+    Network::Util::Packet::sendHudParam( *this );
   }
 }
 
-void Sapphire::Entity::Player::unequipSoulCrystal()
+void Player::unequipSoulCrystal()
 {
   auto& exdData = Common::Service< Sapphire::Data::ExdData >::ref();
 
   auto currentClassJob = exdData.getRow< Excel::ClassJob >( static_cast< uint32_t >( getClass() ) );
   auto parentClass = static_cast< ClassJob >( currentClassJob->data().MainClass );
-  setClassJob( parentClass );
+  playerMgr().onClassJobChanged( *this, parentClass );
 }
 
-uint32_t Sapphire::Entity::Player::currencyTypeToItem( Common::CurrencyType type ) const
+uint32_t Player::currencyTypeToItem( Common::CurrencyType type ) const
 {
   switch( type )
   {
@@ -301,7 +304,7 @@ uint32_t Sapphire::Entity::Player::currencyTypeToItem( Common::CurrencyType type
 }
 
 // TODO: these next functions are so similar that they could likely be simplified
-void Sapphire::Entity::Player::addCurrency( CurrencyType type, uint32_t amount )
+void Player::addCurrency( CurrencyType type, uint32_t amount )
 {
   auto slot = static_cast< uint8_t >( static_cast< uint8_t >( type ) - 1 );
   auto currItem = m_storageMap[ Currency ]->getItem( slot );
@@ -339,7 +342,7 @@ void Sapphire::Entity::Player::addCurrency( CurrencyType type, uint32_t amount )
   server().queueForPlayer( getCharacterId(), invTransFinPacket );
 }
 
-void Sapphire::Entity::Player::removeCurrency( Common::CurrencyType type, uint32_t amount )
+void Player::removeCurrency( Common::CurrencyType type, uint32_t amount )
 {
 
   auto currItem = m_storageMap[ Currency ]->getItem( static_cast< uint8_t >( type ) - 1 );
@@ -373,7 +376,7 @@ void Sapphire::Entity::Player::removeCurrency( Common::CurrencyType type, uint32
 }
 
 
-void Sapphire::Entity::Player::addCrystal( Common::CrystalType type, uint32_t amount )
+void Player::addCrystal( Common::CrystalType type, uint32_t amount )
 {
   auto currItem = m_storageMap[ Crystal ]->getItem( static_cast< uint8_t >( type ) - 1 );
 
@@ -412,7 +415,7 @@ void Sapphire::Entity::Player::addCrystal( Common::CrystalType type, uint32_t am
   server().queueForPlayer( getCharacterId(), makeActorControlSelf( getId(), ItemObtainIcon, static_cast< uint8_t >( type ) + 1, amount ) );
 }
 
-void Sapphire::Entity::Player::removeCrystal( Common::CrystalType type, uint32_t amount )
+void Player::removeCrystal( Common::CrystalType type, uint32_t amount )
 {
   auto currItem = m_storageMap[ Crystal ]->getItem( static_cast< uint8_t >( type ) - 1 );
 
@@ -446,9 +449,9 @@ void Sapphire::Entity::Player::removeCrystal( Common::CrystalType type, uint32_t
   server().queueForPlayer( getCharacterId(), invTransFinPacket );
 }
 
-void Sapphire::Entity::Player::sendInventory()
+void Player::sendInventory()
 {
-  auto& invMgr = Common::Service< World::Manager::InventoryMgr >::ref();
+  auto& invMgr = Common::Service< Manager::InventoryMgr >::ref();
 
   for( auto& it : m_storageMap )
   {
@@ -456,14 +459,14 @@ void Sapphire::Entity::Player::sendInventory()
   }
 }
 
-void Sapphire::Entity::Player::sendGearInventory()
+void Player::sendGearInventory()
 {
-  auto& invMgr = Common::Service< World::Manager::InventoryMgr >::ref();
+  auto& invMgr = Common::Service< Manager::InventoryMgr >::ref();
 
   invMgr.sendInventoryContainer( *this, m_storageMap[ GearSet0 ] );
 }
 
-Sapphire::Entity::Player::InvSlotPairVec Sapphire::Entity::Player::getSlotsOfItemsInInventory( uint32_t catalogId )
+Player::InvSlotPairVec Player::getSlotsOfItemsInInventory( uint32_t catalogId )
 {
   InvSlotPairVec outVec;
   for( auto i : { Bag0, Bag1, Bag2, Bag3 } )
@@ -478,7 +481,7 @@ Sapphire::Entity::Player::InvSlotPairVec Sapphire::Entity::Player::getSlotsOfIte
   return outVec;
 }
 
-Sapphire::Entity::Player::InvSlotPair Sapphire::Entity::Player::getFreeBagSlot()
+Player::InvSlotPair Player::getFreeBagSlot()
 {
   for( auto i : { Bag0, Bag1, Bag2, Bag3 } )
   {
@@ -491,7 +494,7 @@ Sapphire::Entity::Player::InvSlotPair Sapphire::Entity::Player::getFreeBagSlot()
   return std::make_pair( 0, -1 );
 }
 
-Sapphire::Entity::Player::InvSlotPair Sapphire::Entity::Player::getFreeContainerSlot( uint32_t containerId )
+Player::InvSlotPair Player::getFreeContainerSlot( uint32_t containerId )
 {
   auto freeSlot = static_cast< int8_t >( m_storageMap[ containerId ]->getFreeSlot() );
 
@@ -502,13 +505,13 @@ Sapphire::Entity::Player::InvSlotPair Sapphire::Entity::Player::getFreeContainer
   return std::make_pair( 0, -1 );
 }
 
-Sapphire::ItemPtr Sapphire::Entity::Player::getItemAt( uint16_t containerId, uint16_t slotId )
+ItemPtr Player::getItemAt( uint16_t containerId, uint16_t slotId )
 {
   return m_storageMap[ containerId ]->getItem( slotId );
 }
 
 
-uint32_t Sapphire::Entity::Player::getCurrency( CurrencyType type )
+uint32_t Player::getCurrency( CurrencyType type )
 {
 
   auto currItem = m_storageMap[ Currency ]->getItem( static_cast< uint8_t >( type ) - 1 );
@@ -520,7 +523,7 @@ uint32_t Sapphire::Entity::Player::getCurrency( CurrencyType type )
 
 }
 
-uint32_t Sapphire::Entity::Player::getCrystal( CrystalType type )
+uint32_t Player::getCrystal( CrystalType type )
 {
 
   auto currItem = m_storageMap[ Crystal ]->getItem( static_cast< uint8_t >( type ) - 1 );
@@ -532,7 +535,7 @@ uint32_t Sapphire::Entity::Player::getCrystal( CrystalType type )
 
 }
 
-void Sapphire::Entity::Player::writeInventory( InventoryType type )
+void Player::writeInventory( InventoryType type )
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
 
@@ -561,7 +564,7 @@ void Sapphire::Entity::Player::writeInventory( InventoryType type )
   db.execute( query );
 }
 
-void Sapphire::Entity::Player::writeItem( Sapphire::ItemPtr pItem ) const
+void Player::writeItem( ItemPtr pItem ) const
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
   auto stmt = db.getPreparedStatement( Db::CHARA_ITEMGLOBAL_UP );
@@ -577,7 +580,7 @@ void Sapphire::Entity::Player::writeItem( Sapphire::ItemPtr pItem ) const
   db.directExecute( stmt );
 }
 
-void Sapphire::Entity::Player::writeCurrencyItem( CurrencyType type )
+void Player::writeCurrencyItem( CurrencyType type )
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
 
@@ -590,7 +593,7 @@ void Sapphire::Entity::Player::writeCurrencyItem( CurrencyType type )
   db.execute( query );
 }
 
-void Sapphire::Entity::Player::deleteItemDb( Sapphire::ItemPtr item ) const
+void Player::deleteItemDb( ItemPtr item ) const
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
   auto stmt = db.getPreparedStatement( Db::CHARA_ITEMGLOBAL_DELETE );
@@ -601,14 +604,14 @@ void Sapphire::Entity::Player::deleteItemDb( Sapphire::ItemPtr item ) const
 }
 
 
-bool Sapphire::Entity::Player::isObtainable( uint32_t catalogId, uint8_t quantity )
+bool Player::isObtainable( uint32_t catalogId, uint8_t quantity )
 {
 
   return true;
 }
 
 
-Sapphire::ItemPtr Sapphire::Entity::Player::addItem( uint32_t catalogId, uint32_t quantity, bool isHq, bool silent, bool canMerge )
+ItemPtr Player::addItem( uint32_t catalogId, uint32_t quantity, bool isHq, bool silent, bool canMerge )
 {
   auto& exdData = Common::Service< Data::ExdData >::ref();
   auto itemInfo = exdData.getRow< Excel::Item >( catalogId );
@@ -741,7 +744,7 @@ Sapphire::ItemPtr Sapphire::Entity::Player::addItem( uint32_t catalogId, uint32_
   return item;
 }
 
-bool Sapphire::Entity::Player::removeItem( uint32_t catalogId, uint32_t quantity, bool isHq )
+bool Player::removeItem( uint32_t catalogId, uint32_t quantity, bool isHq )
 {
   std::vector< uint16_t > bags = { Bag0, Bag1, Bag2, Bag3 };
 
@@ -790,7 +793,7 @@ bool Sapphire::Entity::Player::removeItem( uint32_t catalogId, uint32_t quantity
 }
 
 void
-Sapphire::Entity::Player::moveItem( uint16_t fromInventoryId, uint16_t fromSlotId, uint16_t toInventoryId, uint16_t toSlot )
+Player::moveItem( uint16_t fromInventoryId, uint16_t fromSlotId, uint16_t toInventoryId, uint16_t toSlot )
 {
 
   auto tmpItem = m_storageMap[ fromInventoryId ]->getItem( fromSlotId );
@@ -819,9 +822,9 @@ Sapphire::Entity::Player::moveItem( uint16_t fromInventoryId, uint16_t fromSlotI
     sendStatusEffectUpdate(); // send if any equip is changed
 }
 
-bool Sapphire::Entity::Player::updateContainer( uint16_t storageId, uint16_t slotId, ItemPtr pItem )
+bool Player::updateContainer( uint16_t storageId, uint16_t slotId, ItemPtr pItem )
 {
-  auto containerType = World::Manager::ItemMgr::getContainerType( storageId );
+  auto containerType = Manager::ItemMgr::getContainerType( storageId );
 
   auto pOldItem = getItemAt( storageId, slotId );
   m_storageMap[ storageId ]->setItem( slotId, pItem );
@@ -857,8 +860,7 @@ bool Sapphire::Entity::Player::updateContainer( uint16_t storageId, uint16_t slo
   return true;
 }
 
-void Sapphire::Entity::Player::splitItem( uint16_t fromInventoryId, uint16_t fromSlotId,
-                                          uint16_t toInventoryId, uint16_t toSlot, uint16_t itemCount )
+void Player::splitItem( uint16_t fromInventoryId, uint16_t fromSlotId, uint16_t toInventoryId, uint16_t toSlot, uint16_t itemCount )
 {
   if( itemCount == 0 )
     return;
@@ -890,8 +892,7 @@ void Sapphire::Entity::Player::splitItem( uint16_t fromInventoryId, uint16_t fro
   writeItem( fromItem );
 }
 
-void Sapphire::Entity::Player::mergeItem( uint16_t fromInventoryId, uint16_t fromSlotId,
-                                          uint16_t toInventoryId, uint16_t toSlot )
+void Player::mergeItem( uint16_t fromInventoryId, uint16_t fromSlotId, uint16_t toInventoryId, uint16_t toSlot )
 {
   auto fromItem = m_storageMap[ fromInventoryId ]->getItem( fromSlotId );
   auto toItem = m_storageMap[ toInventoryId ]->getItem( toSlot );
@@ -925,8 +926,7 @@ void Sapphire::Entity::Player::mergeItem( uint16_t fromInventoryId, uint16_t fro
   updateContainer( toInventoryId, toSlot, toItem );
 }
 
-void Sapphire::Entity::Player::swapItem( uint16_t fromInventoryId, uint16_t fromSlotId,
-                                         uint16_t toInventoryId, uint16_t toSlot )
+void Player::swapItem( uint16_t fromInventoryId, uint16_t fromSlotId, uint16_t toInventoryId, uint16_t toSlot )
 {
   auto fromItem = m_storageMap[ fromInventoryId ]->getItem( fromSlotId );
   auto toItem = m_storageMap[ toInventoryId ]->getItem( toSlot );
@@ -959,7 +959,7 @@ void Sapphire::Entity::Player::swapItem( uint16_t fromInventoryId, uint16_t from
     sendStatusEffectUpdate(); // send if any equip is changed
 }
 
-void Sapphire::Entity::Player::discardItem( uint16_t fromInventoryId, uint16_t fromSlotId )
+void Player::discardItem( uint16_t fromInventoryId, uint16_t fromSlotId )
 {
   // i am not entirely sure how this should be generated or if it even is important for us...
   uint32_t sequence = getNextInventorySequence();
@@ -988,7 +988,7 @@ void Sapphire::Entity::Player::discardItem( uint16_t fromInventoryId, uint16_t f
   server().queueForPlayer( getCharacterId(), invTransFinPacket );
 }
 
-uint16_t Sapphire::Entity::Player::calculateItemLevel()
+uint16_t Player::calculateItemLevel()
 {
   uint32_t iLvlResult = 0;
 
@@ -1020,7 +1020,7 @@ uint16_t Sapphire::Entity::Player::calculateItemLevel()
   return ilvl;
 }
 
-void Sapphire::Entity::Player::calculateBonusStats()
+void Player::calculateBonusStats()
 {
   m_bonusStats.fill( 0 );
 
@@ -1052,12 +1052,12 @@ void Sapphire::Entity::Player::calculateBonusStats()
 }
 
 
-Sapphire::ItemPtr Sapphire::Entity::Player::getEquippedWeapon()
+ItemPtr Player::getEquippedWeapon()
 {
   return m_storageMap[ GearSet0 ]->getItem( GearSetSlot::MainHand );
 }
 
-uint16_t Sapphire::Entity::Player::getFreeSlotsInBags()
+uint16_t Player::getFreeSlotsInBags()
 {
   uint16_t slots = 0;
   for( uint8_t container : { Bag0, Bag1, Bag2, Bag3 } )
@@ -1068,7 +1068,7 @@ uint16_t Sapphire::Entity::Player::getFreeSlotsInBags()
   return slots;
 }
 
-bool Sapphire::Entity::Player::collectHandInItems( std::vector< uint32_t > itemIds )
+bool Player::collectHandInItems( std::vector< uint32_t > itemIds )
 {
   // todo: figure out how the game gets the required stack count
   const auto& container = m_storageMap[ HandIn ];
@@ -1102,12 +1102,12 @@ bool Sapphire::Entity::Player::collectHandInItems( std::vector< uint32_t > itemI
   return true;
 }
 
-uint32_t Sapphire::Entity::Player::getNextInventorySequence()
+uint32_t Player::getNextInventorySequence()
 {
   return m_inventorySequence++;
 }
 
-Sapphire::ItemPtr Sapphire::Entity::Player::dropInventoryItem( Sapphire::Common::InventoryType storageId, uint8_t slotId )
+ItemPtr Player::dropInventoryItem( Sapphire::Common::InventoryType storageId, uint8_t slotId )
 {
   auto& container = m_storageMap[ storageId ];
 
@@ -1141,24 +1141,24 @@ Sapphire::ItemPtr Sapphire::Entity::Player::dropInventoryItem( Sapphire::Common:
   return item;
 }
 
-void Sapphire::Entity::Player::addSoldItem( uint32_t itemId, uint8_t stackSize )
+void Player::addSoldItem( uint32_t itemId, uint8_t stackSize )
 {
   if( m_soldItems.size() > 10 )
     m_soldItems.pop_back();
   m_soldItems.emplace_front( itemId, stackSize );
 }
 
-std::deque< std::pair< uint32_t, uint8_t > > *Sapphire::Entity::Player::getSoldItems()
+std::deque< std::pair< uint32_t, uint8_t > >* Player::getSoldItems()
 {
   return &m_soldItems;
 }
 
-void Sapphire::Entity::Player::clearSoldItems()
+void Player::clearSoldItems()
 {
   m_soldItems.clear();
 }
 
-bool Sapphire::Entity::Player::getFreeInventoryContainerSlot( Inventory::InventoryContainerPair& containerPair ) const
+bool Player::getFreeInventoryContainerSlot( Inventory::InventoryContainerPair& containerPair ) const
 {
   for( auto bagId : { Bag0, Bag1, Bag2, Bag3 } )
   {
@@ -1182,8 +1182,7 @@ bool Sapphire::Entity::Player::getFreeInventoryContainerSlot( Inventory::Invento
   return false;
 }
 
-void Sapphire::Entity::Player::insertInventoryItem( Sapphire::Common::InventoryType type, uint16_t slot,
-                                                    const Sapphire::ItemPtr item )
+void Player::insertInventoryItem( Common::InventoryType type, uint16_t slot, const ItemPtr item )
 {
   updateContainer( type, slot, item );
 
@@ -1199,8 +1198,7 @@ void Sapphire::Entity::Player::insertInventoryItem( Sapphire::Common::InventoryT
   server().queueForPlayer( getCharacterId(), invTransFinPacket );
 }
 
-bool Sapphire::Entity::Player::findFirstItemWithId( uint32_t catalogId,
-                                                    Inventory::InventoryContainerPair& location, std::initializer_list< InventoryType > bags )
+bool Player::findFirstItemWithId( uint32_t catalogId, Inventory::InventoryContainerPair& location, std::initializer_list< InventoryType > bags )
 {
   for( auto bagId : bags )
   {
diff --git a/src/world/Actor/PlayerQuest.cpp b/src/world/Actor/PlayerQuest.cpp
index e59d59814..f43609ef0 100644
--- a/src/world/Actor/PlayerQuest.cpp
+++ b/src/world/Actor/PlayerQuest.cpp
@@ -7,16 +7,18 @@
 
 #include "Player.h"
 
-
+using namespace Sapphire;
 using namespace Sapphire::Common;
+using namespace Sapphire::Entity;
+using namespace Sapphire::World;
 using namespace Sapphire::Network::Packets;
 using namespace Sapphire::Network::Packets::WorldPackets::Server;
 
-void Sapphire::Entity::Player::finishQuest( uint16_t questId, uint32_t optionalChoice )
+void Player::finishQuest( uint16_t questId, uint32_t optionalChoice )
 {
   removeQuest( questId );
 
-  auto& questMgr = Common::Service< World::Manager::QuestMgr >::ref();
+  auto& questMgr = Common::Service< Manager::QuestMgr >::ref();
 
   updateQuestsCompleted( questId );
 
@@ -24,14 +26,14 @@ void Sapphire::Entity::Player::finishQuest( uint16_t questId, uint32_t optionalC
   questMgr.onCompleteQuest( *this, questId, optionalChoice );
 }
 
-void Sapphire::Entity::Player::unfinishQuest( uint16_t questId )
+void Player::unfinishQuest( uint16_t questId )
 {
   removeQuestsCompleted( questId );
-  auto& questMgr = Common::Service< World::Manager::QuestMgr >::ref();
+  auto& questMgr = Common::Service< Manager::QuestMgr >::ref();
   questMgr.sendQuestsInfo( *this );
 }
 
-void Sapphire::Entity::Player::removeQuest( uint16_t questId )
+void Player::removeQuest( uint16_t questId )
 {
   int8_t idx = getQuestIndex( questId );
 
@@ -41,8 +43,8 @@ void Sapphire::Entity::Player::removeQuest( uint16_t questId )
     return;
   }
 
-  auto& questMgr = Common::Service< World::Manager::QuestMgr >::ref();
-  auto& mapMgr = Common::Service< World::Manager::MapMgr >::ref();
+  auto& questMgr = Common::Service< Manager::QuestMgr >::ref();
+  auto& mapMgr = Common::Service< Manager::MapMgr >::ref();
 
   m_quests[ idx ] = World::Quest();
   removeQuestTracking( idx );
@@ -53,7 +55,7 @@ void Sapphire::Entity::Player::removeQuest( uint16_t questId )
 
 }
 
-void Sapphire::Entity::Player::removeQuestTracking( int8_t idx )
+void Player::removeQuestTracking( int8_t idx )
 {
   for( int32_t ii = 0; ii < 5; ii++ )
   {
@@ -62,12 +64,12 @@ void Sapphire::Entity::Player::removeQuestTracking( int8_t idx )
   }
 }
 
-bool Sapphire::Entity::Player::hasQuest( uint32_t questId )
+bool Player::hasQuest( uint32_t questId )
 {
   return ( getQuestIndex( static_cast< uint16_t >( questId ) ) > -1 );
 }
 
-int8_t Sapphire::Entity::Player::getQuestIndex( uint16_t questId )
+int8_t Player::getQuestIndex( uint16_t questId )
 {
   for( size_t pos = 0; pos < 30; ++pos )
   {
@@ -77,7 +79,7 @@ int8_t Sapphire::Entity::Player::getQuestIndex( uint16_t questId )
   return -1;
 }
 
-void Sapphire::Entity::Player::updateQuest( const World::Quest& quest )
+void Player::updateQuest( const World::Quest& quest )
 {
   auto& questMgr = Common::Service< World::Manager::QuestMgr >::ref();
   auto& mapMgr = Common::Service< World::Manager::MapMgr >::ref();
@@ -93,7 +95,7 @@ void Sapphire::Entity::Player::updateQuest( const World::Quest& quest )
     addQuest( quest );
 }
 
-bool Sapphire::Entity::Player::addQuest( const World::Quest& quest )
+bool Player::addQuest( const World::Quest& quest )
 {
   int8_t idx = getFreeQuestSlot();
 
@@ -103,8 +105,8 @@ bool Sapphire::Entity::Player::addQuest( const World::Quest& quest )
     return false;
   }
 
-  auto& questMgr = Common::Service< World::Manager::QuestMgr >::ref();
-  auto& mapMgr = Common::Service< World::Manager::MapMgr >::ref();
+  auto& questMgr = Common::Service< Manager::QuestMgr >::ref();
+  auto& mapMgr = Common::Service< Manager::MapMgr >::ref();
 
   m_quests[ idx ] = quest;
 
@@ -117,7 +119,7 @@ bool Sapphire::Entity::Player::addQuest( const World::Quest& quest )
   return true;
 }
 
-std::optional< Sapphire::World::Quest > Sapphire::Entity::Player::getQuest( uint32_t questId )
+std::optional< World::Quest > Player::getQuest( uint32_t questId )
 {
   if( !hasQuest( questId ) )
     return std::nullopt;
@@ -128,7 +130,7 @@ std::optional< Sapphire::World::Quest > Sapphire::Entity::Player::getQuest( uint
   return { quest };
 }
 
-int8_t Sapphire::Entity::Player::getFreeQuestSlot()
+int8_t Player::getFreeQuestSlot()
 {
   int8_t result = -1;
   for( int8_t idx = 0; idx < 30; idx++ )
@@ -141,7 +143,7 @@ int8_t Sapphire::Entity::Player::getFreeQuestSlot()
   return result;
 }
 
-void Sapphire::Entity::Player::addQuestTracking( uint8_t idx )
+void Player::addQuestTracking( uint8_t idx )
 {
   for( int32_t ii = 0; ii < 5; ii++ )
   {
@@ -153,7 +155,7 @@ void Sapphire::Entity::Player::addQuestTracking( uint8_t idx )
   }
 }
 
-void Sapphire::Entity::Player::updateQuestsCompleted( uint32_t questId )
+void Player::updateQuestsCompleted( uint32_t questId )
 {
   uint8_t index = questId / 8;
   uint8_t bitIndex = ( questId ) % 8;
@@ -163,7 +165,7 @@ void Sapphire::Entity::Player::updateQuestsCompleted( uint32_t questId )
   m_questCompleteFlags[ index ] |= value;
 }
 
-bool Sapphire::Entity::Player::isQuestCompleted( uint32_t questId )
+bool Player::isQuestCompleted( uint32_t questId )
 {
   uint8_t index = questId / 8;
   uint8_t bitIndex = ( questId ) % 8;
@@ -173,7 +175,7 @@ bool Sapphire::Entity::Player::isQuestCompleted( uint32_t questId )
   return m_questCompleteFlags[ index ] & value;
 } 
 
-void Sapphire::Entity::Player::removeQuestsCompleted( uint32_t questId )
+void Player::removeQuestsCompleted( uint32_t questId )
 {
   uint8_t index = questId / 8;
   uint8_t bitIndex = ( questId ) % 8;
@@ -182,27 +184,27 @@ void Sapphire::Entity::Player::removeQuestsCompleted( uint32_t questId )
 
   m_questCompleteFlags[ index ] ^= value;
 
-  Common::Service< World::Manager::MapMgr >::ref().updateQuests( *this );
+  Common::Service< Manager::MapMgr >::ref().updateQuests( *this );
 }
 
-Sapphire::World::Quest& Sapphire::Entity::Player::getQuestByIndex( uint16_t index )
+World::Quest& Player::getQuestByIndex( uint16_t index )
 {
   return m_quests[ index ];
 }
 
-std::array< Sapphire::World::Quest, 30 >& Sapphire::Entity::Player::getQuestArrayRef()
+std::array< World::Quest, 30 >& Player::getQuestArrayRef()
 {
   return m_quests;
 }
 
-int16_t Sapphire::Entity::Player::getQuestTracking( uint8_t index ) const
+int16_t Player::getQuestTracking( uint8_t index ) const
 {
   if( index < 0 || index >= 5 )
     return -1;
   return m_questTracking[ index ];
 }
 
-Sapphire::Entity::Player::QuestComplete& Sapphire::Entity::Player::getQuestCompleteFlags()
+Player::QuestComplete& Player::getQuestCompleteFlags()
 {
   return m_questCompleteFlags;
 }
diff --git a/src/world/Actor/PlayerSql.cpp b/src/world/Actor/PlayerSql.cpp
index 58d3123ca..d51a83006 100644
--- a/src/world/Actor/PlayerSql.cpp
+++ b/src/world/Actor/PlayerSql.cpp
@@ -16,12 +16,14 @@
 
 #include "WorldServer.h"
 
+using namespace Sapphire;
+using namespace Sapphire::Entity;
 using namespace Sapphire::Common;
 using namespace Sapphire::Network::Packets;
 using namespace Sapphire::Network::Packets::WorldPackets::Server;
 using namespace Sapphire::World::Manager;
 
-bool Sapphire::Entity::Player::loadFromDb( uint64_t characterId )
+bool Player::loadFromDb( uint64_t characterId )
 {
   m_characterId = characterId;
 
@@ -181,7 +183,7 @@ bool Sapphire::Entity::Player::loadFromDb( uint64_t characterId )
   return true;
 }
 
-bool Sapphire::Entity::Player::loadActiveQuests()
+bool Player::loadActiveQuests()
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
   auto stmt = db.getPreparedStatement( Db::ZoneDbStatements::CHARA_SEL_QUEST );
@@ -194,7 +196,6 @@ bool Sapphire::Entity::Player::loadActiveQuests()
 
   while( res->next() )
   {
-
     auto slotId = res->getUInt8( 2 );
 
     auto quest = World::Quest( res->getUInt16( 3 ), res->getUInt8( 4 ), res->getUInt8( 5 ) );
@@ -205,14 +206,13 @@ bool Sapphire::Entity::Player::loadActiveQuests()
     quest.setUI8E( res->getUInt8( 10 ) );
     quest.setUI8F( res->getUInt8( 11 ) );
     m_quests[ slotId ] = quest;
-
   }
 
   return true;
 
 }
 
-bool Sapphire::Entity::Player::loadAchievements()
+bool Player::loadAchievements()
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
   auto stmt = db.getPreparedStatement( Db::ZoneDbStatements::CHARA_ACHIEV_SEL );
@@ -255,10 +255,10 @@ bool Sapphire::Entity::Player::loadAchievements()
   return true;
 }
 
-bool Sapphire::Entity::Player::loadClassData()
+bool Player::loadClassData()
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
-  // ClassIdx, Exp, Lvl
+  // ClassIdx, Exp, Lvl, BorrowAction
   auto stmt = db.getPreparedStatement( Db::ZoneDbStatements::CHARA_CLASS_SEL );
   stmt->setUInt64( 1, m_characterId );
   auto res = db.query( stmt );
@@ -268,15 +268,17 @@ bool Sapphire::Entity::Player::loadClassData()
     auto index = res->getUInt16( 1 );
     auto exp = res->getUInt( 2 );
     auto lvl = res->getUInt8( 3 );
+    auto borrowAction = res->getBlobVector( "BorrowAction" );
 
     m_classArray[ index ] = lvl;
     m_expArray[ index ] = exp;
+    memcpy( m_borrowActions[ index ].data(), borrowAction.data(), borrowAction.size() );
   }
 
   return true;
 }
 
-bool Sapphire::Entity::Player::loadSearchInfo()
+bool Player::loadSearchInfo()
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
   auto stmt = db.getPreparedStatement( Db::ZoneDbStatements::CHARA_SEL_SEARCHINFO );
@@ -301,7 +303,7 @@ bool Sapphire::Entity::Player::loadSearchInfo()
 }
 
 
-bool Sapphire::Entity::Player::loadHuntingLog()
+bool Player::loadHuntingLog()
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
   auto stmt = db.getPreparedStatement( Db::ZoneDbStatements::CHARA_MONSTERNOTE_SEL );
@@ -324,7 +326,7 @@ bool Sapphire::Entity::Player::loadHuntingLog()
   return true;
 }
 
-void Sapphire::Entity::Player::updateSql()
+void Player::updateSql()
 {
   ////// Update player data
   updateDbChara();
@@ -354,7 +356,7 @@ void Sapphire::Entity::Player::updateSql()
   syncLastDBWrite();
 }
 
-void Sapphire::Entity::Player::updateDbChara() const
+void Player::updateDbChara() const
 {
   auto& db = Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
   /*"Hp 1, Mp 2, Tp 3, Gp 4, Mode 5, Mount 6, InvincibleGM 7, Voice 8, "
@@ -482,22 +484,28 @@ void Sapphire::Entity::Player::updateDbChara() const
   db.execute( stmt );
 }
 
-void Sapphire::Entity::Player::updateDbClass() const
+void Player::updateDbClass() const
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
   auto& exdData = Common::Service< Data::ExdData >::ref();
   uint8_t classJobIndex = exdData.getRow< Excel::ClassJob >( static_cast<uint8_t>( getClass() ) )->data().WorkIndex;
+  auto& borrowAction = m_borrowActions[ classJobIndex ];
 
-  //Exp = ?, Lvl = ? WHERE CharacterId = ? AND ClassIdx = ?
+  //Exp = ?, Lvl = ?, BorrowAction = ? WHERE CharacterId = ? AND ClassIdx = ?
   auto stmtS = db.getPreparedStatement( Db::CHARA_CLASS_UP );
-  stmtS->setInt( 1, getExp() );
+  stmtS->setInt( 1, getCurrentExp() );
   stmtS->setInt( 2, getLevel() );
-  stmtS->setUInt64( 3, m_characterId );
-  stmtS->setInt( 4, classJobIndex );
+
+  std::vector< uint8_t > borrowActionVec( borrowAction.size() * 4 );
+  memcpy( borrowActionVec.data(), borrowAction.data(), borrowAction.size() * 4 );
+  stmtS->setBinary( 3, borrowActionVec );
+
+  stmtS->setUInt64( 4, m_characterId );
+  stmtS->setInt( 5, classJobIndex );
   db.execute( stmtS );
 }
 
-void Sapphire::Entity::Player::updateDbMonsterNote()
+void Player::updateDbMonsterNote()
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
   // Category_0-11
@@ -515,7 +523,7 @@ void Sapphire::Entity::Player::updateDbMonsterNote()
   db.execute( stmt );
 }
 
-void Sapphire::Entity::Player::updateDbFriendList()
+void Player::updateDbFriendList()
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
 
@@ -533,7 +541,7 @@ void Sapphire::Entity::Player::updateDbFriendList()
 }
 
 
-void Sapphire::Entity::Player::updateDbBlacklist()
+void Player::updateDbBlacklist()
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
 
@@ -547,7 +555,7 @@ void Sapphire::Entity::Player::updateDbBlacklist()
   db.execute( stmt );
 }
 
-void Sapphire::Entity::Player::updateDbAchievement()
+void Player::updateDbAchievement()
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
 
@@ -577,18 +585,22 @@ void Sapphire::Entity::Player::updateDbAchievement()
 }
 
 
-void Sapphire::Entity::Player::insertDbClass( const uint8_t classJobIndex, uint8_t level ) const
+void Player::insertDbClass( const uint8_t classJobIndex, uint8_t level ) const
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
   auto stmtClass = db.getPreparedStatement( Db::CHARA_CLASS_INS );
+  auto& borrowAction = m_borrowActions[ classJobIndex ];
+
   stmtClass->setUInt64( 1, m_characterId );
   stmtClass->setInt( 2, classJobIndex );
   stmtClass->setInt( 3, 0 );
   stmtClass->setInt( 4, level );
+  std::vector< uint8_t > borrowActionVec( borrowAction.size() );
+  stmtClass->setBinary( 5, borrowActionVec );
   db.directExecute( stmtClass );
 }
 
-void Sapphire::Entity::Player::updateDbSearchInfo() const
+void Player::updateDbSearchInfo() const
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
   auto stmtS = db.getPreparedStatement( Db::CHARA_SEARCHINFO_UP_SELECTCLASS );
@@ -607,7 +619,7 @@ void Sapphire::Entity::Player::updateDbSearchInfo() const
   db.execute( stmtS2 );
 }
 
-void Sapphire::Entity::Player::updateDbAllQuests() const
+void Player::updateDbAllQuests() const
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
   for( int32_t i = 0; i < 30; i++ )
@@ -633,7 +645,7 @@ void Sapphire::Entity::Player::updateDbAllQuests() const
   }
 }
 
-void Sapphire::Entity::Player::deleteDbQuest( uint16_t questId ) const
+void Player::deleteDbQuest( uint16_t questId ) const
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
   auto stmt = db.getPreparedStatement( Db::CHARA_QUEST_DEL );
@@ -642,7 +654,7 @@ void Sapphire::Entity::Player::deleteDbQuest( uint16_t questId ) const
   db.execute( stmt );
 }
 
-void Sapphire::Entity::Player::insertDbQuest( uint16_t questId, uint8_t index, uint8_t seq ) const
+void Player::insertDbQuest( uint16_t questId, uint8_t index, uint8_t seq ) const
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
   auto stmt = db.getPreparedStatement( Db::CHARA_QUEST_INS );
@@ -661,7 +673,7 @@ void Sapphire::Entity::Player::insertDbQuest( uint16_t questId, uint8_t index, u
   db.execute( stmt );
 }
 
-void Sapphire::Entity::Player::insertDbQuest( const World::Quest& quest, uint8_t index ) const
+void Player::insertDbQuest( const World::Quest& quest, uint8_t index ) const
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
   auto stmt = db.getPreparedStatement( Db::CHARA_QUEST_INS );
@@ -680,7 +692,7 @@ void Sapphire::Entity::Player::insertDbQuest( const World::Quest& quest, uint8_t
   db.execute( stmt );
 }
 
-Sapphire::ItemPtr Sapphire::Entity::Player::createItem( uint32_t catalogId, uint32_t quantity )
+ItemPtr Player::createItem( uint32_t catalogId, uint32_t quantity )
 {
   auto& exdData = Common::Service< Data::ExdData >::ref();
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
@@ -707,7 +719,7 @@ Sapphire::ItemPtr Sapphire::Entity::Player::createItem( uint32_t catalogId, uint
   return pItem;
 }
 
-bool Sapphire::Entity::Player::loadInventory()
+bool Player::loadInventory()
 {
   auto& itemMgr = Common::Service< World::Manager::ItemMgr >::ref();
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
@@ -806,7 +818,7 @@ bool Sapphire::Entity::Player::loadInventory()
   return true;
 }
 
-bool Sapphire::Entity::Player::loadFriendList()
+bool Player::loadFriendList()
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
   auto stmt = db.getPreparedStatement( Db::ZoneDbStatements::CHARA_FRIENDLIST_SEL );
@@ -831,7 +843,7 @@ bool Sapphire::Entity::Player::loadFriendList()
   return true;
 }
 
-bool Sapphire::Entity::Player::loadBlacklist()
+bool Player::loadBlacklist()
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
   auto stmt = db.getPreparedStatement( Db::ZoneDbStatements::CHARA_BLACKLIST_SEL );
@@ -853,7 +865,7 @@ bool Sapphire::Entity::Player::loadBlacklist()
 }
 
 
-bool Sapphire::Entity::Player::syncLastDBWrite()
+bool Player::syncLastDBWrite()
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
   auto res = db.query( "SELECT UNIX_TIMESTAMP(UPDATE_DATE) FROM charainfo WHERE characterid = " + std::to_string( m_characterId ) );
diff --git a/src/world/CMakeLists.txt b/src/world/CMakeLists.txt
index 76deabf93..29772e62d 100644
--- a/src/world/CMakeLists.txt
+++ b/src/world/CMakeLists.txt
@@ -7,6 +7,9 @@ file( GLOB SERVER_SOURCE_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
         *.cpp
         Actor/*.cpp
         Action/*.cpp
+        Action/Job/*.cpp
+        AI/*.cpp
+        AI/Fsm/*.cpp
         ContentFinder/*.cpp
         DebugCommand/*.cpp
         Encounter/*.cpp
diff --git a/src/world/ContentFinder/ContentFinder.cpp b/src/world/ContentFinder/ContentFinder.cpp
index b54990728..8d53c2ea5 100644
--- a/src/world/ContentFinder/ContentFinder.cpp
+++ b/src/world/ContentFinder/ContentFinder.cpp
@@ -18,13 +18,15 @@
 
 #include <WorldServer.h>
 
+using namespace Sapphire;
+using namespace Sapphire::World;
 using namespace Sapphire::Common;
 using namespace Sapphire::Network::Packets;
 using namespace Sapphire::Network::Packets::WorldPackets;
 using namespace Sapphire::Network::Packets::WorldPackets::Server;
 using namespace Sapphire::World::Manager;
 
-void Sapphire::World::ContentFinder::update()
+void World::ContentFinder::update()
 {
   auto& exdData = Service< Data::ExdData >::ref();
   auto& server = Service< WorldServer >::ref();
@@ -114,27 +116,26 @@ void Sapphire::World::ContentFinder::update()
 
 }
 
-void Sapphire::World::ContentFinder::registerContentsRequest( Sapphire::Entity::Player &player, const std::vector< uint32_t >& contentIds )
+void World::ContentFinder::registerContentsRequest( Entity::Player &player, const std::vector< uint32_t >& contentIds )
 {
   queueForContent( player, contentIds );
   completeRegistration( player );
 }
 
-void Sapphire::World::ContentFinder::registerContentRequest( Sapphire::Entity::Player &player, uint32_t contentId, uint8_t flags )
+void World::ContentFinder::registerContentRequest( Entity::Player &player, uint32_t contentId, uint8_t flags )
 {
   queueForContent( player, { contentId } );
   completeRegistration( player, flags );
 }
 
-void Sapphire::World::ContentFinder::registerRandomContentRequest( Sapphire::Entity::Player &player, uint32_t randomContentTypeId )
+void World::ContentFinder::registerRandomContentRequest( Entity::Player &player, uint32_t randomContentTypeId )
 {
   auto& exdData = Service< Data::ExdData >::ref();
-  auto contentListIds = exdData.getIdList< Excel::ContentFinderCondition >();
+  auto contentFinderList = exdData.getRows< Excel::ContentFinderCondition >();
   std::vector< uint32_t > idList;
 
-  for( auto id : contentListIds )
+  for( const auto& [ id, instanceContent ] : contentFinderList )
   {
-    auto instanceContent = exdData.getRow< Excel::ContentFinderCondition >( id );
     if( instanceContent->data().RandomContentType == randomContentTypeId )
     {
       if( instanceContent->data().LevelMin <= player.getLevel() )
@@ -146,9 +147,8 @@ void Sapphire::World::ContentFinder::registerRandomContentRequest( Sapphire::Ent
   completeRegistration( player );
 }
 
-void Sapphire::World::ContentFinder::completeRegistration( const Sapphire::Entity::Player &player, uint8_t flags )
+void World::ContentFinder::completeRegistration( const Entity::Player &player, uint8_t flags )
 {
-
   auto& server = Service< WorldServer >::ref();
   auto queuedContent = m_queuedContent[ m_queuedPlayer[ player.getId() ]->getActiveRegisterId() ];
 
@@ -182,7 +182,7 @@ void Sapphire::World::ContentFinder::completeRegistration( const Sapphire::Entit
   }
 }
 
-void Sapphire::World::ContentFinder::queueForContent( Sapphire::Entity::Player &player, const std::vector< uint32_t >& contentIds )
+void World::ContentFinder::queueForContent( Entity::Player &player, const std::vector< uint32_t >& contentIds )
 {
   for( auto contentId : contentIds )
   {
@@ -215,7 +215,7 @@ void Sapphire::World::ContentFinder::queueForContent( Sapphire::Entity::Player &
   }
 }
 
-void Sapphire::World::QueuedContent::queuePlayer( const std::shared_ptr< QueuedPlayer >& pQPlayer )
+void World::QueuedContent::queuePlayer( const std::shared_ptr< QueuedPlayer >& pQPlayer )
 {
   m_players.push_back( pQPlayer );
   m_partyMemberCount++;
@@ -241,7 +241,7 @@ void Sapphire::World::QueuedContent::queuePlayer( const std::shared_ptr< QueuedP
   }
 }
 
-bool Sapphire::World::QueuedContent::withdrawPlayer( const std::shared_ptr< QueuedPlayer >& pQPlayer )
+bool World::QueuedContent::withdrawPlayer( const std::shared_ptr< QueuedPlayer >& pQPlayer )
 {
   auto preSize = m_players.size();
   auto it = m_players.begin();
@@ -282,12 +282,12 @@ bool Sapphire::World::QueuedContent::withdrawPlayer( const std::shared_ptr< Queu
   return true;
 }
 
-uint32_t Sapphire::World::ContentFinder::getNextRegisterId()
+uint32_t World::ContentFinder::getNextRegisterId()
 {
   return ++m_nextRegisterId;
 }
 
-Sapphire::World::ContentFinder::QueuedContentPtrList Sapphire::World::ContentFinder::getMatchingContentList( Sapphire::Entity::Player &player, uint32_t contentFinderId )
+World::ContentFinder::QueuedContentPtrList World::ContentFinder::getMatchingContentList( Entity::Player &player, uint32_t contentFinderId )
 {
   QueuedContentPtrList outVec;
   for( auto& it : m_queuedContent )
@@ -361,7 +361,7 @@ Sapphire::World::ContentFinder::QueuedContentPtrList Sapphire::World::ContentFin
   return outVec;
 }
 
-void Sapphire::World::ContentFinder::accept( Entity::Player& player )
+void World::ContentFinder::accept( Entity::Player& player )
 {
   auto& server = Service< WorldServer >::ref();
   auto& exdData = Service< Data::ExdData >::ref();
@@ -408,7 +408,7 @@ void Sapphire::World::ContentFinder::accept( Entity::Player& player )
     queuedContent->setState( Accepted );
 }
 
-void Sapphire::World::ContentFinder::withdraw( Entity::Player& player )
+void World::ContentFinder::withdraw( Entity::Player& player )
 {
   auto& server = Service< WorldServer >::ref();
   auto& exdData = Service< Data::ExdData >::ref();
@@ -471,7 +471,7 @@ void Sapphire::World::ContentFinder::withdraw( Entity::Player& player )
 
 }
 
-std::shared_ptr< Sapphire::World::QueuedContent > Sapphire::World::ContentFinder::findContentByRegisterId( uint32_t registerId )
+std::shared_ptr< World::QueuedContent > World::ContentFinder::findContentByRegisterId( uint32_t registerId )
 {
   auto it = m_queuedContent.find( registerId );
   if( it != m_queuedContent.end() )
@@ -479,7 +479,7 @@ std::shared_ptr< Sapphire::World::QueuedContent > Sapphire::World::ContentFinder
   return nullptr;
 }
 
-bool Sapphire::World::ContentFinder::removeContentByRegisterId( uint32_t registerId )
+bool World::ContentFinder::removeContentByRegisterId( uint32_t registerId )
 {
   auto it = m_queuedContent.find( registerId );
   if( it == m_queuedContent.end() )
@@ -490,21 +490,21 @@ bool Sapphire::World::ContentFinder::removeContentByRegisterId( uint32_t registe
 
 //////////////////////////////////////////////////////////////////////
 
-uint32_t Sapphire::World::QueuedContent::getInstanceId() const
+uint32_t World::QueuedContent::getInstanceId() const
 {
   return m_contentFinderId;
 }
 
-uint32_t Sapphire::World::QueuedContent::getRegisterId() const
+uint32_t World::QueuedContent::getRegisterId() const
 {
   return m_registerId;
 }
 
-Sapphire::World::QueuedContent::QueuedContent( uint32_t registerId, uint32_t contentId ) :
-        m_registerId( registerId ),
-        m_contentFinderId( contentId ),
-        m_state( QueuedContentState::MatchingInProgress ),
-        m_contentPopTime( 0 )
+World::QueuedContent::QueuedContent( uint32_t registerId, uint32_t contentId ) :
+  m_registerId( registerId ),
+  m_contentFinderId( contentId ),
+  m_state( QueuedContentState::MatchingInProgress ),
+  m_contentPopTime( 0 )
 {
  // auto& exdData = Common::Service< Data::ExdData >::ref();
  // auto content = exdData.getRow< Excel::InstanceContent >( contentId );
@@ -512,7 +512,7 @@ Sapphire::World::QueuedContent::QueuedContent( uint32_t registerId, uint32_t con
 
 }
 
-uint8_t Sapphire::World::QueuedContent::getRoleCount( Sapphire::Common::Role role ) const
+uint8_t World::QueuedContent::getRoleCount( Common::Role role ) const
 {
   switch( role )
   {
@@ -533,12 +533,12 @@ uint8_t Sapphire::World::QueuedContent::getRoleCount( Sapphire::Common::Role rol
   return 0;
 }
 
-Sapphire::World::QueuedContentState Sapphire::World::QueuedContent::getState() const
+World::QueuedContentState World::QueuedContent::getState() const
 {
   return m_state;
 }
 
-void Sapphire::World::QueuedContent::setState( Sapphire::World::QueuedContentState state )
+void World::QueuedContent::setState( World::QueuedContentState state )
 {
   m_state = state;
 }
@@ -546,7 +546,7 @@ void Sapphire::World::QueuedContent::setState( Sapphire::World::QueuedContentSta
 //////////////////////////////////////////////////////////////////////
 
 
-Sapphire::World::QueuedPlayer::QueuedPlayer( const Entity::Player &player, uint8_t registerId  )
+World::QueuedPlayer::QueuedPlayer( const Entity::Player &player, uint8_t registerId  )
 {
   m_characterId = player.getCharacterId();
   m_classJob = static_cast< uint32_t >( player.getClass() );
@@ -556,27 +556,27 @@ Sapphire::World::QueuedPlayer::QueuedPlayer( const Entity::Player &player, uint8
   m_entityId = player.getId();
 }
 
-Sapphire::Common::Role Sapphire::World::QueuedPlayer::getRole() const
+Common::Role World::QueuedPlayer::getRole() const
 {
   return m_role;
 }
 
-void Sapphire::World::QueuedPlayer::setActiveRegisterId( uint8_t registerId )
+void World::QueuedPlayer::setActiveRegisterId( uint8_t registerId )
 {
   m_activeRegisterId = registerId;
 }
 
-uint8_t Sapphire::World::QueuedPlayer::getActiveRegisterId() const
+uint8_t World::QueuedPlayer::getActiveRegisterId() const
 {
   return m_activeRegisterId;
 }
 
-uint64_t Sapphire::World::QueuedPlayer::getCharacterId() const
+uint64_t World::QueuedPlayer::getCharacterId() const
 {
   return m_characterId;
 }
 
-uint32_t Sapphire::World::QueuedPlayer::getEntityId() const
+uint32_t World::QueuedPlayer::getEntityId() const
 {
   return m_entityId;
 }
diff --git a/src/world/Encounter/EncounterFight.h b/src/world/Encounter/EncounterFight.h
index d8bd421c9..f3fe9c395 100644
--- a/src/world/Encounter/EncounterFight.h
+++ b/src/world/Encounter/EncounterFight.h
@@ -7,6 +7,8 @@
 
 namespace Sapphire
 {
+  using EncounterCallback = std::function< void( EncounterFightPtr, EncounterState ) >;
+
   class EncounterState
   {
   public:
@@ -19,6 +21,11 @@ namespace Sapphire
     StateStackPtr m_stateStack;
     std::shared_ptr< EncounterFight > m_pEncounter;
     uint64_t m_startTime{ 0 };
+    uint64_t m_currTime{ 0 };
+
+    EncounterCallback m_onInitCb;
+    EncounterCallback m_onUpdateCb;
+    EncounterCallback m_onFinishCb;
 
   public:
     EncounterState( std::shared_ptr< EncounterFight > pEncounter ) :
@@ -26,13 +33,51 @@ namespace Sapphire
     {
     };
 
-    virtual ~EncounterState() = default;
-    bool shouldFinish() { return m_bShouldFinish; };
+    bool shouldFinish() const { return m_bShouldFinish; };
 
-    virtual void init() = 0;
-    virtual void update( uint64_t deltaTime ) = 0;
+    void setFinishFlag() { m_bShouldFinish = true; };
+
+    uint64_t getStartTime() const { return m_startTime; };
+    uint64_t getCurrTime() const { return m_currTime; };
+    uint64_t getElapsedTime() const { return m_currTime - m_startTime; };
+
+    void init()
+    {
+      if( m_onInitCb )
+        m_onInitCb( m_pEncounter, *this );
+    }
+
+    void update( uint64_t currTime )
+    {
+      if( m_startTime == 0 )
+        m_startTime = currTime;
 
-    virtual void finish() = 0;
+      m_currTime = currTime;
+
+      if( m_onUpdateCb )
+        m_onUpdateCb( m_pEncounter, *this );
+    }
+
+    void finish()
+    {
+      if( m_onFinishCb )
+        m_onFinishCb( m_pEncounter, *this );
+    }
+
+    void setOnInitCallback( EncounterCallback cb )
+    {
+      m_onInitCb = cb;
+    }
+
+    void setOnUpdateCallback( EncounterCallback cb )
+    {
+      m_onUpdateCb = cb;
+    }
+
+    void setOnFinishCallback( EncounterCallback cb )
+    {
+      m_onFinishCb = cb;
+    }
   };
 
   enum class EncounterFightStatus
@@ -50,19 +95,49 @@ namespace Sapphire
       m_pInstance( pInstance )
     {
     };
+
     virtual ~EncounterFight() = default;
 
     virtual void init() = 0;
     virtual void start() = 0;
-    virtual void update( uint64_t deltaTime ) = 0;
+    virtual void update( uint64_t currTime ) = 0;
     virtual void reset() = 0;
 
-    virtual void addState( EncounterState::EncounterStatePtr pState, bool initState = true ) = 0;
-    virtual void addBNpc( Entity::BNpcPtr pBNpc ) = 0;
-    virtual void removeBNpc( uint32_t layoutId ) = 0;
-    virtual Entity::BNpcPtr getBNpc( uint32_t layoutId ) = 0;
+    void addState( EncounterState::EncounterStatePtr pState, bool initState = true )
+    {
+      m_stateStack->push( pState );
+      if( initState )
+        pState->init();
+    }
+
+    EncounterFightStatus getEncounterFightStatus() const
+    {
+      return m_status;
+    }
+
+    void addBNpc( Entity::BNpcPtr pBNpc )
+    {
+      m_bnpcs[ pBNpc->getLayoutId() ] = pBNpc;
+    }
+
+    Entity::BNpcPtr getBNpc( uint32_t layoutId ) const
+    {
+      auto bnpc = m_bnpcs.find( layoutId );
+      if( bnpc != std::end( m_bnpcs ) )
+        return bnpc->second;
+
+      return nullptr;
+    }
 
-    virtual EncounterFightStatus getEncounterFightStatus() const = 0;
+    void removeBNpc( uint32_t layoutId )
+    {
+      m_bnpcs.erase( layoutId );
+    }
+
+    InstanceContentPtr getInstance()
+    {
+      return m_pInstance;
+    }
 
   protected:
     uint64_t m_startTime{ 0 };
diff --git a/src/world/Encounter/EncounterTimeline.cpp b/src/world/Encounter/EncounterTimeline.cpp
new file mode 100644
index 000000000..2399c8fd5
--- /dev/null
+++ b/src/world/Encounter/EncounterTimeline.cpp
@@ -0,0 +1,416 @@
+#include "EncounterTimeline.h"
+
+#include "Timepoint.h"
+#include "TimelineActorState.h"
+#include "TimelineActor.h"
+#include "PhaseCondition.h"
+#include "Selector.h"
+
+#include <Action/Action.h>
+
+#include <Actor/BNpc.h>
+#include <Actor/Chara.h>
+#include <Actor/EventObject.h>
+#include <Actor/Player.h>
+
+#include <Event/Director.h>
+
+#include <Manager/ActionMgr.h>
+#include <Manager/PlayerMgr.h>
+#include <Service.h>
+
+#include <Territory/QuestBattle.h>
+#include <Territory/InstanceContent.h>
+#include <Util/UtilMath.h>
+#include <Util/Util.h>
+
+#include <filesystem>
+
+namespace Sapphire::Encounter
+{
+
+  /*
+  class RngCondition : TimepointCondition
+  {
+    EncounterTimepointcondition m_type;
+    std::vector< uint32_t > m_params
+    
+    RngCondition( EncounterTimepointcondition condition std::vector< uint32_t params ) : m_type( condition ), m_params( params ){}
+    bool isConditionMet( uint32_t shit )
+    {
+      switch( m_type )
+      {
+        case EncounterTimepointcondition::RngMinMax:
+          return RNGMgr::generate( params[0], params[1] ) == params[2];
+      }
+      return false;
+    }
+  }
+  enum class ActionCallbackType : uint32_t
+  {
+    OnActionInit,
+    OnActionStart,
+    OnActionInterrupt,
+    OnActionExecute
+  };
+
+  using CallbackFunc = std::function< void < CharaPtr, Action > >;
+
+  std::unordered_map< ActionCallbackType, CallbackFunc > m_actionCallbacks;
+  void Chara::registerActionCallback( ActionCallbackType type, CallbackFunc callback )
+  {
+    m_actionCallbacks[ type ].push_back( callback );
+  }
+
+  // call this when changing EncounterPack
+  void Chara::clearActionCallbacks()
+  {
+    for( auto& callback : m_actionCallbacks )
+      callback.second.clear()
+  }
+
+  void Chara::onActionInterrupt()
+  {
+    auto action = getCurrentAction();
+    for( auto& callback : m_actionCallbacks[ ActionCallbackType::OnActionInterrupt ] )
+      callback( this, action );
+  }
+
+  void EncounterTimeline::Timepoint::execute( TerritoryPtr pTeri, uint64_t time )
+  {
+    switch( m_type )
+    {
+      case TimepointDataType::CastAction:
+      {
+        auto pActionData = std::dynamic_pointer_cast< TimepointDataAction, TimepointData >( getData() );
+
+        // todo: filter the correct target
+        // todo: tie to mechanic script?
+      }
+    }
+  }
+  */
+
+  //
+  // parsing stuff below
+  //
+
+  TimelinePack EncounterTimeline::getEncounterPack( const std::string& name, bool reload )
+  {
+    static std::unordered_map< std::string, TimelinePack > cache = {};
+    const static std::unordered_map< std::string, ConditionType > conditionMap =
+    {
+      { "hpPctLessThan",            ConditionType::HpPctLessThan },
+      { "hpPctBetween",             ConditionType::HpPctBetween },
+
+      { "directorVarEquals",        ConditionType::DirectorVarEquals },
+      { "directorVarGreaterThan",   ConditionType::DirectorVarGreaterThan },
+
+      { "directorSeqEquals",        ConditionType::DirectorSeqEquals },
+      { "directorSeqGreaterThan",   ConditionType::DirectorSeqGreaterThan },
+
+      { "directorFlagsEquals",      ConditionType::DirectorFlagsEquals },
+      { "directorFlagsGreaterThan", ConditionType::DirectorFlagsGreaterThan },
+
+      { "encounterTimeElapsed",     ConditionType::EncounterTimeElapsed },
+
+      { "combatState",              ConditionType::CombatState },
+      { "bnpcHasFlags",             ConditionType::BNpcHasFlags },
+
+      { "getAction",                ConditionType::GetAction },
+      { "phaseActive",              ConditionType::PhaseActive }
+    };
+
+    TimelinePack pack;
+    if( cache.find( name ) != cache.end() && !reload )
+      return cache.at( name );
+
+    std::string encounter_name( fmt::format( std::string( "data/EncounterTimelines/{}.json" ), name ) );
+
+    std::fstream f( encounter_name );
+
+    if( !f.is_open() )
+      return pack;
+
+    auto json = nlohmann::json::parse( f );
+
+    std::unordered_map< std::string, TimelineActor > actorNameMap;
+    std::unordered_map< std::string, std::map< std::string, Phase > > actorNamePhaseMap;
+
+    for( const auto& selectorJ : json.at( "selectors" ).items() )
+    {
+      auto& selectorV = selectorJ.value();
+      auto name = selectorV.at( "name" ).get< std::string >();
+      Selector selector;
+      selector.from_json( selectorV );
+
+      pack.addSelector( name, selector );
+    }
+
+    // first run through cache actor info
+    for( const auto& actorJ : json.at( "actors" ).items() )
+    {
+      TimelineActor actor;
+      auto& actorV = actorJ.value();
+      actor.m_hp = actorV.at( "hp" ).get< uint32_t >();
+      actor.m_layoutId = actorV.at( "layoutId" ).get< uint32_t >();
+      actor.m_name = actorV.at( "name" ).get< std::string >();
+
+      auto& subActorsJ = actorV.at( "subactors" );
+
+      if( !subActorsJ.is_null() )
+        for( const auto& subActorV : subActorsJ.items() )
+          actor.addPlaceholderSubactor( subActorV.value().get< std::string >() );
+       
+      actorNameMap.emplace( std::make_pair( actor.m_name, actor ) );
+    }
+
+    // build timeline info per actor
+    for( const auto& actorJ : json.at( "actors" ).items() )
+    {
+      // < actorName, < phasename, phase > >
+      std::map< std::string, Phase > phaseNameMap;
+
+      auto actorV = actorJ.value();
+      std::string actorName = actorV.at( "name" );
+
+      TimelineActor& actor = actorNameMap[ actorName ];
+      // todo: are phases linked by actor, or global in the json
+      for( const auto& phaseJ : actorV.at( "phases" ).items() )
+      {
+        auto& phaseV = phaseJ.value();
+        const auto id = phaseV.at( "id" ).get< uint32_t >();
+        const auto& phaseName = phaseV.at( "name" ).get< std::string >();
+        const auto& timepointsJ = phaseV.at( "timepoints" );
+        const auto& description = phaseV.at( "description" ).get< std::string >();
+
+        Phase phase;
+        phase.m_name = phaseName;
+        phase.m_description = description;
+        for( const auto& timepointJ : timepointsJ.items() )
+        {
+          auto timepointV = timepointJ.value();
+          Timepoint timepoint;
+          timepoint.from_json( timepointV, actorNameMap, actor.m_layoutId );
+
+          phase.m_timepoints.push_back( timepoint );
+        }
+
+        if( phaseNameMap.find( phaseName ) != phaseNameMap.end() )
+          throw std::runtime_error( fmt::format( std::string( "EncounterTimeline::getEncounterPack - duplicate phase by name: {}" ), phaseName ) );
+
+        phaseNameMap.emplace( std::make_pair( phaseName, phase ) );
+      }
+      actorNamePhaseMap[ actorName ] = phaseNameMap;
+    }
+
+    // build the condition list
+    for( const auto& pcJ : json.at( "conditions" ).items() )
+    {
+      auto& pcV = pcJ.value();
+      auto conditionName = pcV.at( "condition" ).get< std::string >();
+      auto phaseRef = pcV.at( "targetPhase" ).get< std::string >();
+      auto actorRef = pcV.at( "targetActor" ).get< std::string >();
+      
+      ConditionType condition;
+
+      // make sure condition exists
+      if( auto it = conditionMap.find( conditionName ); it != conditionMap.end() )
+        condition = it->second;
+      else
+        throw std::runtime_error( fmt::format( std::string( "EncounterTimeline::getEncounterPack - no condition id found by name: {}" ), conditionName ) );
+
+      // make sure the actor we're referencing exists
+      if( auto actorIt = actorNameMap.find( actorRef ); actorIt != actorNameMap.end() )
+      {
+        auto& phaseNameMap = actorNamePhaseMap[ actorRef ];
+
+        TimelineActor& actor = actorIt->second;
+
+        // make sure phase we're referencing exists
+        if( auto phaseIt = phaseNameMap.find( phaseRef ); phaseIt != phaseNameMap.end() )
+        {
+          Phase& phase = phaseIt->second;
+
+          // build the condition
+          PhaseConditionPtr pCondition = nullptr;
+          switch( condition )
+          {
+            case ConditionType::HpPctLessThan:
+            case ConditionType::HpPctBetween:
+            {
+              pCondition = std::make_shared< ConditionHp >();
+              pCondition->from_json( pcV, phase, condition, actorNameMap );
+            }
+            break;
+            case ConditionType::DirectorVarEquals:
+            case ConditionType::DirectorVarGreaterThan:
+            case ConditionType::DirectorFlagsEquals:
+            case ConditionType::DirectorFlagsGreaterThan:
+            case ConditionType::DirectorSeqEquals:
+            case ConditionType::DirectorSeqGreaterThan:
+            {
+              pCondition = std::make_shared< ConditionDirectorVar >();
+              pCondition->from_json( pcV, phase, condition, actorNameMap );
+            }
+            break;
+            case ConditionType::EncounterTimeElapsed:
+            {
+              pCondition = std::make_shared< ConditionEncounterTimeElapsed >();
+              pCondition->from_json( pcV, phase, condition, actorNameMap );
+            }
+            break;
+            case ConditionType::CombatState:
+            {
+              pCondition = std::make_shared< ConditionCombatState >();
+              pCondition->from_json( pcV, phase, condition, actorNameMap );
+            }
+            break;
+            case ConditionType::GetAction:
+            {
+              pCondition = std::make_shared< ConditionGetAction >();
+              pCondition->from_json( pcV, phase, condition, actorNameMap );
+            }
+            break;
+            case ConditionType::PhaseActive:
+            {
+              pCondition = std::make_shared< ConditionPhaseActive >();
+              pCondition->from_json( pcV, phase, condition, actorNameMap );
+            }
+            break;
+            default:
+              break;
+          }
+          actor.addPhaseCondition( pCondition );
+        }
+      }
+      else
+      {
+        throw std::runtime_error( fmt::format( std::string( "EncounterTimeline::getEncounterPack - no state found by name: {}" ), phaseRef ) );
+      }
+    }
+
+    for( const auto& actor : actorNameMap )
+      pack.addTimelineActor( actor.second );
+
+    pack.setName( name );
+
+    // todo: reload will probably kill the server when CastAction.callbacks are added
+    if( reload )
+      cache[ name ] = pack;
+    else
+      cache.emplace( std::make_pair( name, pack ) );
+    return pack;
+  }
+
+  void TimelinePack::setName( const std::string& name )
+  {
+    m_name = name;
+  }
+
+  void TimelinePack::addSelector( const std::string& name, const Selector& selector )
+  {
+    m_selectors.emplace( std::make_pair( name, selector ) );
+  }
+
+  void TimelinePack::createSnapshot( const std::string& selectorName, Entity::CharaPtr pSrc, const std::vector< uint32_t >& exclude )
+  {
+    if( auto it = m_selectors.find( selectorName ); it != m_selectors.end() )
+      it->second.createSnapshot( pSrc, exclude );
+  }
+
+  const World::AI::Snapshot::Results& TimelinePack::getSnapshotResults( const std::string& selectorName )
+  {
+    static World::AI::Snapshot::Results empty;
+    if( auto it = m_selectors.find( selectorName ); it != m_selectors.end() )
+      return it->second.getResults();
+    return empty;
+  }
+
+  const World::AI::Snapshot::TargetIds& TimelinePack::getSnapshotTargetIds( const std::string& selectorName )
+  {
+    static World::AI::Snapshot::TargetIds empty;
+    if( auto it = m_selectors.find( selectorName ); it != m_selectors.end() )
+      return it->second.getTargetIds();
+    return empty;
+  }
+
+  void TimelinePack::addTimelineActor( const TimelineActor& actor )
+  {
+    m_actors.emplace_back( actor );
+  }
+
+  Entity::BNpcPtr TimelinePack::getBNpcByRef( const std::string& name, TerritoryPtr pTeri )
+  {
+    for( const auto& actor : m_actors )
+    {
+      auto pBNpc = actor.getBNpcByRef( name, pTeri );
+      if( pBNpc )
+        return pBNpc;
+    }
+    return nullptr;
+  }
+
+  void TimelinePack::reset( TerritoryPtr pTeri )
+  {
+    for( auto& actor : m_actors )
+    {
+      actor.resetAllSubActors( pTeri );
+      actor.resetAllConditionStates();
+    }
+  }
+
+  void TimelinePack::setStartTime( uint64_t time )
+  {
+    m_startTime = time;
+  }
+
+  uint64_t TimelinePack::getStartTime() const
+  {
+    return m_startTime;
+  }
+
+  void TimelinePack::update( TerritoryPtr pTeri, uint64_t time )
+  {
+    auto now = Common::Util::getTimeMs(); 
+    for( auto& actor : m_actors )
+      actor.update( pTeri, *this, now );
+  }
+
+  void TimelinePack::spawnSubActors( TerritoryPtr pTeri )
+  {
+    for( auto& actor : m_actors )
+      actor.spawnAllSubActors( pTeri );
+  }
+
+  bool TimelinePack::isPhaseActive( const std::string& actorName, const std::string& phaseName )
+  {
+    for( const auto& actor : m_actors )
+      if( actor.getName() == actorName )
+        return actor.isPhaseActive( phaseName );
+    return false;
+  }
+
+  void TimelinePack::resetConditionState( uint32_t id, bool toDefault )
+  {
+    for( auto& actor : m_actors )
+    {
+      if( actor.resetConditionState( id, toDefault ) )
+        return;
+    }
+  }
+
+  void TimelinePack::setConditionStateEnabled( uint32_t id, bool enabled )
+  {
+    for( auto& actor : m_actors )
+    {
+      if( actor.setConditionStateEnabled( id, enabled ) )
+        return;
+    }
+  }
+
+  bool TimelinePack::valid()
+  {
+    return !m_actors.empty();
+  }
+}// namespace Sapphire::Encounter
\ No newline at end of file
diff --git a/src/world/Encounter/EncounterTimeline.h b/src/world/Encounter/EncounterTimeline.h
new file mode 100644
index 000000000..3ef8e0320
--- /dev/null
+++ b/src/world/Encounter/EncounterTimeline.h
@@ -0,0 +1,100 @@
+#pragma once
+
+#include <fstream>
+#include <memory>
+
+#include <optional>
+#include <stack>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include <nlohmann/json.hpp>
+
+#include <AI/TargetHelper.h>
+#include <Common.h>
+#include <Forwards.h>
+
+#include "TimelineActor.h"
+
+#include "Selector.h"
+#include "Forwards.h"
+
+namespace Sapphire::Encounter
+{
+  enum class TimelinePackType : uint32_t
+  {
+    Solo,
+    EncounterFight
+  };
+
+  // todo: actually handle solo stuff properly (or tie to zone director/content director at least)
+  class TimelinePack
+  {
+    TimelinePackType m_type{ TimelinePackType::EncounterFight };
+    std::vector< TimelineActor > m_actors;
+    std::string m_name;
+
+    std::unordered_map< std::string, Selector > m_selectors;
+    
+    uint64_t m_startTime{ 0 };
+
+  public:
+    TimelinePack() {}
+    TimelinePack( const TimelinePack& rhs ) :
+      m_type( rhs.m_type ),
+      m_name( rhs.m_name ),
+      m_actors( rhs.m_actors ),
+      m_selectors( rhs.m_selectors ),
+      m_startTime( 0 )
+    {
+      for( auto& selector : m_selectors )
+        selector.second.clearResults();
+    }
+
+    TimelinePack( TimelinePackType type ) : m_type( type ) {}
+
+    void setName( const std::string& name );
+
+    void addSelector( const std::string& name, const Selector& selector );
+
+    void createSnapshot( const std::string& selectorName, Entity::CharaPtr pSrc,
+                         const std::vector< uint32_t >& exclude );
+
+    const World::AI::Snapshot::Results& getSnapshotResults( const std::string& selectorName );
+
+    const World::AI::Snapshot::TargetIds& getSnapshotTargetIds( const std::string& selectorName );
+
+    void addTimelineActor( const TimelineActor& actor );
+
+    // get bnpc by internal timeline name
+    Entity::BNpcPtr getBNpcByRef( const std::string& name, TerritoryPtr pTeri );
+
+    void reset( TerritoryPtr pTeri );
+
+    void setStartTime( uint64_t time );
+
+    uint64_t getStartTime() const;
+
+    void update( TerritoryPtr pTeri, uint64_t time );
+
+    // todo: probably just make this a Timepoint in an InitPhase
+    void spawnSubActors( TerritoryPtr pTeri );
+
+    bool isPhaseActive( const std::string& actorRef, const std::string& phaseName );
+
+    void resetConditionState( uint32_t id, bool toDefault = false );
+
+    void setConditionStateEnabled( uint32_t id, bool enabled );
+
+    bool valid();
+  };
+
+  class EncounterTimeline
+  {
+  public:
+
+    static TimelinePack getEncounterPack( const std::string& name, bool reload = false );
+  };
+}// namespace Sapphire
\ No newline at end of file
diff --git a/src/world/Encounter/Forwards.h b/src/world/Encounter/Forwards.h
new file mode 100644
index 000000000..6b4312709
--- /dev/null
+++ b/src/world/Encounter/Forwards.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <memory>
+
+namespace Sapphire::Encounter
+{
+  class Selector;
+  class TimelineActor;
+  class Phase;
+  class PhaseCondition;
+  class Timepoint;
+
+  class TimelinePack;
+
+  using PhaseConditionPtr = std::shared_ptr< PhaseCondition >;
+}
\ No newline at end of file
diff --git a/src/world/Encounter/InstanceContent/IfritNormal.h b/src/world/Encounter/InstanceContent/IfritNormal.h
index 8b2760bef..7c45b535f 100644
--- a/src/world/Encounter/InstanceContent/IfritNormal.h
+++ b/src/world/Encounter/InstanceContent/IfritNormal.h
@@ -1,138 +1,117 @@
 #include <Encounter/EncounterFight.h>
 
+#include <Encounter/EncounterTimeline.h>
+
 namespace Sapphire
 {
-  class IfritNormalData
+  class IfritEncounterFight : public EncounterFight
   {
-  public:
-    static constexpr int IFRIT = 4126276;
-    static constexpr int HELLFIRE = 0;
-  };
+  private:
+    static constexpr int NPC_IFRIT = 4126276;
+    static constexpr int VAL_IFRIT_HP = 13884;
+    static constexpr int ACT_HELLFIRE = 0;
 
-  class IfritStateTwo : public EncounterState
-  {
   public:
-    IfritStateTwo( EncounterFightPtr pEncounter ) : EncounterState( pEncounter )
+    IfritEncounterFight( InstanceContentPtr pInstance ) : EncounterFight( pInstance )
     {
-    }
+      pInstance->setEncounterTimeline( "IfritNormal" );
+    };
 
     void init() override
     {
-      Logger::info( "stage 2 init" );
-    }
-
-    void update( uint64_t deltaTime ) override
-    {
-      if( m_startTime == 0 )
-        m_startTime = deltaTime;
-
-      auto timeElapsedMs = deltaTime - m_startTime;
-
-      auto pIfrit = m_pEncounter->getBNpc( IfritNormalData::IFRIT );
+      m_status = EncounterFightStatus::IDLE;
+      m_startTime = 0;
 
-      pIfrit->setRot( pIfrit->getRot() - .2f );
-      pIfrit->sendPositionUpdate();
+      m_stateStack = std::make_shared< EncounterState::StateStack >();
 
-      if( timeElapsedMs > 5000 )
-      {
-        m_bShouldFinish = true;
-      }
+      // todo: i don't like this
+      auto boss = m_pInstance->createBNpcFromLayoutId( NPC_IFRIT, VAL_IFRIT_HP, Common::BNpcType::Enemy );
+      boss->init();
+      addBNpc( boss );
     }
 
-    void finish() override
+    void start() override
     {
-      Logger::info( "stage 2 done, going back to stage 1" );
-    }
-  };
+      auto ifritInitState = makeIfritPhaseOneState();
 
+      addState( ifritInitState );
 
-  class IfritStateOne : public EncounterState
-  {
-  public:
-    IfritStateOne( EncounterFightPtr pEncounter ) : EncounterState( pEncounter )
-    {
-    }
-
-    void init() override
-    {
-      Logger::info( "stage 1 init" );
+      m_status = EncounterFightStatus::ACTIVE;
     }
 
-    void update( uint64_t deltaTime ) override
+    void reset() override
     {
-      if( m_startTime == 0 )
-        m_startTime = deltaTime;
-
-      auto timeElapsedMs = deltaTime - m_startTime;
-
-      auto pIfrit = m_pEncounter->getBNpc( IfritNormalData::IFRIT );
-
-      pIfrit->setRot( pIfrit->getRot() + .2f );
-      pIfrit->sendPositionUpdate();
-
-      if( timeElapsedMs > 5000 )
+      if( auto boss = m_pInstance->getActiveBNpcByLayoutId( NPC_IFRIT ); boss )
       {
-        auto ifritTwoState = std::make_shared< IfritStateTwo >( m_pEncounter );
-        m_pEncounter->addState( ifritTwoState );
+        removeBNpc( NPC_IFRIT );
+        m_pInstance->removeActor( boss );
       }
+      m_pInstance->getEncounterTimeline().reset( getInstance() );
 
-      if( timeElapsedMs > 12000 )
-      {
-        pIfrit->hateListGetHighest()->die();
-      }
+      init();
     }
 
-    void finish() override
+    EncounterStatePtr makeIfritPhaseOneState()
     {
+      auto ifritInitState = std::make_shared< EncounterState >( shared_from_this() );
+      ifritInitState->setOnUpdateCallback( [ & ]( EncounterFightPtr pEncounter, EncounterState state ) {
+        auto timeElapsedMs = state.getElapsedTime();
 
-    }
-  };
+        auto pIfrit = pEncounter->getBNpc( NPC_IFRIT );
 
-  class IfritEncounterFight : public EncounterFight
-  {
-  public:
-    IfritEncounterFight( InstanceContentPtr pInstance ) : EncounterFight( pInstance )
-    {
+        pIfrit->setRot( pIfrit->getRot() + .2f );
 
-    };
+        // todo: use gambits+timelines for this
+        if( timeElapsedMs > 10000 )
+        {
+          state.setFinishFlag();
+          return;
+        }
 
-    void init() override
-    {
-      m_status = EncounterFightStatus::IDLE;
-      m_startTime = 0;
+        // todo: use gambits+timelines for this
+        if( timeElapsedMs > 5000 )
+        {
+          auto ifritTwoState = makeIfritPhaseTwoState();
+          pEncounter->addState( ifritTwoState );
+        }
+      } );
 
-      m_stateStack = std::make_shared< EncounterState::StateStack >();
+      ifritInitState->setOnFinishCallback( [ & ]( EncounterFightPtr pEncounter, EncounterState state ) {
+        Logger::info( "stage 1 finish - enrage" );
 
-      // todo: i don't like this
-      auto boss = m_pInstance->createBNpcFromLayoutId( IfritNormalData::IFRIT, 13884, Common::BNpcType::Enemy );
-      addBNpc( boss );
+        auto pIfrit = pEncounter->getBNpc( NPC_IFRIT );
+        pIfrit->hateListGetHighest()->die();
+      } );
 
-      //instance.sendForward();
-      /*
-      auto ifritStateTwo = std::make_shared< IfritStateTwo >( m_stateStack );
-      m_stateStack->push( ifritStateTwo );*/
+      return ifritInitState;
     }
 
-    void addState( EncounterState::EncounterStatePtr pState, bool initState = true ) override
+    EncounterStatePtr makeIfritPhaseTwoState()
     {
-      m_stateStack->push( pState );
-      if( initState )
-        pState->init();
-    }
+      auto ifritTwoState = std::make_shared< EncounterState >( shared_from_this() );
+      ifritTwoState->setOnUpdateCallback( [ & ]( EncounterFightPtr pEncounter, EncounterState state ) {
+        auto timeElapsedMs = state.getElapsedTime();
 
-    void start() override
-    {
-      auto ifritInitState = std::make_shared< IfritStateOne >( shared_from_this() );
-      addState( ifritInitState );
+        auto pIfrit = pEncounter->getBNpc( NPC_IFRIT );
 
-      m_status = EncounterFightStatus::ACTIVE;
+        pIfrit->setRot( pIfrit->getRot() - .2f );
+
+        // todo: use gambits+timelines for this
+        if( timeElapsedMs > 5000 )
+        {
+          state.setFinishFlag();
+        }
+      } );
+
+      return ifritTwoState;
     }
 
     void update( uint64_t deltaTime ) override
     {
       // todo: better way to start fights here..
+      // this probably doesn't need to be overriden either
 
-      auto ifrit = getBNpc( IfritNormalData::IFRIT );
+      auto ifrit = getBNpc( NPC_IFRIT );
 
       if( ifrit; ifrit->hateListGetHighestValue() != 0 && m_status == EncounterFightStatus::IDLE )
       {
@@ -140,11 +119,14 @@ namespace Sapphire
         start();
       }
 
-      if( m_status == EncounterFightStatus::ACTIVE && ifrit && !ifrit->hateListGetHighest()->isAlive() )
+      if( m_status == EncounterFightStatus::ACTIVE && ifrit && ( !ifrit->hateListGetHighest() || !ifrit->hateListGetHighest()->isAlive() ) )
       {
         m_status = EncounterFightStatus::FAIL;
       }
 
+      m_pInstance->getEncounterTimeline().update( getInstance(), deltaTime );
+
+      //*
       if( m_stateStack; !m_stateStack->empty() )
       {
         if( m_stateStack->top()->shouldFinish() )
@@ -152,47 +134,11 @@ namespace Sapphire
           m_stateStack->top()->finish();
           m_stateStack->pop();
         }
-          
-        m_stateStack->top()->update( deltaTime );
-      }
-    }
 
-    void reset() override
-    {
-      auto boss = m_pInstance->getActiveBNpcByLayoutId( IfritNormalData::IFRIT );
-      if( boss )
-      {
-        removeBNpc( IfritNormalData::IFRIT );
-        m_pInstance->removeActor( boss );
-        
+        if( !m_stateStack->empty() )
+          m_stateStack->top()->update( deltaTime );
       }
-      
-
-      init();
-    }
-
-    EncounterFightStatus getEncounterFightStatus() const override
-    {
-      return m_status;
-    }
-
-    void addBNpc( Entity::BNpcPtr pBNpc ) override
-    {
-      m_bnpcs[ pBNpc->getLayoutId() ] = pBNpc;
-    }
-
-    Entity::BNpcPtr getBNpc( uint32_t layoutId ) override
-    {
-      auto bnpc = m_bnpcs.find( layoutId );
-      if( bnpc != std::end( m_bnpcs ) )
-        return bnpc->second;
-
-      return nullptr;
-    }
-
-    void removeBNpc( uint32_t layoutId ) override
-    {
-       m_bnpcs.erase( layoutId );
+      //*/
     }
   };
-}
+}// namespace Sapphire
\ No newline at end of file
diff --git a/src/world/Encounter/PhaseCondition.cpp b/src/world/Encounter/PhaseCondition.cpp
new file mode 100644
index 000000000..5a008008d
--- /dev/null
+++ b/src/world/Encounter/PhaseCondition.cpp
@@ -0,0 +1,321 @@
+#include "PhaseCondition.h"
+
+#include "EncounterTimeline.h"
+#include "TimelineActor.h"
+#include "TimelineActorState.h"
+
+#include <Action/Action.h>
+
+#include <Actor/Chara.h>
+#include <Actor/BNpc.h>
+#include <Actor/Player.h>
+
+#include <Territory/Territory.h>
+#include <Territory/InstanceContent.h>
+#include <Territory/QuestBattle.h>
+
+namespace Sapphire::Encounter
+{
+  bool ConditionHp::isConditionMet( ConditionState& state, TimelinePack& pack, TerritoryPtr pTeri, uint64_t time ) const
+  {
+    auto pBNpc = pTeri->getActiveBNpcByLayoutId( layoutId );
+    if( !pBNpc )
+      return false;
+
+    // todo: check time elapsed
+
+    switch( m_conditionType )
+    {
+      case ConditionType::HpPctLessThan:
+        return pBNpc->getHpPercent() < hp.val;
+      case ConditionType::HpPctBetween:
+      {
+        auto hpPct = pBNpc->getHpPercent();
+        return hpPct > hp.min && hpPct < hp.max;
+      }
+    }
+    return false;
+  };
+
+  bool ConditionDirectorVar::isConditionMet( ConditionState& state, TimelinePack& pack, TerritoryPtr pTeri, uint64_t time ) const
+  {
+
+    Event::DirectorPtr pDirector = pTeri->getAsInstanceContent();
+    if( pDirector == nullptr )
+      pDirector = pTeri->getAsQuestBattle();
+
+    switch( m_conditionType )
+    {
+      case ConditionType::DirectorVarEquals:
+        return pDirector->getDirectorVar( param.index ) == param.value;
+      case ConditionType::DirectorVarGreaterThan:
+        return pDirector->getDirectorVar( param.index ) > param.value;
+      case ConditionType::DirectorFlagsEquals:
+        return pDirector->getFlags() == param.flags;
+      case ConditionType::DirectorFlagsGreaterThan:
+        return pDirector->getFlags() > param.flags;
+      case ConditionType::DirectorSeqEquals:
+        return pDirector->getSequence() == param.seq;
+      case ConditionType::DirectorSeqGreaterThan:
+        return pDirector->getSequence() > param.seq;
+    }
+    return false;
+  }
+
+  bool ConditionCombatState::isConditionMet( ConditionState& state, TimelinePack& pack, TerritoryPtr pTeri, uint64_t time ) const
+  {
+    auto pBNpc = pTeri->getActiveBNpcByLayoutId( this->layoutId );
+
+    if( !pBNpc )
+      return false;
+
+    // todo: these should really use callbacks when the state transitions or we could miss this tick
+    switch( combatState )
+    {
+      case CombatStateType::Idle:
+        return pBNpc->getState() == Entity::BNpcState::Idle;
+      case CombatStateType::Combat:
+        return pBNpc->getState() == Entity::BNpcState::Combat;
+      case CombatStateType::Retreat:
+        return pBNpc->getState() == Entity::BNpcState::Retreat;
+      case CombatStateType::Roaming:
+        return pBNpc->getState() == Entity::BNpcState::Roaming;
+      case CombatStateType::JustDied:
+        return pBNpc->getState() == Entity::BNpcState::JustDied;
+      case CombatStateType::Dead:
+        return pBNpc->getState() == Entity::BNpcState::Dead;
+      default:
+        break;
+    }
+    return false;
+  }
+
+  bool ConditionEncounterTimeElapsed::isConditionMet( ConditionState& state, TimelinePack& pack, TerritoryPtr pTeri, uint64_t time ) const
+  {
+    auto elapsed = time - pack.getStartTime();
+    // todo: check encounter time
+    return elapsed >= this->duration;
+  }
+
+  bool ConditionBNpcFlags::isConditionMet( ConditionState& state, TimelinePack& pack, TerritoryPtr pTeri, uint64_t time ) const
+  {
+    auto pBNpc = pTeri->getActiveBNpcByLayoutId( this->layoutId );
+    return pBNpc && pBNpc->hasFlag( this->flags );
+  }
+
+  bool ConditionGetAction::isConditionMet( ConditionState& state, TimelinePack& pack, TerritoryPtr pTeri, uint64_t time ) const
+  {
+    auto pBNpc = pTeri->getActiveBNpcByLayoutId( this->layoutId );
+    return pBNpc && pBNpc->getCurrentAction() && pBNpc->getCurrentAction()->getId() == this->actionId;
+  }
+
+  bool ConditionPhaseActive::isConditionMet( ConditionState& state, TimelinePack& pack, TerritoryPtr pTeri, uint64_t time ) const
+  {
+    return pack.isPhaseActive( this->actorName, this->phaseName );
+  }
+
+  void ConditionHp::from_json( nlohmann::json& json, Phase& phase, ConditionType condition,
+                               const std::unordered_map< std::string, TimelineActor >& actors )
+  {
+    PhaseCondition::from_json( json, phase, condition, actors );
+
+    auto& paramData = json.at( "paramData" );
+    auto actorRef = paramData.at( "sourceActor" ).get< std::string >();
+
+    // resolve the actor whose hp we are checking
+    if( auto it = actors.find( actorRef ); it != actors.end() )
+      this->layoutId = it->second.m_layoutId;
+    else
+      throw std::runtime_error( fmt::format( std::string( "ConditionHp::from_json unable to find actor by name: %s" ), actorRef ) );
+
+    switch( condition )
+    {
+      case ConditionType::HpPctLessThan:
+        this->hp.val = paramData.at( "hp" ).get< uint32_t >();
+        break;
+      case ConditionType::HpPctBetween:
+        this->hp.min = paramData.at( "hpMin" ).get< uint32_t >(),
+        this->hp.max = paramData.at( "hpMax" ).get< uint32_t >();
+        break;
+      default:
+        break;
+    }
+  }
+
+  void ConditionDirectorVar::from_json( nlohmann::json& json, Phase& phase, ConditionType condition,
+                                        const std::unordered_map< std::string, TimelineActor >& actors )
+  {
+    PhaseCondition::from_json( json, phase, condition, actors );
+
+    auto& paramData = json.at( "paramData" );
+
+    switch( condition )
+    {
+      case ConditionType::DirectorVarEquals:
+      case ConditionType::DirectorVarGreaterThan:
+      {
+        param.index = paramData.at( "idx" ).get< uint32_t >();
+        param.value = paramData.at( "val" ).get< uint32_t >();
+      }
+      break;
+      case ConditionType::DirectorFlagsEquals:
+      case ConditionType::DirectorFlagsGreaterThan:
+      {
+        param.flags = paramData.at( "flags" ).get< uint32_t >();
+      }
+      break;
+      case ConditionType::DirectorSeqEquals:
+      case ConditionType::DirectorSeqGreaterThan:
+      {
+        param.seq = paramData.at( "seq" ).get< uint32_t >();
+      }
+      break;
+      default:
+        break;
+    }
+  }
+
+  void ConditionCombatState::from_json( nlohmann::json& json, Phase& phase, ConditionType condition,
+                                        const std::unordered_map< std::string, TimelineActor >& actors )
+  {
+    PhaseCondition::from_json( json, phase, condition, actors );
+
+    auto& paramData = json.at( "paramData" );
+    auto actorRef = paramData.at( "sourceActor" ).get< std::string >();
+
+    // resolve the actor whose name we are checking
+    if( auto it = actors.find( actorRef ); it != actors.end() )
+      this->layoutId = it->second.m_layoutId;
+    else
+      throw std::runtime_error( fmt::format( std::string( "ConditionCombatState::from_json unable to find actor by name: %s" ), actorRef ) );
+
+    this->combatState = paramData.at( "combatState" ).get< CombatStateType >();
+  }
+
+  void ConditionEncounterTimeElapsed::from_json( nlohmann::json& json, Phase& phase, ConditionType condition,
+                                                 const std::unordered_map< std::string, TimelineActor >& actors )
+  {
+    PhaseCondition::from_json( json, phase, condition, actors );
+
+    auto& paramData = json.at( "paramData" );
+    auto duration = paramData.at( "duration" ).get< uint64_t >();
+
+    this->duration = duration;
+  }
+
+  void ConditionBNpcFlags::from_json( nlohmann::json& json, Phase& phase, ConditionType condition,
+                                      const std::unordered_map< std::string, TimelineActor >& actors )
+  {
+    PhaseCondition::from_json( json, phase, condition, actors );
+    auto& paramData = json.at( "paramData" );
+    auto actorRef = paramData.at( "sourceActor" ).get< std::string >();
+
+    // resolve the actor whose name we are checking
+    if( auto it = actors.find( actorRef ); it != actors.end() )
+      this->layoutId = it->second.m_layoutId;
+    else
+      throw std::runtime_error( fmt::format( std::string( "ConditionBNpcFlags::from_json unable to find actor by name: %s" ), actorRef ) );
+
+    this->flags = json.at( "flags" ).get< uint32_t >();
+    // todo: BNpcHasFlags
+  }
+
+  void ConditionGetAction::from_json( nlohmann::json& json, Phase& phase, ConditionType condition,
+                                      const std::unordered_map< std::string, TimelineActor >& actors )
+  {
+    PhaseCondition::from_json( json, phase, condition, actors );
+
+    auto& paramData = json.at( "paramData" );
+    auto actorRef = paramData.at( "sourceActor" ).get< std::string >();
+    auto actionId = paramData.at( "actionId" ).get< uint32_t >();
+
+    // resolve the actor whose name we are checking
+    if( auto it = actors.find( actorRef ); it != actors.end() )
+      this->layoutId = it->second.m_layoutId;
+    else
+      throw std::runtime_error( fmt::format( std::string( "ConditionGetAction::from_json unable to find actor by name: %s" ), actorRef ) );
+
+    this->actionId = actionId;
+  }
+
+  void ConditionPhaseActive::from_json( nlohmann::json& json, Phase& phase, ConditionType condition,
+                                        const std::unordered_map< std::string, TimelineActor >& actors )
+  {
+    PhaseCondition::from_json( json, phase, condition, actors );
+
+    auto& paramData = json.at( "paramData" );
+    auto actorRef = paramData.at( "sourceActor" ).get< std::string >();
+    auto phaseName = paramData.at( "phaseName" ).get< std::string >();
+
+    this->actorName = actorRef;
+    this->phaseName = phaseName;
+  }
+
+  // todo: i wrote this very sleep deprived, ensure it is actually sane
+
+  void Phase::execute( ConditionState& state, TimelineActor& self, TimelinePack& pack, TerritoryPtr pTeri, uint64_t time ) const
+  {
+    if( state.m_startTime == 0 )
+    {
+      state.m_startTime = time;
+      self.spawnAllSubActors( pTeri );
+    }
+
+    if( state.m_phaseInfo.m_startTime == 0 )
+      state.m_phaseInfo.m_startTime = time;
+
+    if( state.m_phaseInfo.m_lastTimepointTime == 0 )
+    {
+      state.m_phaseInfo.m_timepointStates.clear();
+      state.m_phaseInfo.m_timepointStates.resize( m_timepoints.size() );
+      state.m_phaseInfo.m_lastTimepointTime = time;
+    }
+
+    for( auto i = state.m_phaseInfo.m_lastTimepointIndex; i < m_timepoints.size(); )
+    {
+      uint64_t phaseElapsed = time - state.m_phaseInfo.m_startTime;
+
+      auto& tpState = state.m_phaseInfo.m_timepointStates[ i ];
+      auto& timepoint = m_timepoints[ i ];
+
+      uint64_t timepointElapsed = time - tpState.m_startTime;
+
+      if( tpState.m_startTime == 0 )
+        timepointElapsed = 0;
+
+      if( timepoint.canExecute( tpState, timepointElapsed ) )
+      {
+        if( timepoint.execute( tpState, self, pack, pTeri, time ) )
+          state.m_phaseInfo.m_lastTimepointTime = time;
+      }
+      else if( !timepoint.finished( tpState, timepointElapsed ) )
+      {
+        timepoint.update( tpState, self, pack, pTeri, time );
+      }
+
+      if( timepoint.durationElapsed( timepointElapsed ) && timepoint.finished( tpState, timepointElapsed ) )
+      {
+        timepoint.reset( tpState );
+        // make sure this timepoint isnt run again unless phase loops
+        ++i;
+        state.m_phaseInfo.m_lastTimepointIndex = i;
+
+        if( i == m_timepoints.size() )
+          state.m_phaseInfo.m_lastTimepointIndex++;
+      }
+      break;
+    }
+  }
+
+  void Phase::reset( ConditionState& state ) const
+  {
+    state.m_phaseInfo.m_startTime = 0;
+    state.m_phaseInfo.m_lastTimepointIndex = 0;
+    state.m_phaseInfo.m_lastTimepointTime = 0;
+  }
+
+  bool Phase::completed( const ConditionState& state ) const
+  {
+    return state.m_phaseInfo.m_lastTimepointIndex > m_timepoints.size();
+  }
+}// namespace Sapphire::Encounter
\ No newline at end of file
diff --git a/src/world/Encounter/PhaseCondition.h b/src/world/Encounter/PhaseCondition.h
new file mode 100644
index 000000000..2d684e315
--- /dev/null
+++ b/src/world/Encounter/PhaseCondition.h
@@ -0,0 +1,244 @@
+#pragma once
+
+#include <cstdint>
+
+#include "TimelineActorState.h"
+#include "Timepoint.h"
+
+namespace Sapphire::Encounter
+{
+  // todo: just use the actual combat state return type
+  enum class CombatStateType
+  {
+    Idle,
+    Combat,
+    Retreat,
+    Roaming,
+    JustDied,
+    Dead
+  };
+
+  enum class ConditionType : uint32_t
+  {
+    HpPctLessThan,
+    HpPctBetween,
+
+    DirectorVarEquals,
+    DirectorVarGreaterThan,
+    DirectorSeqEquals,
+    DirectorSeqGreaterThan,
+    DirectorFlagsEquals,
+    DirectorFlagsGreaterThan,
+
+    EncounterTimeElapsed,
+    CombatState,
+    BNpcHasFlags,
+
+    GetAction,
+    PhaseActive
+  };
+
+  class Phase : public std::enable_shared_from_this< Phase >
+  {
+  public:
+    // todo: getters/setters
+    std::string m_name;
+    std::vector< Timepoint > m_timepoints;
+    std::string m_description;
+
+    void execute( ConditionState& state, TimelineActor& self, TimelinePack& pack, TerritoryPtr pTeri, uint64_t time ) const;
+
+    void reset( ConditionState& state ) const;
+
+    bool completed( const ConditionState& state ) const;
+  };
+  using PhasePtr = std::shared_ptr< Phase >;
+
+  class PhaseCondition : public std::enable_shared_from_this< PhaseCondition >
+  {
+  protected:
+    ConditionType m_conditionType{ 0 };
+    Phase m_phase;
+    std::string m_description;
+    uint32_t m_cooldown{ 0 };
+    bool m_loop{ false };
+    bool m_enabled{ true };
+    uint32_t m_id{ 0 };
+
+  public:
+    PhaseCondition() {}
+    ~PhaseCondition() {}
+
+    virtual void from_json( nlohmann::json& json, Phase& phase, ConditionType condition, const std::unordered_map< std::string, TimelineActor >& actors )
+    {
+      this->m_conditionType = condition;
+      this->m_loop = json.at( "loop" ).get< bool >();
+      //this->m_cooldown = json.at( "cooldown" ).get< uint32_t >();
+      this->m_phase = phase;
+      this->m_description = json.at( "description" ).get< std::string >();
+      this->m_enabled = json.at( "enabled" ).get< bool >();
+      this->m_id = json.at( "id" ).get< uint32_t >();
+    }
+
+    const std::string& getPhaseName()
+    {
+      return m_phase.m_name;
+    }
+
+    void execute( ConditionState& state, TimelineActor& self, TimelinePack& pack, TerritoryPtr pTeri, uint64_t time ) const
+    {
+      m_phase.execute( state, self, pack, pTeri, time );
+    };
+
+    void update( ConditionState& state, TimelineActor& self, TimelinePack& pack, TerritoryPtr pTeri, uint64_t time ) const
+    {
+      m_phase.execute( state, self, pack, pTeri, time );
+    }
+
+    void setEnabled( ConditionState& state, bool enabled )
+    {
+      state.m_enabled = enabled;
+    }
+
+    void reset( ConditionState& state, bool toDefaults = false ) const
+    {
+      state.m_startTime = 0;
+
+      if( toDefaults )
+        state.m_enabled = isDefaultEnabled();
+
+      m_phase.reset( state );
+    }
+
+    bool inProgress( const ConditionState& state ) const
+    {
+      return state.m_startTime != 0;
+    }
+
+    // todo: better naming
+    bool isStateEnabled( const ConditionState& state ) const
+    {
+      return state.m_enabled;
+    }
+
+    bool isDefaultEnabled() const
+    {
+      return m_enabled;
+    }
+
+    bool completed( const ConditionState& state ) const
+    {
+      return m_phase.completed( state );
+    }
+
+    bool isLoopable() const
+    {
+      return m_loop;
+    }
+
+    bool loopReady( ConditionState& state, uint64_t time ) const
+    {
+      return m_phase.completed( state ) && m_loop && ( state.m_startTime + m_cooldown <= time );
+    }
+
+    virtual bool isConditionMet( ConditionState& state, TimelinePack& pack, TerritoryPtr pTeri, uint64_t time ) const
+    {
+      return false;
+    };
+
+    uint32_t getId() const
+    {
+      return m_id;
+    }
+  };
+  using PhaseConditionPtr = std::shared_ptr< PhaseCondition >;
+
+  //
+  // Conditions
+  //
+  class ConditionHp : public PhaseCondition
+  {
+  public:
+    uint32_t layoutId;
+    union
+    {
+      uint8_t val;
+      struct
+      {
+        uint8_t min, max;
+      };
+    } hp;
+
+    void from_json( nlohmann::json& json, Phase& phase, ConditionType condition, const std::unordered_map< std::string, TimelineActor >& actors ) override;
+
+    bool isConditionMet( ConditionState& state, TimelinePack& pack, TerritoryPtr pTeri, uint64_t time ) const override;
+  };
+
+  class ConditionDirectorVar : public PhaseCondition
+  {
+  public:
+    union
+    {
+      struct
+      {
+        uint32_t index;
+        uint32_t value;
+      };
+      uint8_t seq;
+      uint8_t flags;
+    } param;
+
+    void from_json( nlohmann::json& json, Phase& phase, ConditionType condition, const std::unordered_map< std::string, TimelineActor >& actors ) override;
+    bool isConditionMet( ConditionState& state, TimelinePack& pack, TerritoryPtr pTeri, uint64_t time ) const override;
+  };
+
+  class ConditionEncounterTimeElapsed : public PhaseCondition
+  {
+  public:
+    uint64_t duration;
+
+    void from_json( nlohmann::json& json, Phase& phase, ConditionType condition, const std::unordered_map< std::string, TimelineActor >& actors ) override;
+    bool isConditionMet( ConditionState& state, TimelinePack& pack, TerritoryPtr pTeri, uint64_t time ) const override;
+  };
+
+  class ConditionCombatState : public PhaseCondition
+  {
+  public:
+    uint32_t layoutId;
+    CombatStateType combatState;
+
+    void from_json( nlohmann::json& json, Phase& phase, ConditionType condition, const std::unordered_map< std::string, TimelineActor >& actors ) override;
+    bool isConditionMet( ConditionState& state, TimelinePack& pack, TerritoryPtr pTeri, uint64_t time ) const override;
+  };
+
+  class ConditionBNpcFlags : public PhaseCondition
+  {
+  public:
+    uint32_t layoutId;
+    uint32_t flags;
+
+    void from_json( nlohmann::json& json, Phase& phase, ConditionType condition, const std::unordered_map< std::string, TimelineActor >& actors ) override;
+    bool isConditionMet( ConditionState& state, TimelinePack& pack, TerritoryPtr pTeri, uint64_t time ) const override;
+  };
+
+  class ConditionGetAction : public PhaseCondition
+  {
+  public:
+    uint32_t layoutId;
+    uint32_t actionId;
+
+    void from_json( nlohmann::json& json, Phase& phase, ConditionType condition, const std::unordered_map< std::string, TimelineActor >& actors ) override;
+    bool isConditionMet( ConditionState& state, TimelinePack& pack, TerritoryPtr pTeri, uint64_t time ) const override;
+  };
+
+  class ConditionPhaseActive : public PhaseCondition
+  {
+  public:
+    std::string actorName;
+    std::string phaseName;
+
+    void from_json( nlohmann::json& json, Phase& phase, ConditionType condition, const std::unordered_map< std::string, TimelineActor >& actors ) override;
+    bool isConditionMet( ConditionState& state, TimelinePack& pack, TerritoryPtr pTeri, uint64_t time ) const override;    
+  };
+
+}// namespace Sapphire::Encounter
\ No newline at end of file
diff --git a/src/world/Encounter/Selector.cpp b/src/world/Encounter/Selector.cpp
new file mode 100644
index 000000000..b436b9377
--- /dev/null
+++ b/src/world/Encounter/Selector.cpp
@@ -0,0 +1,141 @@
+#include "Selector.h"
+
+#include <Actor/Chara.h>
+
+namespace Sapphire::Encounter
+{
+  void Selector::from_json( const nlohmann::json& json )
+  {
+    const static std::unordered_map< std::string, World::AI::TargetSelectFilter::Type > filterMap =
+    {
+      { "insideRadius", World::AI::TargetSelectFilter::Type::InsideRadius },
+      { "outsideRadius", World::AI::TargetSelectFilter::Type::OutsideRadius },
+
+      { "player", World::AI::TargetSelectFilter::Type::Player },
+      { "ally", World::AI::TargetSelectFilter::Type::Ally },
+      { "ownBattalion", World::AI::TargetSelectFilter::Type::OwnBattalion },
+
+      { "tank", World::AI::TargetSelectFilter::Type::Tank },
+      { "healer", World::AI::TargetSelectFilter::Type::Healer },
+      { "dps", World::AI::TargetSelectFilter::Type::Dps },
+
+      { "hasStatusEffect", World::AI::TargetSelectFilter::Type::HasStatusEffect },
+
+      { "topAggro", World::AI::TargetSelectFilter::Type::TopAggro },
+      { "secondAggro", World::AI::TargetSelectFilter::Type::SecondAggro },
+      { "partyMember", World::AI::TargetSelectFilter::Type::PartyMember }
+    };
+
+    m_name = json.at( "name" ).get< std::string >();
+    m_fillWithRandom = json.at( "fillRandomEntries" ).get< bool >();
+    m_count = json.at( "count" ).get< uint32_t >();
+
+    std::vector< World::AI::TargetSelectFilterPtr > filters;
+    auto filtersJ = json.at( "filters" ).items();
+    for( const auto& filterJ : filtersJ )
+    {
+      auto& filterV = filterJ.value();
+      auto name = filterV.at( "type" ).get< std::string >();
+      auto typeId = filterMap.find( name )->second;
+      auto negate = filterV.at( "negate" ).get< bool >();
+
+      World::AI::TargetSelectFilterPtr pFilter = nullptr;
+
+      switch( typeId )
+      {
+        case World::AI::TargetSelectFilter::Type::InsideRadius:
+        {
+          auto radius = filterV.at( "param" ).get< uint32_t >();
+          pFilter = std::make_shared< World::AI::InsideRadiusFilter >( static_cast< float >( radius ), negate );
+        }
+        break;
+        case World::AI::TargetSelectFilter::Type::OutsideRadius:
+        {
+          auto radius = filterV.at( "param" ).get< uint32_t >();
+          pFilter = std::make_shared< World::AI::OutsideRadiusFilter >( static_cast< float >( radius ), negate );
+        }
+        break;
+
+        case World::AI::TargetSelectFilter::Type::Player:
+        {
+          pFilter = std::make_shared< World::AI::PlayerFilter >( negate );
+        }
+        break;
+        case World::AI::TargetSelectFilter::Type::Ally:
+        {
+          pFilter = std::make_shared< World::AI::AllyFilter >( negate );
+        }
+        break;
+        case World::AI::TargetSelectFilter::Type::OwnBattalion:
+        {
+          pFilter = std::make_shared< World::AI::OwnBattalionFilter >( negate );
+        }
+        break;
+
+        case World::AI::TargetSelectFilter::Type::Tank:
+        {
+          pFilter = std::make_shared< World::AI::TankFilter >( negate );
+        }
+        break;
+        case World::AI::TargetSelectFilter::Type::Healer:
+        {
+          pFilter = std::make_shared< World::AI::HealerFilter >( negate );
+        }
+        break;
+        case World::AI::TargetSelectFilter::Type::Dps:
+        {
+          pFilter = std::make_shared< World::AI::DpsFilter >( negate );
+        }
+        break;
+
+        case World::AI::TargetSelectFilter::Type::HasStatusEffect:
+        {
+          auto statusId = filterV.at( "param" ).get< uint32_t >();
+          pFilter = std::make_shared< World::AI::HasStatusEffectFilter >( statusId, negate );
+        }
+        break;
+
+        case World::AI::TargetSelectFilter::Type::TopAggro:
+        {
+          pFilter = std::make_shared< World::AI::TopAggroFilter >( negate );
+        }
+        break;
+        case World::AI::TargetSelectFilter::Type::SecondAggro:
+        {
+          pFilter = std::make_shared< World::AI::SecondAggroFilter >( negate );
+        }
+        break;
+
+        case World::AI::TargetSelectFilter::Type::PartyMember:
+        {
+          pFilter = std::make_shared< World::AI::PartyMemberFilter >( negate );
+        }
+        break;
+
+        default:
+          break;
+      }
+      m_filters.push_back( pFilter );
+    }
+  }
+
+  void Selector::createSnapshot( Entity::CharaPtr pSrc, const std::vector< uint32_t >& exclude )
+  {
+    m_snapshot.createSnapshot( pSrc, pSrc->getInRangeActors(), m_count, m_fillWithRandom, m_filters, exclude );
+  }
+
+  const World::AI::Snapshot::Results& Selector::getResults()
+  {
+    return m_snapshot.getResults();
+  }
+
+  const World::AI::Snapshot::TargetIds& Selector::getTargetIds()
+  {
+    return m_snapshot.getTargetIds();
+  }
+
+  void Selector::clearResults()
+  {
+    m_snapshot.clearResults();
+  }
+}// namespace Sapphire::Encounter
\ No newline at end of file
diff --git a/src/world/Encounter/Selector.h b/src/world/Encounter/Selector.h
new file mode 100644
index 000000000..d24ecf816
--- /dev/null
+++ b/src/world/Encounter/Selector.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <cstdint>
+#include <AI/TargetHelper.h>
+
+#include <nlohmann/json.hpp>
+
+namespace Sapphire::Encounter
+{
+  class Selector
+  {
+  private:
+    std::string m_name;
+    bool m_fillWithRandom{ true };
+    uint32_t m_count{ 0 };
+    std::vector< World::AI::TargetSelectFilterPtr > m_filters;
+    World::AI::Snapshot m_snapshot;
+
+  public:
+    Selector(){}
+    void createSnapshot( Entity::CharaPtr pSrc, const std::vector< uint32_t >& exclude = {} );
+    const World::AI::Snapshot::Results& getResults();
+    const World::AI::Snapshot::TargetIds& getTargetIds();
+    void clearResults();
+    void from_json( const nlohmann::json& json );
+  };
+};// namespace Sapphire::Encounter
\ No newline at end of file
diff --git a/src/world/Encounter/TimelineActor.cpp b/src/world/Encounter/TimelineActor.cpp
new file mode 100644
index 000000000..37e48aab2
--- /dev/null
+++ b/src/world/Encounter/TimelineActor.cpp
@@ -0,0 +1,221 @@
+#include "TimelineActor.h"
+
+#include "EncounterTimeline.h"
+
+#include <Actor/BNpc.h>
+#include <Action/Action.h>
+
+#include <Manager/PlayerMgr.h>
+#include <Service.h>
+
+#include <Territory/Territory.h>
+
+namespace Sapphire::Encounter
+{
+  const std::string& TimelineActor::getName() const
+  {
+    return m_name;
+  }
+
+  uint32_t TimelineActor::getLayoutId() const
+  {
+    return m_layoutId;
+  }
+
+  bool TimelineActor::isPhaseActive( const std::string& name ) const
+  {
+    for( const auto& condition : m_phaseConditions )
+    {
+      const auto& pCondition = condition.second;
+      const auto& state = m_conditionStates.at( condition.first );
+      if( pCondition->inProgress( state ) && pCondition->getPhaseName() == name )
+        return true;
+    }
+    return false;
+  }
+
+  void TimelineActor::addPhaseCondition( PhaseConditionPtr pCondition )
+  {
+    m_phaseConditions.emplace( std::make_pair( pCondition->getId(), pCondition ) );
+    m_conditionStates[ pCondition->getId() ] = {};
+    m_conditionStates[ pCondition->getId() ].m_enabled = pCondition->isDefaultEnabled();
+  }
+
+  // todo: make this sane
+
+  void TimelineActor::update( TerritoryPtr pTeri, TimelinePack& pack, uint64_t time )
+  {
+    // todo: handle interrupts
+    for( const auto& condition : m_phaseConditions )
+    {
+      const auto& pCondition = condition.second;
+      auto& state = m_conditionStates[ pCondition->getId() ];
+
+      // ignore if not enabled, unless overriden to enable
+      if( !pCondition->isStateEnabled( state ) )
+        continue;
+
+      if( pCondition->completed( state ) )
+      {
+        if( pCondition->isLoopable() )
+        {
+          if( pCondition->loopReady( state, time ) )
+            pCondition->reset( state );
+        }
+      }
+      // update or execute
+      else if( pCondition->isConditionMet( state, pack, pTeri, time ) )
+      {
+        if( pCondition->inProgress( state ) )
+        {
+          pCondition->update( state, *this, pack, pTeri, time );
+        }
+        else
+        {
+          pCondition->execute( state, *this, pack, pTeri, time );
+
+          if( pack.getStartTime() == 0 )
+            pack.setStartTime( state.m_startTime );
+        }
+      }
+    }
+  }
+
+  bool TimelineActor::resetConditionState( uint32_t conditionId, bool toDefault )
+  {
+    if( auto it = m_phaseConditions.find( conditionId ); it != m_phaseConditions.end() )
+    {
+      auto& state = m_conditionStates.at( it->first );
+      it->second->reset( state, toDefault );
+      return true;
+    }
+    return false;
+  }
+
+  bool TimelineActor::setConditionStateEnabled( uint32_t conditionId, bool enabled )
+  {
+    if( auto it = m_conditionStates.find( conditionId ); it != m_conditionStates.end() )
+    {
+      auto& state = m_conditionStates.at( it->first );
+      state.m_enabled = enabled;
+      return true;
+    }
+    return false;
+  }
+
+  void TimelineActor::resetAllConditionStates()
+  {
+    for( const auto& condition : m_phaseConditions )
+    {
+      const auto& pCondition = condition.second;
+      auto& state = m_conditionStates.at( condition.first );
+
+      pCondition->reset( state, true );
+    }
+  }
+
+  void TimelineActor::spawnAllSubActors( TerritoryPtr pTeri )
+  {
+    std::vector< std::string > toSpawn;
+    for( const auto& subActor : m_subActors )
+      if( getSubActor( subActor.first ) == nullptr )
+        toSpawn.push_back( subActor.first );
+
+    for( const auto& name : toSpawn )
+      spawnSubActor( name, pTeri );
+  }
+
+
+  void TimelineActor::addPlaceholderSubactor( const std::string& name )
+  {
+    // populate m_subActors with nullptr BNpcs
+    // then spawn them all in first timepoint and ref them by name subsequently
+    if( getSubActor( name ) == nullptr )
+      m_subActors.emplace( std::make_pair( name, nullptr ) );
+  }
+
+  Entity::BNpcPtr TimelineActor::getBNpcByRef( const std::string& name, TerritoryPtr pTeri ) const
+  {
+    if( name == m_name )
+      return pTeri->getActiveBNpcByLayoutId( m_layoutId );
+    return getSubActor( name );
+  }
+
+  void TimelineActor::resetAllSubActors( TerritoryPtr pTeri )
+  {
+    for( auto& subActor : m_subActors )
+    {
+      if( subActor.second )
+      {
+        auto inRange = subActor.second->getInRangeActors();
+        for( const auto& pActor : inRange )
+        {
+          if( auto pPlayer = pActor->getAsPlayer() )
+            subActor.second->despawn( pPlayer );
+        }
+        // todo: need to reset the ai on interrupt
+        auto pAction = subActor.second->getCurrentAction();
+        if( pAction )
+          pAction->interrupt();
+
+        pTeri->removeActor( subActor.second );
+        subActor.second = nullptr;
+      }
+    }
+  }
+
+  Entity::BNpcPtr TimelineActor::spawnSubActor( const std::string& name, TerritoryPtr pTeri )
+  {
+    // todo: retail straight up respawns sub actors, even bnpc parts (qarn adjudicator body parts respawn each time with new ids)
+    auto flags = Entity::BNpcFlag::Invincible | Entity::BNpcFlag::Untargetable |
+                 Entity::BNpcFlag::Immobile | Entity::BNpcFlag::AutoAttackDisabled |
+                 Entity::BNpcFlag::TurningDisabled | Entity::BNpcFlag::NoDeaggro;
+
+    auto pActor = getSubActor( name );
+    if( pActor == nullptr )
+    {
+      auto pParent = pTeri->getActiveBNpcByLayoutId( m_layoutId );
+      Common::BNpcType type = pParent ? pParent->getBNpcType() : Common::BNpcType::Enemy;
+      
+      pActor = pTeri->createBNpcFromLayoutId( m_layoutId, 1000, type );
+      m_subActors[ name ] = pActor;
+
+      pActor->setInvincibilityType( Common::InvincibilityIgnoreDamage );
+      pActor->setFlag( flags );
+      pActor->init();
+
+      pTeri->pushActor( pActor );
+
+      auto& playerMgr = Common::Service< World::Manager::PlayerMgr >::ref();
+      for( const auto& player : pTeri->getPlayers() )
+      {
+        pActor->spawn( player.second );
+        playerMgr.sendDebug( *player.second, fmt::format( "Spawned subactor {}", name ) );
+      }
+    }
+
+    return pActor;
+  }
+
+  Entity::BNpcPtr TimelineActor::getSubActor( const std::string& name ) const
+  {
+    if( auto it = m_subActors.find( name ); it != m_subActors.end() )
+      return it->second;
+    return nullptr;
+  }
+
+  void TimelineActor::resetSubActors( TerritoryPtr pTeri )
+  {
+    for( auto& subActor : m_subActors )
+    {
+      if( subActor.second )
+      {
+        auto& pBNpc = subActor.second;
+        pTeri->removeActor( pBNpc );
+        // todo: despawn?
+        subActor.second = nullptr;
+      }
+    }
+  }
+
+};
\ No newline at end of file
diff --git a/src/world/Encounter/TimelineActor.h b/src/world/Encounter/TimelineActor.h
new file mode 100644
index 000000000..5e0bfc87b
--- /dev/null
+++ b/src/world/Encounter/TimelineActor.h
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cstdint>
+
+#include "PhaseCondition.h"
+#include "TimelineActorState.h"
+
+namespace Sapphire::Encounter
+{
+  enum class TimelineActorType : uint32_t
+  {
+    LayerSetObject,
+    BattleNpc
+  };
+
+  class TimelineActor
+  {
+  protected:
+    std::unordered_map< uint32_t, PhaseConditionPtr > m_phaseConditions;
+    std::unordered_map< uint32_t, ConditionState > m_conditionStates;
+
+    // PARENTNAME_SUBACTOR_1, ..., PARENTNAME_SUBACTOR_69
+    std::unordered_map< std::string, Entity::BNpcPtr > m_subActors;
+
+  public:
+    uint32_t m_layoutId{ 0 };
+    uint32_t m_hp{ 0 };
+    std::string m_name;
+
+    TimelineActor() {}
+    TimelineActor( const TimelineActor& rhs ) :
+      m_layoutId( rhs.m_layoutId ),
+      m_hp( rhs.m_hp ),
+      m_name( rhs.m_name ),
+      m_phaseConditions( rhs.m_phaseConditions )
+    {
+      // yeah
+      for( const auto& subActor : rhs.m_subActors )
+        m_subActors.emplace( std::make_pair( subActor.first, nullptr ) );
+
+      m_conditionStates = rhs.m_conditionStates;
+      for( const auto& state : rhs.m_phaseConditions )
+        state.second->reset( m_conditionStates[ state.first ], true );
+    }
+
+    const std::string& getName() const;
+
+    uint32_t getLayoutId() const;
+
+    bool isPhaseActive( const std::string& name ) const;
+
+    void addPhaseCondition( PhaseConditionPtr pCondition );
+
+    // todo: make this sane
+    void update( TerritoryPtr pTeri, TimelinePack& pack, uint64_t time );
+
+    bool resetConditionState( uint32_t conditionId, bool toDefault = false );
+
+    bool setConditionStateEnabled( uint32_t conditionId, bool enabled );
+
+    void resetAllConditionStates();
+
+    void spawnAllSubActors( TerritoryPtr pTeri );
+
+    void resetAllSubActors( TerritoryPtr pTeri );
+
+    // get self or subactor
+    Entity::BNpcPtr getBNpcByRef( const std::string& name, TerritoryPtr pTeri ) const;
+
+    // todo: i hate this but it's the only way to ref subactors while staying self contained
+    void addPlaceholderSubactor( const std::string& name );
+
+    Entity::BNpcPtr spawnSubActor( const std::string& name, TerritoryPtr pTeri );
+    Entity::BNpcPtr getSubActor( const std::string& name ) const;
+    void resetSubActors( TerritoryPtr pTeri );
+  };
+}
\ No newline at end of file
diff --git a/src/world/Encounter/TimelineActorState.h b/src/world/Encounter/TimelineActorState.h
new file mode 100644
index 000000000..a30dbd39c
--- /dev/null
+++ b/src/world/Encounter/TimelineActorState.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+namespace Sapphire::Encounter
+{
+struct TimepointState
+{
+  uint64_t m_startTime{ 0 };
+  uint64_t m_lastTick{ 0 };
+  bool m_finished{ false };
+};
+
+struct ConditionState
+{
+  uint64_t m_startTime{ 0 };
+  bool m_loop{ false };
+  bool m_completed{ false };
+  bool m_enabled{ false };
+
+  struct
+  {
+    uint64_t m_startTime{ 0 };
+    uint64_t m_lastTimepointTime{ 0 };
+    uint32_t m_lastTimepointIndex{ 0 };
+
+    std::vector< TimepointState > m_timepointStates;
+  } m_phaseInfo;
+};
+}; // namespace Sapphire::Encounter
\ No newline at end of file
diff --git a/src/world/Encounter/Timepoint.cpp b/src/world/Encounter/Timepoint.cpp
new file mode 100644
index 000000000..3cacd7741
--- /dev/null
+++ b/src/world/Encounter/Timepoint.cpp
@@ -0,0 +1,735 @@
+#include "Timepoint.h"
+#include "TimelineActor.h"
+#include "EncounterTimeline.h"
+
+#include <Action/Action.h>
+
+#include <Actor/BNpc.h>
+#include <Actor/Chara.h>
+#include <Actor/EventObject.h>
+#include <Actor/Player.h>
+
+#include <Event/Director.h>
+
+#include <Manager/ActionMgr.h>
+#include <Manager/PlayerMgr.h>
+#include <Service.h>
+
+#include <Territory/QuestBattle.h>
+#include <Territory/InstanceContent.h>
+#include <Util/UtilMath.h>
+
+namespace Sapphire::Encounter
+{
+  const TimepointDataPtr Timepoint::getData() const
+  {
+    return m_pData;
+  }
+
+  bool Timepoint::canExecute( const TimepointState& state, uint64_t elapsed ) const
+  {
+    return state.m_startTime == 0;
+  }
+
+  bool Timepoint::durationElapsed( uint64_t elapsed ) const
+  {
+    return m_duration <= elapsed;
+  }
+
+  bool Timepoint::finished( const TimepointState& state, uint64_t elapsed ) const
+  {
+    return durationElapsed( elapsed ) || state.m_finished;
+  }
+
+  void Timepoint::reset( TimepointState& state ) const
+  {
+    state.m_startTime = 0;
+    state.m_lastTick = 0;
+    state.m_finished = false;
+  }
+
+  void Timepoint::from_json( const nlohmann::json& json, const std::unordered_map< std::string, TimelineActor >& actors, uint32_t selfLayoutId )
+  {
+    const static std::unordered_map< std::string, TimepointDataType > timepointTypeMap =
+    {
+      { "idle",          TimepointDataType::Idle },
+      { "castAction",    TimepointDataType::CastAction },
+      { "setPos",        TimepointDataType::SetPos },
+
+      { "logMessage",    TimepointDataType::LogMessage },
+      { "battleTalk",    TimepointDataType::BattleTalk },
+
+      { "directorVar",   TimepointDataType::DirectorVar },
+      { "directorSeq",   TimepointDataType::DirectorSeq },
+      { "directorFlags", TimepointDataType::DirectorFlags },
+
+      { "bNpcDespawn",   TimepointDataType::BNpcDespawn },
+      { "bNpcSpawn",     TimepointDataType::BNpcSpawn },
+      { "bNpcFlags",     TimepointDataType::BNpcFlags },
+      { "setEObjState",  TimepointDataType::SetEObjState },
+      { "setBGM",        TimepointDataType::SetBgm },
+
+      { "setCondition",  TimepointDataType::SetCondition },
+      { "snapshot",      TimepointDataType::Snapshot }
+    };
+
+    const static std::unordered_map< std::string, DirectorOpId > directorOpMap =
+    {
+      { "set", DirectorOpId::Set },
+      { "add", DirectorOpId::Add },
+      { "sub", DirectorOpId::Sub },
+      { "mul", DirectorOpId::Mul },
+      { "div", DirectorOpId::Div },
+      { "mod", DirectorOpId::Mod },
+      { "sll", DirectorOpId::Sll },
+      { "srl", DirectorOpId::Srl },
+      { "or",  DirectorOpId::Or },
+      { "xor", DirectorOpId::Xor },
+      { "nor", DirectorOpId::Nor },
+      { "and", DirectorOpId::And }
+    };
+
+    const static std::unordered_map< std::string, Common::BNpcType > bnpcTypeMap =
+    {
+      { "bnpc", Common::BNpcType::Enemy },
+      { "ally", Common::BNpcType::Friendly }// todo: rename this
+    };
+
+    const static std::unordered_map< std::string, ActionTargetType > actionTypeMap =
+    {
+      { "none",     ActionTargetType::None },
+      { "self",     ActionTargetType::Self },
+      { "target",   ActionTargetType::Target },
+      { "selector", ActionTargetType::Selector }
+    };
+
+    TimepointDataType tpType{ 0 };
+
+    auto typeStr = json.at( "type" ).get< std::string >();
+    if( auto it = timepointTypeMap.find( typeStr ); it != timepointTypeMap.end() )
+      tpType = it->second;
+    else
+      throw std::runtime_error( fmt::format( "Timepoint::from_json unable to find timepoint by type: {}", typeStr ) );
+
+    m_duration = json.at( "duration" ).get< uint64_t >();
+    //m_overrideFlags = json.at( "overrideFlags" ).get< TimepointOverrideFlags >();
+    m_description = json.at( "description" ).get< std::string >();
+    m_type = tpType;
+
+    switch( tpType )
+    {
+      case TimepointDataType::Idle:
+      {
+        m_pData = std::make_shared< TimepointDataIdle >( m_duration );
+      }
+      break;
+      case TimepointDataType::CastAction:
+      {
+        // todo: CastAction
+        // todo: parse and build callback funcs
+        auto& dataJ = json.at( "data" );
+        auto sourceRef = dataJ.at( "sourceActor" ).get< std::string >();
+        auto actionId = dataJ.at( "actionId" ).get< uint32_t >();
+        auto targetType = actionTypeMap.find( dataJ.at( "targetType" ).get< std::string >() )->second;
+        auto selectorRef = dataJ.at( "selectorName" ).get< std::string >();
+        auto selectorIndex = dataJ.at( "selectorIndex" ).get< uint32_t >();
+
+        m_pData = std::make_shared< TimepointDataAction >( sourceRef, actionId, targetType,
+                                                           selectorRef, selectorIndex - 1 );
+      }
+      break;
+      case TimepointDataType::SetPos:
+      {
+        auto& dataJ = json.at( "data" );
+        auto pos = dataJ.at( "pos" ).get< std::vector< float > >();
+        auto rot = dataJ.at( "rot" ).get< float >();
+        auto actorRef = dataJ.at( "actorName" ).get< std::string >();
+
+        m_pData = std::make_shared< TimepointDataSetPos >( actorRef, MoveType::SetPos,
+                                                           pos[ 0 ], pos[ 1 ], pos[ 2 ], rot );
+      }
+      break;
+      case TimepointDataType::LogMessage:
+      {
+        auto& dataJ = json.at( "data" );
+        auto messageId = dataJ.at( "messageId" ).get< uint32_t >();
+        auto params = dataJ.at( "params" ).get< std::vector< uint32_t > >();
+
+        m_pData = std::make_shared< TimepointDataLogMessage >( messageId, params );
+      }
+      break;
+      case TimepointDataType::BattleTalk:
+      {
+        auto& dataJ = json.at( "data" );
+        auto params = dataJ.at( "params" ).get< std::vector< uint32_t > >();
+
+        auto pBattleTalkData = std::make_shared< TimepointDataBattleTalk >( params );
+
+        pBattleTalkData->m_battleTalkId = dataJ.at( "battleTalkId" ).get< uint32_t >();
+        pBattleTalkData->m_handlerRef = dataJ.at( "handlerActorName" ).get< std::string >();
+        pBattleTalkData->m_kind = dataJ.at( "kind" ).get< uint32_t >();
+        pBattleTalkData->m_nameId = dataJ.at( "nameId" ).get< uint32_t >();
+        pBattleTalkData->m_talkerRef = dataJ.at( "talkerActorName" ).get< std::string >();
+
+        m_pData = pBattleTalkData;
+      }
+      break;
+
+      //
+      // Directors
+      //
+      case TimepointDataType::DirectorVar:
+      {
+        auto& dataJ = json.at( "data" );
+        auto index = dataJ.at( "idx" ).get< uint32_t >();
+        auto val = dataJ.at( "val" ).get< uint32_t >();
+        auto opStr = dataJ.at( "opc" ).get< std::string >();
+        DirectorOpId op = directorOpMap.at( opStr );
+
+        auto pDirectorData = std::make_shared< TimepointDataDirector >( tpType, op );
+        pDirectorData->m_data.index = index;
+        pDirectorData->m_data.value.val = val;
+
+        m_pData = pDirectorData;
+      }
+      break;
+      case TimepointDataType::DirectorVarLR:
+      {
+        auto& dataJ = json.at( "data" );
+        auto index = dataJ.at( "idx" ).get< uint32_t >();
+        auto left = dataJ.at( "left" ).get< uint32_t >();
+        auto right = dataJ.at( "right" ).get< uint32_t >();
+        auto opStr = dataJ.at( "opc" ).get< std::string >();
+        DirectorOpId op = directorOpMap.at( opStr );
+
+        auto pDirectorData = std::make_shared< TimepointDataDirector >( tpType, op );
+        pDirectorData->m_data.index = index;
+        pDirectorData->m_data.value.left = left;
+        pDirectorData->m_data.value.right = right;
+
+        m_pData = pDirectorData;
+      }
+      break;
+      case TimepointDataType::DirectorSeq:
+      {
+        auto& dataJ = json.at( "data" );
+        auto seq = dataJ.at( "val" ).get< uint32_t >();
+        auto opStr = dataJ.at( "opc" ).get< std::string >();
+        DirectorOpId op = directorOpMap.at( opStr );
+
+        auto pDirectorData = std::make_shared< TimepointDataDirector >( tpType, op );
+        pDirectorData->m_data.seq = seq;
+
+        m_pData = pDirectorData;
+      }
+      break;
+      case TimepointDataType::DirectorFlags:
+      {
+        auto& dataJ = json.at( "data" );
+        auto flags = dataJ.at( "val" ).get< uint32_t >();
+        auto opStr = dataJ.at( "opc" ).get< std::string >();
+        DirectorOpId op = directorOpMap.at( opStr );
+
+        auto pDirectorData = std::make_shared< TimepointDataDirector >( tpType, op );
+        pDirectorData->m_data.flags = flags;
+
+        m_pData = pDirectorData;
+      }
+      break;
+
+      //
+      // Status Effects
+      //
+      case TimepointDataType::AddStatusEffect:
+      case TimepointDataType::RemoveStatusEffect:
+      {
+        // todo: add/remove status effects
+      }
+      break;
+
+      case TimepointDataType::BNpcDespawn:
+      {
+        auto& dataJ = json.at( "data" );
+        auto actorRef = dataJ.at( "despawnActor" ).get< std::string >();
+
+        uint32_t layoutId = 0xE0000000;
+        if( auto it = actors.find( actorRef ); it != actors.end() )
+          layoutId = it->second.m_layoutId;
+        else
+          throw std::runtime_error( fmt::format( std::string( "Timepoint::from_json: SpawnBNpc invalid actor ref: {}" ), actorRef ) );
+
+        m_pData = std::make_shared< TimepointDataBNpcDespawn >( layoutId );
+      }
+      break;
+      case TimepointDataType::BNpcSpawn:
+      {
+        auto& dataJ = json.at( "data" );
+        // auto hateSrcJ = dataJ.at( "hateSrc" );
+        auto actorRef = dataJ.at( "spawnActor" ).get< std::string >();
+        auto flags = dataJ.at( "flags" ).get< uint32_t >();
+        // todo: batallion
+        // auto battalion = dataJ.at( "batallion" ).get< uint32_t >();
+        auto bnpcType = Common::BNpcType::Enemy;//bnpcTypeMap.at( dataJ.at( "type" ).get< std::string >() );
+
+        // todo: hateSrc
+
+        uint32_t layoutId = 0xE0000000;
+        if( auto it = actors.find( actorRef ); it != actors.end() )
+          layoutId = it->second.m_layoutId;
+        else
+          throw std::runtime_error( fmt::format( std::string( "Timepoint::from_json: SpawnBNpc invalid actor ref: {}" ), actorRef ) );
+
+        m_pData = std::make_shared< TimepointDataBNpcSpawn >( layoutId, flags, bnpcType );
+      }
+      break;
+      case TimepointDataType::BNpcFlags:
+      {
+        auto& dataJ = json.at( "data" );
+        auto actorRef = dataJ.at( "targetActor" ).get< std::string >();
+        auto flags = dataJ.at( "flags" ).get< uint32_t >();
+
+        // todo: hateSrc
+
+        uint32_t layoutId = selfLayoutId;
+        //if( auto it = actors.find( actorRef ); it != actors.end() )
+        //  layoutId = it->second.m_layoutId;
+        //else
+        //  throw std::runtime_error( fmt::format( std::string( "Timepoint::from_json: SetBNpcFlags invalid actor ref: {}" ), actorRef ) );
+
+        m_pData = std::make_shared< TimepointDataBNpcFlags >( layoutId, flags );
+        // todo: SetBNpcFlags
+      }
+      break;
+
+      case TimepointDataType::SetEObjState:
+      {
+        auto& dataJ = json.at( "data" );
+
+        // todo: SetEObjState
+      }
+      break;
+      case TimepointDataType::SetBgm:
+      {
+        auto& dataJ = json.at( "data" );
+        auto bgmId = dataJ.at( "bgmId" ).get< uint32_t >();
+
+        m_pData = std::make_shared< TimepointDataBGM >( bgmId );
+      }
+      break;
+      case TimepointDataType::SetCondition:
+      {
+        auto& dataJ = json.at( "data" );
+        auto conditionId = dataJ.at( "conditionId" ).get< uint32_t >();
+        auto enabled = dataJ.at( "enabled" ).get< bool >();
+
+        m_pData = std::make_shared< TimepointDataCondition >( conditionId, enabled );
+      }
+      break;
+
+      case TimepointDataType::Snapshot:
+      {
+        auto& dataJ = json.at( "data" );
+        auto selectorName = dataJ.at( "selectorName" ).get< std::string >();
+        auto actorRef = dataJ.at( "sourceActor" ).get< std::string >();
+        auto excludeSelector = std::string(); // dataJ.at( "excludeSelectorName" ).get< std::string >();
+        // todo: use exclude selector when added to ui
+
+        m_pData = std::make_shared< TimepointDataSnapshot >( selectorName, actorRef, excludeSelector );
+      }
+      break;
+      default:
+        break;
+    }
+  }
+
+  bool Timepoint::execute( TimepointState& state, TimelineActor& self, TimelinePack& pack, TerritoryPtr pTeri, uint64_t time ) const
+  {
+    if( update( state, self, pack, pTeri, time ) )
+    {
+      state.m_startTime = time;
+      state.m_finished = true;
+
+      const auto& players = pTeri->getPlayers();
+      // send debug msg
+      if( !m_description.empty() )
+      {
+        auto& playerMgr = Common::Service< Sapphire::World::Manager::PlayerMgr >::ref();
+
+        for( const auto& player : players )
+          playerMgr.sendDebug( *player.second, m_description );
+      }
+
+      return true;
+    }
+    return false;
+  }
+
+  bool Timepoint::update( TimepointState& state, TimelineActor& self, TimelinePack& pack, TerritoryPtr pTeri, uint64_t time ) const
+  {
+    state.m_lastTick = time;
+
+    // todo: separate execute and update?
+    if( state.m_finished )
+      return true;
+
+    switch( m_type )
+    {
+      case TimepointDataType::Idle:
+      {
+        // just wait up the duration of this timepoint
+      }
+      break;
+      case TimepointDataType::CastAction:
+      {
+        auto pActionData = std::dynamic_pointer_cast< TimepointDataAction, TimepointData >( m_pData );
+        auto pBNpc = pack.getBNpcByRef( pActionData->m_sourceRef, pTeri );
+        // todo: filter the correct target
+        // todo: tie to mechanic script?
+        // todo: mechanic should probably just be an Action::onTick, with instance/director passed to it
+        if( pBNpc )
+        {
+          uint32_t targetId = pBNpc->getId();
+          switch( pActionData->m_targetType )
+          {
+            case ActionTargetType::None:
+              targetId = 0xE0000000;
+              break;
+            case ActionTargetType::Target:
+              targetId = static_cast< uint32_t >( pBNpc->getTargetId() );
+              break;
+            case ActionTargetType::Self:
+              targetId = pBNpc->getId();
+              break;
+            case ActionTargetType::Selector:
+            {
+              const auto& results = pack.getSnapshotTargetIds( pActionData->m_selectorRef );
+              if( pActionData->m_selectorIndex < results.size() )
+                targetId = results[ pActionData->m_selectorIndex ];
+            }
+            break;
+            default:
+              break;
+          }
+          auto& actionMgr = Common::Service< Sapphire::World::Manager::ActionMgr >::ref();
+          auto pAction = pBNpc->getCurrentAction();
+
+          // todo: this is probably wrong
+          if( !pAction || pAction->isInterrupted() )
+          {
+            actionMgr.handleTargetedAction( *pBNpc, pActionData->m_actionId, targetId, pTeri->getNextActionResultId() );
+          }
+          // todo: this really shouldnt exist, but need to figure out why actions interrupt
+          else if( pAction->getId() == pActionData->m_actionId )
+          {
+            pAction->setInterrupted( Common::ActionInterruptType::RegularInterrupt );
+            pAction->interrupt();
+            pBNpc->setCurrentAction( nullptr );
+            return false;
+          }
+          else
+          {
+            return false;
+          }
+        }
+      }
+      break;
+      case TimepointDataType::SetPos:
+      {
+        auto pSetPosData = std::dynamic_pointer_cast< TimepointDataSetPos, TimepointData >( m_pData );
+        auto pBNpc = pack.getBNpcByRef( pSetPosData->m_actorRef, pTeri );
+
+        if( pBNpc )
+        {
+          pBNpc->setRot( pSetPosData->m_rot );
+          pBNpc->setPos( pSetPosData->m_x, pSetPosData->m_y, pSetPosData->m_z, true );
+        }
+      }
+      break;
+      /*
+      case TimepointDataType::MoveTo:
+      {
+        auto pMoveToData = std::dynamic_pointer_cast< TimepointDataMoveTo, TimepointData >( m_pData );
+        auto pBNpc = pack.getBNpcByRef( pMoveToData->m_actorRef, pTeri );
+
+        if( pBNpc )
+        {
+          auto currPos = pBNpc->getPos();
+          Common::FFXIVARR_POSITION3 targetPos = { pMoveToData->m_x, pMoveToData->m_y, pMoveToData->m_z };
+
+          auto distance = Common::Util::distance( currPos, targetPos );
+          if( distance > 0.5f )
+          {
+            if( pMoveToData->m_moveType == MoveType::WalkPath )
+              pBNpc->moveTo( targetPos );
+            else
+              pBNpc->setPos( pMoveToData->m_x, pMoveToData->m_y, pMoveToData->m_z );
+          }
+          else
+          {
+            // if we are at the pos, stop waiting
+            //state.m_finished = true;
+          }
+          pBNpc->setRot( pMoveToData->m_rot );
+        }
+      }
+      break;
+      */
+      case TimepointDataType::LogMessage:
+      {
+        auto pLogMessage = std::dynamic_pointer_cast< TimepointDataLogMessage, TimepointData >( m_pData );
+        auto params = pLogMessage->m_params;
+
+        // todo: probably should use ContentDirector
+
+        {
+          auto& playerMgr = Common::Service< Sapphire::World::Manager::PlayerMgr >::ref();
+          for( auto& player : pTeri->getPlayers() )
+          {
+            auto& pPlayer = player.second;
+            if( pPlayer )
+              playerMgr.sendLogMessage( *pPlayer.get(), pLogMessage->m_messageId,
+                                        params[ 0 ], params[ 1 ], params[ 2 ], params[ 3 ], params[ 4 ] );
+          }
+        }
+      }
+      break;
+      case TimepointDataType::BattleTalk:
+      {
+        // todo: BattleTalk
+        auto pBtData = std::dynamic_pointer_cast< TimepointDataBattleTalk, TimepointData >( m_pData );
+        auto params = pBtData->m_params;
+
+        auto pHandler = pack.getBNpcByRef( pBtData->m_handlerRef , pTeri );
+        auto pTalker = pack.getBNpcByRef( pBtData->m_talkerRef, pTeri );
+
+        auto handlerId = pHandler ? pHandler->getId() : 0xE0000000;
+        auto talkerId = pTalker ? pTalker->getId() : 0xE0000000;
+
+        // todo: use Actrl EventBattleDialog = 0x39C maybe?,
+        auto& playerMgr = Common::Service< Sapphire::World::Manager::PlayerMgr >::ref();
+        for( auto& player : pTeri->getPlayers() )
+        {
+          auto& pPlayer = player.second;
+          if( pPlayer )
+            playerMgr.sendBattleTalk( *pPlayer.get(), pBtData->m_battleTalkId, handlerId,
+                                      pBtData->m_kind, pBtData->m_nameId, talkerId,
+                                      params[ 0 ], params[ 1 ], params[ 2 ], params[ 3 ],
+                                      params[ 4 ], params[ 5 ], params[ 6 ], params[ 7 ] );
+        }
+      }
+      break;
+      case TimepointDataType::DirectorSeq:
+      case TimepointDataType::DirectorVar:
+      case TimepointDataType::DirectorVarLR:
+      case TimepointDataType::DirectorFlags:
+      {
+        auto pDirectorData = std::dynamic_pointer_cast< TimepointDataDirector, TimepointData >( m_pData );
+
+        uint32_t val = 0;
+        uint32_t param = 0;
+
+        // todo: expand for fates
+        Event::DirectorPtr pDirector = pTeri->getAsInstanceContent();
+        if( pDirector == nullptr )
+          pDirector = pTeri->getAsQuestBattle();
+
+        // todo: this should never not be set?
+        // todo: probably should use ContentDirector
+        // todo: this needs to resend packets too
+        if( pDirector )
+        {
+          switch( m_type )
+          {
+            case TimepointDataType::DirectorVar:
+              val = pDirector->getDirectorVar( pDirectorData->m_data.index );
+              param = pDirectorData->m_data.value.val;
+              break;
+            case TimepointDataType::DirectorFlags:
+              val = pDirector->getFlags();
+              param = pDirectorData->m_data.flags;
+              break;
+            case TimepointDataType::DirectorSeq:
+              val = pDirector->getSequence();
+              param = pDirectorData->m_data.seq;
+              break;
+            default:
+              break;
+          }
+
+          switch( pDirectorData->m_directorOp )
+          {
+            case DirectorOpId::Set:
+              val = param;
+              break;
+            case DirectorOpId::Add:
+              val += param;
+              break;
+            case DirectorOpId::Sub:
+              val -= param;
+              break;
+            case DirectorOpId::Mul:
+              val *= param;
+              break;
+            case DirectorOpId::Div:
+              val /= param;
+              break;
+            case DirectorOpId::Mod:
+              val %= param;
+              break;
+            case DirectorOpId::Sll:
+              val = val << param;
+              break;
+            case DirectorOpId::Srl:
+              val = val >> param;
+              break;
+            case DirectorOpId::Or:
+              val |= param;
+              break;
+            case DirectorOpId::Xor:
+              val ^= param;
+              break;
+            case DirectorOpId::Nor:
+              val = ~( val | param );
+              break;
+            case DirectorOpId::And:
+              val &= param;
+              break;
+            default:
+              break;
+          }
+
+          // todo: resend packets
+          switch( m_type )
+          {
+            case TimepointDataType::DirectorVar:
+              pDirector->setDirectorVar( pDirectorData->m_data.index, val );
+              break;
+            case TimepointDataType::DirectorFlags:
+              pDirector->setDirectorFlags( val );
+              break;
+            case TimepointDataType::DirectorSeq:
+              pDirector->setDirectorSequence( val );
+              break;
+            default:
+              break;
+          }
+        }
+      }
+      break;
+      case TimepointDataType::AddStatusEffect:
+      {
+        // todo:
+      }
+      break;
+      case TimepointDataType::RemoveStatusEffect:
+      {
+      }
+      break;
+      case TimepointDataType::BNpcDespawn:
+      {
+        auto pDespawnData = std::dynamic_pointer_cast< TimepointDataBNpcDespawn, TimepointData >( m_pData );
+        auto pBNpc = pTeri->getActiveBNpcByLayoutId( pDespawnData->m_layoutId );
+
+        if( pBNpc )
+        {
+          for( const auto& player : pTeri->getPlayers() )
+            pBNpc->despawn( player.second );
+
+          pTeri->removeActor( pBNpc );
+        }
+      }
+      break;
+      case TimepointDataType::BNpcSpawn:
+      {
+        auto pSpawnData = std::dynamic_pointer_cast< TimepointDataBNpcSpawn, TimepointData >( m_pData );
+        auto pBNpc = pTeri->getActiveBNpcByLayoutId( pSpawnData->m_layoutId );
+
+        // todo: probably have this info in the timepoint data
+        if( !pBNpc )
+          pBNpc = pTeri->createBNpcFromLayoutId( pSpawnData->m_layoutId, 100, Common::BNpcType::Enemy );
+
+        if( pBNpc )
+        {
+          pBNpc->clearFlags();
+          pBNpc->setFlag( pSpawnData->m_flags );
+          pBNpc->init();
+
+          for( const auto& player : pTeri->getPlayers() )
+            pBNpc->spawn( player.second );
+        }
+      }
+      break;
+      case TimepointDataType::BNpcFlags:
+      {
+        auto pBNpcFlagData = std::dynamic_pointer_cast< TimepointDataBNpcFlags, TimepointData >( m_pData );
+        auto pBNpc = pTeri->getActiveBNpcByLayoutId( pBNpcFlagData->m_layoutId );
+
+        if( pBNpc )
+        {
+          pBNpc->clearFlags();
+          pBNpc->setFlag( pBNpcFlagData->m_flags );
+          // todo: resend some bnpc packet/actrl?
+        }
+      }
+      break;
+      case TimepointDataType::SetEObjState:
+      {
+        auto pEObjData = std::dynamic_pointer_cast< TimepointDataEObjState, TimepointData >( m_pData );
+
+        auto pInstance = pTeri->getAsInstanceContent();
+        auto pQBattle = pTeri->getAsQuestBattle();
+
+        // todo: event objects on quest battles
+        // todo: SetEObjAnimationFlag?
+
+        if( pInstance )
+        {
+          auto pEObj = pInstance->getEObjById( pEObjData->m_eobjId );
+          if( pEObj )
+          {
+            pEObj->setState( pEObjData->m_state );
+            // todo: resend the eobj spawn packet?
+          }
+        }
+      }
+      break;
+      case TimepointDataType::SetBgm:
+      {
+        auto pBgmData = std::dynamic_pointer_cast< TimepointDataBGM, TimepointData >( m_pData );
+        auto pInstance = pTeri->getAsInstanceContent();
+        auto pQBattle = pTeri->getAsQuestBattle();
+
+        // todo: quest battles refactor to inherit InstanceContent
+        if( pInstance )
+        {
+          pInstance->setCurrentBGM( pBgmData->m_bgmId );
+        }
+      }
+      break;
+      case TimepointDataType::SetCondition:
+      {
+        auto pConditionData = std::dynamic_pointer_cast< TimepointDataCondition, TimepointData >( m_pData );
+
+        // todo: dont reset so things can resume? idk
+        pack.resetConditionState( pConditionData->m_conditionId );
+        pack.setConditionStateEnabled( pConditionData->m_conditionId, pConditionData->m_enabled );
+      }
+      break;
+      case TimepointDataType::Snapshot:
+      {
+        auto pSnapshotData = std::dynamic_pointer_cast< TimepointDataSnapshot, TimepointData >( m_pData );
+        auto pBNpc = pack.getBNpcByRef( pSnapshotData->m_actorRef, pTeri );
+
+        if( pBNpc )
+        {
+          const auto& exclude = pack.getSnapshotTargetIds( pSnapshotData->m_excludeSelector );
+          pack.createSnapshot( pSnapshotData->m_selector, pBNpc, exclude );
+        }
+      }
+      break;
+      default:
+        break;
+    }
+    return true;
+  }
+}
\ No newline at end of file
diff --git a/src/world/Encounter/Timepoint.h b/src/world/Encounter/Timepoint.h
new file mode 100644
index 000000000..e1aa726cd
--- /dev/null
+++ b/src/world/Encounter/Timepoint.h
@@ -0,0 +1,311 @@
+#pragma once
+
+#include "TimelineActorState.h"
+#include "Forwards.h"
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include <ForwardsZone.h>
+
+#include <nlohmann/json.hpp>
+
+namespace Sapphire::Encounter
+{
+  enum class TimepointDataType : uint32_t
+  {
+    Idle,
+    CastAction,
+    SetPos,
+
+    LogMessage,
+    BattleTalk,
+
+    DirectorVar,
+    DirectorVarLR,
+    DirectorSeq,
+    DirectorFlags,
+
+    AddStatusEffect,
+    RemoveStatusEffect,
+
+    BNpcSpawn,
+    BNpcDespawn,
+    BNpcFlags,
+    SetEObjState,
+    SetBgm,
+
+    SetCondition,
+
+    Snapshot
+  };
+
+  enum class ActionTargetType : uint32_t
+  {
+    None,
+    Self,
+    Target,
+    Selector
+  };
+
+  enum class MoveType : uint32_t
+  {
+    WalkPath,
+    Teleport,
+    SetPos
+  };
+
+  enum class DirectorOpId
+  {
+    Set,// idx = val
+    Add,// idx += val
+    Sub,// idx -= val
+    Mul,// idx *= val
+    Div,// idx /= val
+    Mod,// idx %= val
+    Sll,// idx << val
+    Srl,// idx >> val
+    Or, // idx |= val
+    Xor,// idx ^= val
+    Nor,// idx ~= val
+    And // idx &= val
+  };
+
+  //
+  // Timepoint.m_pData objects
+  //
+  struct TimepointData : public std::enable_shared_from_this< TimepointData > {
+    TimepointData( TimepointDataType type ) : m_type( type ) {}
+    virtual ~TimepointData(){};
+    TimepointDataType m_type{ 0 };
+  };
+  using TimepointDataPtr = std::shared_ptr< TimepointData >;
+
+  struct TimepointDataIdle : public TimepointData {
+    uint64_t m_durationMs;
+
+    TimepointDataIdle( uint64_t durationMs ) :
+      TimepointData( TimepointDataType::Idle ),
+      m_durationMs( durationMs )
+    {
+    }
+  };
+
+  struct TimepointDataAction : public TimepointData
+  {
+    std::string m_sourceRef;
+    uint32_t m_actionId;
+    ActionTargetType m_targetType;
+    std::string m_selectorRef;
+    uint32_t m_selectorIndex;
+
+    TimepointDataAction( const std::string& sourceRef, uint32_t actionId,
+                         ActionTargetType type, const std::string& selectorRef,
+                         uint32_t selectorIndex = 0 ) :
+      TimepointData( TimepointDataType::CastAction ),
+      m_sourceRef( sourceRef ),
+      m_actionId( actionId ),
+      m_targetType( type ),
+      m_selectorRef( selectorRef ),
+      m_selectorIndex( selectorIndex )
+    {
+    }
+  };
+
+  struct TimepointDataSetPos : public TimepointData {
+    // todo: use internal id
+    std::string m_actorRef;
+    MoveType m_moveType;
+    float m_x, m_y, m_z, m_rot;
+
+    TimepointDataSetPos( const std::string& actorRef, MoveType moveType,
+                        float x, float y, float z, float rot ) :
+      TimepointData( TimepointDataType::SetPos ),
+      m_actorRef( actorRef ),
+      m_moveType( moveType ),
+      m_x( x ), m_y( y ), m_z( z ), m_rot( rot )
+    {
+    }
+  };
+
+  struct TimepointDataLogMessage : public TimepointData {
+    uint32_t m_messageId;
+    uint32_t m_params[ 5 ]{ 0 };
+
+    TimepointDataLogMessage( uint32_t messageId, const std::vector< uint32_t >& params ) :
+      TimepointData( TimepointDataType::LogMessage ),
+      m_messageId( messageId )
+    {
+      for( auto i = 0; i < params.size() && i < 5; ++i )
+        m_params[ i ] = params[ i ];
+    }
+  };
+
+  struct TimepointDataBattleTalk : public TimepointData {
+    uint32_t m_battleTalkId;
+    std::string m_handlerRef;
+    uint32_t m_kind;
+    uint32_t m_nameId;
+    std::string m_talkerRef;
+
+    uint32_t m_params[ 8 ]{ 0 };
+
+    TimepointDataBattleTalk( const std::vector< uint32_t >& params ) :
+      TimepointData( TimepointDataType::BattleTalk )
+    {
+      for( auto i = 0; i < params.size() && i < 8; ++i )
+        m_params[ i ] = params[ i ];
+    }
+  };
+
+  struct TimepointDataDirector : public TimepointData
+  {
+    DirectorOpId m_directorOp{ 0 };
+    union
+    {
+      struct
+      {
+        uint8_t index;
+        union
+        {
+          uint8_t val;
+          struct
+          {
+            uint8_t left, right;
+          };
+        } value;
+      };
+      uint8_t seq;
+      uint8_t flags;
+    } m_data{ 0 };
+
+    TimepointDataDirector( TimepointDataType type, DirectorOpId op ) :
+      TimepointData( type ),
+      m_directorOp( op )
+    {
+    }
+  };
+
+  struct TimepointDataBNpcDespawn : public TimepointData
+  {
+    uint32_t m_layoutId{ 0xE0000000 };
+
+    TimepointDataBNpcDespawn( uint32_t layoutId ) :
+    TimepointData( TimepointDataType::BNpcDespawn ),
+    m_layoutId( layoutId )
+    {
+    }
+  };
+
+  struct TimepointDataBNpcSpawn : public TimepointData
+  {
+    uint32_t m_layoutId{ 0xE0000000 };
+    uint32_t m_flags{ 0 };
+    uint32_t m_type{ 0 };
+
+    // todo: hate type, source
+
+    TimepointDataBNpcSpawn( uint32_t layoutId, uint32_t flags, uint32_t type ) :
+      TimepointData( TimepointDataType::BNpcSpawn ),
+      m_layoutId( layoutId ),
+      m_flags( flags ),
+      m_type( type )
+    {
+    }
+  };
+
+  struct TimepointDataBNpcFlags : public TimepointData
+  {
+    uint32_t m_layoutId{ 0xE0000000 };
+    uint32_t m_flags{ 0 };
+
+    TimepointDataBNpcFlags( uint32_t layoutId, uint32_t flags ) :
+      TimepointData( TimepointDataType::BNpcFlags ),
+      m_layoutId( layoutId ),
+      m_flags( flags )
+    {
+    }
+  };
+
+  struct TimepointDataEObjState : public TimepointData
+  {
+    uint32_t m_eobjId{ 0xE0000000 };
+    uint32_t m_state{ 0 };
+
+    TimepointDataEObjState( uint32_t eobjId, uint32_t state ) :
+      TimepointData( TimepointDataType::SetEObjState ),
+      m_eobjId( eobjId ),
+      m_state( state )
+    {
+    }
+  };
+
+  struct TimepointDataBGM : public TimepointData
+  {
+    uint32_t m_bgmId{ 0 };
+
+    TimepointDataBGM( uint32_t bgmId ) :
+      TimepointData( TimepointDataType::SetBgm ),
+      m_bgmId( bgmId )
+    {
+    }
+  };
+
+  struct TimepointDataCondition : public TimepointData
+  {
+    // todo: rng?
+    uint32_t m_conditionId;
+    bool m_enabled;
+
+    TimepointDataCondition( uint32_t conditionId, bool enabled ) :
+      TimepointData( TimepointDataType::SetCondition ),
+      m_conditionId( conditionId ),
+      m_enabled( enabled )
+    {
+    }
+  };
+
+  struct TimepointDataSnapshot : public TimepointData
+  {
+    // todo: rng?
+    std::string m_selector;
+    std::string m_actorRef;
+    std::string m_excludeSelector;
+
+    TimepointDataSnapshot( const std::string& selector, const std::string& actorRef, const std::string& excludeSelector ) :
+      TimepointData( TimepointDataType::Snapshot ),
+      m_selector( selector ),
+      m_actorRef( actorRef ),
+      m_excludeSelector( excludeSelector )
+    {
+    }
+  };
+
+  // todo: refactor all this to allow solo actor to use
+  class Timepoint : public std::enable_shared_from_this< Timepoint >
+  {
+  public:
+    TimepointDataType m_type;
+    uint64_t m_duration{ 0 };// milliseconds
+    TimepointDataPtr m_pData;
+    std::string m_description;
+
+    // todo: repeatable?
+
+    const TimepointDataPtr getData() const;
+
+    bool canExecute( const TimepointState& state, uint64_t elapsed ) const;
+
+    bool durationElapsed( uint64_t elapsed ) const;
+
+    bool finished( const TimepointState& state, uint64_t elapsed ) const;
+
+    void reset( TimepointState& state ) const;
+
+    void from_json( const nlohmann::json& json, const std::unordered_map< std::string, TimelineActor >& actors, uint32_t selfLayoutId );
+    // todo: separate execute/update into onStart and onTick?
+    bool update( TimepointState& state, TimelineActor& self, TimelinePack& pack, TerritoryPtr pTeri, uint64_t time ) const;
+    bool execute( TimepointState& state, TimelineActor& self, TimelinePack& pack, TerritoryPtr pTeri, uint64_t time ) const;
+  };
+}// namespace Sapphire::Encounter
\ No newline at end of file
diff --git a/src/world/Event/Director.cpp b/src/world/Event/Director.cpp
index 104f18758..89b05e055 100644
--- a/src/world/Event/Director.cpp
+++ b/src/world/Event/Director.cpp
@@ -5,17 +5,19 @@
 #include <Network/PacketWrappers/EventLogMessagePacket.h>
 #include <Network/PacketDef/Zone/ServerZoneDef.h>
 #include <Network/CommonActorControl.h>
+#include "Network/PacketWrappers/ActorControlPacket.h"
+#include "Network/PacketWrappers/ActorControlSelfPacket.h"
+#include "Network/GameConnection.h"
+#include "Network/Util/PacketUtil.h"
 
 #include "Actor/Player.h"
 
-#include "Network/PacketWrappers/ActorControlPacket.h"
-#include "Network/PacketWrappers/ActorControlSelfPacket.h"
 #include <Logging/Logger.h>
 
 #include <Service.h>
 #include "WorldServer.h"
 #include "Session.h"
-#include "Network/GameConnection.h"
+
 
 using namespace Sapphire::Common;
 using namespace Sapphire::Network::Packets;
@@ -83,8 +85,7 @@ void Sapphire::Event::Director::sendEventLogMessage( Sapphire::Entity::Player& p
 
 void Sapphire::Event::Director::sendDirectorClear( Sapphire::Entity::Player& player ) const
 {
-  auto& server = Common::Service< World::WorldServer >::ref();
-  server.queueForPlayer( player.getCharacterId(), makeActorControlSelf( player.getId(), DirectorClear, m_directorId ) );
+  Network::Util::Packet::sendActorControlSelf( player, player.getId(), DirectorClear, m_directorId );
 }
 
 void Sapphire::Event::Director::sendDirectorVars( Sapphire::Entity::Player& player ) const
@@ -102,8 +103,7 @@ void Sapphire::Event::Director::sendDirectorVars( Sapphire::Entity::Player& play
 void Sapphire::Event::Director::sendDirectorInit( Sapphire::Entity::Player& player ) const
 {
   Logger::debug( "[{}] directorInit: directorId#{}, contextId#{}", player.getId(), m_directorId, m_contextId );
-  auto& server = Common::Service< World::WorldServer >::ref();
-  server.queueForPlayer( player.getCharacterId(), makeActorControlSelf( player.getId(), DirectorInit, m_directorId, m_contextId ) );
+  Network::Util::Packet::sendActorControlSelf( player, player.getId(), DirectorInit, m_directorId, m_contextId );
 }
 
 Sapphire::Event::Director::DirectorType Sapphire::Event::Director::getType() const
diff --git a/src/world/Event/EventHandler.cpp b/src/world/Event/EventHandler.cpp
index 39f195b5d..4b5857001 100644
--- a/src/world/Event/EventHandler.cpp
+++ b/src/world/Event/EventHandler.cpp
@@ -2,8 +2,9 @@
 
 #include <utility>
 
-Sapphire::Event::EventHandler::EventHandler( uint64_t actorId, uint32_t eventId,
-                                             EventType eventType, uint32_t eventParam ) :
+using namespace Sapphire;
+
+Event::EventHandler::EventHandler( uint64_t actorId, uint32_t eventId, EventType eventType, uint32_t eventParam ) :
   m_actorId( actorId ),
   m_eventId( eventId ),
   m_eventType( eventType ),
@@ -15,107 +16,107 @@ Sapphire::Event::EventHandler::EventHandler( uint64_t actorId, uint32_t eventId,
   m_returnCallback = nullptr;
 }
 
-uint64_t Sapphire::Event::EventHandler::getActorId() const
+uint64_t Event::EventHandler::getActorId() const
 {
   return m_actorId;
 }
 
-uint32_t Sapphire::Event::EventHandler::getId() const
+uint32_t Event::EventHandler::getId() const
 {
   return m_eventId;
 }
 
-uint8_t Sapphire::Event::EventHandler::getEventType() const
+uint8_t Event::EventHandler::getEventType() const
 {
   return m_eventType;
 }
 
-uint16_t Sapphire::Event::EventHandler::getType() const
+uint16_t Event::EventHandler::getType() const
 {
   return m_type;
 }
 
-uint16_t Sapphire::Event::EventHandler::getEntryId() const
+uint16_t Event::EventHandler::getEntryId() const
 {
   return m_entryId;
 }
 
-uint32_t Sapphire::Event::EventHandler::getEventParam() const
+uint32_t Event::EventHandler::getEventParam() const
 {
   return m_eventParam;
 }
 
-Sapphire::Event::EventHandler::SceneReturnCallback Sapphire::Event::EventHandler::getEventReturnCallback() const
+Event::EventHandler::SceneReturnCallback Event::EventHandler::getEventReturnCallback() const
 {
   return m_returnCallback;
 }
 
-void Sapphire::Event::EventHandler::setEventReturnCallback( SceneReturnCallback callback )
+void Event::EventHandler::setEventReturnCallback( SceneReturnCallback callback )
 {
   m_returnCallback = std::move( callback );
 }
 
-Sapphire::Event::EventHandler::QuestSceneReturnCallback Sapphire::Event::EventHandler::getQuestEventReturnCallback() const
+Event::EventHandler::QuestSceneReturnCallback Event::EventHandler::getQuestEventReturnCallback() const
 {
   return m_questReturnCallback;
 }
 
-void Sapphire::Event::EventHandler::setQuestEventReturnCallback( QuestSceneReturnCallback callback )
+void Event::EventHandler::setQuestEventReturnCallback( QuestSceneReturnCallback callback )
 {
   m_questReturnCallback = std::move( callback );
 }
 
-Sapphire::Event::EventHandler::SceneChainCallback Sapphire::Event::EventHandler::getSceneChainCallback() const
+Event::EventHandler::SceneChainCallback Event::EventHandler::getSceneChainCallback() const
 {
   return m_chainCallback;
 }
 
-void Sapphire::Event::EventHandler::setSceneChainCallback( Sapphire::Event::EventHandler::SceneChainCallback callback )
+void Event::EventHandler::setSceneChainCallback( Event::EventHandler::SceneChainCallback callback )
 {
   m_chainCallback = std::move( callback );
 }
 
-Sapphire::Event::EventHandler::QuestSceneChainCallback Sapphire::Event::EventHandler::getQuestSceneChainCallback() const
+Event::EventHandler::QuestSceneChainCallback Event::EventHandler::getQuestSceneChainCallback() const
 {
   return m_questChainCallback;
 }
 
-void Sapphire::Event::EventHandler::setQuestSceneChainCallback( Sapphire::Event::EventHandler::QuestSceneChainCallback callback )
+void Event::EventHandler::setQuestSceneChainCallback( Event::EventHandler::QuestSceneChainCallback callback )
 {
   m_questChainCallback = std::move( callback );
 }
 
-Sapphire::Event::EventHandler::EventFinishCallback Sapphire::Event::EventHandler::getEventFinishCallback() const
+Event::EventHandler::EventFinishCallback Event::EventHandler::getEventFinishCallback() const
 {
   return m_finishCallback;
 }
 
-void Sapphire::Event::EventHandler::setEventFinishCallback( EventFinishCallback callback )
+void Event::EventHandler::setEventFinishCallback( EventFinishCallback callback )
 {
   m_finishCallback = std::move( callback );
 }
 
-bool Sapphire::Event::EventHandler::hasPlayedScene() const
+bool Event::EventHandler::hasPlayedScene() const
 {
   return m_playedScene;
 }
 
-void Sapphire::Event::EventHandler::setPlayedScene( bool playedScene )
+void Event::EventHandler::setPlayedScene( bool playedScene )
 {
   m_playedScene = playedScene;
 }
 
-bool Sapphire::Event::EventHandler::hasNestedEvent() const
+bool Event::EventHandler::hasNestedEvent() const
 {
   return m_pNestedEvent != nullptr;
 }
 
-void Sapphire::Event::EventHandler::removeNestedEvent()
+void Event::EventHandler::removeNestedEvent()
 {
   m_pNestedEvent.reset();
 }
 
-Sapphire::Event::ScenePlayParam *Sapphire::Event::EventHandler::getScenePlayParams()
+Event::ScenePlayParam* Event::EventHandler::getScenePlayParams()
 {
   return &m_scenePlayParams;
 }
\ No newline at end of file
diff --git a/src/world/ForwardsZone.h b/src/world/ForwardsZone.h
index ce8a4d2e3..f021b52ee 100644
--- a/src/world/ForwardsZone.h
+++ b/src/world/ForwardsZone.h
@@ -30,6 +30,7 @@ TYPE_FORWARD( Land );
 TYPE_FORWARD( Linkshell );
 TYPE_FORWARD( FreeCompany );
 TYPE_FORWARD( EncounterFight );
+TYPE_FORWARD( EncounterState );
 
 namespace World
 {
@@ -46,6 +47,43 @@ TYPE_FORWARD( NaviProvider );
 namespace World::Territory::Housing
 {
 TYPE_FORWARD( HousingInteriorTerritory );
+}
+
+namespace World::AI
+{
+  TYPE_FORWARD( GambitTargetCondition );
+  TYPE_FORWARD( TopHateTargetCondition );
+  TYPE_FORWARD( HPSelfPctLessThanTargetCondition );
+
+  TYPE_FORWARD( GambitRule );
+  TYPE_FORWARD( GambitPack );
+  TYPE_FORWARD( GambitTimeLinePack );
+  TYPE_FORWARD( GambitRuleSetPack );
+}
+
+namespace World::AI::Fsm
+{
+
+  TYPE_FORWARD( Condition );
+  TYPE_FORWARD( State );
+  TYPE_FORWARD( Transition );
+  TYPE_FORWARD( StateMachine );
+
+  TYPE_FORWARD( StateIdle );
+  TYPE_FORWARD( StateRoam );
+  TYPE_FORWARD( StateCombat );
+  TYPE_FORWARD( StateRetreat );
+  TYPE_FORWARD( StateDead );
+
+  TYPE_FORWARD( RoamNextTimeReachedCondition );
+  TYPE_FORWARD( RoamTargetReachedCondition );
+  TYPE_FORWARD( HateListEmptyCondition );
+  TYPE_FORWARD( HateListHasEntriesCondition );
+  TYPE_FORWARD( SpawnPointDistanceGtMaxDistanceCondition );
+  TYPE_FORWARD( IsDeadCondition );
+
+
+
 }
 
 namespace Inventory
@@ -89,8 +127,8 @@ TYPE_FORWARD( ItemAction );
 TYPE_FORWARD( EventItemAction );
 TYPE_FORWARD( MountAction );
 TYPE_FORWARD( ItemManipulationAction );
-TYPE_FORWARD( EffectBuilder );
-TYPE_FORWARD( EffectResult );
+TYPE_FORWARD( ActionResultBuilder );
+TYPE_FORWARD( ActionResult );
 
 using ActionCallback = std::function< void( Entity::Player&, uint32_t, uint64_t ) >;
 }
diff --git a/src/world/FreeCompany/FreeCompany.cpp b/src/world/FreeCompany/FreeCompany.cpp
index 22e7fa70c..5edac548c 100644
--- a/src/world/FreeCompany/FreeCompany.cpp
+++ b/src/world/FreeCompany/FreeCompany.cpp
@@ -2,7 +2,9 @@
 
 #include <utility>
 
-Sapphire::FreeCompany::FreeCompany( uint64_t id, std::string name, std::string tag, uint64_t masterId, uint64_t chatChannelId ) :
+using namespace Sapphire;
+
+FreeCompany::FreeCompany( uint64_t id, std::string name, std::string tag, uint64_t masterId, uint64_t chatChannelId ) :
   m_id( id ),
   m_name( std::move( name ) ),
   m_tag( std::move( tag ) ),
@@ -12,211 +14,211 @@ Sapphire::FreeCompany::FreeCompany( uint64_t id, std::string name, std::string t
 
 }
 
-uint64_t Sapphire::FreeCompany::getId() const
+uint64_t FreeCompany::getId() const
 {
   return m_id;
 }
 
-const std::string& Sapphire::FreeCompany::getName() const
+const std::string& FreeCompany::getName() const
 {
   return m_name;
 }
 
-void Sapphire::FreeCompany::setName( std::string name )
+void FreeCompany::setName( std::string name )
 {
   m_name = std::move( name );
 }
 
-const std::string& Sapphire::FreeCompany::getTag() const
+const std::string& FreeCompany::getTag() const
 {
   return m_tag;
 }
 
-void Sapphire::FreeCompany::setTag( std::string tag )
+void FreeCompany::setTag( std::string tag )
 {
   m_tag = std::move( tag );
 }
 
-uint64_t Sapphire::FreeCompany::getMasterId() const
+uint64_t FreeCompany::getMasterId() const
 {
   return m_masterCharacterId;
 }
 
-void Sapphire::FreeCompany::setMasterId( uint64_t masterId )
+void FreeCompany::setMasterId( uint64_t masterId )
 {
   m_masterCharacterId = masterId;
 }
 
-uint64_t Sapphire::FreeCompany::getCredit() const
+uint64_t FreeCompany::getCredit() const
 {
   return m_credit;
 }
 
-void Sapphire::FreeCompany::setCredit( uint64_t credit )
+void FreeCompany::setCredit( uint64_t credit )
 {
   m_credit = credit;
 }
 
-uint64_t Sapphire::FreeCompany::getCreditAccumulated() const
+uint64_t FreeCompany::getCreditAccumulated() const
 {
   return m_creditAccumulated;
 }
 
-void Sapphire::FreeCompany::setCreditAccumulated( uint64_t credit )
+void FreeCompany::setCreditAccumulated( uint64_t credit )
 {
   m_creditAccumulated = credit;
 }
 
-uint8_t Sapphire::FreeCompany::getRank() const
+uint8_t FreeCompany::getRank() const
 {
   return m_rank;
 }
 
-void Sapphire::FreeCompany::setRank( uint8_t rank )
+void FreeCompany::setRank( uint8_t rank )
 {
   m_rank = rank;
 }
 
-uint64_t Sapphire::FreeCompany::getPoints() const
+uint64_t FreeCompany::getPoints() const
 {
   return m_points;
 }
 
-void Sapphire::FreeCompany::setPoints( uint64_t points )
+void FreeCompany::setPoints( uint64_t points )
 {
   m_points = points;
 }
 
-uint64_t Sapphire::FreeCompany::getCrest() const
+uint64_t FreeCompany::getCrest() const
 {
   return m_crest;
 }
 
-void Sapphire::FreeCompany::setCrest( uint64_t crest )
+void FreeCompany::setCrest( uint64_t crest )
 {
   m_crest = crest;
 }
 
-uint32_t Sapphire::FreeCompany::getCreateDate() const
+uint32_t FreeCompany::getCreateDate() const
 {
   return m_createDate;
 }
 
-void Sapphire::FreeCompany::setCreateDate( uint32_t createDate )
+void FreeCompany::setCreateDate( uint32_t createDate )
 {
   m_createDate = createDate;
 }
 
-uint8_t Sapphire::FreeCompany::getGrandCompany() const
+uint8_t FreeCompany::getGrandCompany() const
 {
   return m_gc;
 }
 
-void Sapphire::FreeCompany::setGrandCompany( uint8_t gcIndex )
+void FreeCompany::setGrandCompany( uint8_t gcIndex )
 {
   if( gcIndex > 2 )
     return;
   m_gc = gcIndex;
 }
 
-uint64_t Sapphire::FreeCompany::getGcReputation( uint8_t gcIndex ) const
+uint64_t FreeCompany::getGcReputation( uint8_t gcIndex ) const
 {
   if( gcIndex > 2 )
     return 0;
   return m_gcReputation[ gcIndex ];
 }
 
-void Sapphire::FreeCompany::setGcReputation( uint8_t gcIndex, uint64_t reputation )
+void FreeCompany::setGcReputation( uint8_t gcIndex, uint64_t reputation )
 {
   if( gcIndex > 2 )
     return;
   m_gcReputation[ gcIndex ] = reputation;
 }
 
-Sapphire::Common::FreeCompanyStatus Sapphire::FreeCompany::getFcStatus() const
+Common::FreeCompanyStatus FreeCompany::getFcStatus() const
 {
   return m_status;
 }
 
-void Sapphire::FreeCompany::setFcStatus( Sapphire::Common::FreeCompanyStatus status )
+void FreeCompany::setFcStatus( Common::FreeCompanyStatus status )
 {
   m_status = status;
 }
 
-const std::string& Sapphire::FreeCompany::getFcBoard() const
+const std::string& FreeCompany::getFcBoard() const
 {
   return m_fcBoard;
 }
 
-void Sapphire::FreeCompany::setFcBoard( const std::string& board )
+void FreeCompany::setFcBoard( const std::string& board )
 {
   m_fcBoard = board;
 }
 
-const std::string& Sapphire::FreeCompany::getFcMotto() const
+const std::string& FreeCompany::getFcMotto() const
 {
   return m_fcMotto;
 }
 
-void Sapphire::FreeCompany::setFcMotto( const std::string& motto )
+void FreeCompany::setFcMotto( const std::string& motto )
 {
   m_fcMotto = motto;
 }
 
-uint32_t Sapphire::FreeCompany::getFcVersion() const
+uint32_t FreeCompany::getFcVersion() const
 {
   return m_fcVersion;
 }
 
-void Sapphire::FreeCompany::setFcVersion( uint32_t version )
+void FreeCompany::setFcVersion( uint32_t version )
 {
   m_fcVersion = version;
 }
 
-const std::array< uint64_t, 3 >& Sapphire::FreeCompany::getActiveActionIdArr() const
+const std::array< uint64_t, 3 >& FreeCompany::getActiveActionIdArr() const
 {
   return m_activeActionId;
 }
 
-const std::array< uint64_t, 3 >& Sapphire::FreeCompany::getActiveActionTimeLeftArr() const
+const std::array< uint64_t, 3 >& FreeCompany::getActiveActionTimeLeftArr() const
 {
   return m_activeActionTimeLeft;
 }
 
-const std::array< uint64_t, 15 >& Sapphire::FreeCompany::getActionStockArr() const
+const std::array< uint64_t, 15 >& FreeCompany::getActionStockArr() const
 {
   return m_actionStock;
 }
 
-uint64_t Sapphire::FreeCompany::getChatChannel() const
+uint64_t FreeCompany::getChatChannel() const
 {
   return m_chatChannelId;
 }
 
-const std::set< uint64_t >& Sapphire::FreeCompany::getMemberIdList() const
+const std::set< uint64_t >& FreeCompany::getMemberIdList() const
 {
   return m_memberIds;
 }
 
-std::set< uint64_t >& Sapphire::FreeCompany::getMemberIdList()
+std::set< uint64_t >& FreeCompany::getMemberIdList()
 {
   return m_memberIds;
 }
 
-void Sapphire::FreeCompany::addMember( uint64_t memberId, uint8_t hierarchyId, uint32_t lastLogout )
+void FreeCompany::addMember( uint64_t memberId, uint8_t hierarchyId, uint32_t lastLogout )
 {
   FcMember member{ memberId, hierarchyId, lastLogout };
   m_memberDetails[ memberId ] = member;
   m_memberIds.insert( memberId );
 }
 
-void Sapphire::FreeCompany::removeMember( uint64_t memberId )
+void FreeCompany::removeMember( uint64_t memberId )
 {
   m_memberDetails.erase( memberId );
   m_memberIds.erase( memberId );
 }
 
-void Sapphire::FreeCompany::setChatChannel( uint64_t chatChannelId )
+void FreeCompany::setChatChannel( uint64_t chatChannelId )
 {
   m_chatChannelId = chatChannelId;
 }
diff --git a/src/world/Manager/AchievementMgr.cpp b/src/world/Manager/AchievementMgr.cpp
index 75fbe184f..2c41e1239 100644
--- a/src/world/Manager/AchievementMgr.cpp
+++ b/src/world/Manager/AchievementMgr.cpp
@@ -2,7 +2,7 @@
 #include <Util/Util.h>
 
 #include "AchievementMgr.h"
-#include <Network/Util/PlayerUtil.h>
+#include <Network/Util/PacketUtil.h>
 #include <Network/CommonActorControl.h>
 
 using namespace Sapphire;
@@ -14,12 +14,10 @@ using namespace Sapphire::World::Manager;
 bool AchievementMgr::cacheAchievements()
 {
   auto& exdData = Common::Service< Data::ExdData >::ref();
-  auto idList = exdData.getIdList< Excel::Achievement >();
+  auto achvDat = exdData.getRows< Excel::Achievement >();
 
-  for( auto id : idList )
+  for( const auto& [ id, achvExdData ] : achvDat )
   {
-    auto achvExdData = exdData.getRow< Excel::Achievement >( id );
-
     uint32_t key = achvExdData->data().ConditionType;
     auto achvType = static_cast< Common::Achievement::Type >( key );
 
@@ -69,9 +67,9 @@ void AchievementMgr::unlockAchievement( Entity::Player& player, uint32_t achieve
 
   // fire packets
   player.setAchievementData( achvData );
-  Network::Util::Player::sendAchievementList( player );
-  Network::Util::Player::sendActorControl( player, AchievementComplete, achievementId );
-  Network::Util::Player::sendActorControl( player, AchievementObtainMsg, achievementId );
+  Network::Util::Packet::sendAchievementList( player );
+  Network::Util::Packet::sendActorControl( player, player.getId(), AchievementComplete, achievementId );
+  Network::Util::Packet::sendActorControl( player, player.getId(), AchievementObtainMsg, achievementId );
 
   // check and add title to player
   auto achvTitleId = achvExd->data().Title;
diff --git a/src/world/Manager/ActionMgr.cpp b/src/world/Manager/ActionMgr.cpp
index 27605f1ac..46cb7b4d7 100644
--- a/src/world/Manager/ActionMgr.cpp
+++ b/src/world/Manager/ActionMgr.cpp
@@ -23,19 +23,20 @@ bool ActionMgr::cacheActionLut()
   return Action::ActionLutData::cacheActions();
 }
 
-void ActionMgr::handlePlacedPlayerAction( Entity::Player& player, uint32_t actionId,
-                                          Excel::ExcelStructPtr< Excel::Action > actionData, Common::FFXIVARR_POSITION3 pos,
-                                          uint16_t sequence )
+void ActionMgr::handlePlacedAction( Entity::Chara& chara, uint32_t actionId, Common::FFXIVARR_POSITION3 pos, uint16_t requestId )
 {
-  PlayerMgr::sendDebug( player, "got aoe act: {0}", actionData->getString( actionData->data().Text.Name ) );
-
-  auto action = Action::make_Action( player.getAsPlayer(), actionId, sequence, actionData );
+  auto action = Action::make_Action( chara.getAsChara(), actionId, requestId );
 
   action->setPos( pos );
 
   if( !action->init() )
     return;
 
+  auto actionData = action->getActionData();
+
+  if( chara.isPlayer() )
+    PlayerMgr::sendDebug( *chara.getAsPlayer(), "got aoe act: {0}", actionData->getString( actionData->data().Text.Name ) );
+
   if( !actionData->data().EffectRange )
   {
     // not an action that has an aoe, cancel it
@@ -43,13 +44,12 @@ void ActionMgr::handlePlacedPlayerAction( Entity::Player& player, uint32_t actio
     return;
   }
 
-  bootstrapAction( player, action, actionData );
+  bootstrapAction( chara, action, actionData );
 }
 
-void ActionMgr::handleItemManipulationAction( Entity::Player& player, uint32_t actionId,
-                                    Excel::ExcelStructPtr< Excel::Action > actionData, uint16_t sequence )
+void ActionMgr::handleItemManipulationAction( Entity::Player& player, uint32_t actionId,  uint16_t sequence )
 {
-  auto action = Action::make_ItemManipulationAction( player.getAsPlayer(), actionId, sequence, actionData, 2500 ); // todo: maybe the delay can be retrieved from data
+  auto action = Action::make_ItemManipulationAction( player.getAsPlayer(), actionId, sequence, nullptr, 2500 ); // todo: maybe the delay can be retrieved from data
 
   player.setCurrentAction( action );
 
@@ -59,26 +59,19 @@ void ActionMgr::handleItemManipulationAction( Entity::Player& player, uint32_t a
   action->start();
 }
 
-void ActionMgr::handleTargetedPlayerAction( Entity::Player& player, uint32_t actionId,
-                                            Excel::ExcelStructPtr< Excel::Action > actionData, uint64_t targetId, uint16_t requestId )
+void ActionMgr::handleTargetedAction( Entity::Chara& src, uint32_t actionId, uint64_t targetId, uint16_t requestId )
 {
-  auto action = Action::make_Action( player.getAsPlayer(), actionId, requestId, actionData );
+  auto action = Action::make_Action( src.getAsChara(), actionId, requestId );
 
   action->setTargetId( targetId );
-
-  action->setPos( player.getPos() );
+  action->setPos( src.getPos() );
 
   if( !action->init() )
     return;
 
-  // cancel any aoe actions casted with this packet
-  if( actionData->data().EffectRange )
-  {
-    action->interrupt();
-    return;
-  }
+  auto actionData = action->getActionData();
 
-  bootstrapAction( player, action, actionData );
+  bootstrapAction( src, action, actionData );
 }
 
 void ActionMgr::handleItemAction( Sapphire::Entity::Player& player, uint32_t itemId,
@@ -125,7 +118,7 @@ void ActionMgr::handleMountAction( Entity::Player& player, uint16_t mountId,
   bootstrapAction( player, action, actionData );
 }
 
-void ActionMgr::bootstrapAction( Entity::Player& player, Action::ActionPtr currentAction,
+void ActionMgr::bootstrapAction( Entity::Chara& src, Action::ActionPtr currentAction,
                                  Excel::ExcelStructPtr< Excel::Action > actionData )
 {
   /*
@@ -138,22 +131,25 @@ void ActionMgr::bootstrapAction( Entity::Player& player, Action::ActionPtr curre
   }
   */
 
-  if( player.getCurrentAction() )
+  if( src.getCurrentAction() )
   {
-    PlayerMgr::sendDebug( player, "Skill queued: {0}", currentAction->getId() );
-    player.setQueuedAction( currentAction );
+    if( src.isPlayer() )
+    {
+      auto& player = *src.getAsPlayer();
+      PlayerMgr::sendDebug( player, "Skill queued: {0}", currentAction->getId() );
+      player.setQueuedAction( currentAction );
+    }
+
   }
   else
   {
     // if we have a cast time we want to associate the action with the player so update is called
     if( currentAction->hasCastTime() )
-    {
-      player.setCurrentAction( currentAction );
-    }
+      src.setCurrentAction( currentAction );
 
     // todo: what do in cases of swiftcast/etc? script callback?
     currentAction->start();
-    player.setLastAttack( Common::Util::getTimeMs() );
+    src.setLastAttack( Common::Util::getTimeMs() );
   }
 }
 
diff --git a/src/world/Manager/ActionMgr.h b/src/world/Manager/ActionMgr.h
index acae5d610..8268c35ae 100644
--- a/src/world/Manager/ActionMgr.h
+++ b/src/world/Manager/ActionMgr.h
@@ -22,12 +22,9 @@ namespace Sapphire::World::Manager
 
     bool cacheActionLut();
 
-    void handleItemManipulationAction( Entity::Player& player, uint32_t actionId, Excel::ExcelStructPtr< Excel::Action > actionData, uint16_t sequence );
-
-    void handleTargetedPlayerAction( Entity::Player& player, uint32_t actionId,
-                                     std::shared_ptr< Excel::ExcelStruct< Excel::Action > > actionData, uint64_t targetId, uint16_t requestId );
-    void handlePlacedPlayerAction( Entity::Player& player, uint32_t actionId,
-                                   std::shared_ptr< Excel::ExcelStruct< Excel::Action > > actionData, Common::FFXIVARR_POSITION3 pos, uint16_t sequence );
+    void handleItemManipulationAction( Entity::Player& player, uint32_t actionId, uint16_t requestId );
+    void handleTargetedAction( Entity::Chara& chara, uint32_t actionId, uint64_t targetId, uint16_t requestId );
+    void handlePlacedAction( Entity::Chara& chara, uint32_t actionId, Common::FFXIVARR_POSITION3 pos, uint16_t requestId );
 
     void handleItemAction( Entity::Player& player, uint32_t itemId, std::shared_ptr< Excel::ExcelStruct< Excel::ItemAction > > itemActionData,
                            uint16_t itemSourceSlot, uint16_t itemSourceContainer );
@@ -40,7 +37,7 @@ namespace Sapphire::World::Manager
 
     bool actionHasCastTime( uint32_t actionId );
   private:
-    void bootstrapAction( Entity::Player& player, Action::ActionPtr currentAction, std::shared_ptr< Excel::ExcelStruct< Excel::Action > > actionData );
+    void bootstrapAction( Entity::Chara& src, Action::ActionPtr currentAction, std::shared_ptr< Excel::ExcelStruct< Excel::Action > > actionData );
 
     // item action handlers
     void handleItemActionVFX( Entity::Player& player, uint32_t itemId, uint16_t vfxId );
diff --git a/src/world/Manager/DebugCommandMgr.cpp b/src/world/Manager/DebugCommandMgr.cpp
index 44c7a2bcb..028ec6488 100644
--- a/src/world/Manager/DebugCommandMgr.cpp
+++ b/src/world/Manager/DebugCommandMgr.cpp
@@ -11,6 +11,7 @@
 #include <Database/DatabaseDef.h>
 #include <cmath>
 #include <Network/PacketWrappers/EffectPacket.h>
+#include <Network/Util/PacketUtil.h>
 #include <Service.h>
 
 #include "DebugCommand/DebugCommand.h"
@@ -19,6 +20,8 @@
 #include "Network/PacketWrappers/ServerNoticePacket.h"
 #include "Network/PacketWrappers/ActorControlPacket.h"
 #include "Network/PacketWrappers/ActorControlSelfPacket.h"
+#include "Network/CommonActorControl.h"
+#include "Network/PacketWrappers/MoveActorPacket.h"
 #include "Network/PacketWrappers/PlayerSetupPacket.h"
 #include "Network/PacketWrappers/PlayerSpawnPacket.h"
 #include "Network/GameConnection.h"
@@ -52,6 +55,8 @@
 
 #include "Session.h"
 
+#include "Util/UtilMath.h"
+
 
 using namespace Sapphire::Network;
 using namespace Sapphire::Network::Packets;
@@ -80,6 +85,8 @@ DebugCommandMgr::DebugCommandMgr()
   registerCommand( "cf", &DebugCommandMgr::contentFinder, "Content-Finder", 1 );
   registerCommand( "ew", &DebugCommandMgr::easyWarp, "Easy warping", 1 );
   registerCommand( "reload", &DebugCommandMgr::hotReload, "Reloads a resource", 1 );
+  registerCommand( "facing", &DebugCommandMgr::facing, "Checks if you are facing an actor", 1 );
+  registerCommand( "cbt", &DebugCommandMgr::cbt, "Create, bind and teleport to an instance", 1 );
 }
 
 // clear all loaded commands
@@ -158,6 +165,7 @@ void DebugCommandMgr::help( char* data, Entity::Player& player, std::shared_ptr<
 void DebugCommandMgr::set( char* data, Entity::Player& player, std::shared_ptr< DebugCommand > command )
 {
   auto& server = Sapphire::Common::Service< Sapphire::World::WorldServer >::ref();
+  auto& playerMgr = Common::Service< PlayerMgr >::ref();
   auto& terriMgr = Common::Service< TerritoryMgr >::ref();
   auto pCurrentZone = terriMgr.getTerritoryByGuId( player.getTerritoryId() );
 
@@ -232,7 +240,8 @@ void DebugCommandMgr::set( char* data, Entity::Player& player, std::shared_ptr<
   else if( subCommand == "discovery_reset" )
   {
     player.resetDiscovery();
-    server.queueForPlayer( player.getCharacterId(), std::make_shared< PlayerSetupPacket >( player ) );
+    player.setIsLogin( true );
+    playerMgr.onMoveZone( player );
   }
   else if( subCommand == "classjob" )
   {
@@ -243,10 +252,9 @@ void DebugCommandMgr::set( char* data, Entity::Player& player, std::shared_ptr<
     if( player.getLevelForClass( static_cast< Common::ClassJob > ( id ) ) == 0 )
     {
       player.setLevelForClass( 1, static_cast< Common::ClassJob > ( id ) );
-      player.setClassJob( static_cast< Common::ClassJob > ( id ) );
     }
-    else
-      player.setClassJob( static_cast< Common::ClassJob > ( id ) );
+
+    playerMgr.onClassJobChanged( player, static_cast< Common::ClassJob > ( id ) );
   }
   else if( subCommand == "cfpenalty" )
   {
@@ -384,6 +392,7 @@ void DebugCommandMgr::set( char* data, Entity::Player& player, std::shared_ptr<
 void DebugCommandMgr::add( char* data, Entity::Player& player, std::shared_ptr< DebugCommand > command )
 {
   auto& terriMgr = Common::Service< TerritoryMgr >::ref();
+  auto& playerMgr = Common::Service< PlayerMgr >::ref();
   auto pCurrentZone = terriMgr.getTerritoryByGuId( player.getTerritoryId() );
 
   std::string subCommand;
@@ -524,25 +533,78 @@ void DebugCommandMgr::add( char* data, Entity::Player& player, std::shared_ptr<
     sscanf( params.c_str(), "%d", &id );
     player.setRewardFlag( static_cast< Common::UnlockEntry >( id ) );
   }
+  else if( subCommand == "unlockall" )
+  {
+    player.fillRewardFlags();
+
+    player.setIsLogin( true );
+    playerMgr.onMoveZone( player );
+  }
   else if( subCommand == "effect" )
   {
     uint16_t param1;
     sscanf( params.c_str(), "%hu", &param1 );
 
-    auto effectPacket = std::make_shared< EffectPacket >( player.getId(), param1 );
+    auto effectPacket = std::make_shared< EffectPacket >( player.getId(), static_cast< uint32_t >( player.getTargetId() ), param1 );
     effectPacket->setRotation( Common::Util::floatToUInt16Rot( player.getRot() ) );
-    effectPacket->setTargetActor( static_cast< uint32_t >( player.getTargetId() ) );
 
     Common::CalcResultParam entry{};
     entry.Value = static_cast< int16_t >( param1 );
-    entry.Type = Common::ActionEffectType::CALC_RESULT_TYPE_DAMAGE_HP;
-    entry.Arg0 = static_cast< uint8_t >( Common::ActionHitSeverityType::NormalDamage );
+    entry.Type = Common::CalcResultType::TypeDamageHp;
+    entry.Arg0 = 1;
 
     effectPacket->addTargetEffect( entry, static_cast< uint64_t >( player.getId() ) );
-    effectPacket->setResultId( pCurrentZone->getNextEffectResultId() );
+    effectPacket->setResultId( pCurrentZone->getNextActionResultId() );
 
     server().queueForPlayer( player.getCharacterId(), effectPacket );
   }
+  else if( subCommand == "actorMove" )
+  {
+    uint8_t animationType{ 0 };
+    uint8_t animationState{ 0 };
+    uint8_t speed{ 20 };
+    float x{ 0 }, y{ 0 }, z{ 0 };
+
+    sscanf( params.c_str(), "%u %u %u %d %d %d", &animationType, &animationState, &speed, &x, &y, &z );
+    auto targetId = static_cast< uint32_t >( player.getTargetId() );
+    auto actorMovePacket = makeZonePacket< FFXIVIpcActorMove >( targetId, player.getId() );
+
+    Entity::GameObjectPtr pTarget = nullptr;
+    auto inRange = player.getInRangeActors();
+    for( auto& pChara : inRange )
+    {
+      if( pChara->getId() == targetId )
+      {
+        pTarget = pChara;
+        break;
+      }
+    }
+
+    if( pTarget )
+    {
+      actorMovePacket->data().dir = Common::Util::floatToUInt8Rot( pTarget->getRot() );
+      actorMovePacket->data().dirBeforeSlip = Common::Util::floatToUInt8Rot( pTarget->getRot() );
+      actorMovePacket->data().flag = animationType;
+      actorMovePacket->data().flag2 = animationState;
+      actorMovePacket->data().speed = speed;
+      actorMovePacket->data().pos[ 0 ] = Common::Util::floatToUInt16( x );
+      actorMovePacket->data().pos[ 1 ] = Common::Util::floatToUInt16( y );
+      actorMovePacket->data().pos[ 2 ] = Common::Util::floatToUInt16( z );
+
+      server().queueForPlayer( player.getCharacterId(), actorMovePacket );
+    }
+  }
+  else if( subCommand == "knockback" )
+  {
+    float distance{ 0.f };
+    sscanf( params.c_str(), "%f", &distance );
+
+    for( auto& pActor : player.getInRangeActors() )
+    {
+      if( auto pBNpc = pActor->getAsBNpc(); pBNpc && Common::Util::distance( pBNpc->getPos(), player.getPos() ) <= distance )
+        pBNpc->knockback( player.getPos(), distance );
+    }
+  }
   else if( subCommand == "achvGeneral" )
   {
     uint32_t achvSubtype;
@@ -698,6 +760,11 @@ void DebugCommandMgr::nudge( char* data, Entity::Player& player, std::shared_ptr
     PlayerMgr::sendServerNotice( player, "nudge: Placing down {0} yalms", offset );
 
   }
+  else if( direction[ 0 ] == 'r' )
+  {
+    pos = Common::Util::getOffsettedPosition( pos, player.getRot(), offset, 0, 0 );
+    PlayerMgr::sendServerNotice( player, "nudge: Placing right {0} yalms", offset );
+  }
   else
   {
     float angle = player.getRot() + ( PI / 2 );
@@ -811,6 +878,7 @@ void DebugCommandMgr::script( char* data, Entity::Player& player, std::shared_pt
 
 void DebugCommandMgr::instance( char* data, Entity::Player& player, std::shared_ptr< DebugCommand > command )
 {
+  auto& server = Common::Service< World::WorldServer >::ref();
   auto& terriMgr = Common::Service< TerritoryMgr >::ref();
   auto pCurrentZone = terriMgr.getTerritoryByGuId( player.getTerritoryId() );
 
@@ -912,7 +980,7 @@ void DebugCommandMgr::instance( char* data, Entity::Player& player, std::shared_
   }
   else if( subCommand == "return" || subCommand == "ret" )
   {
-    player.exitInstance();
+    playerMgr().onExitInstance( player );
   }
   else if( subCommand == "stringendomode" || subCommand == "sm" )
   {
@@ -1071,6 +1139,14 @@ void DebugCommandMgr::instance( char* data, Entity::Player& player, std::shared_
     if( auto instance = pCurrentZone->getAsInstanceContent() )
       instance->setCurrentBGM( bgmId );
   }
+  else if( subCommand == "dir_update" ) {
+    uint32_t dirType;
+    uint32_t param;
+    sscanf( params.c_str(), "%x %d", &dirType, &param );
+    if( auto instance = pCurrentZone->getAsInstanceContent() )
+      server.queueForPlayer( player.getCharacterId(), makeActorControlSelf( player.getId(), Network::ActorControl::DirectorUpdate, instance->getDirectorId(),
+                                                 dirType, param ) );
+  }
   else
   {
     PlayerMgr::sendDebug( player, "Unknown sub command." );
@@ -1154,7 +1230,7 @@ void DebugCommandMgr::questBattle( char* data, Entity::Player& player, std::shar
   }
   else if( subCommand == "return" || subCommand == "ret" )
   {
-    player.exitInstance();
+    playerMgr().onExitInstance( player );
   }
   else if( subCommand == "set" )
   {
@@ -1398,6 +1474,58 @@ void DebugCommandMgr::contentFinder( char *data, Sapphire::Entity::Player &playe
 
 }
 
+void DebugCommandMgr::cbt( char* data, Sapphire::Entity::Player& player, std::shared_ptr< DebugCommand > command )
+{
+  std::string subCommand;
+  std::string params = "";
+
+  // check if the command has parameters
+  std::string tmpCommand = std::string( data + command->getName().length() + 1 );
+
+  std::size_t pos = tmpCommand.find_first_of( ' ' );
+
+  if( pos != std::string::npos )
+    // command has parameters, grab the first part
+    subCommand = tmpCommand.substr( 0, pos );
+  else
+    // no subcommand given
+    subCommand = tmpCommand;
+
+  if( command->getName().length() + 1 + pos + 1 < strlen( data ) )
+    params = std::string( data + command->getName().length() + 1 + pos + 1 );
+
+  auto& terriMgr = Common::Service< TerritoryMgr >::ref();
+  auto& warpMgr = Common::Service< WarpMgr >::ref();
+
+  uint32_t contentFinderConditionId;
+  sscanf( params.c_str(), "%d", &contentFinderConditionId );
+
+  auto instance = terriMgr.createInstanceContent( contentFinderConditionId );
+  if( instance )
+    PlayerMgr::sendDebug( player, "Created instance with id#{0} -> {1}", instance->getGuId(), instance->getName() );
+  else
+    return PlayerMgr::sendDebug( player, "Failed to create instance with id#{0}", contentFinderConditionId );
+
+
+  auto terri = terriMgr.getTerritoryByGuId( instance->getGuId() );
+  if( terri )
+  {
+    auto pInstanceContent = terri->getAsInstanceContent();
+    if( !pInstanceContent )
+    {
+      PlayerMgr::sendDebug( player, "Instance id#{} is not an InstanceContent territory.", pInstanceContent->getGuId() );
+      return;
+    }
+
+    pInstanceContent->bindPlayer( player.getId() );
+    PlayerMgr::sendDebug( player,
+      "Now bound to instance with id: " + std::to_string( pInstanceContent->getGuId() ) +
+      " -> " + pInstanceContent->getName() );
+
+    warpMgr.requestMoveTerritory( player, Common::WarpType::WARP_TYPE_INSTANCE_CONTENT, instance->getGuId(), { 0.f, 0.f, 0.f }, 0.f );
+  }
+}
+
 void DebugCommandMgr::easyWarp( char* data, Sapphire::Entity::Player& player, std::shared_ptr< DebugCommand > command )
 {
   std::string subCommand;
@@ -1482,4 +1610,43 @@ void DebugCommandMgr::hotReload( char* data, Sapphire::Entity::Player& player, s
   {
     PlayerMgr::sendDebug( player, "Unknown sub command." );
   }
+}
+
+void DebugCommandMgr::facing( char* data, Sapphire::Entity::Player& player, std::shared_ptr< DebugCommand > command )
+{
+  std::string subCommand;
+  std::string params = "";
+
+  // check if the command has parameters
+  std::string tmpCommand = std::string( data + command->getName().length() + 1 );
+
+  std::size_t pos = tmpCommand.find_first_of( ' ' );
+
+  if( pos != std::string::npos )
+    // command has parameters, grab the first part
+    subCommand = tmpCommand.substr( 0, pos );
+  else
+    // no subcommand given
+    subCommand = tmpCommand;
+
+  if( command->getName().length() + 1 + pos + 1 < strlen( data ) )
+    params = std::string( data + command->getName().length() + 1 + pos + 1 );
+
+  Logger::debug( "[{0}] subCommand: {1} params: {2}", player.getId(), subCommand, params );
+
+  float threshold = 0.95f;
+  sscanf( params.c_str(), "%f", &threshold );
+
+  if( player.getTargetId() != 0 )
+  {
+    auto target = player.lookupTargetById( player.getTargetId() );
+
+    if( !target )
+      return;
+
+    if( auto bnpc = target->getAsBNpc() )
+    {
+      PlayerMgr::sendDebug( player, "Player facing target {0}: {1}", bnpc->getLayoutId(), player.isFacingTarget( *bnpc->getAsChara(), threshold ) );
+    }
+  }
 }
\ No newline at end of file
diff --git a/src/world/Manager/DebugCommandMgr.h b/src/world/Manager/DebugCommandMgr.h
index 084b99b69..d25471b1a 100644
--- a/src/world/Manager/DebugCommandMgr.h
+++ b/src/world/Manager/DebugCommandMgr.h
@@ -61,10 +61,14 @@ namespace Sapphire::World::Manager
 
     void contentFinder( char* data, Entity::Player& player, std::shared_ptr< DebugCommand > command );
 
+    void cbt( char* data, Entity::Player& player, std::shared_ptr< DebugCommand > command );
+
     void easyWarp( char* data, Entity::Player& player, std::shared_ptr< DebugCommand > command );
 
     void hotReload( char* data, Sapphire::Entity::Player& player, std::shared_ptr< DebugCommand > command );
 
+    void facing( char* data, Sapphire::Entity::Player& player, std::shared_ptr< DebugCommand > command );
+
   };
 
 }
\ No newline at end of file
diff --git a/src/world/Manager/EventMgr.cpp b/src/world/Manager/EventMgr.cpp
index e2b87ef4e..51861d855 100644
--- a/src/world/Manager/EventMgr.cpp
+++ b/src/world/Manager/EventMgr.cpp
@@ -552,6 +552,9 @@ void EventMgr::eventFinish( Sapphire::Entity::Player& player, uint32_t eventId,
 
   if( player.hasCondition( Common::PlayerCondition::WatchingCutscene ) )
     player.removeCondition( Common::PlayerCondition::WatchingCutscene );
+  
+  if( player.hasCondition( Common::PlayerCondition::Casting ))
+    player.removeCondition( Common::PlayerCondition::Casting );
 
   player.removeEvent( pEvent->getId() );
 
diff --git a/src/world/Manager/HousingMgr.cpp b/src/world/Manager/HousingMgr.cpp
index bcc9a008b..fdb702969 100644
--- a/src/world/Manager/HousingMgr.cpp
+++ b/src/world/Manager/HousingMgr.cpp
@@ -8,6 +8,7 @@
 #include <Network/PacketWrappers/ActorControlSelfPacket.h>
 #include <Network/CommonActorControl.h>
 #include <Network/GameConnection.h>
+#include <Network/Util/PacketUtil.h>
 
 #include <unordered_map>
 #include <cstring>
@@ -288,7 +289,6 @@ uint32_t HousingMgr::toLandSetId( int16_t territoryTypeId, int16_t wardId ) cons
   return ( static_cast< uint32_t >( territoryTypeId ) << 16 ) | wardId;
 }
 
-
 LandPtr HousingMgr::getLandByOwnerId( uint64_t id )
 {
 
@@ -404,7 +404,7 @@ LandPurchaseResult HousingMgr::purchaseLand( Entity::Player& player, HousingZone
       pLand->setStatus( Common::HouseStatus::Sold );
       pLand->setLandType( Common::LandType::Private );
 
-      player.setLandFlags( Common::LandFlagsSlot::Private, 0x00, pLand->getLandIdent() );
+      player.setLandFlags( Common::LandFlagsSlot::Private, 0, pLand->getLandIdent() );
 
       sendLandFlagsSlot( player, Common::LandFlagsSlot::Private );
 
@@ -432,10 +432,9 @@ bool HousingMgr::relinquishLand( Entity::Player& player, HousingZone& zone, uint
 
   // can't relinquish when you are not the owner
   // TODO: actually use permissions here for FC houses
-  if( !hasPermission( player, *pLand, 0 ) )
+  if( !pLand || !hasPermission( player, *pLand, 0 ) )
   {
-    auto msgPkt = makeActorControlSelf( player.getId(), ActorControl::LogMsg, 3304, 0 );
-    server.queueForPlayer( player.getCharacterId(), msgPkt );
+    Network::Util::Packet::sendActorControlSelf( player, player.getId(), ActorControl::LogMsg, 3304 );
     return false;
   }
 
@@ -443,8 +442,7 @@ bool HousingMgr::relinquishLand( Entity::Player& player, HousingZone& zone, uint
   // TODO: additionally check for yard items
   if( pLand->getHouse() )
   {
-    auto msgPkt = makeActorControlSelf( player.getId(), ActorControl::LogMsg, 3315, 0 );
-    server.queueForPlayer( player.getCharacterId(), msgPkt );
+    Network::Util::Packet::sendActorControlSelf( player, player.getId(), ActorControl::LogMsg, 3315 );
     return false;
   }
 
@@ -456,15 +454,12 @@ bool HousingMgr::relinquishLand( Entity::Player& player, HousingZone& zone, uint
 
   Common::LandIdent ident { 0xFF, 0xFF, 0xFF, 0xFF };
 
-  player.setLandFlags( Common::LandFlagsSlot::Private, 0x00, ident );
+  player.setLandFlags( Common::LandFlagsSlot::Private, 0, ident );
 
   sendLandFlagsSlot( player, Common::LandFlagsSlot::Private );
 
-  auto screenMsgPkt2 = makeActorControlSelf( player.getId(), ActorControl::LogMsg, 3351, 0x1AA,
-                                             pLand->getLandIdent().wardNum + 1, plot + 1 );
-  server.queueForPlayer( player.getCharacterId(), screenMsgPkt2 );
+  Network::Util::Packet::sendActorControlSelf( player, player.getId(), ActorControl::LogMsg, 3351, 0x1AA, pLand->getLandIdent().wardNum + 1, plot + 1 );
   zone.sendLandUpdate( plot );
-
   return true;
 }
 
@@ -680,10 +675,7 @@ void HousingMgr::buildPresetEstate( Entity::Player& player, HousingZone& zone, u
   auto& server = Common::Service< World::WorldServer >::ref();
 
   auto pLand = zone.getLand( plotNum );
-  if( !pLand )
-    return;
-
-  if( !hasPermission( player, *pLand, 0 ) )
+  if( !pLand || !hasPermission( player, *pLand, 0 ) )
     return;
 
   // create house
@@ -708,9 +700,7 @@ void HousingMgr::buildPresetEstate( Entity::Player& player, HousingZone& zone, u
   pLand->setLandType( Common::LandType::Private );
   zone.sendLandUpdate( plotNum );
 
-  auto pSuccessBuildingPacket = makeActorControl( player.getId(), ActorControl::BuildPresetResponse, plotNum );
-
-  server.queueForPlayer( player.getCharacterId(), pSuccessBuildingPacket );
+  Network::Util::Packet::sendActorControl( player, player.getId(), ActorControl::BuildPresetResponse, plotNum );
 
   pLand->updateLandDb();
 
@@ -790,10 +780,7 @@ void HousingMgr::updateEstateGreeting( Entity::Player& player, const Common::Lan
     return;
 
   auto land = hZone->getLand( static_cast< uint8_t >( ident.landId ) );
-  if( !land )
-    return;
-
-  if( !hasPermission( player, *land, 0 ) )
+  if( !land || !hasPermission( player, *land, 0 ) )
     return;
 
   auto house = land->getHouse();
@@ -819,10 +806,7 @@ void HousingMgr::requestEstateEditGuestAccess( Entity::Player& player, const Com
     return;
 
   auto land = hZone->getLand( ident.landId );
-  if( !land )
-    return;
-
-  if( !hasPermission( player, *land, 0 ) )
+  if( !land || !hasPermission( player, *land, 0 ) )
     return;
 
   auto packet = makeZonePacket< FFXIVIpcHousingWelcome >( player.getId() );
@@ -886,10 +870,7 @@ void HousingMgr::sendEstateInventory( Entity::Player& player, uint16_t inventory
     targetLand = zone->getLand( plotNum );
   }
 
-  if( !targetLand )
-    return;
-
-  if( !hasPermission( player, *targetLand, 0 ) )
+  if( !targetLand || !hasPermission( player, *targetLand, 0 ) )
     return;
 
   auto& containers = getEstateInventory( targetLand->getLandIdent() );
@@ -1024,10 +1005,7 @@ void HousingMgr::reqPlaceHousingItem( Entity::Player& player, uint16_t landId, u
   else
     return;
 
-  if( !land )
-    return;
-
-  if( !hasPermission( player, *land, 0 ) )
+  if( !land || !hasPermission( player, *land, 0 ) )
     return;
 
   // todo: check item position and make sure it's not outside the plot
@@ -1065,7 +1043,7 @@ void HousingMgr::reqPlaceHousingItem( Entity::Player& player, uint16_t landId, u
     status = placeInteriorItem( player, item );
 
   if( status )
-    server.queueForPlayer( player.getCharacterId(), makeActorControlSelf( player.getId(), 0x3f3 ) );
+    Network::Util::Packet::sendActorControlSelf( player, player.getId(), 0x3f3 );
   else
     PlayerMgr::sendUrgent( player, "An internal error occurred when placing the item." );
 }
@@ -1281,10 +1259,7 @@ void HousingMgr::reqMoveHousingItem( Entity::Player& player, Common::LandIdent i
   auto hZone = std::dynamic_pointer_cast< HousingZone >( pTeri );
   auto land = hZone->getLand( static_cast< uint8_t >( ident.landId ) );
 
-  if( !land )
-    return;
-
-  if( !hasPermission( player, *land, 0 ) )
+  if( !land || !hasPermission( player, *land, 0 ) )
     return;
 
   auto pZone = teriMgr.getTerritoryByGuId( player.getTerritoryId() );
@@ -1343,7 +1318,7 @@ bool HousingMgr::moveInternalItem( Entity::Player& player, Common::LandIdent ide
   // send confirmation to player
   uint32_t param1 = static_cast< uint32_t >( ( ident.landId << 16 ) | containerId );
 
-  server.queueForPlayer( player.getCharacterId(), makeActorControlSelf( player.getId(), ActorControl::HousingItemMoveConfirm, param1, slotIdx ) );
+  Network::Util::Packet::sendActorControlSelf( player, player.getId(), ActorControl::HousingItemMoveConfirm, param1, slotIdx );
 
   return true;
 }
@@ -1353,8 +1328,7 @@ bool HousingMgr::moveExternalItem( Entity::Player& player, Common::LandIdent ide
   auto& server = Common::Service< World::WorldServer >::ref();
 
   auto land = terri.getLand( static_cast< uint8_t >( ident.landId ) );
-
-  if( !hasPermission( player, *land, 0 ) )
+  if( !land || !hasPermission( player, *land, 0 ) )
     return false;
 
   auto& containers = getEstateInventory( ident );
@@ -1377,7 +1351,7 @@ bool HousingMgr::moveExternalItem( Entity::Player& player, Common::LandIdent ide
   terri.updateYardObjectPos( player, slot, static_cast< uint16_t >( ident.landId ), *item );
 
   uint32_t param1 = static_cast< uint32_t >( ( ident.landId << 16 ) | Common::InventoryType::HousingExteriorPlacedItems );
-  server.queueForPlayer( player.getCharacterId(), makeActorControlSelf( player.getId(), ActorControl::HousingItemMoveConfirm, param1, slot ) );
+  Network::Util::Packet::sendActorControlSelf( player, player.getId(), ActorControl::HousingItemMoveConfirm, param1, slot );
 
   return true;
 }
@@ -1396,11 +1370,7 @@ void HousingMgr::reqRemoveHousingItem( Entity::Player& player, uint16_t plot, ui
     auto hZone = std::dynamic_pointer_cast< HousingZone >( pTeri );
 
     auto land = hZone->getLand( static_cast< uint8_t >( ident.landId ) );
-
-    if( !land )
-      return;
-
-    if( !hasPermission( player, *land, 0 ) )
+    if( !land || !hasPermission( player, *land, 0 ) )
       return;
 
     removeInternalItem( player, *terri, containerId, slot, sendToStoreroom );
@@ -1408,10 +1378,7 @@ void HousingMgr::reqRemoveHousingItem( Entity::Player& player, uint16_t plot, ui
   else if( auto terri = std::dynamic_pointer_cast< HousingZone >( pZone ) )
   {
     auto land = terri->getLand( static_cast< uint8_t >( plot ) );
-    if( !land )
-      return;
-
-    if( !hasPermission( player, *land, 0 ) )
+    if( !land || !hasPermission( player, *land, 0 ) )
       return;
 
     auto containerType = static_cast< Common::InventoryType >( containerId );
@@ -1614,9 +1581,7 @@ void HousingMgr::reqEstateExteriorRemodel( Entity::Player& player, uint16_t plot
 
   invMgr.sendInventoryContainer( player, it->second );
 
-  auto pkt = makeActorControlSelf( player.getId(), Network::ActorControl::ShowEstateExternalAppearanceUI, plot );
-  server.queueForPlayer( player.getCharacterId(), pkt );
-
+  Network::Util::Packet::sendActorControlSelf( player, player.getId(), ActorControl::ShowEstateExternalAppearanceUI, plot );
 }
 
 void HousingMgr::reqEstateInteriorRemodel( Entity::Player& player )
@@ -1653,8 +1618,7 @@ void HousingMgr::reqEstateInteriorRemodel( Entity::Player& player )
 
   invMgr.sendInventoryContainer( player, it->second );
 
-  auto pkt = makeActorControlSelf( player.getId(), Network::ActorControl::ShowEstateInternalAppearanceUI );
-  server.queueForPlayer( player.getCharacterId(), pkt );
+  Network::Util::Packet::sendActorControlSelf( player, player.getId(), ActorControl::ShowEstateInternalAppearanceUI );
 }
 
 bool HousingMgr::hasPermission( Entity::Player& player, Sapphire::Land& land, uint32_t permission )
@@ -1697,8 +1661,7 @@ void HousingMgr::removeHouse( Entity::Player& player, uint16_t plot )
   // TODO: actually use permissions here for FC houses
   if( !hasPermission( player, *pLand, 0 ) )
   {
-    auto msgPkt = makeActorControlSelf( player.getId(), ActorControl::LogMsg, 3305, 0 );
-    server.queueForPlayer( player.getCharacterId(), msgPkt );
+    Network::Util::Packet::sendActorControlSelf( player, player.getId(), ActorControl::LogMsg, 3305 );
     return;
   }
 
diff --git a/src/world/Manager/MapMgr.cpp b/src/world/Manager/MapMgr.cpp
index 2824f4aed..fb6603154 100644
--- a/src/world/Manager/MapMgr.cpp
+++ b/src/world/Manager/MapMgr.cpp
@@ -35,13 +35,24 @@ using namespace Sapphire::World::Manager;
 bool MapMgr::loadQuests()
 {
   auto& exdData = Common::Service< Data::ExdData >::ref();
-  auto idList = exdData.getIdList< Excel::Quest >();
 
-  for( auto id : idList )
+  auto questList = exdData.getRows< Excel::Quest >();
+  auto eNpcList = exdData.getRows< Excel::ENpcBase >();
+  auto eObjList = exdData.getRows< Excel::EObj >();
+
+  for( auto& [ id, questExdData ] : questList )
   {
-    auto questExdData = exdData.getRow< Excel::Quest >( id );
+    m_questCacheMap.emplace( id, std::move( questExdData ) );
+  }
 
-    m_quests.emplace( id, std::move( questExdData ) );
+  for( auto& [ id, eNpcExdData ] : eNpcList )
+  {
+    m_eNpcCacheMap.emplace( id, std::move( eNpcExdData ) );
+  }
+
+  for( auto& [ id, eObjExdData ] : eObjList )
+  {
+    m_eObjCacheMap.emplace( id, std::move( eObjExdData ) );
   }
 
   return true;
@@ -60,12 +71,12 @@ void MapMgr::updateAll( Entity::Player& player )
   
   for( const auto& eventNpc : *eventNpcs )
   {
-    auto eNpc = exdData.getRow< Excel::ENpcBase >( eventNpc.second->data.enpcId );
-    if( !eNpc )
+    auto eNpcIt = m_eNpcCacheMap.find( eventNpc.second->data.enpcId );
+    if( eNpcIt == std::end( m_eNpcCacheMap ) )
       continue;
 
-    auto eNpcData = eNpc->data().EventHandler;
-    for( int npcEvent = 0; npcEvent < 32; npcEvent++ )
+    auto eNpcData = eNpcIt->second->data().EventHandler;
+    for( auto npcEvent = 0; npcEvent < 32; ++npcEvent )
     {
       auto npcData = eNpcData[ npcEvent ].EventHandler;
 
@@ -82,7 +93,7 @@ void MapMgr::updateAll( Entity::Player& player )
       {
         case EventHandler::EventHandlerType::Quest:
         {
-          auto& quest = m_quests[ npcData ]->data();
+          auto& quest = m_questCacheMap[ npcData ]->data();
 
           if( quest.Client == eventNpc.second->data.enpcId )
           {
@@ -104,7 +115,7 @@ void MapMgr::updateAll( Entity::Player& player )
             {
               if( guildLeve.NeedGrandCompanyRank > 0 && player.getGc() != 0 )
               {
-                for( int8_t i = 0; i < 3; i++ )
+                for( int8_t i = 0; i < 3; ++i )
                 {
                   if( player.getGcRankArray()[ i ] >= guildLeve.NeedGrandCompanyRank )
                   {
@@ -164,11 +175,11 @@ void MapMgr::updateAll( Entity::Player& player )
 
   for( const auto& eventObj : *eventObjs )
   {
-    auto eObj = exdData.getRow< Excel::EObj >( eventObj.second->data.BaseId );
-    if( !eObj )
-      return;
+    auto eObjIt = m_eObjCacheMap.find( eventObj.second->data.BaseId );
+    if( eObjIt == std::end( m_eObjCacheMap ) )
+      continue;
 
-    auto eObjData = eObj->data();
+    auto eObjData = eObjIt->second->data();
     EventData eventData;
     eventData.handlerId = eObjData.EventHandler;
     eventData.layoutId = eventObj.first;
@@ -177,7 +188,7 @@ void MapMgr::updateAll( Entity::Player& player )
 
     if( eventHandlerType == EventHandler::EventHandlerType::Quest )
     {
-      auto& quest = m_quests[ eObjData.EventHandler ]->data();
+      auto& quest = m_questCacheMap[ eObjData.EventHandler ]->data();
 
       if( quest.Client == eventObj.second->data.BaseId )
       {
@@ -202,13 +213,13 @@ void MapMgr::updateQuests( Entity::Player& player )
 
   for( const auto& eventNpc : *eventNpcs )
   {
-    auto eNpc = exdData.getRow< Excel::ENpcBase >( eventNpc.second->data.enpcId );
-    if( !eNpc )
+    auto eNpcIt = m_eNpcCacheMap.find( eventNpc.second->data.enpcId );
+    if( eNpcIt == std::end( m_eNpcCacheMap ) )
       continue;
 
-    auto eNpcData = eNpc->data().EventHandler;
+    auto eNpcData = eNpcIt->second->data().EventHandler;
 
-    for( int npcEvent = 0; npcEvent < 32; npcEvent++ )
+    for( auto npcEvent = 0; npcEvent < 32; ++npcEvent )
     {
       auto npcData = eNpcData[ npcEvent ].EventHandler;
 
@@ -223,7 +234,7 @@ void MapMgr::updateQuests( Entity::Player& player )
 
       if( eventHandlerType == EventHandler::EventHandlerType::Quest )
       {
-        auto& quest = m_quests[ npcData ]->data();
+        auto& quest = m_questCacheMap[ npcData ]->data();
 
         if( quest.Client == eventNpc.second->data.enpcId )
         {
@@ -239,11 +250,11 @@ void MapMgr::updateQuests( Entity::Player& player )
 
   for( const auto& eventObj : *eventObjs )
   {
-    auto eObj = exdData.getRow< Excel::EObj >( eventObj.second->data.BaseId );
-    if( !eObj )
-      return;
+    auto eObjIt = m_eObjCacheMap.find( eventObj.second->data.BaseId );
+    if( eObjIt == std::end( m_eObjCacheMap ) )
+      continue;
 
-    auto eObjData = eObj->data();
+    auto eObjData = eObjIt->second->data();
     EventData eventData;
     eventData.handlerId = eObjData.EventHandler;
     eventData.layoutId = eventObj.first;
@@ -252,7 +263,7 @@ void MapMgr::updateQuests( Entity::Player& player )
 
     if( eventHandlerType == EventHandler::EventHandlerType::Quest )
     {
-      auto& quest = m_quests[ eObjData.EventHandler ]->data();
+      auto& quest = m_questCacheMap[ eObjData.EventHandler ]->data();
 
       if( quest.Client == eventObj.second->data.BaseId )
       {
@@ -269,7 +280,7 @@ void MapMgr::insertQuest( Entity::Player& player, uint32_t questId, uint32_t lay
   auto& exdData = Common::Service< Data::ExdData >::ref();
   auto& scriptMgr = Common::Service< Scripting::ScriptMgr >::ref();
 
-  auto& quest = m_quests[ questId ]->data();
+  auto& quest = m_questCacheMap[ questId ]->data();
 
   if( isQuestVisible( player, questId, quest ) )
   {
@@ -309,7 +320,7 @@ bool MapMgr::isQuestAvailable( Entity::Player& player, uint32_t questId, Excel::
 
   if( quest.InstanceContentOperator == 1 )
   {
-    for( int32_t i = 0; i < 3; i++ )
+    for( int32_t i = 0; i < 3; ++i )
     {
       if( quest.InstanceContent[ i ] == 0 )
         continue;
@@ -321,7 +332,7 @@ bool MapMgr::isQuestAvailable( Entity::Player& player, uint32_t questId, Excel::
   }
   else if( quest.InstanceContentOperator == 2 )
   {
-    for( int32_t i = 0; i < 3; i++ )
+    for( int32_t i = 0; i < 3; ++i )
     {
       if( quest.InstanceContent[ i ] == 0 )
         continue;
@@ -398,7 +409,7 @@ bool MapMgr::isQuestVisible( Entity::Player& player, uint32_t questId, Excel::Qu
 
   if( quest.PrevQuestOperator == 1 )
   {
-    for( int32_t i = 0; i < 3; i++ )
+    for( auto i = 0; i < 3; ++i )
     {
       if( quest.PrevQuest[ i ] == 0 )
         continue;
@@ -421,7 +432,7 @@ bool MapMgr::isQuestVisible( Entity::Player& player, uint32_t questId, Excel::Qu
   }
   else if( quest.PrevQuestOperator == 2 )
   {
-    for( int32_t i = 0; i < 3; i++ )
+    for( auto i = 0; i < 3; ++i )
     {
       if( quest.PrevQuest[ i ] == 0 )
         continue;
@@ -436,7 +447,7 @@ bool MapMgr::isQuestVisible( Entity::Player& player, uint32_t questId, Excel::Qu
 
   if( quest.ExcludeQuestOperator == 1 )
   {
-    for( int32_t i = 0; i < 2; i++ )
+    for( auto i = 0; i < 2; ++i )
     {
       if( quest.ExcludeQuest[ i ] == 0 )
         continue;
@@ -450,7 +461,7 @@ bool MapMgr::isQuestVisible( Entity::Player& player, uint32_t questId, Excel::Qu
   }
   else if( quest.ExcludeQuestOperator == 2 )
   {
-    for( int32_t i = 0; i < 2; i++ )
+    for( auto i = 0; i < 2; ++i )
     {
       if( quest.ExcludeQuest[ i ] == 0 )
         continue;
@@ -477,7 +488,7 @@ bool MapMgr::isQuestVisible( Entity::Player& player, uint32_t questId, Excel::Qu
   {
     auto classJobCategory = exdData.getRow< Excel::ClassJobCategory >( quest.ClassJob )->data().ClassJob;
 
-    for( int32_t i = 1; i <= Common::CLASSJOB_TOTAL; i++ )
+    for( auto i = 1; i <= Common::CLASSJOB_TOTAL; ++i )
     {
       if( i == Common::CLASSJOB_TOTAL )
         return false;
@@ -496,13 +507,14 @@ bool MapMgr::isQuestVisible( Entity::Player& player, uint32_t questId, Excel::Qu
   }
 
   // TODO: I think this changed in 3.x to be for all relics, more research is needed.
-  for( int32_t i = 0; i < Common::CLASSJOB_TOTAL; i++ )
+  // todo: fix this inner j loop
+  for( auto i = 0; i < Common::CLASSJOB_TOTAL; ++i )
   {
     auto classJob = exdData.getRow< Excel::ClassJob >( i );
 
     if( classJob->data().ARRRelicQuestId == questId )
     {
-      for( int32_t j = 0; i < Common::CLASSJOB_TOTAL; i++ )
+      for( auto j = 0; i < Common::CLASSJOB_TOTAL; ++i )
       {
         classJob = exdData.getRow< Excel::ClassJob >( i );
 
diff --git a/src/world/Manager/MapMgr.h b/src/world/Manager/MapMgr.h
index 6981ecf03..c23500e4a 100644
--- a/src/world/Manager/MapMgr.h
+++ b/src/world/Manager/MapMgr.h
@@ -11,6 +11,8 @@
 namespace Sapphire::World::Manager
 {
   using QuestMap = std::unordered_map< uint32_t, std::shared_ptr< Excel::ExcelStruct< Excel::Quest > > >;
+  using EObjDataCache = std::unordered_map< uint32_t, std::shared_ptr< Excel::ExcelStruct< Excel::EObj > > >;
+  using ENpcDataCache = std::unordered_map< uint32_t, std::shared_ptr< Excel::ExcelStruct< Excel::ENpcBase > > >;
 
   class MapMgr
   {
@@ -64,8 +66,11 @@ namespace Sapphire::World::Manager
     };
 
     using EventSet = std::multiset< EventData, less >;
+    
 
-    QuestMap m_quests;
+    QuestMap m_questCacheMap;
+    ENpcDataCache m_eNpcCacheMap;
+    EObjDataCache m_eObjCacheMap;
 
     void insertQuest( Entity::Player& player, uint32_t questId, uint32_t layoutId, EventSet& mapData );
 
diff --git a/src/world/Manager/PartyMgr.cpp b/src/world/Manager/PartyMgr.cpp
index a110db2b2..657be52e2 100644
--- a/src/world/Manager/PartyMgr.cpp
+++ b/src/world/Manager/PartyMgr.cpp
@@ -200,7 +200,7 @@ void PartyMgr::onMemberDisconnect( Entity::Player& disconnectingPlayer )
   {
     // TODO: 2nd argument here makes it automatically send passing leadership message
     server.queueForPlayer( member->getCharacterId(), { makePcPartyUpdate( disconnectingPlayer, UpdateStatus::OFFLINE_MEMBER, party->PartyCount ),
-                                                          makeZonePacket< FFXIVIpcUpdateParty >( member->getId() ) } );
+                                                       makeZonePacket< FFXIVIpcUpdateParty >( member->getId() ) } );
   }
 
   sendPartyUpdate( *party );
diff --git a/src/world/Manager/PlayerMgr.cpp b/src/world/Manager/PlayerMgr.cpp
index 48e64eaa9..44e50de90 100644
--- a/src/world/Manager/PlayerMgr.cpp
+++ b/src/world/Manager/PlayerMgr.cpp
@@ -3,14 +3,15 @@
 #include <Service.h>
 
 #include <Exd/ExdData.h>
-
+#include <Util/Util.h>
 #include <Territory/Land.h>
 
-#include <Manager/TerritoryMgr.h>
 #include <Manager/AchievementMgr.h>
-#include <Manager/PartyMgr.h>
+#include <Manager/TerritoryMgr.h>
 #include <Manager/HousingMgr.h>
 #include <Manager/QuestMgr.h>
+#include <Manager/WarpMgr.h>
+#include <Manager/MapMgr.h>
 
 #include <Script/ScriptMgr.h>
 #include <Common.h>
@@ -18,18 +19,8 @@
 #include <Database/ZoneDbConnection.h>
 #include <Database/DbWorkerPool.h>
 
-#include <Network/GameConnection.h>
 #include <Network/CommonActorControl.h>
-#include <Network/PacketDef/Zone/ServerZoneDef.h>
-#include <Network/PacketWrappers/ActorControlPacket.h>
-#include <Network/PacketWrappers/ActorControlSelfPacket.h>
-#include <Network/PacketWrappers/ActorControlTargetPacket.h>
-#include <Network/PacketWrappers/InitZonePacket.h>
-#include <Network/PacketWrappers/PlayerSetupPacket.h>
-#include <Network/PacketWrappers/ServerNoticePacket.h>
-#include <Network/PacketWrappers/ChatPacket.h>
-#include <Network/PacketWrappers/HudParamPacket.h>
-#include <Network/Util/PlayerUtil.h>
+#include <Network/Util/PacketUtil.h>
 
 #include <Actor/Player.h>
 #include <Actor/BNpc.h>
@@ -93,7 +84,6 @@ std::vector< Sapphire::Entity::PlayerPtr > PlayerMgr::searchPlayersByName( const
   return results;
 }
 
-
 std::string PlayerMgr::getPlayerNameFromDb( uint64_t characterId, bool forceDbLoad )
 {
   if( !forceDbLoad )
@@ -108,14 +98,13 @@ std::string PlayerMgr::getPlayerNameFromDb( uint64_t characterId, bool forceDbLo
   auto res = db.query( "SELECT name FROM charainfo WHERE characterid = " + std::to_string( characterId ) );
 
   if( !res->next() )
-    return "Unknown";
+    return "Obtaining Signature";
 
   std::string playerName = res->getString( 1 );
 
   return playerName;
 }
 
-
 Sapphire::Entity::PlayerPtr PlayerMgr::addPlayer( uint64_t characterId )
 {
   auto pPlayer = Entity::make_Player();
@@ -218,9 +207,7 @@ void PlayerMgr::onMobKill( Entity::Player& player, Entity::BNpc& bnpc )
   scriptMgr.onBNpcKill( player, bnpc );
 
   if( player.hasReward( Common::UnlockEntry::HuntingLog ) )
-  {
-    player.updateHuntingLog( bnpc.getBNpcNameId() );
-  }
+    onUpdateHuntingLog( player, bnpc.getBNpcNameId() );
 }
 
 void PlayerMgr::sendLoginMessage( Entity::Player& player )
@@ -262,48 +249,48 @@ void PlayerMgr::onMoveZone( Sapphire::Entity::Player& player )
   }
   auto& teri = *pZone;
 
-  Network::Util::Player::sendLogin( player );
+  Network::Util::Packet::sendLogin( player );
 
   player.sendInventory();
 
   if( player.isLogin() )
   {
-    Network::Util::Player::sendActorControlSelf( player, SetConfigFlags, player.getConfigFlags(), 1 );
-    Network::Util::Player::sendActorControlSelf( player, SetMaxGearSets, player.getMaxGearSets() );
+    Network::Util::Packet::sendActorControlSelf( player, player.getId(), SetConfigFlags, player.getConfigFlags(), 1 );
+    Network::Util::Packet::sendActorControlSelf( player, player.getId(), SetMaxGearSets, player.getMaxGearSets() );
   }
 
   // set flags, will be reset automatically by zoning ( only on client side though )
   //setStateFlag( PlayerStateFlag::BetweenAreas );
   //setStateFlag( PlayerStateFlag::BetweenAreas1 );
 
-  Network::Util::Player::sendHuntingLog( player );
+  Network::Util::Packet::sendHuntingLog( player );
 
   if( player.isLogin() )
-    Network::Util::Player::sendPlayerSetup( player );
+    Network::Util::Packet::sendPlayerSetup( player );
 
-  Network::Util::Player::sendRecastGroups( player );
-  Network::Util::Player::sendBaseParams( player );
-  Network::Util::Player::sendActorControl( player, SetItemLevel, player.getItemLevel() );
+  Network::Util::Packet::sendRecastGroups( player );
+  Network::Util::Packet::sendBaseParams( player );
+  Network::Util::Packet::sendActorControl( player, player.getId(), SetItemLevel, player.getItemLevel() );
   if( player.isLogin() )
   {
-    Network::Util::Player::sendChangeClass( player );
-    Network::Util::Player::sendActorControl( player, 0x112, 0x24 ); // unknown
-    Network::Util::Player::sendContentAttainFlags( player );
+    Network::Util::Packet::sendChangeClass( player );
+    Network::Util::Packet::sendActorControl( player, player.getId(), 0x112, 0x24 ); // unknown
+    Network::Util::Packet::sendContentAttainFlags( player );
     player.clearSoldItems();
   }
 
   housingMgr.sendLandFlags( player );
 
-  Network::Util::Player::sendInitZone( player );
+  Network::Util::Packet::sendInitZone( player );
 
   if( player.isLogin() )
   {
-    Network::Util::Player::sendDailyQuests( player );
-    Network::Util::Player::sendQuestRepeatFlags( player );
+    Network::Util::Packet::sendDailyQuests( player );
+    Network::Util::Packet::sendQuestRepeatFlags( player );
 
     auto &questMgr = Common::Service< World::Manager::QuestMgr >::ref();
     questMgr.sendQuestsInfo( player );
-    Network::Util::Player::sendGrandCompany( player );
+    Network::Util::Packet::sendGrandCompany( player );
   }
 
   teri.onPlayerZoneIn( player );
@@ -321,35 +308,135 @@ void PlayerMgr::onUpdate( Entity::Player& player, uint64_t tickCount )
   if( !player.isAlive() )
     return;
 
-  auto mainWeap = player.getItemAt( Common::GearSet0, Common::GearSetSlot::MainHand );
-  if( mainWeap && !player.checkAction() && ( player.getTargetId() && player.getStance() == Common::Stance::Active && player.isAutoattackOn() ) )
+  checkAutoAttack( player, tickCount );
+}
+
+void PlayerMgr::checkAutoAttack( Entity::Player& player, uint64_t tickCount ) const
+{
+  auto mainWeap = player.getItemAt( Common::GearSet0, Common::MainHand );
+  if( !mainWeap || player.checkAction() || !player.isAutoattackOn() || !player.getTargetId() || player.getStance() != Common::Active )
+    return;
+
+  for( const auto& actor : player.getInRangeActors() )
   {
-    // @TODO i dislike this, iterating over all in range actors when you already know the id of the actor you need...
-    for( const auto& actor : player.getInRangeActors() )
-    {
-      if( actor->getId() != player.getTargetId() || !actor->getAsChara()->isAlive() )
-        continue;
-      auto chara = actor->getAsChara();
+    if( actor->getId() != player.getTargetId() || !actor->getAsChara()->isAlive() )
+      continue;
+    auto chara = actor->getAsChara();
 
-      // default autoattack range
-      float range = 3.f + chara->getRadius() + player.getRadius() * 0.5f;
+    // default autoattack range
+    float range = 3.f + chara->getRadius() + player.getRadius() * 0.5f;
 
-      // default autoattack range for ranged classes
-      auto classJob = player.getClass();
+    // default autoattack range for ranged classes
+    auto classJob = player.getClass();
 
-      if( classJob == Common::ClassJob::Machinist || classJob == Common::ClassJob::Bard || classJob == Common::ClassJob::Archer )
-        range = 25.f + chara->getRadius() + player.getRadius() * 0.5f;
+    if( classJob == Common::ClassJob::Machinist || classJob == Common::ClassJob::Bard || classJob == Common::ClassJob::Archer )
+      range = 25.f + chara->getRadius() + player.getRadius() * 0.5f;
 
-      if( Common::Util::distance( player.getPos(), actor->getPos() ) <= range )
-      {
-        if( ( tickCount - player.getLastAttack() ) > mainWeap->getDelay() )
-        {
-          player.setLastAttack( tickCount );
-          player.autoAttack( actor->getAsChara() );
-        }
-      }
+    if( ( Common::Util::distance( player.getPos(), actor->getPos() ) <= range ) &&
+        ( ( tickCount - player.getLastAttack() ) > mainWeap->getDelay() ) )
+    {
+      player.setLastAttack( tickCount );
+      player.autoAttack( actor->getAsChara() );
     }
   }
+
+}
+
+void PlayerMgr::onGainExp( Entity::Player& player, uint32_t exp )
+{
+  uint32_t currentExp = player.getCurrentExp();
+  uint16_t level = player.getLevel();
+  uint32_t expGained = exp;
+
+  auto currentClass = static_cast< uint8_t >( player.getClass() );
+
+  if( level >= Common::MAX_PLAYER_LEVEL )
+  {
+    player.setCurrentExp( 0 );
+    if( currentExp != 0 )
+      Network::Util::Packet::sendActorControlSelf( player, player.getId(), UpdateUiExp, currentClass, 0 );
+
+    return;
+  }
+  auto& exdData = Common::Service< Data::ExdData >::ref();
+
+  uint32_t neededExpToLevel = exdData.getRow< Excel::ParamGrow >( level )->data().NextExp;
+  uint32_t neededExpToLevelPlus1 = exdData.getRow< Excel::ParamGrow >( level + 1 )->data().NextExp;
+
+  if( ( currentExp + exp ) >= neededExpToLevel )
+  {
+    // levelup
+    exp = ( currentExp + exp - neededExpToLevel ) > neededExpToLevelPlus1 ? neededExpToLevelPlus1 - 1 : ( currentExp + exp - neededExpToLevel );
+
+    if( level + 1 >= Common::MAX_PLAYER_LEVEL )
+      exp = 0;
+    else
+      onLevelChanged( player, level + 1 );
+
+    player.setCurrentExp( exp );
+
+  }
+  else
+    player.setCurrentExp( currentExp + exp );
+
+  Network::Util::Packet::sendActorControlSelf( player, player.getId(), GainExpMsg, currentClass, expGained );
+  Network::Util::Packet::sendActorControlSelf( player, player.getId(), UpdateUiExp, currentClass, player.getCurrentExp() );
+}
+
+void PlayerMgr::onDiscoverArea( Entity::Player& player, int16_t mapId, int16_t subId )
+{
+  auto& exdData = Common::Service< Data::ExdData >::ref();
+
+  int32_t offset;
+
+  auto info = exdData.getRow< Excel::Map >( mapId );
+  if( !info )
+  {
+    sendDebug( player, "discover(): Could not obtain map data for map_id == {0}", mapId );
+    return;
+  }
+
+  const auto& mapData = info->data();
+
+  if( mapData.IsUint16Discovery )
+    offset = 2 * mapData.DiscoveryIndex;
+  else
+    offset = 320 + 4 * mapData.DiscoveryIndex;
+
+  uint16_t index;
+  uint8_t value;
+  Common::Util::valueToFlagByteIndexValue( subId, value, index );
+
+  auto& discovery = player.getDiscoveryBitmask();
+
+  discovery[ offset + index ] |= value;
+
+  uint16_t level = player.getLevel();
+
+  uint32_t exp = ( exdData.getRow< Excel::ParamGrow >( level )->data().NextExp * 5 / 100 );
+  onGainExp( player, exp );
+
+  // gain 10x additional EXP if entire map is completed
+  uint32_t mask = mapData.DiscoveryFlag;
+  uint32_t discoveredAreas;
+  if( info->data().IsUint16Discovery )
+  {
+    discoveredAreas = ( discovery[ offset + 1 ] << 8 ) | discovery[ offset ];
+  }
+  else
+  {
+    discoveredAreas = ( discovery[ offset + 3 ] << 24 ) |
+                      ( discovery[ offset + 2 ] << 16 ) |
+                      ( discovery[ offset + 1 ] << 8  ) |
+                        discovery[ offset ];
+  }
+
+  bool allDiscovered = ( ( discoveredAreas & mask ) == mask );
+
+  if( allDiscovered )
+  {
+    onGainExp( player, exp * 10 );
+  }
 }
 
 
@@ -357,22 +444,156 @@ void PlayerMgr::onUpdate( Entity::Player& player, uint64_t tickCount )
 
 void PlayerMgr::sendServerNotice( Entity::Player& player, const std::string& message ) //Purple Text
 {
-  server().queueForPlayer( player.getCharacterId(), std::make_shared< ServerNoticePacket >( player.getId(), message ) );
+  Network::Util::Packet::sendServerNotice( player, message );
 }
 
 void PlayerMgr::sendUrgent( Entity::Player& player, const std::string& message ) //Red Text
 {
-  server().queueForPlayer( player.getCharacterId(), std::make_shared< ChatPacket >( player, Common::ChatType::ServerUrgent, message ) );
+  Network::Util::Packet::sendChat( player, Common::ChatType::ServerUrgent, message );
 }
 
 void PlayerMgr::sendDebug( Entity::Player& player, const std::string& message ) //Grey Text
 {
-  server().queueForPlayer( player.getCharacterId(), std::make_shared< ChatPacket >( player, Common::ChatType::SystemMessage, message ) );
+  Network::Util::Packet::sendChat( player, Common::ChatType::SystemMessage, message );
 }
 
 void PlayerMgr::sendLogMessage( Entity::Player& player, uint32_t messageId, uint32_t param2, uint32_t param3,
                                 uint32_t param4, uint32_t param5, uint32_t param6 )
 {
-  server().queueForPlayer( player.getCharacterId(), makeActorControlTarget( player.getId(), ActorControlType::LogMsg, messageId,
-                                                                            param2, param3, param4, param5, param6 ) );
+  Network::Util::Packet::sendActorControlTarget( player, player.getId(), LogMsg, messageId, param2, param3, param4, param5, param6 );
+}
+
+void PlayerMgr::sendBattleTalk( Sapphire::Entity::Player& player, uint32_t battleTalkId, uint32_t handlerId,
+                                uint32_t kind, uint32_t nameId, uint32_t talkerId,
+                                uint32_t param1, uint32_t param2, uint32_t param3, uint32_t param4,
+                                uint32_t param5, uint32_t param6, uint32_t param7, uint32_t param8 )
+{
+  Network::Util::Packet::sendBattleTalk( player, battleTalkId, handlerId, kind, nameId, talkerId,
+                                         param1, param2, param3, param4, param5, param6, param7, param8 );
+}
+
+void PlayerMgr::onUpdateHuntingLog( Entity::Player& player, uint8_t id )
+{
+  std::vector< uint32_t > rankRewards{ 2500, 10000, 20000, 30000, 40000 };
+  const auto maxRank = 4;
+  auto& pExdData = Common::Service< Data::ExdData >::ref();
+
+  // make sure we get the matching base-class if a job is being used
+  auto classJobInfo = pExdData.getRow< Excel::ClassJob >( static_cast< uint8_t >( player.getClass() ) );
+  if( !classJobInfo )
+    return;
+
+  auto currentClassId = classJobInfo->data().MonsterNote;
+  if( currentClassId == -1 || currentClassId == 127 )
+    return;
+
+  auto& logEntry = player.getHuntingLogEntry( currentClassId );
+
+  bool logChanged = false;
+
+  bool allSectionsComplete = true;
+  for( int i = 1; i <= 10; ++i )
+  {
+    bool sectionComplete = true;
+    bool sectionChanged = false;
+    auto monsterNoteId = static_cast< uint32_t >( classJobInfo->data().MainClass * 10000 + logEntry.rank * 10 + i );
+    auto note = pExdData.getRow< Excel::MonsterNote >( monsterNoteId );
+
+    // for classes that don't have entries, if the first fails the rest will fail
+    if( !note )
+      break;
+
+    for( auto x = 0; x < 4; ++x )
+    {
+      auto note1 = pExdData.getRow< Excel::MonsterNoteTarget >( note->data().Target[ x ] );
+      if( note1->data().Monster == id && logEntry.entries[ i - 1 ][ x ] < note->data().NeededKills[ x ] )
+      {
+        logEntry.entries[ i - 1 ][ x ]++;
+        Network::Util::Packet::sendActorControlSelf( player, player.getId(), HuntingLogEntryUpdate, monsterNoteId, x, logEntry.entries[ i - 1 ][ x ] );
+        logChanged = true;
+        sectionChanged = true;
+      }
+      if( logEntry.entries[ i - 1 ][ x ] != note->data().NeededKills[ x ] )
+        sectionComplete = false;
+    }
+    if( logChanged && sectionComplete && sectionChanged )
+    {
+      Network::Util::Packet::sendActorControlSelf( player, player.getId(), HuntingLogSectionFinish, monsterNoteId, i, 0 );
+      onGainExp( player, note->data().RewardExp );
+    }
+    if( !sectionComplete )
+    {
+      allSectionsComplete = false;
+    }
+  }
+  if( logChanged && allSectionsComplete )
+  {
+    Network::Util::Packet::sendActorControlSelf( player, player.getId(), HuntingLogRankFinish, 4 );
+    onGainExp( player, rankRewards[ logEntry.rank ] );
+    if( logEntry.rank < 4 )
+    {
+      logEntry.rank++;
+      memset( logEntry.entries, 0, 40 );
+      Network::Util::Packet::sendActorControlSelf( player, player.getId(), HuntingLogRankUnlock, currentClassId, logEntry.rank + 1, 0 );
+    }
+  }
+
+  if( logChanged )
+    Network::Util::Packet::sendHuntingLog( player );
+}
+
+void PlayerMgr::onExitInstance( Entity::Player& player )
+{
+  auto& warpMgr = Common::Service< WarpMgr >::ref();
+
+  player.resetHp();
+  player.resetMp();
+
+  warpMgr.requestMoveTerritory( player, Common::WarpType::WARP_TYPE_CONTENT_END_RETURN,
+                                player.getPrevTerritoryId(), player.getPrevPos(), player.getPrevRot() );
+
 }
+
+void PlayerMgr::onClassJobChanged( Entity::Player& player, Common::ClassJob classJob )
+{
+  player.setClassJob( classJob );
+  if( player.getHp() > player.getMaxHp() )
+    player.setHp( player.getMaxHp() );
+
+  if( player.getMp() > player.getMaxMp() )
+    player.setMp( player.getMaxMp() );
+
+  player.setTp( 0 );
+
+  Network::Util::Packet::sendChangeClass( player );
+  Network::Util::Packet::sendStatusUpdate( player );
+  Network::Util::Packet::sendActorControl( player.getInRangePlayerIds( true ), player.getId(), ClassJobChange, 4 );
+  Network::Util::Packet::sendHudParam( player );
+  Common::Service< World::Manager::MapMgr >::ref().updateQuests( player );
+}
+
+void PlayerMgr::onLevelChanged( Entity::Player& player, uint8_t level )
+{
+  player.setLevel( level );
+  player.calculateStats();
+
+  player.setHp( player.getMaxHp() );
+  player.setMp( player.getMaxMp() );
+  Network::Util::Packet::sendBaseParams( player );
+  Network::Util::Packet::sendHudParam( player );
+  Network::Util::Packet::sendStatusUpdate( player );
+  Network::Util::Packet::sendActorControl( player.getInRangePlayerIds( true ), player.getId(), LevelUpEffect, static_cast< uint8_t >( player.getClass() ), player.getLevel(), player.getLevel() - 1 );
+
+  auto& achvMgr = Common::Service< World::Manager::AchievementMgr >::ref();
+  achvMgr.progressAchievementByType< Common::Achievement::Type::Classjob >( player, static_cast< uint32_t >( player.getClass() ) );
+  Common::Service< World::Manager::MapMgr >::ref().updateQuests( player );
+}
+
+void PlayerMgr::onSongLearned( Entity::Player& player, uint8_t songId, uint32_t itemId )
+{
+  player.learnSong( songId, itemId );
+  Network::Util::Packet::sendActorControlSelf( player, player.getId(), ToggleOrchestrionUnlock, songId, 1, itemId );
+}
+
+
+
diff --git a/src/world/Manager/PlayerMgr.h b/src/world/Manager/PlayerMgr.h
index 3abb7cfbd..d88a8960b 100644
--- a/src/world/Manager/PlayerMgr.h
+++ b/src/world/Manager/PlayerMgr.h
@@ -34,6 +34,20 @@ namespace Sapphire::World::Manager
 
     void onUpdate( Sapphire::Entity::Player& player, uint64_t tickCount );
 
+    void onGainExp( Sapphire::Entity::Player& player, uint32_t exp );
+
+    void onDiscoverArea( Sapphire::Entity::Player& player, int16_t mapId, int16_t subId );
+
+    void onUpdateHuntingLog( Sapphire::Entity::Player& player, uint8_t id );
+
+    void onExitInstance( Sapphire::Entity::Player& player );
+
+    void onClassJobChanged( Sapphire::Entity::Player& player, Common::ClassJob classJob );
+
+    void onLevelChanged( Sapphire::Entity::Player& player, uint8_t level );
+
+    void onSongLearned( Sapphire::Entity::Player& player, uint8_t songId, uint32_t itemId );
+
   //////////// Helpers
 
     static void sendServerNotice( Sapphire::Entity::Player& player, const std::string& message );
@@ -61,10 +75,17 @@ namespace Sapphire::World::Manager
     static void sendLogMessage( Sapphire::Entity::Player& player, uint32_t messageId, uint32_t param2 = 0, uint32_t param3 = 0,
                                 uint32_t param4 = 0, uint32_t param5 = 0, uint32_t param6 = 0 );
 
+    static void sendBattleTalk( Sapphire::Entity::Player& player, uint32_t battleTalkId, uint32_t handlerId, uint32_t kind,
+                                uint32_t nameId, uint32_t talkerId,
+                                uint32_t param1 = 0, uint32_t param2 = 0, uint32_t param3 = 0, uint32_t param4 = 0,
+                                uint32_t param5 = 0, uint32_t param6 = 0, uint32_t param7 = 0, uint32_t param8 = 0 );
+
   private:
     std::map< uint32_t, Entity::PlayerPtr > m_playerMapById;
     std::map< uint64_t, Entity::PlayerPtr > m_playerMapByCharacterId;
     std::map< std::string, Entity::PlayerPtr > m_playerMapByName;
+
+    void checkAutoAttack( Entity::Player& player, uint64_t tickCount ) const;
   };
 
 
diff --git a/src/world/Manager/QuestMgr.cpp b/src/world/Manager/QuestMgr.cpp
index d1afbcc5c..52aac52e2 100644
--- a/src/world/Manager/QuestMgr.cpp
+++ b/src/world/Manager/QuestMgr.cpp
@@ -9,6 +9,8 @@
 
 #include "Network/GameConnection.h"
 
+#include <Manager/PlayerMgr.h>
+
 #include "QuestMgr.h"
 #include "AchievementMgr.h"
 
@@ -60,6 +62,7 @@ void QuestMgr::onRemoveQuest( Entity::Player &player, uint8_t questIndex )
 
 bool QuestMgr::giveQuestRewards( Entity::Player& player, uint16_t questId, uint32_t optionalChoice )
 {
+  auto& playerMgr = Common::Service< World::Manager::PlayerMgr >::ref();
   auto& exdData = Common::Service< Data::ExdData >::ref();
   auto questInfo = exdData.getRow< Excel::Quest >( static_cast< uint32_t >( Event::EventHandler::EventHandlerType::Quest ) << 16 | questId );
 
@@ -71,7 +74,9 @@ bool QuestMgr::giveQuestRewards( Entity::Player& player, uint16_t questId, uint3
 
   // TODO: check if there is room in inventory, else return false;
   if( exp > 0 )
-    player.gainExp( exp );
+  {
+    playerMgr.onGainExp( player, exp );
+  }
 
   for( uint32_t i = 0; i < 6; i++ )
   {
diff --git a/src/world/Manager/RNGMgr.h b/src/world/Manager/RNGMgr.h
index 6e9cd6324..ad5ae401d 100644
--- a/src/world/Manager/RNGMgr.h
+++ b/src/world/Manager/RNGMgr.h
@@ -10,6 +10,8 @@
 #include <type_traits>
 #include <vector>
 
+#include <Logging/Logger.h>
+
 namespace Sapphire::World::Manager
 {
   /*!
@@ -95,6 +97,11 @@ namespace Sapphire::World::Manager
       return RandGenerator< T >( m_engine );
     }
 
+    std::shared_ptr< std::mt19937 > getRNGEngine()
+    {
+      return m_engine;
+    }
+
   private:
 
     template< std::size_t STATE_SIZE >
diff --git a/src/world/Manager/ShopMgr.cpp b/src/world/Manager/ShopMgr.cpp
index 2edeec1c4..7d9c9aa5f 100644
--- a/src/world/Manager/ShopMgr.cpp
+++ b/src/world/Manager/ShopMgr.cpp
@@ -12,13 +12,12 @@ using namespace Sapphire::World::Manager;
 void ShopMgr::cacheShop( uint32_t shopId )
 {
   auto& exdData = Common::Service< Data::ExdData >::ref();
-  auto itemShopList = exdData.getIdList< Excel::Shop >();
+  auto itemShopList = exdData.getRows< Excel::Shop >();
   uint8_t count = 0;
-  for( auto itemShop : itemShopList )
+  for( const auto& [ itemShop, shop ] : itemShopList )
   {
     if( shopId == itemShop )
     {
-      auto shop = exdData.getRow< Excel::Shop >( itemShop );
       for( auto shopItemId : shop->data().Item )
       {
         auto shopItem = exdData.getRow< Excel::ShopItem >( shopItemId );
diff --git a/src/world/Manager/TaskMgr.cpp b/src/world/Manager/TaskMgr.cpp
index b3d3eebef..b17e79f26 100644
--- a/src/world/Manager/TaskMgr.cpp
+++ b/src/world/Manager/TaskMgr.cpp
@@ -9,27 +9,32 @@ using namespace Sapphire::World;
 
 void TaskMgr::update( uint64_t tickCount )
 {
-
-  for( auto it = m_taskList.begin(); it != m_taskList.end(); )
+  std::vector< TaskPtr > tmpTaskList;
+  for( const auto& pTask : m_taskList )
   {
-    auto pTask = *it;
     // is the task ready for execution?
     if( ( tickCount - pTask->getQueueTimeMs() ) >= pTask->getDelayTimeMs() )
     {
       Logger::info( "[TaskMgr] " + pTask->toString() );
       pTask->execute();
-      it = m_taskList.erase( it );
     }
     else
-      ++it;
+      tmpTaskList.push_back( pTask );
   }
 
+  m_taskList = tmpTaskList;
   m_lastTick = tickCount;
 
+  while( !m_deferredTasks.empty() )
+  {
+    auto pTask = m_deferredTasks.front();
+    m_deferredTasks.pop();
+    m_taskList.push_back( pTask );
+  }
 }
 
 void TaskMgr::queueTask( const TaskPtr& pTask )
 {
   pTask->onQueue();
-  m_taskList.push_back( pTask );
+  m_deferredTasks.push( pTask );
 }
diff --git a/src/world/Manager/TaskMgr.h b/src/world/Manager/TaskMgr.h
index c4325489d..a52371d71 100644
--- a/src/world/Manager/TaskMgr.h
+++ b/src/world/Manager/TaskMgr.h
@@ -2,6 +2,7 @@
 
 #include <cstdint>
 #include <string>
+#include <queue>
 #include <ForwardsZone.h>
 #include <Util/Util.h>
 
@@ -45,6 +46,7 @@ namespace Sapphire::World::Manager
   private:
     uint64_t m_lastTick{};
     std::vector< TaskPtr > m_taskList;
+    std::queue< TaskPtr > m_deferredTasks;
 
   };
 
diff --git a/src/world/Manager/TerritoryMgr.cpp b/src/world/Manager/TerritoryMgr.cpp
index 540a06176..a7a27a7f5 100644
--- a/src/world/Manager/TerritoryMgr.cpp
+++ b/src/world/Manager/TerritoryMgr.cpp
@@ -35,14 +35,12 @@ TerritoryMgr::TerritoryMgr() :
 void TerritoryMgr::loadTerritoryTypeDetailCache()
 {
   auto& exdData = Common::Service< Data::ExdData >::ref();
-  auto idList = exdData.getIdList< Excel::TerritoryType >();
+  auto teriList = exdData.getRows< Excel::TerritoryType >();
 
-  for( auto id : idList )
+  for( const auto& [ id, teri ] : teriList )
   {
-    auto teri1 = exdData.getRow< Excel::TerritoryType >( id );
-
-    if( !teri1->getString( teri1->data().Name ).empty() && id > 90 )
-      m_territoryTypeDetailCacheMap[ id ] = teri1;
+    if( !teri->getString( teri->data().Name ).empty() && id > 90 )
+      m_territoryTypeDetailCacheMap[ id ] = teri;
   }
 
 }
@@ -77,12 +75,11 @@ uint32_t TerritoryMgr::getNextInstanceId()
 
 Excel::ExcelStructPtr< Excel::TerritoryType > TerritoryMgr::getTerritoryDetail( uint32_t territoryTypeId ) const
 {
-  auto& exdData = Common::Service< Data::ExdData >::ref();
-  auto teri1 = exdData.getRow< Excel::TerritoryType >( territoryTypeId );
-  if( !teri1 )
+  auto it = m_territoryTypeDetailCacheMap.find( territoryTypeId );
+  if( it == m_territoryTypeDetailCacheMap.end() )
     return nullptr;
 
-  return teri1;
+  return it->second;
 }
 
 bool TerritoryMgr::isInstanceContentTerritory( uint32_t territoryTypeId ) const
@@ -159,11 +156,10 @@ bool TerritoryMgr::isHousingTerritory( uint32_t territoryTypeId ) const
 uint32_t TerritoryMgr::getInstanceContentId( uint32_t territoryTypeId ) const
 {
   auto& exdData = Common::Service< Data::ExdData >::ref();
-  auto contentListIds = exdData.getIdList< Excel::InstanceContent >();
+  auto contentFinderList = exdData.getRows< Excel::InstanceContent >();
 
-  for( auto id : contentListIds )
+  for( const auto& [ id, instanceContent ] : contentFinderList )
   {
-    auto instanceContent = exdData.getRow< Excel::InstanceContent >( id );
     if( instanceContent->data().TerritoryType == territoryTypeId )
     {
       return id;
@@ -198,8 +194,6 @@ bool TerritoryMgr::createDefaultTerritories()
                                                  pPlaceName->getString( pPlaceName->data().Text.SGL ) );
     pZone->init();
 
-    std::string bgPath = territoryInfo->getString( territoryData.LVB );
-
     bool hasNaviMesh = pZone->getNaviProvider() != nullptr;
 
     Logger::info( "{0}\t{1}\t{2}\t{3:<10}\t{4}\t{5}\t{6}",
@@ -309,10 +303,10 @@ TerritoryPtr TerritoryMgr::createQuestBattle( uint32_t questBattleId )
   if( !pQuestInfo || pQuestInfo->getString( pQuestInfo->data().Text.Name ).empty() )
     return nullptr;
 
-  for( auto& teriId : exdData.getIdList< Excel::TerritoryType >() )
-  {
+  auto teriList = exdData.getRows< Excel::TerritoryType >();
 
-    auto pTeri = exdData.getRow< Excel::TerritoryType >( teriId );
+  for( const auto& [ teriId, pTeri ] : teriList )
+  {
     if( !pTeri || pTeri->data().QuestBattle != questBattleId )
       continue;
 
@@ -332,8 +326,6 @@ TerritoryPtr TerritoryMgr::createQuestBattle( uint32_t questBattleId )
     m_instanceZoneSet.insert( pZone );
 
     return pZone;
-
-
   }
 
   return nullptr;
diff --git a/src/world/Manager/WarpMgr.cpp b/src/world/Manager/WarpMgr.cpp
index 2f3e1cac7..11c1d290d 100644
--- a/src/world/Manager/WarpMgr.cpp
+++ b/src/world/Manager/WarpMgr.cpp
@@ -14,6 +14,7 @@
 #include <Network/CommonActorControl.h>
 #include <Network/PacketWrappers/ActorControlSelfPacket.h>
 #include <Network/PacketWrappers/ActorControlPacket.h>
+#include <Network/Util/PacketUtil.h>
 
 #include <Manager/PlayerMgr.h>
 #include <Manager/MapMgr.h>
@@ -90,10 +91,8 @@ void WarpMgr::requestWarp( Entity::Player& player, Common::WarpType warpType, Co
 {
   m_entityIdToWarpInfoMap[ player.getId() ] = { 0, warpType, targetPos, targetRot };
 
-  server().queueForPlayers( player.getInRangePlayerIds( true ),
-                            makeActorControlSelf( player.getId(), WarpStart, warpType, warpType, 0, player.getTerritoryTypeId(), 1 ) );
-  server().queueForPlayers( player.getInRangePlayerIds(),
-                            makeActorControl( player.getId(), ActorDespawnEffect, warpType, player.getTerritoryTypeId() ) );
+  Network::Util::Packet::sendActorControlSelf( player.getInRangePlayerIds( true ), player.getId(), WarpStart, warpType, warpType, 0, player.getTerritoryTypeId(), 1 );
+  Network::Util::Packet::sendActorControl( player.getInRangePlayerIds(), player.getId(), ActorDespawnEffect, warpType, player.getTerritoryTypeId() );
 
   auto& taskMgr = Common::Service< TaskMgr >::ref();
   taskMgr.queueTask( makeWarpTask( player, warpType, targetPos, targetRot, 1000 ) );
@@ -127,14 +126,11 @@ void WarpMgr::finishWarp( Entity::Player& player )
 
   auto warpFinishAnim = warpType - 1;
 
-  auto zoneInPacket = makeActorControlSelf( player.getId(), Appear, warpFinishAnim, raiseAnim, 0, 0 );
-  auto setStatusPacket = makeActorControl( player.getId(), SetStatus, static_cast< uint8_t >( Common::ActorStatus::Idle ) );
-
   if( !player.getGmInvis() )
-    server().queueForPlayers( player.getInRangePlayerIds(), zoneInPacket );
+    Network::Util::Packet::sendActorControlSelf( player.getInRangePlayerIds(), player.getId(), Appear, warpFinishAnim, raiseAnim );
 
-  server().queueForPlayer( player.getCharacterId(), zoneInPacket );
-  server().queueForPlayers( player.getInRangePlayerIds( true ), setStatusPacket );
+  Network::Util::Packet::sendActorControlSelf( player, player.getId(), Appear, warpFinishAnim, raiseAnim );
+  Network::Util::Packet::sendActorControl( player.getInRangePlayerIds( true ), player.getId(), SetStatus, static_cast< uint8_t >( Common::ActorStatus::Idle ) );
 
   player.removeCondition( PlayerCondition::BetweenAreas );
 
diff --git a/src/world/Math/CalcStats.cpp b/src/world/Math/CalcStats.cpp
index b62070fb0..d66d4daf7 100644
--- a/src/world/Math/CalcStats.cpp
+++ b/src/world/Math/CalcStats.cpp
@@ -85,16 +85,14 @@ const int levelTable[61][6] =
   { 218, 354, 858, 2600, 282, 215 },
 };
 
-std::random_device CalcStats::dev;
-std::mt19937 CalcStats::rng( dev() );
-std::uniform_int_distribution< std::mt19937::result_type > CalcStats::range100( 0, 99 );
+std::unique_ptr< RandGenerator< float > > CalcStats::rnd = nullptr;
 
 /*
    Class used for battle-related formulas and calculations.
    Big thanks to the Theoryjerks group!
 
    NOTE:
-   Formulas here shouldn't be considered final. It's possible that the formula it was based on is correct but 
+   Formulas here shouldn't be considered final. It's possible that the formula it was based on is correct but
    wasn't implemented correctly here, or approximated things due to limited knowledge of how things work in retail.
    It's also possible that we're using formulas that were correct for previous patches, but not the current version.
 
@@ -144,12 +142,15 @@ uint32_t CalcStats::calculateMaxHp( Player& player )
   uint16_t hpMod = paramGrowthInfo->data().ParamBase;
   uint16_t jobModHp = classInfo->data().Hp;
   float approxBaseHp = 0.0f; // Read above
+  float hpModPercent = player.getModifier( Common::ParamModifier::HPPercent );
 
   approxBaseHp = static_cast< float >( levelTable[ level ][ Common::LevelTableEntry::HP ] );
 
   auto result = static_cast< uint32_t >( floor( jobModHp * ( approxBaseHp / 100.0f ) ) +
                                          floor( hpMod / 100.0f * ( vitStat - baseStat ) ) );
 
+  result *= hpModPercent;
+
   return result;
 }
 
@@ -287,19 +288,6 @@ float CalcStats::blockProbability( const Chara& chara )
   return std::floor( ( 30 * blockRate ) / levelVal + 10 );
 }
 
-float CalcStats::directHitProbability( const Chara& chara )
-{
-  const auto& baseStats = chara.getStats();
-  auto level = chara.getLevel();
-
-  auto dhRate = chara.getStatValueFloat( Common::BaseParam::Accuracy );
-
-  auto divVal = static_cast< float >( levelTable[ level ][ Common::LevelTableEntry::DIV ] );
-  auto subVal = static_cast< float >( levelTable[ level ][ Common::LevelTableEntry::SUB ] );
-
-  return std::floor( 550.f * ( dhRate - subVal ) / divVal ) / 10.f;
-}
-
 float CalcStats::criticalHitProbability( const Chara& chara )
 {
   const auto& baseStats = chara.getStats();
@@ -564,7 +552,7 @@ float CalcStats::healingMagicPotency( const Sapphire::Entity::Chara& chara )
   return std::floor( 100.f * ( chara.getStatValue( Common::BaseParam::HealingMagicPotency ) - 292.f ) / 264.f + 100.f ) / 100.f;
 }
 
-std::pair< float, Sapphire::Common::ActionHitSeverityType > CalcStats::calcAutoAttackDamage( const Sapphire::Entity::Chara& chara )
+std::pair< float, Sapphire::Common::CalcResultType > CalcStats::calcAutoAttackDamage( const Sapphire::Entity::Chara& chara )
 {
   // D = ⌊ f(ptc) × f(aa) × f(ap) × f(det) × f(tnc) × traits ⌋ × f(ss) ⌋ ×
   // f(chr) ⌋ × f(dhr) ⌋ × rand[ 0.95, 1.05 ] ⌋ × buff_1 ⌋ × buff... ⌋
@@ -577,27 +565,19 @@ std::pair< float, Sapphire::Common::ActionHitSeverityType > CalcStats::calcAutoA
 
   // todo: everything after tenacity
   auto factor = Common::Util::trunc( pot * aa * ap * det, 0 );
-  Sapphire::Common::ActionHitSeverityType hitType = Sapphire::Common::ActionHitSeverityType::NormalDamage;
+  Sapphire::Common::CalcResultType hitType = Sapphire::Common::CalcResultType::TypeDamageHp;
 
   // todo: traits
 
   factor = std::floor( factor * speed( chara ) );
 
-  if( criticalHitProbability( chara ) > range100( rng ) )
+  if( criticalHitProbability( chara ) > getRandomNumber0To100() )
   {
     factor *= criticalHitBonus( chara );
-    hitType = Sapphire::Common::ActionHitSeverityType::CritDamage;
-  }
-
-  if( directHitProbability( chara ) > range100( rng ) )
-  {
-    factor *= 1.25f;
-    hitType = hitType == Sapphire::Common::ActionHitSeverityType::CritDamage ?
-                         Sapphire::Common::ActionHitSeverityType::CritDirectHitDamage :
-                         Sapphire::Common::ActionHitSeverityType::DirectHitDamage;
+    hitType = Sapphire::Common::CalcResultType::TypeCriticalDamageHp;
   }
 
-  factor *= 1.0f + ( ( range100( rng ) - 50.0f ) / 1000.0f );
+  factor *= 1.0f + ( ( getRandomNumber0To100() - 50.0f ) / 1000.0f );
 
   // todo: buffs
 
@@ -615,7 +595,7 @@ std::pair< float, Sapphire::Common::ActionHitSeverityType > CalcStats::calcAutoA
   return std::pair( factor, hitType );
 }
 
-std::pair< float, Sapphire::Common::ActionHitSeverityType > CalcStats::calcActionDamage( const Sapphire::Entity::Chara& chara, uint32_t ptc, float wepDmg )
+std::pair< float, Sapphire::Common::CalcResultType > CalcStats::calcActionDamage( const Sapphire::Entity::Chara& chara, uint32_t ptc, float wepDmg )
 {
   // D = ⌊ f(pot) × f(wd) × f(ap) × f(det) × f(tnc) × traits ⌋
   // × f(chr) ⌋ × f(dhr) ⌋ × rand[ 0.95, 1.05 ] ⌋ buff_1 ⌋ × buff_1 ⌋ × buff... ⌋
@@ -624,33 +604,29 @@ std::pair< float, Sapphire::Common::ActionHitSeverityType > CalcStats::calcActio
   auto wd = weaponDamage( chara, wepDmg );
   auto ap = getPrimaryAttackPower( chara );
   auto det = determination( chara );
+  auto damageDealtMod = chara.getModifier( Common::ParamModifier::DamageDealtPercent );
 
   auto factor = Common::Util::trunc( pot * wd * ap * det, 0 );
-  Sapphire::Common::ActionHitSeverityType hitType = Sapphire::Common::ActionHitSeverityType::NormalDamage;
+  Sapphire::Common::CalcResultType hitType = Sapphire::Common::CalcResultType::TypeDamageHp;
 
-  if( criticalHitProbability( chara ) > range100( rng ) )
+  if( criticalHitProbability( chara ) > getRandomNumber0To100() )
   {
     factor *= criticalHitBonus( chara );
-    hitType = Sapphire::Common::ActionHitSeverityType::CritDamage;
-  }
-
-  if( directHitProbability( chara ) > range100( rng ) )
-  {
-    factor *= 1.25f;
-    hitType = hitType == Sapphire::Common::ActionHitSeverityType::CritDamage ?
-                         Sapphire::Common::ActionHitSeverityType::CritDirectHitDamage :
-                         Sapphire::Common::ActionHitSeverityType::DirectHitDamage;
+    hitType = Sapphire::Common::CalcResultType::TypeCriticalDamageHp;
   }
 
-  factor *= 1.0f + ( ( range100( rng ) - 50.0f ) / 1000.0f );
+  factor *= 1.0f + ( ( getRandomNumber0To100() - 50.0f ) / 1000.0f );
 
   // todo: buffs
 
+  factor *= damageDealtMod;
+
   constexpr auto format = "dmg: pot: {} ({}) wd: {} ({}) ap: {} det: {}  = {}";
 
   if( auto player = const_cast< Entity::Chara& >( chara ).getAsPlayer() )
   {
     PlayerMgr::sendDebug( *player, format, pot, ptc, wd, wepDmg, ap, det, factor );
+    PlayerMgr::sendDebug( *player, "DamageDealtPercent: {}", damageDealtMod );
   }
   else
   {
@@ -660,19 +636,23 @@ std::pair< float, Sapphire::Common::ActionHitSeverityType > CalcStats::calcActio
   return std::pair( factor, hitType );
 }
 
-std::pair< float, Sapphire::Common::ActionHitSeverityType > CalcStats::calcActionHealing( const Sapphire::Entity::Chara& chara, uint32_t ptc, float wepDmg )
+std::pair< float, Sapphire::Common::CalcResultType > CalcStats::calcActionHealing( const Sapphire::Entity::Chara& chara, uint32_t ptc, float wepDmg )
 {
   // lol just for testing
-  auto factor = std::floor( ptc * ( wepDmg / 10.0f ) + ptc );
-  Sapphire::Common::ActionHitSeverityType hitType = Sapphire::Common::ActionHitSeverityType::NormalHeal;
+  float det = chara.getStatValue( Common::BaseParam::Determination );
+  float mnd = chara.getStatValue( Common::BaseParam::Mind );
+
+  auto factor = std::floor( ( wepDmg * ( mnd / 200 ) + ( det / 10 ) ) * ( ptc / 100 ) * 1.3f );
+
+  Sapphire::Common::CalcResultType hitType = Sapphire::Common::CalcResultType::TypeRecoverHp;
 
-  if( criticalHitProbability( chara ) > range100( rng ) )
+  if( criticalHitProbability( chara ) > getRandomNumber0To100() )
   {
     factor *= criticalHitBonus( chara );
-    hitType = Sapphire::Common::ActionHitSeverityType::CritHeal;
+    hitType = Sapphire::Common::CalcResultType::TypeCriticalRecoverHp;
   }
 
-  factor *= 1.0f + ( ( range100( rng ) - 50.0f ) / 1000.0f );
+  factor *= 1.0f + ( ( getRandomNumber0To100() - 50.0f ) / 1000.0f );
 
   return std::pair( factor, hitType );
 }
@@ -680,4 +660,13 @@ std::pair< float, Sapphire::Common::ActionHitSeverityType > CalcStats::calcActio
 uint32_t CalcStats::primaryStatValue( const Sapphire::Entity::Chara& chara )
 {
   return chara.getStatValue( chara.getPrimaryStat() );
-}
\ No newline at end of file
+}
+
+float CalcStats::getRandomNumber0To100()
+{
+  if( !rnd )
+  {
+    rnd = std::make_unique< RandGenerator< float > >( Common::Service< RNGMgr >::ref().getRandGenerator< float >( 0, 100 ) );
+  }
+  return rnd->next();
+}
diff --git a/src/world/Math/CalcStats.h b/src/world/Math/CalcStats.h
index 87625067b..ad1d5b94f 100644
--- a/src/world/Math/CalcStats.h
+++ b/src/world/Math/CalcStats.h
@@ -1,11 +1,12 @@
 #pragma once
 
-#include <random>
 #include <Common.h>
 #include "Forwards.h"
+#include "Manager/RNGMgr.h"
 
 namespace Sapphire::Math
 {
+  using namespace Sapphire::World::Manager;
 
   class CalcStats
   {
@@ -34,11 +35,6 @@ namespace Sapphire::Math
      */
     static float blockProbability( const Sapphire::Entity::Chara& chara );
 
-    /*!
-     * @brief Calculates the probability of a direct hit happening
-     */
-    static float directHitProbability( const Sapphire::Entity::Chara& chara );
-
     /*!
      * @brief Calculates the probability of a critical hit happening
      */
@@ -140,11 +136,11 @@ namespace Sapphire::Math
 
     ////////////////////////////////////////////
 
-    static std::pair< float, Common::ActionHitSeverityType > calcAutoAttackDamage( const Sapphire::Entity::Chara& chara );
+    static std::pair< float, Common::CalcResultType > calcAutoAttackDamage( const Sapphire::Entity::Chara& chara );
 
-    static std::pair< float, Common::ActionHitSeverityType > calcActionDamage( const Sapphire::Entity::Chara& chara, uint32_t ptc, float wepDmg );
+    static std::pair< float, Common::CalcResultType > calcActionDamage( const Sapphire::Entity::Chara& chara, uint32_t ptc, float wepDmg );
 
-    static std::pair< float, Common::ActionHitSeverityType > calcActionHealing( const Sapphire::Entity::Chara& chara, uint32_t ptc, float wepDmg );
+    static std::pair< float, Common::CalcResultType > calcActionHealing( const Sapphire::Entity::Chara& chara, uint32_t ptc, float wepDmg );
 
     static uint32_t primaryStatValue( const Sapphire::Entity::Chara& chara );
   private:
@@ -156,9 +152,8 @@ namespace Sapphire::Math
      */
     static float calcAttackPower( const Sapphire::Entity::Chara& chara, uint32_t attackPower );
 
-    static std::random_device dev;
-    static std::mt19937 rng;
-    static std::uniform_int_distribution< std::mt19937::result_type > range100;
+    static float getRandomNumber0To100();
+    static std::unique_ptr< RandGenerator< float > > rnd;
   };
 
 }
diff --git a/src/world/Navi/NaviProvider.cpp b/src/world/Navi/NaviProvider.cpp
index b510a6bbe..0a4ae78c4 100644
--- a/src/world/Navi/NaviProvider.cpp
+++ b/src/world/Navi/NaviProvider.cpp
@@ -355,6 +355,7 @@ std::vector< Sapphire::Common::FFXIVARR_POSITION3 >
     //               iterPos[ 0 ], iterPos[ 1 ], iterPos[ 2 ],
     //               targetPos[ 0 ], targetPos[ 1 ], targetPos[ 2 ] );
 
+    // todo: adjust these for the actor radius
     const float STEP_SIZE = 0.5f;
     const float SLOP = 0.15f;
 
diff --git a/src/world/Network/Handlers/ActionHandler.cpp b/src/world/Network/Handlers/ActionHandler.cpp
index 379c387d0..4465f64d1 100644
--- a/src/world/Network/Handlers/ActionHandler.cpp
+++ b/src/world/Network/Handlers/ActionHandler.cpp
@@ -50,9 +50,9 @@ void Sapphire::Network::GameConnection::actionRequest( const Packets::FFXIVARR_P
       auto category = static_cast< Common::ActionCategory >( action->data().Category );
 
       if( category  == Common::ActionCategory::ItemManipulation )
-        actionMgr.handleItemManipulationAction( player, actionId, action, requestId );
+        actionMgr.handleItemManipulationAction( player, actionId, requestId );
       else
-        actionMgr.handleTargetedPlayerAction( player, actionId, action, targetId, requestId );
+        actionMgr.handleTargetedAction( player, actionId, targetId, requestId );
       break;
     }
 
@@ -111,7 +111,7 @@ void Sapphire::Network::GameConnection::selectGroundActionRequest( const Packets
     return;
   }
 
-  PlayerMgr::sendDebug( player, "Skill type: {0}, sequence: {1}, actionId: {2}, x:{3}, y:{4}, z:{5}",
+  PlayerMgr::sendDebug( player, "Skill type: {0}, requestId: {1}, actionId: {2}, x:{3}, y:{4}, z:{5}",
                         type, requestId, actionId, pos.x, pos.y, pos.z );
 
   auto& exdData = Common::Service< Data::ExdData >::ref();
@@ -123,5 +123,5 @@ void Sapphire::Network::GameConnection::selectGroundActionRequest( const Packets
     return;
 
   auto& actionMgr = Common::Service< World::Manager::ActionMgr >::ref();
-  actionMgr.handlePlacedPlayerAction( player, actionId, action, pos, requestId );
+  actionMgr.handlePlacedAction( player, actionId, pos, requestId );
 }
diff --git a/src/world/Network/Handlers/CFHandlers.cpp b/src/world/Network/Handlers/CFHandlers.cpp
index 6aef66e0a..61c0484c4 100644
--- a/src/world/Network/Handlers/CFHandlers.cpp
+++ b/src/world/Network/Handlers/CFHandlers.cpp
@@ -74,12 +74,12 @@ void Sapphire::Network::GameConnection::find5Contents( const Packets::FFXIVARR_P
     if( territoryType != 0 )
       selectedContent.insert( territoryType );
 
-  auto contentListIds = exdData.getIdList< Excel::InstanceContent >();
-
   std::vector< uint32_t > idList;
-  for( auto id : contentListIds )
+
+  auto contentFinderList = exdData.getRows< Excel::InstanceContent >();
+  
+  for( const auto& [ id, instanceContent ] : contentFinderList )
   {
-    auto instanceContent = exdData.getRow< Excel::InstanceContent >( id );
     if( selectedContent.count( instanceContent->data().TerritoryType ) )
     {
       idList.push_back( id );
diff --git a/src/world/Network/Handlers/GMCommandHandlers.cpp b/src/world/Network/Handlers/GMCommandHandlers.cpp
index ace19b6d8..dcf3701c7 100644
--- a/src/world/Network/Handlers/GMCommandHandlers.cpp
+++ b/src/world/Network/Handlers/GMCommandHandlers.cpp
@@ -225,7 +225,7 @@ void Sapphire::Network::GameConnection::gmCommandHandler( const Packets::FFXIVAR
                                targetPlayer->getTerritoryTypeId(),
                                static_cast< uint8_t >( targetPlayer->getClass() ),
                                targetPlayer->getLevel(),
-                               targetPlayer->getExp(),
+                                   targetPlayer->getCurrentExp(),
                                targetPlayer->getSearchMessage(),
                                targetPlayer->getPlayTime() );
       break;
@@ -253,7 +253,7 @@ void Sapphire::Network::GameConnection::gmCommandHandler( const Packets::FFXIVAR
     }
     case GmCommand::Kill:
     {
-      targetActor->getAsChara()->takeDamage( 9999999 );
+      targetActor->getAsChara()->takeDamage( 0xFFFFFFFF );
       PlayerMgr::sendServerNotice( player, "Killed {0}", targetActor->getId());
       break;
     }
@@ -307,7 +307,7 @@ void Sapphire::Network::GameConnection::gmCommandHandler( const Packets::FFXIVAR
     }
     case GmCommand::Exp:
     {
-      targetPlayer->gainExp( param1 );
+      playerMgr().onGainExp( *targetPlayer, param1 );
       PlayerMgr::sendServerNotice( player, "{0} Exp was added to {1}", param1, targetPlayer->getName());
       break;
     }
@@ -328,7 +328,9 @@ void Sapphire::Network::GameConnection::gmCommandHandler( const Packets::FFXIVAR
         if( param2 == 0 )
         {
           for( uint8_t i = 0; i < 255; i++ )
-            targetPlayer->learnSong( i, 0 );
+          {
+            playerMgr().onSongLearned( *targetPlayer, i, 0 );
+          }
 
           PlayerMgr::sendServerNotice( player, "All Songs for {0} were turned on.", targetPlayer->getName() );
         }
@@ -506,19 +508,14 @@ void Sapphire::Network::GameConnection::gmCommandHandler( const Packets::FFXIVAR
 
         bool doTeleport = false;
         uint16_t teleport;
-        auto idList = exdData.getIdList< Excel::Aetheryte >();
+        auto aetheryteList = exdData.getRows< Excel::Aetheryte >();
 
-        for( auto i : idList )
+        for( const auto& [ id, data ] : aetheryteList )
         {
-          auto data = exdData.getRow< Excel::Aetheryte >( i );
-
-          if( !data )
-            continue;
-
           if( data->data().TerritoryType == param1 && data->data().Telepo )
           {
             doTeleport = true;
-            teleport = static_cast< uint16_t >( i );
+            teleport = static_cast< uint16_t >( id );
             break;
           }
 
diff --git a/src/world/Network/Handlers/PacketCommandHandler.cpp b/src/world/Network/Handlers/PacketCommandHandler.cpp
index 54acc210e..194914b6b 100644
--- a/src/world/Network/Handlers/PacketCommandHandler.cpp
+++ b/src/world/Network/Handlers/PacketCommandHandler.cpp
@@ -17,7 +17,7 @@
 #include "Network/PacketWrappers/ActorControlPacket.h"
 #include "Network/PacketWrappers/ActorControlTargetPacket.h"
 #include "Network/PacketWrappers/MoveActorPacket.h"
-#include "Network/Util/PlayerUtil.h"
+#include "Network/Util/PacketUtil.h"
 
 #include "Action/Action.h"
 
@@ -388,15 +388,9 @@ void examineHandler( Sapphire::Entity::Player& player, uint32_t targetId )
     return;
 
   if( pPlayer->isActingAsGm() || pPlayer->getTerritoryTypeId() != player.getTerritoryTypeId() )
-  {
-    server().queueForPlayer( player.getCharacterId(), makeActorControl( player.getId(), ActorControlType::ExamineError ) );
-  }
+    Network::Util::Packet::sendActorControl( player, player.getId(), ExamineError );
   else
-  {
     server().queueForPlayer( player.getCharacterId(), std::make_shared< InspectPacket >( player, pPlayer ) );
-  }
-
-
 }
 
 void Sapphire::Network::GameConnection::commandHandler( const Packets::FFXIVARR_PACKET_RAW& inPacket, Entity::Player& player )
@@ -424,7 +418,7 @@ void Sapphire::Network::GameConnection::commandHandler( const Packets::FFXIVARR_
         player.setStance( Stance::Passive );
         player.setAutoattack( false );
       }
-      server().queueForPlayers( player.getInRangePlayerIds(), makeActorControl( player.getId(), 0, data.Arg0, 1 ) );
+      Network::Util::Packet::sendActorControl( player.getInRangePlayerIds(), player.getId(), ToggleWeapon, data.Arg0, 1 );
       break;
     }
     case PacketCommand::AUTO_ATTACK:  // Toggle auto-attack
@@ -437,7 +431,7 @@ void Sapphire::Network::GameConnection::commandHandler( const Packets::FFXIVARR_
       else
         player.setAutoattack( false );
 
-      server().queueForPlayers( player.getInRangePlayerIds(), makeActorControl( player.getId(), 1, data.Arg0, 1 ) );
+      Network::Util::Packet::sendActorControl( player.getInRangePlayerIds(), player.getId(), AutoAttack, data.Arg0, 1 );
 
       break;
     }
@@ -494,7 +488,12 @@ void Sapphire::Network::GameConnection::commandHandler( const Packets::FFXIVARR_
     }
     case PacketCommand::TITLE_LIST: // Get title list
     {
-      Network::Util::Player::sendTitleList( player );
+      Network::Util::Packet::sendTitleList( player );
+      break;
+    }
+    case PacketCommand::BORROW_ACTION:
+    {
+      player.setBorrowAction( static_cast< uint8_t >( data.Arg1 ), data.Arg2 );
       break;
     }
     case PacketCommand::SET_HOWTO: // Update howtos seen
@@ -504,7 +503,7 @@ void Sapphire::Network::GameConnection::commandHandler( const Packets::FFXIVARR_
     }
     case PacketCommand::SET_CUTSCENE:
     {
-      server().queueForPlayer( player.getCharacterId(), makeActorControl( player.getId(), ActorControlType::SetCutsceneFlag, data.Arg0, 1 ) );
+      Network::Util::Packet::sendActorControl( player, player.getId(), SetCutsceneFlag, data.Arg0, 1 );
       break;
     }
     case PacketCommand::EMOTE: // emote
@@ -519,8 +518,7 @@ void Sapphire::Network::GameConnection::commandHandler( const Packets::FFXIVARR_
       if( !emoteData )
         return;
 
-      server().queueForPlayers( player.getInRangePlayerIds(),
-                                makeActorControlTarget( player.getId(), ActorControlType::Emote, emoteId, 0, isSilent ? 1 : 0, 0, targetId ) );
+      Network::Util::Packet::sendActorControlTarget( player.getInRangePlayerIds(), player.getId(), Emote, emoteId, 0, isSilent ? 1 : 0, 0, targetId );
 
       bool isPersistent = emoteData->data().Mode != 0;
 
@@ -531,9 +529,8 @@ void Sapphire::Network::GameConnection::commandHandler( const Packets::FFXIVARR_
         player.setPersistentEmote( emoteData->data().Mode );
         player.setStatus( ActorStatus::EmoteMode );
 
-        server().queueForPlayers( player.getInRangePlayerIds( true ), makeActorControl( player.getId(), ActorControlType::SetStatus,
-                                                                                        static_cast< uint8_t >( ActorStatus::EmoteMode ),
-                                                                                        emoteData->data().IsEndEmoteMode ? 1 : 0 ) );
+        Network::Util::Packet::sendActorControl( player.getInRangePlayerIds( true ), player.getId(), SetStatus, static_cast< uint8_t >( ActorStatus::EmoteMode ),
+                                                 emoteData->data().IsEndEmoteMode ? 1 : 0  );
       }
 
       if( emoteData->data().IsAvailableWhenDrawn )
@@ -545,7 +542,7 @@ void Sapphire::Network::GameConnection::commandHandler( const Packets::FFXIVARR_
     }
     case PacketCommand::EMOTE_CANCEL: // emote
     {
-      server().queueForPlayers( player.getInRangePlayerIds(), makeActorControl( player.getId(), ActorControlType::EmoteInterrupt ) );
+      Network::Util::Packet::sendActorControl( player.getInRangePlayerIds(), player.getId(), EmoteModeInterrupt );
       break;
     }
     case PacketCommand::EMOTE_MODE_CANCEL:
@@ -556,8 +553,9 @@ void Sapphire::Network::GameConnection::commandHandler( const Packets::FFXIVARR_
         player.setStatus( ActorStatus::Idle );
 
         server().queueForPlayers( player.getInRangePlayerIds(), std::make_shared< MoveActorPacket >( player, player.getRot(), 2, 0, 0, 0x5A / 4 ) );
-        server().queueForPlayers( player.getInRangePlayerIds(), makeActorControl( player.getId(), ActorControlType::EmoteModeInterrupt ) );
-        server().queueForPlayers( player.getInRangePlayerIds(), makeActorControl( player.getId(), SetStatus, static_cast< uint8_t >( ActorStatus::Idle ) ) );
+
+        Network::Util::Packet::sendActorControl( player.getInRangePlayerIds(), player.getId(), EmoteModeInterrupt );
+        Network::Util::Packet::sendActorControl( player.getInRangePlayerIds(), player.getId(), SetStatus, static_cast< uint8_t >( ActorStatus::Idle ) );
       }
       break;
     }
@@ -565,7 +563,7 @@ void Sapphire::Network::GameConnection::commandHandler( const Packets::FFXIVARR_
     case PacketCommand::POSE_EMOTE_WORK: // reapply pose
     {
       player.setPose( static_cast< uint8_t >( data.Arg1 ) );
-      server().queueForPlayers( player.getInRangePlayerIds( true ), makeActorControl( player.getId(), SetPose, data.Arg0, data.Arg1 ) );
+      Network::Util::Packet::sendActorControl( player.getInRangePlayerIds( true ), player.getId(), SetPose, data.Arg0, data.Arg1 );
       break;
     }
     case PacketCommand::POSE_EMOTE_CANCEL: // cancel pose
@@ -604,18 +602,19 @@ void Sapphire::Network::GameConnection::commandHandler( const Packets::FFXIVARR_
       auto achievementId = data.Arg0;
       auto& achvMgr = Common::Service< AchievementMgr >::ref();
       auto achvProgress = achvMgr.getAchievementDataById( player, achievementId );
-      Network::Util::Player::sendActorControl( player, AchievementSetRate, achievementId, achvProgress.first, achvProgress.second );
+      Network::Util::Packet::sendActorControl( player, player.getId(), AchievementSetRate, achievementId, achvProgress.first, achvProgress.second );
       break;
     }
     case PacketCommand::ACHIEVEMENT_REQUEST:
     {
-      Network::Util::Player::sendAchievementList( player );
+      Network::Util::Packet::sendAchievementList( player );
       break;
     }
     case PacketCommand::TELEPO_INQUIRY: // Teleport
     {
-
-      player.teleportQuery( static_cast< uint16_t >( data.Arg0 ) );
+      // data.Arg0 = aetheryte id
+      // data.Arg1 = confirm or cancel if using aetheryte ticket
+      player.teleportQuery( static_cast< uint16_t >( data.Arg0 ), data.Arg1 == 1 );
       break;
     }
     case PacketCommand::DYE_ITEM: // Dye item
@@ -670,7 +669,7 @@ void Sapphire::Network::GameConnection::commandHandler( const Packets::FFXIVARR_
 
       player.setActiveLand( static_cast< uint8_t >( data.Arg0 ), hZone->getWardNum() );
 
-      server().queueForPlayer( player.getCharacterId(), makeActorControl( player.getId(), ShowBuildPresetUI, data.Arg0 ) );
+      Network::Util::Packet::sendActorControl( player, player.getId(), ShowBuildPresetUI, data.Arg0 );
       break;
     }
     case PacketCommand::HOUSING_AUCTION_INFO:
@@ -748,8 +747,7 @@ void Sapphire::Network::GameConnection::commandHandler( const Packets::FFXIVARR_
 
       uint8_t ward = ( data.Arg1 >> 16 ) & 0xFF;
       uint8_t plot = ( data.Arg1 & 0xFF );
-      server().queueForPlayer( player.getCharacterId(), makeActorControl( player.getId(), ShowHousingItemUI, 0, plot ) );
-
+      Network::Util::Packet::sendActorControl( player, player.getId(), ShowHousingItemUI, 0, plot );
       //TODO: show item housing container
 
       break;
diff --git a/src/world/Network/Handlers/PacketHandlers.cpp b/src/world/Network/Handlers/PacketHandlers.cpp
index 19057acb7..e4d1679de 100644
--- a/src/world/Network/Handlers/PacketHandlers.cpp
+++ b/src/world/Network/Handlers/PacketHandlers.cpp
@@ -29,6 +29,7 @@
 #include "Network/PacketWrappers/ActorControlSelfPacket.h"
 #include "Network/PacketWrappers/ActorControlTargetPacket.h"
 #include "Network/PacketWrappers/UpdateInventorySlotPacket.h"
+#include "Network/Util/PacketUtil.h"
 
 #include "Manager/DebugCommandMgr.h"
 #include "Manager/MarketMgr.h"
@@ -83,8 +84,7 @@ void Sapphire::Network::GameConnection::setProfileHandler( const Packets::FFXIVA
   strcpy( searchInfoPacket->data().SearchComment, player.getSearchMessage() );
   queueOutPacket( searchInfoPacket );
 
-  server().queueForPlayers( player.getInRangePlayerIds( true ), makeActorControl( player.getId(), SetStatusIcon,
-                                                                                  static_cast< uint8_t >( player.getOnlineStatus() ) ) );
+  Network::Util::Packet::sendActorControl( player.getInRangePlayerIds( true ), player.getId(), SetStatusIcon, static_cast< uint8_t >( player.getOnlineStatus() ) );
 }
 
 void Sapphire::Network::GameConnection::getProfileHandler( const Packets::FFXIVARR_PACKET_RAW& inPacket, Entity::Player& player )
@@ -103,17 +103,15 @@ void Sapphire::Network::GameConnection::getSearchCommentHandler( const Packets::
 
   Logger::debug( "getSearchCommentHandler: {0}", targetId );
 
-  if( pPlayer )
-  {
-    if( pPlayer->isActingAsGm() || pPlayer->getTerritoryTypeId() != player.getTerritoryTypeId() )
-      return;
-
-    // retail sends the requester's id as both (isForSelf)
-    auto searchInfoPacket = makeZonePacket< FFXIVIpcGetSearchCommentResult >( player.getId() );
-    searchInfoPacket->data().TargetEntityID = targetId;
-    strcpy( searchInfoPacket->data().SearchComment, pPlayer->getSearchMessage() );
-    server().queueForPlayer( player.getCharacterId(), searchInfoPacket );
-  }
+  if( !pPlayer || pPlayer->isActingAsGm() || pPlayer->getTerritoryTypeId() != player.getTerritoryTypeId() )
+    return;
+
+  // retail sends the requester's id as both (isForSelf)
+  auto searchInfoPacket = makeZonePacket< FFXIVIpcGetSearchCommentResult >( player.getId() );
+  searchInfoPacket->data().TargetEntityID = targetId;
+  strcpy( searchInfoPacket->data().SearchComment, pPlayer->getSearchMessage() );
+  server().queueForPlayer( player.getCharacterId(), searchInfoPacket );
+
 }
 
 void Sapphire::Network::GameConnection::reqExamineFcInfo( const Packets::FFXIVARR_PACKET_RAW& inPacket, Entity::Player& player )
@@ -236,7 +234,7 @@ void Sapphire::Network::GameConnection::moveHandler( const Packets::FFXIVARR_PAC
     unknownRotation = 0x7F;
   }
 
-  uint64_t currentTime = Util::getTimeMs();
+  uint64_t currentTime = Common::Util::getTimeMs();
 
   player.m_lastMoveTime = currentTime;
   player.m_lastMoveflag = animationType;
@@ -245,6 +243,7 @@ void Sapphire::Network::GameConnection::moveHandler( const Packets::FFXIVARR_PAC
   if( !player.hasInRangeActor() )
     return;
 
+  // todo: probably move this into a builder and send the packet on Player::update if( m_dirtyFlags & DirtyFlag::Position )
   //auto movePacket = std::make_shared< MoveActorPacket >( player, headRotation, animationType, animationState, animationSpeed, unknownRotation );
   auto movePacket = std::make_shared< MoveActorPacket >( player, headRotation, data.flag, data.flag2, animationSpeed, unknownRotation );
   server().queueForPlayers( player.getInRangePlayerIds(), movePacket );
@@ -313,14 +312,14 @@ void Sapphire::Network::GameConnection::newDiscoveryHandler( const Packets::FFXI
 
   PlayerMgr::sendDebug( player, "Discovery ref pos id#{0}", layoutId );
 
-  if( pRefInfo )
-  {
-    auto discoveryPacket = makeZonePacket< FFXIVIpcDiscoveryReply >( player.getId() );
-    discoveryPacket->data().mapId = tInfo->data().Map;
-    discoveryPacket->data().mapPartId = pRefInfo->data.discoveryIndex;
-    server().queueForPlayer( player.getCharacterId(), discoveryPacket );
-    player.discover( tInfo->data().Map, pRefInfo->data.discoveryIndex );
-  }
+  if( !pRefInfo )
+    return;
+
+  auto discoveryPacket = makeZonePacket< FFXIVIpcDiscoveryReply >( player.getId() );
+  discoveryPacket->data().mapId = tInfo->data().Map;
+  discoveryPacket->data().mapPartId = pRefInfo->data.discoveryIndex;
+  server().queueForPlayer( player.getCharacterId(), discoveryPacket );
+  playerMgr().onDiscoverArea( player, tInfo->data().Map, pRefInfo->data.discoveryIndex );
 
 }
 
@@ -363,9 +362,7 @@ void Sapphire::Network::GameConnection::setLanguageHandler( const Packets::FFXIV
 
   // if this is a login event
   if( player.isLogin() )
-  {
     playerMgr().sendLoginMessage( player );
-  }
 
   // spawn the player for himself
   player.spawn( player.getAsPlayer() );
@@ -619,9 +616,7 @@ void Sapphire::Network::GameConnection::gearSetEquip( const Packets::FFXIVARR_PA
   player.sendGearInventory();
 
   if( packet.data().contextId < 0xFE )
-  {
-    server().queueForPlayer( player.getCharacterId(), makeActorControlSelf( player.getId(), Network::ActorControl::GearSetEquipMsg, packet.data().contextId ) );
-  }
+    Network::Util::Packet::sendActorControlSelf( player, player.getId(), GearSetEquipMsg, packet.data().contextId );
 
   auto invTransFinPacket = makeZonePacket< FFXIVIpcItemOperationBatch >( player.getId() );
   invTransFinPacket->data().contextId = contextId;
diff --git a/src/world/Network/PacketWrappers/EffectPacket.h b/src/world/Network/PacketWrappers/EffectPacket.h
index 4e418f3cd..9e190a344 100644
--- a/src/world/Network/PacketWrappers/EffectPacket.h
+++ b/src/world/Network/PacketWrappers/EffectPacket.h
@@ -13,15 +13,15 @@ namespace Sapphire::Network::Packets::WorldPackets::Server
   class EffectPacket : public ZoneChannelPacket< FFXIVIpcActionResult >
   {
   public:
-    EffectPacket( uint64_t sourceId, uint32_t actionId ) :
-      ZoneChannelPacket< FFXIVIpcActionResult >( static_cast< uint32_t >( sourceId ) )
+    EffectPacket( uint64_t sourceId, uint32_t mainTarget, uint32_t actionId ) :
+      ZoneChannelPacket< FFXIVIpcActionResult >( static_cast< uint32_t >( sourceId ), mainTarget )
     {
       m_data.Flag = 0;
       m_data.ActionKey = actionId;
       m_data.Action = static_cast< uint16_t >( actionId );
       m_data.ActionKind = 1;
 
-      m_data.MainTarget = Common::INVALID_GAME_OBJECT_ID;
+      m_data.MainTarget = static_cast< uint64_t >( mainTarget );
       m_data.BallistaEntityId = Common::INVALID_GAME_OBJECT_ID;
 
       m_data.LockTime = 0.6f;
@@ -58,9 +58,9 @@ namespace Sapphire::Network::Packets::WorldPackets::Server
       std::memcpy( &m_data.CalcResult[ m_data.TargetCount - 1 ].CalcResultCt[ m_sourceEffectCount++ ], &effect, sizeof( Common::CalcResultParam ) );
     }
 
-    void setAnimationId( uint16_t animationId )
+    void setActionId( uint16_t actionId )
     {
-      m_data.Action = animationId;
+      m_data.Action = actionId;
     }
 
     void setDisplayType( Common::ActionEffectDisplayType displayType )
@@ -78,13 +78,6 @@ namespace Sapphire::Network::Packets::WorldPackets::Server
       m_data.DirTarget = rotation;
     }
 
-    void setTargetActor( const uint32_t targetId )
-    {
-      m_data.MainTarget = static_cast< uint64_t >( targetId );
-
-      FFXIVPacketBase::setTargetActor( targetId );
-    }
-
     void setRequestId( uint16_t requestId )
     {
       m_data.RequestId = static_cast< uint32_t >( requestId );
@@ -99,4 +92,10 @@ namespace Sapphire::Network::Packets::WorldPackets::Server
     uint8_t m_sourceEffectCount{ 0 };
   };
 
+  template< typename... Args >
+  std::shared_ptr< EffectPacket > makeEffectPacket( Args... args )
+  {
+    return std::make_shared< EffectPacket >( args... );
+  }
+
 }
\ No newline at end of file
diff --git a/src/world/Network/PacketWrappers/EffectPacket1.h b/src/world/Network/PacketWrappers/EffectPacket1.h
index 37393d370..b6752374d 100644
--- a/src/world/Network/PacketWrappers/EffectPacket1.h
+++ b/src/world/Network/PacketWrappers/EffectPacket1.h
@@ -83,5 +83,10 @@ namespace Sapphire::Network::Packets::WorldPackets::Server
     uint8_t m_sourceEffectCount{ 0 };
   };
 
+  template< typename... Args >
+  std::shared_ptr< EffectPacket1 > makeEffectPacket1( Args... args )
+  {
+    return std::make_shared< EffectPacket1 >( args... );
+  }
 }
 
diff --git a/src/world/Network/PacketWrappers/NpcSpawnPacket.h b/src/world/Network/PacketWrappers/NpcSpawnPacket.h
index 1cf379823..f3ff593c6 100644
--- a/src/world/Network/PacketWrappers/NpcSpawnPacket.h
+++ b/src/world/Network/PacketWrappers/NpcSpawnPacket.h
@@ -77,6 +77,16 @@ namespace Sapphire::Network::Packets::WorldPackets::Server
       m_data.NpcId = bnpc.getBNpcBaseId();
       m_data.NameId = bnpc.getBNpcNameId();
 
+      if( bnpc.getInstanceObjectInfo() )
+      {
+        m_data.LinkCountLimit = bnpc.getInstanceObjectInfo()->LinkCountLimit;
+        m_data.LinkFamily = bnpc.getInstanceObjectInfo()->LinkFamily;
+        m_data.LinkGroup = bnpc.getInstanceObjectInfo()->LinkGroup;
+        m_data.LinkParent = bnpc.getInstanceObjectInfo()->LinkParent;
+        m_data.LinkRange = bnpc.getInstanceObjectInfo()->LinkRange;
+        m_data.LinkReply = bnpc.getInstanceObjectInfo()->LinkReply;
+      }
+
       assert( target.getId() != bnpc.getId() );
 
       m_data.Index = target.getSpawnIdForActorId( bnpc.getId() );
diff --git a/src/world/Network/Util/PlayerUtil.cpp b/src/world/Network/Util/PacketUtil.cpp
similarity index 62%
rename from src/world/Network/Util/PlayerUtil.cpp
rename to src/world/Network/Util/PacketUtil.cpp
index f9f3d6115..2c03de54c 100644
--- a/src/world/Network/Util/PlayerUtil.cpp
+++ b/src/world/Network/Util/PacketUtil.cpp
@@ -1,4 +1,4 @@
-#include "PlayerUtil.h"
+#include "PacketUtil.h"
 
 #include <Exd/ExdData.h>
 
@@ -18,23 +18,25 @@
 #include <Network/PacketWrappers/RestingPacket.h>
 #include <Network/PacketWrappers/PlayerSetupPacket.h>
 #include <Network/PacketWrappers/InitZonePacket.h>
+#include <Network/PacketWrappers/ServerNoticePacket.h>
+#include <Network/PacketWrappers/ChatPacket.h>
 
 using namespace Sapphire;
 using namespace Sapphire::World::Manager;
 using namespace Sapphire::Network;
-using namespace Sapphire::Network::Util::Player;
+using namespace Sapphire::Network::Util::Packet;
 using namespace Sapphire::Network::Packets;
 using namespace Sapphire::Network::Packets::WorldPackets::Server;
 using namespace Sapphire::Network::ActorControl;
 
-void Util::Player::sendConfigFlags( Entity::Player& player )
+void Util::Packet::sendConfigFlags( Entity::Player& player )
 {
   auto paramPacket = makeZonePacket< FFXIVIpcConfig >( player.getId() );
   paramPacket->data().flag = player.getConfigFlags();
   server().queueForPlayers( player.getInRangePlayerIds( true ), paramPacket );
 }
 
-void Util::Player::sendOnlineStatus( Entity::Player& player )
+void Util::Packet::sendOnlineStatus( Entity::Player& player )
 {
   auto statusPacket = makeZonePacket< FFXIVIpcSetOnlineStatus >( player.getId() );
   statusPacket->data().onlineStatusFlags = player.getFullOnlineStatusMask();
@@ -44,21 +46,19 @@ void Util::Player::sendOnlineStatus( Entity::Player& player )
                             makeActorControl( player.getId(), SetStatusIcon, static_cast< uint8_t >( player.getOnlineStatus() ) ) );
 }
 
-void Util::Player::sendBaseParams( Entity::Player& player )
+void Util::Packet::sendBaseParams( Entity::Player& player )
 {
   std::array< uint32_t, 50 > statParams{};
   std::fill( std::begin( statParams ), std::end( statParams ), 0 );
 
   auto& exd = Common::Service< Data::ExdData >::ref();
-  auto idList = exd.getIdList< Excel::BaseParam >();
+  auto baseParamList = exd.getRows< Excel::BaseParam >();
 
-  for( const auto id : idList )
+  for( const auto& [ id, row ] : baseParamList )
   {
-    auto row = exd.getRow< Excel::BaseParam >( id );
-    if( !row )
-      continue;
-    if( row->data().PacketIndex < 0 )
+    if( !row || row->data().PacketIndex < 0 )
       continue;
+
     statParams[ row->data().PacketIndex ] = player.getStatValue( static_cast< Common::BaseParam >( id ) );
   }
 
@@ -67,25 +67,29 @@ void Util::Player::sendBaseParams( Entity::Player& player )
   server().queueForPlayer( player.getCharacterId(), statPacket );
 }
 
-void Util::Player::sendHudParam( Entity::Player& player )
+void Util::Packet::sendHudParam( Entity::Chara& source )
 {
-  auto hudParamPacket = makeHudParam( player );
-  server().queueForPlayer( player.getCharacterId(), hudParamPacket );
+  if( source.isPlayer() )
+    server().queueForPlayers( source.getInRangePlayerIds( true ), makeHudParam( *source.getAsPlayer() ) );
+  else if( source.isBattleNpc() )
+    server().queueForPlayers( source.getInRangePlayerIds( false ), makeHudParam( *source.getAsBNpc() ) );
+  else
+    server().queueForPlayers( source.getInRangePlayerIds( false ), makeHudParam( source ) );
 }
 
-void Util::Player::sendStatusUpdate( Entity::Player& player )
+void Util::Packet::sendStatusUpdate( Entity::Player& player )
 {
   auto playerStatusUpdate = makeZonePacket< FFXIVIpcPlayerStatusUpdate >( player.getId() );
   playerStatusUpdate->data().ClassJob = static_cast< uint8_t >( player.getClass() );
   playerStatusUpdate->data().Lv = player.getLevel();
   playerStatusUpdate->data().Lv1 = player.getLevel();
   playerStatusUpdate->data().LvSync = 0; //player.getLevelSync();
-  playerStatusUpdate->data().Exp = player.getExp();
+  playerStatusUpdate->data().Exp = player.getCurrentExp();
 
   server().queueForPlayer( player.getCharacterId(), playerStatusUpdate );
 }
 
-void Util::Player::sendHuntingLog( Entity::Player& player )
+void Util::Packet::sendHuntingLog( Entity::Player& player )
 {
   auto& exdData = Common::Service< Data::ExdData >::ref();
   for( auto entryCount = 0; entryCount < Common::ARRSIZE_MONSTERNOTE; ++entryCount )
@@ -128,37 +132,74 @@ void Util::Player::sendHuntingLog( Entity::Player& player )
   }
 }
 
-void Util::Player::sendActorControlSelf( Entity::Player& player, uint16_t category, uint32_t param1, uint32_t param2, uint32_t param3,
+void Util::Packet::sendActorControlSelf( Entity::Player& player, uint32_t srcId, uint16_t category, uint32_t param1, uint32_t param2, uint32_t param3,
                                          uint32_t param4, uint32_t param5 )
 {
-  server().queueForPlayer( player.getCharacterId(), makeActorControlSelf( player.getId(), category, param1, param2, param3, param4, param5 ) );
+  server().queueForPlayer( player.getCharacterId(), makeActorControlSelf( srcId, category, param1, param2, param3, param4, param5 ) );
 }
 
-void Util::Player::sendActorControlSelf( const std::set< uint64_t >& characterIds, Entity::Player& player, uint16_t category, uint32_t param1,
+void Util::Packet::sendActorControlSelf( const std::set< uint64_t >& characterIds, uint32_t srcId, uint16_t category, uint32_t param1,
                                          uint32_t param2, uint32_t param3, uint32_t param4, uint32_t param5 )
 {
-  server().queueForPlayers( characterIds, makeActorControlSelf( player.getId(), category, param1, param2, param3, param4, param5 ) );
+  server().queueForPlayers( characterIds, makeActorControlSelf( srcId, category, param1, param2, param3, param4, param5 ) );
 }
 
-void Util::Player::sendActorControl( Entity::Player& player, uint16_t category, uint32_t param1, uint32_t param2, uint32_t param3, uint32_t param4 )
+void Util::Packet::sendActorControl( Entity::Player& player, uint32_t srcId, uint16_t category, uint32_t param1, uint32_t param2, uint32_t param3, uint32_t param4 )
 {
-  server().queueForPlayer( player.getCharacterId(), makeActorControl( player.getId(), category, param1, param2, param3, param4 ) );
+  server().queueForPlayer( player.getCharacterId(), makeActorControl( srcId, category, param1, param2, param3, param4 ) );
 }
 
-void Util::Player::sendActorControl( const std::set< uint64_t >& characterIds, Entity::Player& player, uint16_t category, uint32_t param1,
+void Util::Packet::sendActorControl( const std::set< uint64_t >& characterIds, uint32_t srcId, uint16_t category, uint32_t param1,
                                      uint32_t param2, uint32_t param3, uint32_t param4 )
 {
-  server().queueForPlayers( characterIds, makeActorControl( player.getId(), category, param1, param2, param3, param4 ) );
+  server().queueForPlayers( characterIds, makeActorControl( srcId, category, param1, param2, param3, param4 ) );
+}
+
+void Util::Packet::sendActorControlTarget( Entity::Player& player, uint32_t srcId, uint16_t category, uint32_t param1, uint32_t param2, uint32_t param3,
+                                           uint32_t param4, uint32_t param5, uint32_t param6 )
+{
+  server().queueForPlayer( player.getCharacterId(), makeActorControlTarget( srcId, category, param1, param2, param3, param4, param5, param6 ) );
+}
+
+void Util::Packet::sendActorControlTarget( const std::set< uint64_t >& characterIds, uint32_t srcId, uint16_t category, uint32_t param1,
+                                           uint32_t param2, uint32_t param3, uint32_t param4, uint32_t param5, uint32_t param6 )
+{
+  server().queueForPlayers( characterIds, makeActorControlTarget( srcId, category, param1, param2, param3, param4, param5, param6 ) );
 }
 
-void Util::Player::sendTitleList( Entity::Player& player )
+void Sapphire::Network::Util::Packet::sendBattleTalk( Sapphire::Entity::Player& player, uint32_t battleTalkId, uint32_t handlerId,
+                                                      uint32_t kind, uint32_t nameId, uint32_t talkerId,
+                                                      uint32_t param1, uint32_t param2, uint32_t param3, uint32_t param4,
+                                                      uint32_t param5, uint32_t param6, uint32_t param7, uint32_t param8 )
+{
+  auto battleTalkPacket = makeZonePacket< FFXIVIpcBattleTalk8 >( talkerId, player.getId() );
+  auto& data = battleTalkPacket->data();
+  data.battleTalkId = battleTalkId;
+  data.handlerId = handlerId;
+  data.nameId = nameId;
+  data.kind = kind;
+  data.talkerId = talkerId;
+
+  data.args[ 0 ] = param1;
+  data.args[ 1 ] = param2;
+  data.args[ 2 ] = param3;
+  data.args[ 3 ] = param4;
+  data.args[ 4 ] = param5;
+  data.args[ 5 ] = param6;
+  data.args[ 6 ] = param7;
+  data.args[ 7 ] = param8;
+
+  server().queueForPlayer( player.getCharacterId(), battleTalkPacket );
+}
+
+void Util::Packet::sendTitleList( Entity::Player& player )
 {
   auto titleListPacket = makeZonePacket< FFXIVIpcTitleList >( player.getId() );
   memcpy( titleListPacket->data().TitleFlagsArray, player.getTitleList().data(), sizeof( titleListPacket->data().TitleFlagsArray ) );
   server().queueForPlayer( player.getCharacterId(), titleListPacket );
 }
 
-void Util::Player::sendGrandCompany( Entity::Player& player )
+void Util::Packet::sendGrandCompany( Entity::Player& player )
 {
   auto gcAffPacket = makeZonePacket< FFXIVIpcGrandCompany >( player.getId() );
   gcAffPacket->data().ActiveCompanyId = player.getGc();
@@ -168,7 +209,7 @@ void Util::Player::sendGrandCompany( Entity::Player& player )
   server().queueForPlayer( player.getCharacterId(), gcAffPacket );
 }
 
-void Util::Player::sendDeletePlayer( Entity::Player& player, uint32_t actorId, uint8_t spawnIndex )
+void Util::Packet::sendDeletePlayer( Entity::Player& player, uint32_t actorId, uint8_t spawnIndex )
 {
   auto freeActorSpawnPacket = makeZonePacket< FFXIVIpcActorFreeSpawn >( player.getId() );
   freeActorSpawnPacket->data().actorId = actorId;
@@ -176,14 +217,14 @@ void Util::Player::sendDeletePlayer( Entity::Player& player, uint32_t actorId, u
   server().queueForPlayer( player.getCharacterId(), freeActorSpawnPacket );
 }
 
-void Util::Player::sendDeleteObject( Entity::Player& player, uint8_t spawnIndex )
+void Util::Packet::sendDeleteObject( Entity::Player& player, uint8_t spawnIndex )
 {
   auto freeObjectSpawnPacket = makeZonePacket< FFXIVIpcDeleteObject >( player.getId() );
   freeObjectSpawnPacket->data().Index = spawnIndex;
   server().queueForPlayer( player.getCharacterId(), freeObjectSpawnPacket );
 }
 
-void Util::Player::sendHateList( Entity::Player& player )
+void Util::Packet::sendHateList( Entity::Player& player )
 {
   auto& teriMgr = Common::Service< World::Manager::TerritoryMgr >::ref();
 
@@ -211,7 +252,7 @@ void Util::Player::sendHateList( Entity::Player& player )
     if( hateValue == 0 )
       continue;
 
-    auto hatePercent = ( hateValue / static_cast< float >( pBNpc->hateListGetHighestValue() ) ) * 100.f;
+    auto hatePercent = ( static_cast< float >( hateValue ) / static_cast< float >( pBNpc->hateListGetHighestValue() ) ) * 100.f;
 
     hateListPacket->data().List[ i ].Id = player.getId();
     hateListPacket->data().List[ i ].Value = hateValue;
@@ -223,36 +264,36 @@ void Util::Player::sendHateList( Entity::Player& player )
   server().queueForPlayer( player.getCharacterId(), { hateListPacket, hateRankPacket } );
 }
 
-void Util::Player::sendMount( Entity::Player& player )
+void Util::Packet::sendMount( Entity::Player& player )
 {
   auto mountId = player.getCurrentMount();
   auto inRangePlayerIds = player.getInRangePlayerIds( true );
   if( mountId != 0 )
   {
-    Network::Util::Player::sendActorControl( inRangePlayerIds, player, SetStatus, static_cast< uint8_t >( Common::ActorStatus::Mounted ) );
-    Network::Util::Player::sendActorControlSelf( inRangePlayerIds, player, 0x39e, 12 );
+    Network::Util::Packet::sendActorControl( inRangePlayerIds, player.getId(), SetStatus, static_cast< uint8_t >( Common::ActorStatus::Mounted ) );
+    Network::Util::Packet::sendActorControlSelf( inRangePlayerIds, player.getId(), 0x39e, 12 );
   }
   else
   {
-    Network::Util::Player::sendActorControl( inRangePlayerIds, player, SetStatus, static_cast< uint8_t >( Common::ActorStatus::Idle ) );
-    Network::Util::Player::sendActorControlSelf( inRangePlayerIds, player, Dismount, 1 );
+    Network::Util::Packet::sendActorControl( inRangePlayerIds, player.getId(), SetStatus, static_cast< uint8_t >( Common::ActorStatus::Idle ) );
+    Network::Util::Packet::sendActorControlSelf( inRangePlayerIds, player.getId(), Dismount, 1 );
   }
   auto mountPacket = makeZonePacket< FFXIVIpcMount >( player.getId() );
   mountPacket->data().id = mountId;
   server().queueForPlayers( inRangePlayerIds, mountPacket );
 }
 
-void Util::Player::sendEquip( Entity::Player& player )
+void Util::Packet::sendEquip( Entity::Player& player )
 {
   server().queueForPlayers( player.getInRangePlayerIds( true ), std::make_shared< ModelEquipPacket >( player ) );
 }
 
-void Util::Player::sendCondition( Entity::Player& player )
+void Util::Packet::sendCondition( Entity::Player& player )
 {
   server().queueForPlayer( player.getCharacterId(), std::make_shared< ConditionPacket >( player ) );
 }
 
-void Util::Player::sendRecastGroups( Entity::Player& player )
+void Util::Packet::sendRecastGroups( Entity::Player& player )
 {
   const auto& recastGroups = player.getRecastGroups();
   const auto& recastGroupsMax = player.getRecastGroupsMax();
@@ -262,7 +303,7 @@ void Util::Player::sendRecastGroups( Entity::Player& player )
   server().queueForPlayer( player.getCharacterId(), recastGroupPaket );
 }
 
-void Util::Player::sendAchievementList( Entity::Player& player )
+void Util::Packet::sendAchievementList( Entity::Player& player )
 {
   auto achvData = player.getAchievementData();
   auto achvPacket = makeZonePacket< FFXIVIpcAchievement >( player.getId() );
@@ -271,34 +312,36 @@ void Util::Player::sendAchievementList( Entity::Player& player )
   server().queueForPlayer( player.getCharacterId(), achvPacket );
 }
 
-void Util::Player::sendRestingUpdate( Entity::Player& player )
+void Util::Packet::sendRestingUpdate( Entity::Player& player )
 {
   server().queueForPlayers( player.getInRangePlayerIds( true ), std::make_shared< RestingPacket >( player ) );
 }
 
-void Util::Player::sendLogin( Entity::Player& player )
+void Util::Packet::sendLogin( Entity::Player& player )
 {
   auto initPacket = makeZonePacket< FFXIVIpcLogin >( player.getId() );
   initPacket->data().playerActorId = player.getId();
   server().queueForPlayer( player.getCharacterId(), initPacket );
 }
 
-void Util::Player::sendPlayerSetup( Entity::Player& player )
+void Util::Packet::sendPlayerSetup( Entity::Player& player )
 {
   server().queueForPlayer( player.getCharacterId(), makePlayerSetup( player ) );
 }
 
-void Util::Player::sendChangeClass( Entity::Player& player )
+void Util::Packet::sendChangeClass( Entity::Player& player )
 {
   auto classInfo = makeZonePacket< FFXIVIpcChangeClass >( player.getId() );
+  auto& borrowAction = player.getBorrowAction();
   classInfo->data().ClassJob = static_cast< uint8_t >( player.getClass() );
   classInfo->data().Lv = player.getLevel();
   classInfo->data().Lv1 = player.getLevel();
   classInfo->data().Login = player.isLogin() ? 1 : 0;
+  memcpy( &classInfo->data().BorrowAction[ 0 ], borrowAction.data(), borrowAction.size() * 4 );
   server().queueForPlayer( player.getCharacterId(), classInfo );
 }
 
-void Util::Player::sendContentAttainFlags( Entity::Player& player )
+void Util::Packet::sendContentAttainFlags( Entity::Player& player )
 {
   // todo - fill with actual data from player
   auto contentFinderList = makeZonePacket< FFXIVIpcContentAttainFlags >( player.getId() );
@@ -306,7 +349,7 @@ void Util::Player::sendContentAttainFlags( Entity::Player& player )
   server().queueForPlayer( player.getCharacterId(), contentFinderList );
 }
 
-void Util::Player::sendInitZone( Entity::Player& player )
+void Util::Packet::sendInitZone( Entity::Player& player )
 {
   auto& teriMgr = Common::Service< World::Manager::TerritoryMgr >::ref();
   auto pZone = teriMgr.getTerritoryByGuId( player.getTerritoryId() );
@@ -319,12 +362,22 @@ void Util::Player::sendInitZone( Entity::Player& player )
   server().queueForPlayer( player.getCharacterId(), makeInitZone( player, teri ) );
 }
 
-void Util::Player::sendDailyQuests( Entity::Player& player )
+void Util::Packet::sendDailyQuests( Entity::Player& player )
 {
   server().queueForPlayer( player.getCharacterId(), makeZonePacket< FFXIVIpcDailyQuests >( player.getId() ) );
 }
 
-void Util::Player::sendQuestRepeatFlags( Entity::Player& player )
+void Util::Packet::sendQuestRepeatFlags( Entity::Player& player )
 {
   server().queueForPlayer( player.getCharacterId(), makeZonePacket< FFXIVIpcQuestRepeatFlags >( player.getId() ) );
+}
+
+void Util::Packet::sendServerNotice( Entity::Player& player, const std::string& message )
+{
+  server().queueForPlayer( player.getCharacterId(), std::make_shared< ServerNoticePacket >( player.getId(), message ) );
+}
+
+void Util::Packet::sendChat( Entity::Player& player, Common::ChatType chatType, const std::string& message )
+{
+  server().queueForPlayer( player.getCharacterId(), std::make_shared< ChatPacket >( player, chatType, message ) );
 }
\ No newline at end of file
diff --git a/src/world/Network/Util/PlayerUtil.h b/src/world/Network/Util/PacketUtil.h
similarity index 53%
rename from src/world/Network/Util/PlayerUtil.h
rename to src/world/Network/Util/PacketUtil.h
index fab84d70b..0aa7739b5 100644
--- a/src/world/Network/Util/PlayerUtil.h
+++ b/src/world/Network/Util/PacketUtil.h
@@ -5,12 +5,12 @@
 #include <Actor/Player.h>
 #include "Forwards.h"
 
-namespace Sapphire::Network::Util::Player
+namespace Sapphire::Network::Util::Packet
 {
   void sendConfigFlags( Entity::Player& player );
   void sendOnlineStatus( Entity::Player& player );
   void sendBaseParams( Entity::Player& player );
-  void sendHudParam( Entity::Player& player );
+  void sendHudParam( Entity::Chara& player );
   void sendStatusUpdate( Entity::Player& player );
 
   void sendHuntingLog( Entity::Player& player );
@@ -48,15 +48,29 @@ namespace Sapphire::Network::Util::Player
   void sendDailyQuests( Entity::Player& player );
   void sendQuestRepeatFlags( Entity::Player& player );
 
-  void sendActorControlSelf( Entity::Player& player, uint16_t category, uint32_t param1 = 0, uint32_t param2 = 0, uint32_t param3 = 0,
+  void sendServerNotice( Entity::Player& player, const std::string& message );
+
+  void sendChat( Entity::Player& player, Common::ChatType chatType, const std::string& message );
+
+  void sendActorControlSelf( Entity::Player& player, uint32_t srcId, uint16_t category, uint32_t param1 = 0, uint32_t param2 = 0, uint32_t param3 = 0,
                              uint32_t param4 = 0, uint32_t param5 = 0 );
 
-  void sendActorControlSelf( const std::set< uint64_t >& characterIds, Entity::Player& player, uint16_t category, uint32_t param1 = 0,
+  void sendActorControlSelf( const std::set< uint64_t >& characterIds, uint32_t srcId, uint16_t category, uint32_t param1 = 0,
                              uint32_t param2 = 0, uint32_t param3 = 0, uint32_t param4 = 0, uint32_t param5 = 0 );
 
-  void sendActorControl( Entity::Player& player, uint16_t category, uint32_t param1 = 0, uint32_t param2 = 0, uint32_t param3 = 0, uint32_t param4 = 0 );
+  void sendActorControl( Entity::Player& player, uint32_t srcId, uint16_t category, uint32_t param1 = 0, uint32_t param2 = 0, uint32_t param3 = 0, uint32_t param4 = 0 );
 
-  void sendActorControl( const std::set< uint64_t >& characterIds, Entity::Player& player, uint16_t category, uint32_t param1 = 0, uint32_t param2 = 0,
+  void sendActorControl( const std::set< uint64_t >& characterIds, uint32_t srcId, uint16_t category, uint32_t param1 = 0, uint32_t param2 = 0,
                          uint32_t param3 = 0, uint32_t param4 = 0 );
 
+  void sendActorControlTarget( Entity::Player& player, uint32_t srcId, uint16_t category, uint32_t param1 = 0, uint32_t param2 = 0, uint32_t param3 = 0,
+                               uint32_t param4 = 0, uint32_t param5 = 0, uint32_t param6 = 0 );
+
+  void sendActorControlTarget( const std::set< uint64_t >& characterIds, uint32_t srcId, uint16_t category, uint32_t param1 = 0,
+                               uint32_t param2 = 0, uint32_t param3 = 0, uint32_t param4 = 0, uint32_t param5 = 0, uint32_t param6 = 0 );
+
+  void sendBattleTalk( Sapphire::Entity::Player& player, uint32_t battleTalkId, uint32_t handlerId,
+                       uint32_t kind, uint32_t nameId, uint32_t talkerId,
+                       uint32_t param1 = 0, uint32_t param2= 0, uint32_t param3 = 0, uint32_t param4 = 0,
+                       uint32_t param5 = 0, uint32_t param6= 0, uint32_t param7 = 0, uint32_t param8 = 0 );
 }
\ No newline at end of file
diff --git a/src/world/Script/ScriptMgr.cpp b/src/world/Script/ScriptMgr.cpp
index c000d028c..f6662b629 100644
--- a/src/world/Script/ScriptMgr.cpp
+++ b/src/world/Script/ScriptMgr.cpp
@@ -644,9 +644,6 @@ bool Sapphire::Scripting::ScriptMgr::onStatusTick( Entity::CharaPtr pChara, Sapp
   auto script = m_nativeScriptMgr->getScript< Sapphire::ScriptAPI::StatusEffectScript >( effect.getId() );
   if( script )
   {
-    if( pChara->isPlayer() )
-      PlayerMgr::sendDebug( *pChara->getAsPlayer(), "Calling status tick for statusid#{0}", effect.getId() );
-
     script->onTick( *pChara );
     return true;
   }
diff --git a/src/world/Session.cpp b/src/world/Session.cpp
index 7890a3095..f95967e59 100644
--- a/src/world/Session.cpp
+++ b/src/world/Session.cpp
@@ -160,7 +160,7 @@ void Sapphire::World::Session::startReplay( const std::string& path )
     Logger::info( "Registering {0} for {1}, oldTime {2}", std::get< 1 >( set ), setTime - startTime, setTime );
   }
 
-  PlayerMgr::sendDebug( *getPlayer(), "Registered {0} sets for replay" ), m_replayCache.size();
+  PlayerMgr::sendDebug( *getPlayer(), "Registered {0} sets for replay" , m_replayCache.size() );
   m_isReplaying = true;
 }
 
@@ -204,27 +204,35 @@ void Sapphire::World::Session::sendReplayInfo()
   PlayerMgr::sendDebug( *getPlayer(), message );
 }
 
+void Sapphire::World::Session::processOutQueue()
+{
+  if( !m_pZoneConnection )
+    return;
+
+  m_pZoneConnection->processOutQueue();
+}
+
 void Sapphire::World::Session::update()
 {
   if( m_isReplaying )
     processReplay();
 
-  if( m_pZoneConnection )
-  {
-    m_pZoneConnection->processInQueue();
+  if( !m_pZoneConnection )
+    return;
 
-    // SESSION LOGIC
-    m_pPlayer->update( Common::Util::getTimeMs() );
+  m_pZoneConnection->processInQueue();
 
-    if( Common::Util::getTimeSeconds() - static_cast< uint32_t >( getLastSqlTime() ) > 10 )
-    {
-      updateLastSqlTime();
-      m_pPlayer->updateSql();
-    }
+  // SESSION LOGIC
+  m_pPlayer->update( Common::Util::getTimeMs() );
 
-    m_pZoneConnection->processOutQueue();
+  if( Common::Util::getTimeSeconds() - static_cast< uint32_t >( getLastSqlTime() ) > 10 )
+  {
+    updateLastSqlTime();
+    m_pPlayer->updateSql();
   }
 
+  m_pZoneConnection->processOutQueue();
+
   if( m_pChatConnection )
   {
     m_pChatConnection->processInQueue();
diff --git a/src/world/Session.h b/src/world/Session.h
index 162bca7a7..60207381c 100644
--- a/src/world/Session.h
+++ b/src/world/Session.h
@@ -47,6 +47,8 @@ namespace Sapphire::World
 
     void update();
 
+    void processOutQueue();
+
     bool isValid() const;
 
     Entity::PlayerPtr getPlayer() const;
diff --git a/src/world/StatusEffect/StatusEffect.cpp b/src/world/StatusEffect/StatusEffect.cpp
index 1b371938c..0bb160a0f 100644
--- a/src/world/StatusEffect/StatusEffect.cpp
+++ b/src/world/StatusEffect/StatusEffect.cpp
@@ -6,26 +6,41 @@
 #include <algorithm>
 #include <Service.h>
 
+#include "Manager/PlayerMgr.h"
+
 #include "Actor/Chara.h"
+#include "Actor/Player.h"
 #include "Actor/GameObject.h"
 
 #include "Script/ScriptMgr.h"
 
 #include "StatusEffect.h"
 
+using namespace Sapphire;
 using namespace Sapphire::Common;
 using namespace Sapphire::Network::Packets;
 //using namespace Sapphire::Network::Packets::WorldPackets::Server;
 
+Sapphire::StatusEffect::StatusEffect::StatusEffect( uint32_t id, Entity::CharaPtr sourceActor, Entity::CharaPtr targetActor,
+                                                    uint32_t duration, const std::vector< World::Action::StatusModifier >& modifiers,
+                                                    uint32_t flag, uint32_t tickRate ) :
+  StatusEffect( id, sourceActor, targetActor, duration, tickRate )
+{
+  m_statusModifiers = modifiers;
+  m_flag = flag;
+}
+
 Sapphire::StatusEffect::StatusEffect::StatusEffect( uint32_t id, Entity::CharaPtr sourceActor, Entity::CharaPtr targetActor,
                                                     uint32_t duration, uint32_t tickRate ) :
   m_id( id ),
   m_sourceActor( sourceActor ),
   m_targetActor( targetActor ),
   m_duration( duration ),
+  m_modifiers( 0 ),
   m_startTime( 0 ),
   m_tickRate( tickRate ),
-  m_lastTick( 0 )
+  m_lastTick( 0 ),
+  m_flag( 0 )
 {
   auto& exdData = Common::Service< Data::ExdData >::ref();
   auto entry = exdData.getRow< Excel::Status >( id );
@@ -40,6 +55,22 @@ Sapphire::StatusEffect::StatusEffect::StatusEffect( uint32_t id, Entity::CharaPt
   Util::eraseAll( m_name, '-' );
   Util::eraseAll( m_name, '(' );
   Util::eraseAll( m_name, ')' );
+
+  m_flag |= entry->data().Category;
+  if( entry->data().Forever )
+    m_flag |= static_cast< uint32_t >( Common::StatusEffectFlag::Permanent );
+  if( entry->data().CanOff )
+    m_flag |= static_cast< uint32_t >( Common::StatusEffectFlag::CanStatusOff );
+  if( entry->data().NotAction )
+    m_flag |= static_cast< uint32_t >( Common::StatusEffectFlag::LockActions );
+  if( entry->data().NotControl )
+    m_flag |= static_cast< uint32_t >( Common::StatusEffectFlag::LockControl );
+  if( entry->data().NotMove )
+    m_flag |= static_cast< uint32_t >( Common::StatusEffectFlag::LockMovement );
+  if( entry->data().NotLookAt )
+    m_flag |= static_cast< uint32_t >( Common::StatusEffectFlag::IsGaze );
+  if( entry->data().FcAction )
+    m_flag |= static_cast< uint32_t >( Common::StatusEffectFlag::FcBuff );
 }
 
 
@@ -47,16 +78,14 @@ Sapphire::StatusEffect::StatusEffect::~StatusEffect()
 {
 }
 
-void Sapphire::StatusEffect::StatusEffect::registerTickEffect( uint8_t type, uint32_t param )
+void Sapphire::StatusEffect::StatusEffect::registerTickEffect( ParamModifier type, uint32_t param )
 {
   m_currTickEffect = std::make_pair( type, param );
 }
 
-std::pair< uint8_t, uint32_t > Sapphire::StatusEffect::StatusEffect::getTickEffect()
+std::pair< ParamModifier, uint32_t > Sapphire::StatusEffect::StatusEffect::getTickEffect()
 {
-  auto thisTick = m_currTickEffect;
-  m_currTickEffect = std::make_pair( 0, 0 );
-  return thisTick;
+  return m_currTickEffect;
 }
 
 void Sapphire::StatusEffect::StatusEffect::onTick()
@@ -72,6 +101,11 @@ uint32_t Sapphire::StatusEffect::StatusEffect::getSrcActorId() const
   return m_sourceActor->getId();
 }
 
+Sapphire::Entity::CharaPtr Sapphire::StatusEffect::StatusEffect::getSrcActor() const
+{
+  return m_sourceActor;
+}
+
 uint32_t Sapphire::StatusEffect::StatusEffect::getTargetActorId() const
 {
   return m_targetActor->getId();
@@ -82,28 +116,48 @@ uint16_t Sapphire::StatusEffect::StatusEffect::getParam() const
   return m_param;
 }
 
+const std::unordered_map< Common::ParamModifier, int32_t >& Sapphire::StatusEffect::StatusEffect::getModifiers() const
+{
+  return m_modifiers;
+}
+
+void Sapphire::StatusEffect::StatusEffect::setModifier( Common::ParamModifier paramModifier, int32_t value )
+{
+  m_modifiers[ paramModifier ] = value;
+
+  if( auto pPlayer = m_targetActor->getAsPlayer(); pPlayer )
+    Common::Service< World::Manager::PlayerMgr >::ref().sendDebug( *pPlayer, "Modifier: {}, value: {}", static_cast< int32_t >( paramModifier ),
+                                                                   pPlayer->getModifier( paramModifier ) );
+}
+
+void Sapphire::StatusEffect::StatusEffect::delModifier( Common::ParamModifier paramModifier )
+{
+  if( m_modifiers.find( paramModifier ) == m_modifiers.end() )
+    return;
+
+  m_modifiers.erase( paramModifier );
+
+  if( auto pPlayer = m_targetActor->getAsPlayer(); pPlayer )
+    Common::Service< World::Manager::PlayerMgr >::ref().sendDebug( *pPlayer, "Modifier: {}, value: {}", static_cast< int32_t >( paramModifier ),
+                                                                   pPlayer->getModifier( paramModifier ) );
+}
+
 void Sapphire::StatusEffect::StatusEffect::applyStatus()
 {
   m_startTime = Util::getTimeMs();
   auto& scriptMgr = Common::Service< Scripting::ScriptMgr >::ref();
 
-  // this is only right when an action is being used by the player
-  // else you probably need to use an actorcontrol
-
-  //GamePacketNew< FFXIVIpcEffect > effectPacket( m_sourceActor->getId() );
-  //effectPacket.data().targetId = m_sourceActor->getId();
-  //effectPacket.data().actionAnimationId = 3;
-  //effectPacket.data().unknown_3 = 1;
-  //effectPacket.data().actionTextId = 3;
-  //effectPacket.data().unknown_5 = 1;
-  //effectPacket.data().unknown_6 = 321;
-  //effectPacket.data().rotation = ( uint16_t ) ( 0x8000 * ( ( m_sourceActor->getPos().getR() + 3.1415926 ) ) / 3.1415926 );
-  //effectPacket.data().effectTargetId = m_sourceActor->getId();
-  //effectPacket.data().effects[4].unknown_1 = 17;
-  //effectPacket.data().effects[4].bonusPercent = 30;
-  //effectPacket.data().effects[4].param1 = m_id;
-  //effectPacket.data().effects[4].unknown_5 = 0x80;
-  //m_sourceActor->sendToInRangeSet( effectPacket, true );
+  for( const auto& mod : m_statusModifiers )
+  {
+    if( mod.modifier != Common::ParamModifier::TickDamage && mod.modifier != Common::ParamModifier::TickHeal )
+      setModifier( mod.modifier, mod.value );
+    else if( mod.modifier == Common::ParamModifier::TickDamage )
+      registerTickEffect( mod.modifier, mod.value );
+    else if( mod.modifier == Common::ParamModifier::TickHeal )
+      registerTickEffect( mod.modifier, mod.value );
+  }
+
+  m_targetActor->calculateStats();
 
   scriptMgr.onStatusReceive( m_targetActor, m_id );
 }
@@ -111,6 +165,11 @@ void Sapphire::StatusEffect::StatusEffect::applyStatus()
 void Sapphire::StatusEffect::StatusEffect::removeStatus()
 {
   auto& scriptMgr = Common::Service< Scripting::ScriptMgr >::ref();
+
+  m_modifiers.clear();
+
+  m_targetActor->calculateStats();
+
   scriptMgr.onStatusTimeOut( m_targetActor, m_id );
 }
 
@@ -139,6 +198,21 @@ uint64_t Sapphire::StatusEffect::StatusEffect::getStartTimeMs() const
   return m_startTime;
 }
 
+uint32_t Sapphire::StatusEffect::StatusEffect::getFlag() const
+{
+  return m_flag;
+}
+
+const std::vector< World::Action::StatusModifier >& Sapphire::StatusEffect::StatusEffect::getStatusModifiers() const
+{
+  return m_statusModifiers;
+}
+
+void Sapphire::StatusEffect::StatusEffect::setFlag( uint32_t flag )
+{
+  m_flag = flag;
+}
+
 void Sapphire::StatusEffect::StatusEffect::setLastTick( uint64_t lastTick )
 {
   m_lastTick = lastTick;
@@ -153,3 +227,13 @@ const std::string& Sapphire::StatusEffect::StatusEffect::getName() const
 {
   return m_name;
 }
+
+uint8_t Sapphire::StatusEffect::StatusEffect::getSlot() const
+{
+  return m_slot;
+}
+
+void Sapphire::StatusEffect::StatusEffect::setSlot( uint8_t slot )
+{
+  m_slot = slot;
+}
diff --git a/src/world/StatusEffect/StatusEffect.h b/src/world/StatusEffect/StatusEffect.h
index e6bb1c8e4..f8a24dde9 100644
--- a/src/world/StatusEffect/StatusEffect.h
+++ b/src/world/StatusEffect/StatusEffect.h
@@ -2,6 +2,7 @@
 #define _STATUSEFFECT_H_
 
 #include "Forwards.h"
+#include "Action/ActionLut.h"
 
 namespace Sapphire {
 namespace StatusEffect {
@@ -10,6 +11,9 @@ namespace StatusEffect {
 class StatusEffect
 {
 public:
+  StatusEffect( uint32_t id, Entity::CharaPtr sourceActor, Entity::CharaPtr targetActor,
+                uint32_t duration, const std::vector< World::Action::StatusModifier >& modifiers, uint32_t flag, uint32_t tickRate );
+
   StatusEffect( uint32_t id, Entity::CharaPtr sourceActor, Entity::CharaPtr targetActor,
                 uint32_t duration, uint32_t tickRate );
 
@@ -17,6 +21,12 @@ class StatusEffect
 
   void onTick();
 
+  const std::unordered_map< Common::ParamModifier, int32_t >& getModifiers() const;
+
+  void setModifier( Common::ParamModifier paramModifier, int32_t value );
+
+  void delModifier( Common::ParamModifier paramModifier );
+
   void applyStatus();
 
   void removeStatus();
@@ -28,6 +38,7 @@ class StatusEffect
   uint32_t getTickRate() const;
 
   uint32_t getSrcActorId() const;
+  Entity::CharaPtr getSrcActor() const;
 
   uint32_t getTargetActorId() const;
 
@@ -37,16 +48,25 @@ class StatusEffect
 
   uint16_t getParam() const;
 
+  uint32_t getFlag() const;
+
+  const std::vector< World::Action::StatusModifier >& getStatusModifiers() const;
+
   void setLastTick( uint64_t lastTick );
 
   void setParam( uint16_t param );
 
-  void registerTickEffect( uint8_t type, uint32_t param );
+  void setFlag( uint32_t flag );
 
-  std::pair< uint8_t, uint32_t > getTickEffect();
+  void registerTickEffect( Common::ParamModifier type, uint32_t param );
+
+  std::pair< Common::ParamModifier, uint32_t > getTickEffect();
 
   const std::string& getName() const;
 
+  uint8_t getSlot() const;
+  void setSlot( uint8_t slot );
+
 private:
   uint32_t m_id;
   Entity::CharaPtr m_sourceActor;
@@ -56,8 +76,12 @@ class StatusEffect
   uint32_t m_tickRate;
   uint64_t m_lastTick;
   uint16_t m_param;
+  uint32_t m_flag;
   std::string m_name;
-  std::pair< uint8_t, uint32_t > m_currTickEffect;
+  std::pair< Common::ParamModifier, uint32_t > m_currTickEffect;
+  std::vector< World::Action::StatusModifier > m_statusModifiers;
+  std::unordered_map< Common::ParamModifier, int32_t > m_modifiers;
+  uint8_t m_slot;
 
 };
 
diff --git a/src/world/Task/ActionIntegrityTask.cpp b/src/world/Task/ActionIntegrityTask.cpp
index f8f8a1b45..3f2d0749c 100644
--- a/src/world/Task/ActionIntegrityTask.cpp
+++ b/src/world/Task/ActionIntegrityTask.cpp
@@ -6,6 +6,7 @@
 #include <WorldServer.h>
 #include <Service.h>
 #include <Network/PacketWrappers/WarpPacket.h>
+#include <StatusEffect/StatusEffect.h>
 
 #include <utility>
 
@@ -14,10 +15,11 @@ using namespace Sapphire::World::Manager;
 using namespace Sapphire::Network::Packets;
 using namespace Sapphire::Network::Packets::WorldPackets::Server;
 
-ActionIntegrityTask::ActionIntegrityTask( uint32_t resultId, Entity::CharaPtr pTarget, uint64_t delayTime ) : Task( delayTime )
+ActionIntegrityTask::ActionIntegrityTask( uint32_t resultId, Entity::CharaPtr pTarget, Action::ActionResultList& results, uint64_t delayTime ) : Task( delayTime )
 {
   m_resultId = resultId;
   m_pTarget = std::move( pTarget );
+  m_results = results;
 }
 
 void ActionIntegrityTask::onQueue()
@@ -27,6 +29,9 @@ void ActionIntegrityTask::onQueue()
 
 void ActionIntegrityTask::execute()
 {
+  if( !m_pTarget )
+    return;
+
   auto& server = Common::Service< WorldServer >::ref();
 
   auto inRangePlayers = m_pTarget->getInRangePlayerIds( true );
@@ -37,6 +42,29 @@ void ActionIntegrityTask::execute()
   auto integrityPacket = makeZonePacket< FFXIVIpcActionIntegrity >( 0 );
   auto& data = integrityPacket->data();
   integrityPacket->setSourceActor( m_pTarget->getId() );
+
+  for( int i = 0; i < 4; ++i )
+    data.Status[ i ].Source = Common::INVALID_GAME_OBJECT_ID;
+
+  int statusIdx = 0;
+  for( auto& actionResult : m_results )
+  {
+    if( actionResult && actionResult->getTarget() )
+      actionResult->execute();
+
+    if( ( actionResult->getCalcResultParam().Type == Common::TypeSetStatus ) ||
+        ( actionResult->getCalcResultParam().Type == Common::TypeSetStatusMe ) )
+    {
+      auto& status = data.Status[ statusIdx++ ];
+      auto pEffect = actionResult->getStatusEffect();
+      status.Source = pEffect->getSrcActorId();
+      status.Time = static_cast< float >( pEffect->getDuration() ) / 1000;
+      status.Id = static_cast< uint16_t >( pEffect->getId() );
+      status.Slot = static_cast< uint8_t >( pEffect->getSlot() );
+      status.SystemParam = static_cast< int16_t >( pEffect->getParam() );
+    }
+  }
+
   data.Hp = m_pTarget->getHp();
   data.HpMax = m_pTarget->getMaxHp();
   data.Mp = m_pTarget->getMp();
@@ -44,6 +72,9 @@ void ActionIntegrityTask::execute()
   data.Tp = m_pTarget->getTp();
   data.ResultId = m_resultId;
   data.Target = m_pTarget->getId();
+  data.StatusCount = statusIdx;
+  data.ClassJob = static_cast< uint8_t >( m_pTarget->getClass() );
+  data.unknown_E0 = 0xE0;
 
   server.queueForPlayers( inRangePlayers, integrityPacket );
 
@@ -51,7 +82,7 @@ void ActionIntegrityTask::execute()
 
 std::string ActionIntegrityTask::toString()
 {
-  return fmt::format( "ActionIntegrityTask: ResultId#{}, TargetId#{}, ElapsedTimeMs: {}", m_resultId, m_pTarget->getId(), getDelayTimeMs() );
+  return fmt::format( "ActionIntegrityTask: ResultId#{}, TargetId#{}, ElapsedTimeMs: {}", m_resultId, m_pTarget ? m_pTarget->getId() : 0, getDelayTimeMs() );
 }
 
 
diff --git a/src/world/Task/ActionIntegrityTask.h b/src/world/Task/ActionIntegrityTask.h
index 0671c4a00..b0c2812f1 100644
--- a/src/world/Task/ActionIntegrityTask.h
+++ b/src/world/Task/ActionIntegrityTask.h
@@ -4,6 +4,7 @@
 #include <string>
 #include <ForwardsZone.h>
 #include "Task.h"
+#include <Action/ActionResult.h>
 
 namespace Sapphire::World
 {
@@ -11,7 +12,7 @@ namespace Sapphire::World
 class ActionIntegrityTask : public Task
 {
 public:
-  ActionIntegrityTask( uint32_t resultId, Entity::CharaPtr pTarget, uint64_t delayTime );
+  ActionIntegrityTask( uint32_t resultId, Entity::CharaPtr pTarget, Action::ActionResultList& results, uint64_t delayTime );
 
   void onQueue() override;
   void execute() override;
@@ -20,6 +21,7 @@ class ActionIntegrityTask : public Task
 private:
   uint32_t m_resultId;
   Entity::CharaPtr m_pTarget;
+  Action::ActionResultList m_results;
 };
 
 template< typename... Args >
diff --git a/src/world/Task/MoveTerritoryTask.cpp b/src/world/Task/MoveTerritoryTask.cpp
index 30194d9d6..b7d9c061b 100644
--- a/src/world/Task/MoveTerritoryTask.cpp
+++ b/src/world/Task/MoveTerritoryTask.cpp
@@ -41,6 +41,10 @@ void MoveTerritoryTask::execute()
   if( !pPlayer )
     return;
 
+  pPlayer->setTargetId( 0 );
+  pPlayer->setStance( Common::Stance::Passive );
+  pPlayer->setAutoattack( false );
+
   auto inRangePlayerIds = pPlayer->getInRangePlayerIds( true );
 
   auto warpStart = makeActorControlSelf( pPlayer->getId(), WarpStart, m_warpInfo.m_warpType, 1, 0, m_warpInfo.m_targetTerritoryId, 1 );
diff --git a/src/world/Territory/Cell.cpp b/src/world/Territory/Cell.cpp
index 2eebc7a78..42bda6674 100644
--- a/src/world/Territory/Cell.cpp
+++ b/src/world/Territory/Cell.cpp
@@ -102,3 +102,12 @@ void Sapphire::Cell::unload()
   removeActors();
 }
 
+uint32_t Sapphire::Cell::getLastActiveTime() const
+{
+  return m_lastActiveTime;
+}
+
+void Sapphire::Cell::setLastActiveTime( uint32_t lastActiveTime )
+{
+  m_lastActiveTime = lastActiveTime;
+}
\ No newline at end of file
diff --git a/src/world/Territory/Cell.h b/src/world/Territory/Cell.h
index 07c0cfc37..4aca5791e 100644
--- a/src/world/Territory/Cell.h
+++ b/src/world/Territory/Cell.h
@@ -20,6 +20,7 @@ class Cell
   bool m_bActive;
 
   uint16_t m_playerCount;
+  uint32_t m_lastActiveTime;
 
 public:
   Cell();
@@ -82,6 +83,9 @@ class Cell
   {
     return m_posY;
   }
+
+  uint32_t getLastActiveTime() const;
+  void setLastActiveTime( uint32_t lastActiveTime );
 };
 
 }
diff --git a/src/world/Territory/InstanceContent.cpp b/src/world/Territory/InstanceContent.cpp
index fee9886a6..348b87b3d 100644
--- a/src/world/Territory/InstanceContent.cpp
+++ b/src/world/Territory/InstanceContent.cpp
@@ -16,7 +16,7 @@
 #include "Manager/PlayerMgr.h"
 #include "Manager/TerritoryMgr.h"
 #include "Manager/EventMgr.h"
-
+#include "Manager/WarpMgr.h"
 #include "Actor/Player.h"
 #include "Actor/EventObject.h"
 
@@ -29,6 +29,7 @@
 #include "InstanceObjectCache.h"
 
 #include <Encounter/InstanceContent/IfritNormal.h>
+#include <Task/MoveTerritoryTask.h>
 
 
 using namespace Sapphire::Common;
@@ -103,7 +104,7 @@ void Sapphire::InstanceContent::onPlayerZoneIn( Entity::Player& player )
   if( isTerminationReady() ) // wtf
   {
     Logger::warn( "Entity#{0} Appear for a terminated instance!", player.getId() );
-    player.exitInstance();
+    playerMgr().onExitInstance( player );
     return;
   }
 
@@ -118,7 +119,7 @@ void Sapphire::InstanceContent::onLeaveTerritory( Entity::Player& player )
   Logger::debug( "InstanceContent::onLeaveTerritory: Territory#{0}|{1}, Entity#{2}",
                  getGuId(), getTerritoryTypeId(), player.getId() );
 
-  unbindPlayer( player.getId() );
+  //unbindPlayer( player.getId() );
 
   clearDirector( player );
 
@@ -190,6 +191,9 @@ void Sapphire::InstanceContent::onUpdate( uint64_t tickCount )
         m_instanceResetFinishTime = tickCount + 5000;
         m_pEncounter->reset();
 
+        std::vector< Entity::PlayerPtr > playerList;
+
+        auto& warpMgr = Common::Service< WarpMgr >::ref();
         auto& server = Common::Service< World::WorldServer >::ref();
         for( const auto& playerIt : m_playerMap )
         {
@@ -200,12 +204,13 @@ void Sapphire::InstanceContent::onUpdate( uint64_t tickCount )
           pPlayer->setStatus( Common::ActorStatus::Idle );
 
           movePlayerToEntrance( *pPlayer );
-          auto zoneInPacket = makeActorControlSelf( pPlayer->getId(), Appear, 0x3, 0, 0, 0 );
-          auto setStatusPacket = makeActorControl( pPlayer->getId(), SetStatus, static_cast< uint8_t >( Common::ActorStatus::Idle ) );
-          
 
-          server.queueForPlayer( pPlayer->getCharacterId(), zoneInPacket );
-          server.queueForPlayers( pPlayer->getInRangePlayerIds( true ), setStatusPacket );
+          playerList.push_back( pPlayer );
+        }
+
+        for( const auto& pPlayer : playerList )
+        {
+          warpMgr.requestMoveTerritory( *pPlayer, WarpType::WARP_TYPE_INSTANCE_CONTENT, getGuId(), pPlayer->getPos(), pPlayer->getRot() );
         }
 
         if( m_pEntranceEObj )
@@ -216,11 +221,23 @@ void Sapphire::InstanceContent::onUpdate( uint64_t tickCount )
       else if( tickCount < m_instanceResetFinishTime )
         return;
 
-      
+      for( const auto& playerIt : m_playerMap )
+      {
+        auto pPlayer = playerIt.second;
+
+        if( !pPlayer->isLoadingComplete() ||
+            !pPlayer->isDirectorInitialized() ||
+            pPlayer->hasCondition( PlayerCondition::WatchingCutscene ) )
+          return;
+      }
+
       m_pEntranceEObj->setPermissionInvisibility( 1 );
       sendForward();
       
       m_state = DutyInProgress;
+
+      m_instanceResetTime = 0;
+      m_instanceResetFinishTime = 0;
       break;
     }
 
@@ -264,7 +281,7 @@ void Sapphire::InstanceContent::onUpdate( uint64_t tickCount )
             return;
 
           auto player = it->second;
-          player->exitInstance();
+          playerMgr().onExitInstance( *player );
           return;
         }
       }
@@ -299,7 +316,7 @@ void Sapphire::InstanceContent::onEventHandlerOrder( Entity::Player& player, uin
         {
           case 0: // Leave content
           {
-            player.exitInstance();
+            playerMgr().onExitInstance( player );
             break;
           }
           case 1: // Force leave ( afk timer )
@@ -542,7 +559,7 @@ void Sapphire::InstanceContent::movePlayerToEntrance( Sapphire::Entity::Player&
     if( rect )
       player.setRot( Util::eulerToDirection( { rect->header.transform.rotation.x, rect->header.transform.rotation.y, rect->header.transform.rotation.z } ) );
     else
-      player.setRot( PI );
+      player.setRot( PI - PI / 2 );
     player.setPos( m_pEntranceEObj->getPos() );
   }
   else if( rect )
@@ -552,7 +569,7 @@ void Sapphire::InstanceContent::movePlayerToEntrance( Sapphire::Entity::Player&
   }
   else
   {
-    player.setRot( PI );
+    player.setRot( PI - PI / 2 );
     player.setPos( { 0.f, 0.f, 0.f } );
   }
 }
@@ -561,7 +578,7 @@ void Sapphire::InstanceContent::onBeforePlayerZoneIn( Sapphire::Entity::Player&
 {
   // remove any players from the instance who aren't bound on zone in
   if( !isPlayerBound( player.getId() ) )
-    player.exitInstance();
+    playerMgr().onExitInstance( player );
 
   // if a player has already spawned once inside this instance, don't move them if they happen to zone in again
   if( !hasPlayerPreviouslySpawned( player ) )
@@ -581,6 +598,17 @@ Sapphire::Entity::EventObjectPtr Sapphire::InstanceContent::getEObjByName( const
   return it->second;
 }
 
+Sapphire::Entity::EventObjectPtr Sapphire::InstanceContent::getEObjById( uint32_t eobjId )
+{
+  Entity::EventObjectPtr pEObj = nullptr;
+
+  for( auto& eobj : m_eventIdToObjectMap )
+    if( eobj.second->getObjectId() == eobjId )
+      return pEObj;
+
+  return nullptr;
+}
+
 void Sapphire::InstanceContent::onTalk( Sapphire::Entity::Player& player, uint32_t eventId, uint64_t actorId )
 {
   // todo: handle exit (and maybe shortcut?) behaviour here
@@ -633,7 +661,7 @@ void Sapphire::InstanceContent::setCurrentBGM( uint16_t bgmIndex )
     auto player = playerIt.second;
     server.queueForPlayer( player->getCharacterId(),
       makeActorControlSelf( player->getId(), DirectorUpdate, getDirectorId(),
-                            DirectorEventId::BattleGroundMusic, bgmIndex ) );
+                                                 DirectorEventId::BGM, bgmIndex ) );
   }
 }
 
@@ -641,7 +669,7 @@ void Sapphire::InstanceContent::setPlayerBGM( Sapphire::Entity::Player& player,
 {
   auto& server = Common::Service< World::WorldServer >::ref();
   server.queueForPlayer( player.getCharacterId(), makeActorControlSelf( player.getId(), DirectorUpdate, getDirectorId(),
-                                                                           DirectorEventId::BattleGroundMusic, bgmId ) );
+                                                                        DirectorEventId::BGM, bgmId ) );
 }
 
 uint16_t Sapphire::InstanceContent::getCurrentBGM() const
@@ -685,7 +713,7 @@ void Sapphire::InstanceContent::unbindPlayer( uint32_t playerId )
 
   auto it = m_playerMap.find( playerId );
   if( it != m_playerMap.end() )
-    it->second->exitInstance();
+    playerMgr().onExitInstance( *it->second );
 }
 
 void Sapphire::InstanceContent::clearDirector( Entity::Player& player )
@@ -765,3 +793,8 @@ size_t Sapphire::InstanceContent::getInstancePlayerCount() const
 {
   return m_boundPlayerIds.size();
 }
+
+std::set< uint32_t > Sapphire::InstanceContent::getSpawnedPlayerIds() const
+{
+  return m_spawnedPlayers;
+}
\ No newline at end of file
diff --git a/src/world/Territory/InstanceContent.h b/src/world/Territory/InstanceContent.h
index c502f0f6f..50a41c41d 100644
--- a/src/world/Territory/InstanceContent.h
+++ b/src/world/Territory/InstanceContent.h
@@ -37,6 +37,7 @@ namespace Sapphire
       0x4000000E - INSTANCE_CONTENT_ORDER_SYSTEM_Unknown - no args - some timer set */
     enum DirectorEventId : uint32_t
     {
+      // 2.3
       DEBUG_TimeSync = 0xC0000001,
       DutyCommence = 0x40000001,
       DutyComplete = 0x40000002,
@@ -44,7 +45,7 @@ namespace Sapphire
       SetDutyTime = 0x40000004,
       LoadingScreen = 0x40000005,
       Forward = 0x40000006,
-      BattleGroundMusic = 0x40000007,
+      //BattleGroundMusic = 0x40000007,
       InvalidateTodoList = 0x40000008,
       VoteState = 0x40000009,
       VoteStart = 0x4000000A,
@@ -53,6 +54,14 @@ namespace Sapphire
       FirstTimeNotify = 0x4000000D,
       TreasureVoteRefresh = 0x4000000E,
       SetSharedGroupId = 0x4000000F,
+      // 3.3x onwards
+      Sync = 0x80000000,
+      BGM = 0x80000001,
+      SyncDutyTimer = 0x80000003,
+      // some vote stuff here
+      StartEventCutscene = 0x80000008,
+      EndEventCutscene = 0x80000009,
+      StartQTE = 0x8000000A
     };
 
     enum EventHandlerOrderId : uint32_t
@@ -169,6 +178,8 @@ namespace Sapphire
 
     Entity::EventObjectPtr getEObjByName( const std::string& name );
 
+    Entity::EventObjectPtr getEObjById( uint32_t eobjId );
+
     /*! binds a player to the instance */
     bool bindPlayer( uint32_t playerId );
 
@@ -195,6 +206,8 @@ namespace Sapphire
 
     size_t getInstancePlayerCount() const;
 
+    std::set< uint32_t > getSpawnedPlayerIds() const;
+
     void movePlayerToEntrance( Entity::Player& player );
   private:
     std::shared_ptr< Excel::ExcelStruct< Excel::InstanceContent > > m_instanceConfiguration;
diff --git a/src/world/Territory/InstanceObjectCache.cpp b/src/world/Territory/InstanceObjectCache.cpp
index 455975b2b..91ff7a4c3 100644
--- a/src/world/Territory/InstanceObjectCache.cpp
+++ b/src/world/Territory/InstanceObjectCache.cpp
@@ -11,27 +11,24 @@
 #include <ExdCat.h>
 #include <Exd.h>
 
+#include <algorithm>
+#include <execution>
+
 #include <Logging/Logger.h>
 #include <Service.h>
 #include <Util/UtilMath.h>
 
 Sapphire::InstanceObjectCache::InstanceObjectCache()
 {
-
   auto& exdData = Common::Service< Sapphire::Data::ExdData >::ref();
-  auto idList = exdData.getIdList< Excel::TerritoryType >();
+  auto teriList = exdData.getRows< Excel::TerritoryType >();
 
   size_t count = 0;
-  for( const auto& id : idList )
-  {
+  for( const auto& [ id, territoryType ] : teriList ) {
     // show some loading indication...
     if( count++ % 10 == 0 )
       std::cout << ".";
 
-    auto territoryType = exdData.getRow< Excel::TerritoryType >( id );
-    if( !territoryType )
-      continue;
-
     auto path = territoryType->getString( territoryType->data().LVB );
 
     if( path.empty() )
@@ -56,7 +53,11 @@ Sapphire::InstanceObjectCache::InstanceObjectCache()
 
     try
     {
-      bgFile = exdData.getGameData()->getFile( bgLgbPath );
+      if( exdData.getGameData()->doesFileExist( bgLgbPath ) )
+        bgFile = exdData.getGameData()->getFile( bgLgbPath );
+      else
+        continue;
+
       planmap_file = exdData.getGameData()->getFile( planmapLgbPath );
       planevent_file = exdData.getGameData()->getFile( planeventLgbPath );
     }
@@ -101,49 +102,60 @@ Sapphire::InstanceObjectCache::InstanceObjectCache()
       {
         for( const auto& pEntry : group.entries )
         {
-
-          if( pEntry->getType() == LgbEntryType::MapRange )
+          switch( pEntry->getType() )
           {
-            auto pMapRange = std::reinterpret_pointer_cast< LGB_MAP_RANGE_ENTRY >( pEntry );
-            m_mapRangeCache.insert( id, pMapRange );
-          }
-          else if( pEntry->getType() == LgbEntryType::ExitRange )
-          {
-            auto pExitRange = std::reinterpret_pointer_cast< LGB_EXIT_RANGE_ENTRY >( pEntry );
-            m_exitRangeCache.insert( id, pExitRange );
-          }
-          else if( pEntry->getType() == LgbEntryType::PopRange )
-          {
-
-            auto pPopRange = std::reinterpret_pointer_cast< LGB_POP_RANGE_ENTRY >( pEntry );
-            m_popRangeCache.insert( id, pPopRange );
-          }
-          else if( pEntry->getType() == LgbEntryType::CollisionBox )
-          {
-            //auto pEObj = std::reinterpret_pointer_cast< LGB_ENPC_ENTRY >( pEntry );
-
-            //Logger::debug( "CollisionBox {}", pEntry->header.nameOffset );
-          }
-          else if( pEntry->getType() == LgbEntryType::EventObject )
-          {
-            auto pEObj = std::reinterpret_pointer_cast< LGB_EOBJ_ENTRY >( pEntry );
-            m_eobjCache.insert( id, pEObj );
-          }
-          else if( pEntry->getType() == LgbEntryType::EventNpc )
-          {
-            auto pENpc = std::reinterpret_pointer_cast< LGB_ENPC_ENTRY >( pEntry );
-            m_enpcCache.insert( id, pENpc );
-          }
-          else if( pEntry->getType() == LgbEntryType::EventRange )
-          {
-            auto pEventRange = std::reinterpret_pointer_cast< LGB_EVENT_RANGE_ENTRY >( pEntry );
-            m_eventRangeCache.insert( 0, pEventRange );
+            case LgbEntryType::MapRange:
+            {
+              auto pMapRange = std::reinterpret_pointer_cast< LGB_MAP_RANGE_ENTRY >( pEntry );
+              m_mapRangeCache.insert( id, pMapRange );
+
+              break;
+            }
+            case LgbEntryType::ExitRange:
+            {
+              auto pExitRange = std::reinterpret_pointer_cast< LGB_EXIT_RANGE_ENTRY >( pEntry );
+              m_exitRangeCache.insert( id, pExitRange );
+
+              break;
+            }
+            case LgbEntryType::PopRange:
+            {
+              auto pPopRange = std::reinterpret_pointer_cast< LGB_POP_RANGE_ENTRY >( pEntry );
+              m_popRangeCache.insert( id, pPopRange );
+              break;
+            }
+            case LgbEntryType::CollisionBox:
+            {
+              //auto pEObj = std::reinterpret_pointer_cast< LGB_ENPC_ENTRY >( pEntry );
+
+              //Logger::debug( "CollisionBox {}", pEntry->header.nameOffset );
+              break;
+            }
+            case LgbEntryType::EventObject:
+            {
+              auto pEObj = std::reinterpret_pointer_cast< LGB_EOBJ_ENTRY >( pEntry );
+              m_eobjCache.insert( id, pEObj );
+              break;
+            }
+            case LgbEntryType::EventNpc:
+            {
+              auto pENpc = std::reinterpret_pointer_cast< LGB_ENPC_ENTRY >( pEntry );
+              m_enpcCache.insert( id, pENpc );
+              break;
+            }
+            case LgbEntryType::EventRange:
+            {
+              auto pEventRange = std::reinterpret_pointer_cast< LGB_EVENT_RANGE_ENTRY >( pEntry );
+              m_eventRangeCache.insert( 0, pEventRange );
+              break;
+            }
           }
         }
       }
     }
   }
-  std::cout << "\n";
+
+  std::cout << std::endl;
 
   Logger::debug(
     "InstanceObjectCache Cached: MapRange: {} ExitRange: {} PopRange: {} EventObj: {} EventNpc: {} EventRange: {}",
diff --git a/src/world/Territory/QuestBattle.cpp b/src/world/Territory/QuestBattle.cpp
index a0f3f408d..f5fd29918 100644
--- a/src/world/Territory/QuestBattle.cpp
+++ b/src/world/Territory/QuestBattle.cpp
@@ -158,7 +158,7 @@ void Sapphire::QuestBattle::onUpdate( uint64_t tickCount )
 
       if( ( static_cast< int64_t >( tickCount ) - static_cast< int64_t >( m_instanceFailTime ) ) > 6000 )
       {
-        m_pPlayer->exitInstance();
+        playerMgr().onExitInstance( *m_pPlayer );
         m_pPlayer.reset();
       }
       break;
@@ -322,7 +322,7 @@ void Sapphire::QuestBattle::success()
                           auto& scriptMgr = Common::Service< Scripting::ScriptMgr >::ref();
                           scriptMgr.onDutyComplete( *this, *m_pPlayer );
 
-                          player.exitInstance();
+                          playerMgr().onExitInstance( player );
                         } );
 
     } );
diff --git a/src/world/Territory/Territory.cpp b/src/world/Territory/Territory.cpp
index 44a065e9e..c717a8ef4 100644
--- a/src/world/Territory/Territory.cpp
+++ b/src/world/Territory/Territory.cpp
@@ -29,7 +29,7 @@
 #include "Actor/Player.h"
 #include "Actor/EventObject.h"
 
-#include "Action/EffectResult.h"
+#include "Action/ActionResult.h"
 
 #include "Network/GameConnection.h"
 
@@ -466,8 +466,6 @@ bool Territory::update( uint64_t tickCount )
   updateSessions( tickCount, changedWeather );
   onUpdate( tickCount );
 
-  processEffectResults( tickCount );
-
   if( !m_playerMap.empty() )
     m_lastActivityTime = tickCount;
 
@@ -530,6 +528,7 @@ bool Territory::isCellActive( uint32_t x, uint32_t y )
   uint32_t posY;
 
   CellPtr pCell;
+  uint32_t time = Common::Util::getTimeSeconds();
 
   for( posX = startX; posX <= endX; posX++ )
   {
@@ -537,7 +536,7 @@ bool Territory::isCellActive( uint32_t x, uint32_t y )
     {
       pCell = getCellPtr( posX, posY );
 
-      if( pCell && ( pCell->hasPlayers() || pCell->isForcedActive() ) )
+      if( pCell && ( pCell->hasPlayers() || pCell->isForcedActive() || ( time - pCell->getLastActiveTime() ) < 20 ) )
         return true;
     }
   }
@@ -568,13 +567,13 @@ void Territory::updateCellActivity( uint32_t x, uint32_t y, int32_t radius )
         {
           pCell = create( posX, posY );
           pCell->init( posX, posY );
-
           pCell->setActivity( true );
-
+          pCell->setLastActiveTime( Common::Util::getTimeSeconds() );
         }
       }
       else
       {
+        pCell->setLastActiveTime( Common::Util::getTimeSeconds() );
         //Cell is now active
         if( isCellActive( posX, posY ) && !pCell->isActive() )
         {
@@ -583,6 +582,7 @@ void Territory::updateCellActivity( uint32_t x, uint32_t y, int32_t radius )
         else if( !isCellActive( posX, posY ) && pCell->isActive() )
           pCell->setActivity( false );
       }
+
     }
   }
 }
@@ -765,6 +765,18 @@ Entity::EventObjectPtr Territory::getEObj( uint32_t objId )
   return obj->second;
 }
 
+Entity::PlayerPtr Territory::getPlayer( uint32_t playerId )
+{
+  if( auto it = m_playerMap.find( playerId ); it != m_playerMap.end() )
+    return it->second;
+  return nullptr;
+}
+
+const std::unordered_map< uint32_t, Entity::PlayerPtr >& Territory::getPlayers()
+{
+  return m_playerMap;
+}
+
 InstanceContentPtr Territory::getAsInstanceContent()
 {
   return std::dynamic_pointer_cast< InstanceContent, Territory >( shared_from_this() );
@@ -824,7 +836,7 @@ void Territory::updateSpawnPoints()
   }
 }
 
-uint32_t Territory::getNextEffectResultId()
+uint32_t Territory::getNextActionResultId()
 {
   return m_effectCounter++;
 }
@@ -836,6 +848,7 @@ Entity::BNpcPtr Territory::createBNpcFromLayoutId( uint32_t layoutId, uint32_t h
     return nullptr;
 
   auto pBNpc = std::make_shared< Entity::BNpc >( getNextActorId(), infoPtr->second, *this, hp, bnpcType );
+  pBNpc->init();
   pBNpc->setTriggerOwnerId( triggerOwnerId );
   pushActor( pBNpc );
   return pBNpc;
@@ -875,30 +888,6 @@ std::shared_ptr< World::Navi::NaviProvider > Territory::getNaviProvider()
   return m_pNaviProvider;
 }
 
-void Territory::addEffectResult( World::Action::EffectResultPtr result )
-{
-  m_effectResults.emplace_back( std::move( result ) );
-}
-
-void Territory::processEffectResults( uint64_t tickCount )
-{
-  // todo: move this to generic territory/instance delay wrapper cause it might be useful scheduling other things
-  for( auto it = m_effectResults.begin(); it != m_effectResults.end(); )
-  {
-    auto effect = *it;
-
-    if( tickCount < effect->getDelay() )
-    {
-      ++it;
-      continue;
-    }
-
-    effect->execute();
-
-    it = m_effectResults.erase( it );
-  }
-}
-
 bool Territory::loadBNpcs()
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
@@ -906,6 +895,8 @@ bool Territory::loadBNpcs()
   stmt->setUInt( 1, getTerritoryTypeId() );
   auto res = db.query( stmt );
 
+  // todo: load any exd links, cache them, build more info and setup bnpcs properly
+
   while( res->next() )
   {
     auto bnpc = std::make_shared< Common::BNPCInstanceObject >();
@@ -982,3 +973,13 @@ const Common::TerritoryIdent& Territory::getTerritoryIdent() const
 {
   return m_ident;
 }
+
+void Territory::setEncounterTimeline( const std::string& name )
+{
+  m_timelinePack = Encounter::EncounterTimeline::getEncounterPack( name, true );
+}
+
+Encounter::TimelinePack& Territory::getEncounterTimeline()
+{
+  return m_timelinePack;
+}
\ No newline at end of file
diff --git a/src/world/Territory/Territory.h b/src/world/Territory/Territory.h
index 6a84570fd..8d645ee8d 100644
--- a/src/world/Territory/Territory.h
+++ b/src/world/Territory/Territory.h
@@ -7,6 +7,7 @@
 #include "Cell.h"
 #include "CellHandler.h"
 
+#include <Encounter/EncounterTimeline.h>
 #include "ForwardsZone.h"
 
 #include <set>
@@ -72,12 +73,12 @@ namespace Sapphire
     uint32_t m_effectCounter{};
     std::shared_ptr< World::Navi::NaviProvider > m_pNaviProvider;
 
-    std::vector< World::Action::EffectResultPtr > m_effectResults;
-
     Common::TerritoryIdent m_ident;
 
     float m_inRangeDistance;
 
+    Encounter::TimelinePack m_timelinePack;
+
   public:
     Territory();
 
@@ -188,19 +189,22 @@ namespace Sapphire
 
     Entity::EventObjectPtr getEObj( uint32_t objId );
 
+    Entity::PlayerPtr getPlayer( uint32_t playerId );
+
+    const std::unordered_map< uint32_t, Entity::PlayerPtr >& getPlayers();
+
     InstanceContentPtr getAsInstanceContent();
 
     QuestBattlePtr getAsQuestBattle();
 
     void updateSpawnPoints();
 
-    uint32_t getNextEffectResultId();
+    uint32_t getNextActionResultId();
 
     std::shared_ptr< World::Navi::NaviProvider > getNaviProvider();
 
-    void addEffectResult( World::Action::EffectResultPtr result );
-
-    void processEffectResults( uint64_t tickCount );
+    void setEncounterTimeline( const std::string& name );
+    Encounter::TimelinePack& getEncounterTimeline();
   };
 
 }
diff --git a/src/world/WorldServer.cpp b/src/world/WorldServer.cpp
index d471de172..c89cf5508 100644
--- a/src/world/WorldServer.cpp
+++ b/src/world/WorldServer.cpp
@@ -144,6 +144,11 @@ std::string readFileToString( const std::string& filename )
   // Close the file
   file.close();
 
+  // Remove all newlines from the file contents
+  fileContents.erase( std::remove( fileContents.begin(), fileContents.end(), '\n' ), fileContents.end() );
+  fileContents.erase( std::remove( fileContents.begin(), fileContents.end(), '\r' ), fileContents.end() );
+
+
   // Return the file contents as a string
   return fileContents;
 }
@@ -386,20 +391,21 @@ void WorldServer::mainLoop()
   {
     auto tickCount = Common::Util::getTimeMs();
 
+    auto currTime = Common::Util::getTimeSeconds();
+    taskMgr.update( tickCount );
+    updateSessions( currTime );
+
     if( tickCount - m_lastServerTick < 300 )
     {
-      std::this_thread::sleep_for( std::chrono::milliseconds( 50 ) );
+      std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) );
       continue;
     }
     m_lastServerTick = tickCount;
 
-    auto currTime = Common::Util::getTimeSeconds();
-
-    taskMgr.update( tickCount );
     terriMgr.updateTerritoryInstances( tickCount );
     scriptMgr.update();
     contentFinder.update();
-    updateSessions( currTime );
+
 
     DbKeepAlive( currTime );
   }
diff --git a/web/assets/js/github.js b/web/assets/js/github.js
new file mode 100644
index 000000000..0fdb887d4
--- /dev/null
+++ b/web/assets/js/github.js
@@ -0,0 +1,26 @@
+unction fetchRecentActivity() {
+  var url = "https://api.github.com/repos/SapphireMordred/Sapphire/events";
+  var xhr = new XMLHttpRequest();
+  xhr.open("GET", url, true);
+
+  xhr.onreadystatechange = function() {
+    if (xhr.readyState == 4 && xhr.status == 200) {
+      var response = JSON.parse(xhr.responseText);
+      var commitLog = document.getElementById("commit-log");
+
+      for (var i = 0; i < response.length; i++) {
+        var commit = response[i];
+        var commitItem = document.createElement("li");
+        commitItem.innerHTML = commit.type + " - " + commit.actor.login;
+        commitLog.appendChild(commitItem);
+      }
+    }
+  }
+
+  xhr.send();
+}
+
+// Call the fetchRecentActivity function when the page loads
+window.onload = function() {
+  fetchRecentActivity();
+};
diff --git a/web/assets/js/login.js b/web/assets/js/login.js
new file mode 100644
index 000000000..80d1b8d5c
--- /dev/null
+++ b/web/assets/js/login.js
@@ -0,0 +1,49 @@
+
+function readBody(xhr) {
+  var data;
+  if (!xhr.responseType || xhr.responseType === "text") {
+    data = xhr.responseText;
+  } else if (xhr.responseType === "document") {
+    data = xhr.responseXML;
+  } else {
+    data = xhr.response;
+  }
+  return data;
+}
+
+
+function doLogin() {
+  var url = "sapphire-api/lobby/login";
+  var params = "{\"username\":\"" + document.getElementsByName('username')[0].value + "\",\"pass\":\"" + document.getElementsByName('password')[0].value + "\"}";
+  var xhr = new XMLHttpRequest();
+  xhr.open("POST", url, true);
+
+  xhr.onreadystatechange = function() {
+    if (xhr.readyState == 4) {
+      try {
+        var response = readBody(xhr);
+        var parsed = JSON.parse(response);
+        window.external.Boot(parsed.sId, parsed.lobbyHost, parsed.frontierHost);
+      } catch(err) {
+        document.getElementById("Error").innerHTML = "Login failed.";
+      }
+    }
+  }
+  
+  xhr.send(params);
+}
+
+
+function keypressing(e) {
+  if (!e) e = window.event;
+  var keyCode = e.keyCode || e.which;
+  if (keyCode == '13'){
+    doLogin();
+    return false;
+  }
+}
+
+document.getElementsByName('password')[0].addEventListener('keypress', function(event) {
+  return keypressing(event);
+});
+document.getElementById('submitButton').addEventListener('click', doLogin);