diff --git a/.gitignore b/.gitignore
index c7e7582..3964348 100644
--- a/.gitignore
+++ b/.gitignore
@@ -29,4 +29,5 @@ build100.sh
 keys.dat
 .exefs100/
 .exefs130/
-build130.sh
\ No newline at end of file
+build130.sh
+.DS_Store
diff --git a/include/fl/packet.h b/include/fl/packet.h
index 73ef9b0..b10c70a 100644
--- a/include/fl/packet.h
+++ b/include/fl/packet.h
@@ -59,6 +59,7 @@ namespace smo
     class InPacketPlayerTeleport : public InPacket
     {
         sead::Vector3f pos;
+        sead::Quatf rot;
     public:
         void parse(const u8* data, u32 len);
         void on(Server& server);
diff --git a/include/fl/ui.h b/include/fl/ui.h
index a40f061..573a617 100644
--- a/include/fl/ui.h
+++ b/include/fl/ui.h
@@ -15,7 +15,7 @@ class PracticeUI
     sead::Vector3f savedTrans;
     sead::Quatf savedQuat;
     bool saved = false;
-    bool teleportEnabled = false;
+    bool teleportEnabled = true;
     s8 reloadStageForPos = -1;
     sead::Vector3f reloadStagePos;
     sead::Quatf reloadStageQuat;
@@ -45,10 +45,10 @@ class PracticeUI
 
     inline StageScene* getStageScene() {return stageScene;}
 
-    bool shineRefresh = false;
-    bool gotShineRefresh = false;
-    bool alwaysWarp = false;
-    bool disableAutoSave = false;
+    bool shineRefresh = true;
+    bool gotShineRefresh = true;
+    bool alwaysWarp = true;
+    bool disableAutoSave = true;
     bool skipBowser = false;
 
     bool isModeDiverOrJungleGymRom = false;
@@ -60,7 +60,7 @@ class PracticeUI
     
     enum Page : u8
     {
-        About, Options, Stage, Misc, Info, Tas, MoonInfo, Modes, Debug
+        About, Options, Stage, Misc, Info, Info2, Info3, Tas, MoonInfo, Modes, Debug
     };
 
     enum MofumofuPattern : s8
diff --git a/smo-tas-server/include/common.h b/smo-tas-server/include/common.h
index d1b6d2a..aa84275 100644
--- a/smo-tas-server/include/common.h
+++ b/smo-tas-server/include/common.h
@@ -5,6 +5,8 @@
 #include <string>
 #include <vector>
 
+#define RAD(deg) (deg * (M_PI / 180))
+
 namespace smo
 {
     static const std::vector<std::string>& getStages()
diff --git a/smo-tas-server/include/packet.h b/smo-tas-server/include/packet.h
index 49b730b..f6a3a9c 100644
--- a/smo-tas-server/include/packet.h
+++ b/smo-tas-server/include/packet.h
@@ -62,6 +62,7 @@ namespace smo
     {
     public:
         Vector3f pos;
+        Quatf rot;
 
         u32 calcLen();
         void construct(u8* dst);
diff --git a/smo-tas-server/include/server.h b/smo-tas-server/include/server.h
index d96e0dc..6aaaef2 100644
--- a/smo-tas-server/include/server.h
+++ b/smo-tas-server/include/server.h
@@ -4,6 +4,7 @@
 #include <types.h>
 #include <unordered_map>
 #include <packet.h>
+#include <deque>
 
 namespace smo
 {
@@ -28,6 +29,7 @@ namespace smo
     {
     private:
         s32 socketfd;
+        void handleScript(std::deque<std::string> args);
         void loopThread();
     public:
         u8 start(u16 port);
diff --git a/smo-tas-server/include/util.h b/smo-tas-server/include/util.h
new file mode 100644
index 0000000..7a87d83
--- /dev/null
+++ b/smo-tas-server/include/util.h
@@ -0,0 +1,6 @@
+#include <types.h>
+#include <math.h>
+
+namespace fl {
+    smo::Quatf eulerToQuat(smo::Vector3f euler);
+}
\ No newline at end of file
diff --git a/smo-tas-server/src/packet.cpp b/smo-tas-server/src/packet.cpp
index 6c9c932..a25e88b 100644
--- a/smo-tas-server/src/packet.cpp
+++ b/smo-tas-server/src/packet.cpp
@@ -40,7 +40,7 @@ void smo::OutPacketPlayerScriptInfo::construct(u8* dst)
 
 u32 smo::OutPacketPlayerTeleport::calcLen()
 {
-    return 12;
+    return 28;
 }
 
 void smo::OutPacketPlayerTeleport::construct(u8* dst)
@@ -48,6 +48,10 @@ void smo::OutPacketPlayerTeleport::construct(u8* dst)
     *((float*) &dst[0]) = pos.x;
     *((float*) &dst[4]) = pos.y;
     *((float*) &dst[8]) = pos.z;
+    *((float*) &dst[12]) = rot.w;
+    *((float*) &dst[16]) = rot.x;
+    *((float*) &dst[20]) = rot.y;
+    *((float*) &dst[24]) = rot.z;
 }
 
 u32 smo::OutPacketPlayerGo::calcLen()
diff --git a/smo-tas-server/src/server.cpp b/smo-tas-server/src/server.cpp
index 14b386c..4d7a7c8 100644
--- a/smo-tas-server/src/server.cpp
+++ b/smo-tas-server/src/server.cpp
@@ -2,6 +2,7 @@
 #include "script.h"
 #include "tas.h"
 #include "types.h"
+#include "util.h"
 #include <chrono>
 #include <ratio>
 #include <server.h>
@@ -32,6 +33,10 @@
 
 namespace smo
 {
+    std::deque<std::string> scriptArgs;
+    std::deque<std::string> goArgs;
+    std::deque<std::string> tpArgs;
+
     void smo::Client::connect()
     {
         struct in_addr ip;
@@ -115,23 +120,104 @@ namespace smo
         return 0;
     }
 
+    void smo::Server::handleScript(std::deque<std::string> args) {
+        if (args.size() != 1)
+        {
+            if (scriptArgs.empty()) {
+                std::cout << "script <script file>" << std::endl;
+                return;
+            }
+            else
+                args = scriptArgs;
+        }
+        if (!std::filesystem::exists(args[0]))
+        {
+            std::cout << "Specified script file does not exist" << std::endl;
+            return;
+        }
+        scriptArgs = args;
+        std::ifstream scriptFile(args[0]);
+        fl::TasScript script = fl::script::fromText(scriptFile);
+        scriptFile.close();
+
+        OutPacketPlayerScriptInfo p;
+        p.scriptName = args[0];
+        c.sendPacket(this, p, smo::OutPacketType::PlayerScriptInfo);
+
+        std::this_thread::sleep_for(std::chrono::milliseconds(32));
+
+        OutPacketPlayerScriptData pD;
+        {
+            u32 i = 0;
+            for (fl::TasFrame& f : script.frames)
+            {         
+                pD.script.frames.push_back(f);               
+                i++;
+                if (i >= 1500)
+                {
+                    c.sendPacket(this, pD, smo::OutPacketType::PlayerScriptData);
+                    pD.script.frames.clear();
+                    i = 0;
+                    std::this_thread::sleep_for(std::chrono::milliseconds(script.frames.size() / 10000));
+                }
+            }
+            if (i != 0)
+            {
+                c.sendPacket(this, pD, smo::OutPacketType::PlayerScriptData);
+            }
+        }
+    }
+
     void smo::Server::loopThread()
     {
         using namespace std::chrono_literals;
         const std::unordered_map<std::string, std::function<void(std::deque<std::string>&)>> cmd = {
             {"tp", [this](std::deque<std::string>& args)
             {
-                if (args.size() != 3)
+                if (args.size() < 3)
                 {
-                    std::cout << "tp <X> <Y> <Z>" << std::endl;
-                    return;
+                    if (tpArgs.empty()) {
+                        std::cout << "tp <X> <Y> <Z> OR" << std::endl;
+                        std::cout << "tp <X> <Y> <Z> <Y-rot> OR" << std::endl;
+                        std::cout << "tp <X> <Y> <Z> <X-rot> <Y-rot> <Z-rot> OR" << std::endl;
+                        std::cout << "tp <X> <Y> <Z> <quat-W> <quat-X> <quat-Y> <quat-Z>" << std::endl;
+                        return;
+                    }
+                    else
+                        args = tpArgs;
                 }
                 Vector3f pos;
+                Vector3f eulerAngles;
+                Quatf rot;
                 try
                 {
                     pos.x = std::stof(args[0]);
                     pos.y = std::stof(args[1]);
                     pos.z = std::stof(args[2]);
+                    if (args.size() == 3) {
+                        rot.w = 1;
+                        rot.x = 0;
+                        rot.y = 0;
+                        rot.z = 0;
+                    }
+                    else if (args.size() == 4) {
+                        eulerAngles.x = 0;
+                        eulerAngles.y = RAD(std::stof(args[3]));
+                        eulerAngles.z = 0;
+                        rot = fl::eulerToQuat(eulerAngles);
+                    }
+                    else if (args.size() == 6) {
+                        eulerAngles.x = RAD(std::stof(args[3]));
+                        eulerAngles.y = RAD(std::stof(args[4]));
+                        eulerAngles.z = RAD(std::stof(args[5]));
+                        rot = fl::eulerToQuat(eulerAngles);
+                    }
+                    else if (args.size() == 7) {
+                        rot.w = std::stof(args[3]);
+                        rot.x = std::stof(args[4]);
+                        rot.y = std::stof(args[5]);
+                        rot.z = std::stof(args[6]);
+                    }
                 }
                 catch (std::invalid_argument e)
                 {
@@ -140,14 +226,20 @@ namespace smo
                 }
                 OutPacketPlayerTeleport p;
                 p.pos = pos;
+                p.rot = rot;
+                tpArgs = args;
                 c.sendPacket(this, p, smo::OutPacketType::PlayerTeleport);
             }},
             {"go", [this](std::deque<std::string>& args)
             {
                 if (args.size() == 0)
                 {
-                    std::cout << "go <stage name> <scenario> <entrance> <start script (true:false)>" << std::endl;
-                    return;
+                    if (goArgs.empty()) {
+                        std::cout << "go <stage name> <scenario> <entrance> <start script (true:false)>" << std::endl;
+                        return;
+                    }
+                    else
+                        args = goArgs;
                 }
                 std::string entrance = "start";
                 s8 scenario = -1;
@@ -181,56 +273,27 @@ namespace smo
                 p.scenario = scenario;
                 p.stageName = args[0];
                 p.entrance = entrance;
+                goArgs = args;
                 c.sendPacket(this, p, smo::OutPacketType::PlayerGo);
             }},
             {"script", [this](std::deque<std::string>& args)
             {
-                if (args.size() != 1)
-                {
-                    std::cout << "script <script file>" << std::endl;
-                    return;
-                }
-                if (!std::filesystem::exists(args[0]))
-                {
-                    std::cout << "Specified script file does not exist" << std::endl;
-                    return;
-                }
-                std::ifstream scriptFile(args[0]);
-                fl::TasScript script = fl::script::fromText(scriptFile);
-                scriptFile.close();
-
-                OutPacketPlayerScriptInfo p;
-                p.scriptName = args[0];
-                c.sendPacket(this, p, smo::OutPacketType::PlayerScriptInfo);
-
-                std::this_thread::sleep_for(std::chrono::milliseconds(32));
-
-                OutPacketPlayerScriptData pD;
-                {
-                    u32 i = 0;
-                    for (fl::TasFrame& f : script.frames)
-                    {         
-                        pD.script.frames.push_back(f);               
-                        i++;
-                        if (i >= 1500)
-                        {
-                            c.sendPacket(this, pD, smo::OutPacketType::PlayerScriptData);
-                            pD.script.frames.clear();
-                            i = 0;
-                            std::this_thread::sleep_for(std::chrono::milliseconds(script.frames.size() / 10000));
-                        }
-                    }
-                    if (i != 0)
-                    {
-                        c.sendPacket(this, pD, smo::OutPacketType::PlayerScriptData);
-                    }
-                }
+                handleScript(args);
+            }},
+            {"s", [this](std::deque<std::string>& args)
+            {
+                handleScript(args);
             }},
             {"help", [this](std::deque<std::string>& args)
             {
-                std::cout << "tp <X> <Y> <Z>\n  Teleport Player to position" << std::endl;
+                std::cout << "tp <X> <Y> <Z>\n  Teleport Player to position, rotation 0 degrees" << std::endl;
+                std::cout << "tp <X> <Y> <Z> <Y-rot>" << std::endl;
+                std::cout << "tp <X> <Y> <Z> <X-rot> <Y-rot> <Z-rot>" << std::endl;
+                std::cout << "tp <X> <Y> <Z> <quat-W> <quat-X> <quat-Y> <quat-Z>\n Teleport Player to position with specified rotation" << std::endl;
                 std::cout << "go <stage name> <entrance> <scenario>\n  Teleport Player to stage" << std::endl;
                 std::cout << "script <script file>\n  Start script" << std::endl;
+                std::cout << "s <script file>\n  Start script" << std::endl;
+                std::cout << "run a command without arguments to run it with the last valid arguments you used" << std::endl;
             }}
         };
         std::deque<std::string> lastCommand;
diff --git a/smo-tas-server/src/util.cpp b/smo-tas-server/src/util.cpp
new file mode 100644
index 0000000..b91548f
--- /dev/null
+++ b/smo-tas-server/src/util.cpp
@@ -0,0 +1,20 @@
+#include <util.h>
+
+    smo::Quatf fl::eulerToQuat(smo::Vector3f euler) {
+
+        smo::Quatf quat;
+
+        f32 cy = cos(euler.y / 2);
+        f32 sy = sin(euler.y / 2);
+        f32 cp = cos(euler.z / 2);
+        f32 sp = sin(euler.z / 2);
+        f32 cr = cos(euler.x / 2);
+        f32 sr = sin(euler.x / 2);
+
+        quat.w = cr * cp * cy + sr * sp * sy;
+        quat.x = sr * cp * cy - cr * sp * sy;
+        quat.z = cr * sp * cy + sr * cp * sy;
+        quat.y = cr * cp * sy - sr * sp * cy;
+
+        return quat;
+    }
\ No newline at end of file
diff --git a/source/fl/packet.cpp b/source/fl/packet.cpp
index 929ec72..61ddb55 100644
--- a/source/fl/packet.cpp
+++ b/source/fl/packet.cpp
@@ -52,6 +52,10 @@ namespace smo
         pos.x = *(float*) &data[0];
         pos.y = *(float*) &data[4];
         pos.z = *(float*) &data[8];
+        rot.w = *(float*) &data[12];
+        rot.x = *(float*) &data[16];
+        rot.y = *(float*) &data[20];
+        rot.z = *(float*) &data[24];
     }
 
     void InPacketPlayerTeleport::on(Server &server)
@@ -61,6 +65,7 @@ namespace smo
         PlayerActorHakoniwa* player = rs::getPlayerActor(stageScene);
         player->startDemoPuppetable();
         al::setTrans(player, pos);
+        al::updatePoseQuat(player, rot);
         player->endDemoPuppetable();
     }
 
diff --git a/source/fl/ui.cpp b/source/fl/ui.cpp
index 0133a44..d1e4e82 100644
--- a/source/fl/ui.cpp
+++ b/source/fl/ui.cpp
@@ -23,7 +23,7 @@ const char* stageNames[] = {"CapWorldHomeStage", "WaterfallWorldHomeStage", "San
 #endif
 
 
-#define NUM_PAGES 9
+#define NUM_PAGES 11
 #define NUM_STAGES 200
 
 #if(SMOVER==100)
@@ -50,6 +50,56 @@ const char* stageNames[] = {"CapWorldHomeStage", "WaterfallWorldHomeStage", "San
                                     printf("%s" NAME, charCursor);\
                                     if (inputEnabled && curLine == LINE && !nextFrameNoRightInput && al::isPadTriggerRight(CONTROLLER_AUTO)) {ACTION;}
 
+sead::Vector3f relativeTrans;
+double relativeAngle = 0;
+sead::Vector3f oldPlayerTrans = sead::Vector3f::zero;
+
+sead::Vector3f calculateVelocity(sead::Vector3f oldTrans, sead::Vector3f newTrans) {
+    sead::Vector3f velocity;
+    velocity.x = newTrans.x - oldTrans.x;
+    velocity.y = newTrans.y - oldTrans.y;
+    velocity.z = newTrans.z - oldTrans.z;
+    return velocity;
+}
+
+//angle in radians
+void setRelativeAxes(sead::Vector3f trans, double angle) {
+    relativeTrans = trans;
+    relativeAngle = angle;
+}
+
+sead::Vector3f transformToRelativeAxes(sead::Vector3f vec, bool isTransVector) {
+    if (isTransVector) {
+        vec.x -= relativeTrans.x;
+        vec.y -= relativeTrans.y;
+        vec.z -= relativeTrans.z;
+    }
+    double zxAngle = atan2f(vec.x, vec.z);
+    double caAngle = zxAngle - relativeAngle;
+    double magnitude = sqrt(vec.z * vec.z + vec.x * vec.x);
+    vec.z = magnitude * cosf(caAngle);
+    vec.x = magnitude * sinf(caAngle);
+    return vec;
+}
+
+sead::Vector3f transformEulerAnglesToRelativeAxes(sead::Vector3f vec) {
+    sead::Vector3f newVec;
+    newVec.z = atanf(tanf(vec.z) * cosf(relativeAngle) + tanf(vec.x) * sinf(relativeAngle));
+    newVec.x = atanf(tanf(vec.z) * cosf(relativeAngle + M_PI_2) + tanf(vec.x) * sinf(relativeAngle + M_PI_2));
+    newVec.y = vec.y - relativeAngle;
+    if (newVec.y < 0)
+        newVec.y += M_PI * 2;
+    return newVec;
+}
+
+sead::Vector3f calcMagnitudes(sead::Vector3f vec) {
+    sead::Vector3f newVec;
+    newVec.x = sqrt(vec.z * vec.z + vec.x * vec.x);
+    newVec.y = vec.y;
+    newVec.z = sqrt(newVec.x * newVec.x + newVec.y * newVec.y);
+    return newVec;
+}
+
 void fl::PracticeUI::savePosition(PlayerActorHakoniwa& player)
 {
     savedTrans = *al::getTrans(&player);
@@ -165,7 +215,9 @@ void fl::PracticeUI::menu()
                 else if (curPage == Options) curPage = Stage;
                 else if (curPage == Stage) curPage = Misc;
                 else if (curPage == Misc) curPage = Info;
-                else if (curPage == Info) curPage = Tas;
+                else if (curPage == Info) curPage = Info2;
+                else if (curPage == Info2) curPage = Info3;
+                else if (curPage == Info3) curPage = Tas;
                 else if (curPage == Tas) curPage = MoonInfo;
                 else if (curPage == MoonInfo) curPage = Modes;
                 else if (curPage == Modes) curPage = Debug;
@@ -177,7 +229,9 @@ void fl::PracticeUI::menu()
                 else if (curPage == Stage) curPage = Options;
                 else if (curPage == Misc) curPage = Stage;
                 else if (curPage == Info) curPage = Misc;
-                else if (curPage == Tas) curPage = Info;
+                else if (curPage == Tas) curPage = Info3;
+                else if (curPage == Info3) curPage = Info2;
+                else if (curPage == Info2) curPage = Info;
                 else if (curPage == MoonInfo) curPage = Tas;
                 else if (curPage == Modes) curPage = MoonInfo;
                 else if (curPage == Debug) curPage = Modes;
@@ -345,49 +399,184 @@ void fl::PracticeUI::menu()
             }
             case Info:
             {
-                TITLE("Info");
-                MAX_LINE(1);
+                printf("Info\n");
+                MAX_LINE(2);
+                CURSOR(0);
                 CHANGE_PAGE();
 
-                static bool quatRot = false;
-                TOGGLE("Quaternion Rotation: %s\n", quatRot, 1);
-
                 sead::Vector3f* playerTrans = al::getTrans(player);
                 sead::Vector3f* playerVel = al::getVelocity(player);
                 sead::Quatf* playerQuat = al::getQuat(player);
                 sead::Vector3f playerEulerAngles = fl::QuatToEuler(playerQuat);
                 sead::Vector3f playerRot = sead::Vector3f(DEG(playerEulerAngles.x),DEG(playerEulerAngles.y),DEG(playerEulerAngles.z));
                 sead::Vector3f* playerRecoveryPoint = player->mPlayerRecoverPoint->getSafetyPoint();
-                sead::Vector3f* cappyPosition = al::getTrans(cappy);
-                sead::Vector3f* cappyVel = al::getVelocity(cappy);
-                sead::Quatf* cappyQuat = al::getQuat(cappy);
+                sead::Vector3f* cappyTrans = al::getTrans(player->mHackCap);
+                sead::Quatf* cappyQuat = al::getQuat(player->mHackCap);
                 sead::Vector3f cappyEulerAngles = fl::QuatToEuler(cappyQuat);
                 sead::Vector3f cappyRot = sead::Vector3f(DEG(cappyEulerAngles.x),DEG(cappyEulerAngles.y),DEG(cappyEulerAngles.z));
                 const char* anim = player->mPlayerAnimator->mCurrentAnim;
                 float hSpeed = al::calcSpeedH(player), vSpeed = al::calcSpeedV(player), speed = al::calcSpeed(player);
+                float hSpeedAngle = atan2f(playerVel->x, playerVel->z);
+                if (hSpeedAngle < 0)
+                    hSpeedAngle += M_PI * 2;
+
+                fl::TasHolder& h = fl::TasHolder::instance();
+
+                if (h.isRunning)  {TRIGGER("Stop Script\n", 1, h.stop());}
+                else { TRIGGER("Start Script\n", 1, {
+                    if (h.frames) h.start();
+                });
+                }
+
+                if (h.scriptName) {
+                    u64 curFrame = 0; 
+                    if (h.isRunning)
+                        curFrame = h.curFrame;
+                    printf(" Script: %s (%lu/%lu frames)\n", h.scriptName, curFrame, h.frameCount);
+                }
+
+                printf("\n");
+
+                static bool quatRot = false;
+                TOGGLE("Quaternion Rotation: %s\n\n", quatRot, 2);              
 
                 printf(" Player Pos: (X: %.3f Y: %.3f Z: %.3f)\n", playerTrans->x, playerTrans->y, playerTrans->z);
                 printf(" Player Vel: (X: %.3f Y: %.3f Z: %.3f)\n", playerVel->x, playerVel->y, playerVel->z);
+                printf(" Player Vel Angle: %.3f\n", DEG(hSpeedAngle));
                 printf(" Player Speed: (H: %.3f V: %.3f S: %.3f)\n", hSpeed, vSpeed, speed);
                 if (quatRot)
                 {
                     printf(" Player Rot: (W: %.3f X: %.3f Y: %.3f Z: %.3f)\n", playerQuat->w, playerQuat->x, playerQuat->y, playerQuat->z);
                 }
                 else
-                {
                     printf(" Player Rot: (X: %.3f Y: %.3f Z: %.3f)\n", playerRot.x, playerRot.y, playerRot.z);
-                }
-                printf(" Cappy Pos: (X: %.3f Y: %.3f Z: %.3f)\n", cappyPosition->x, cappyPosition->y, cappyPosition->z);
-                printf(" Cappy Vel: (X: %.3f Y: %.3f Z: %.3f)\n", cappyVel->x, cappyVel->y, cappyVel->z);
+                printf(" Cappy Pos: (X: %.3f Y: %.3f Z: %.3f)\n", cappyTrans->x, cappyTrans->y, cappyTrans->z);
                 if (quatRot)
                 {
                     printf(" Cappy Rot: (W: %.3f X: %.3f Y: %.3f Z: %.3f)\n", cappyQuat->w, cappyQuat->x, cappyQuat->y, cappyQuat->z);
                 }
                 else
+                    printf(" Cappy Rot: (X: %.3f Y: %.3f Z: %.3f)\n", cappyRot.x, cappyRot.y, cappyRot.z);
+                printf(" Bubble Pos: (X: %.3f Y: %.3f Z: %.3f)\n", playerRecoveryPoint->x, playerRecoveryPoint->y, playerRecoveryPoint->z);
+                printf(" Current Animation: %s (%.0f/%.0f)\n", anim, player->mPlayerAnimator->getAnimFrame() - 1.0f, player->mPlayerAnimator->getAnimFrameMax());
+
+                break;
+            }
+            case Info2:
+            {
+                printf("Info (Observed Velocity)\n");
+                MAX_LINE(2);
+                CURSOR(0);
+                CHANGE_PAGE();
+
+                sead::Vector3f playerTrans = *al::getTrans(player);
+                sead::Vector3f playerVel = calculateVelocity(oldPlayerTrans, playerTrans);
+                sead::Vector3f playerSpeed = calcMagnitudes(playerVel);
+                sead::Quatf playerQuat = *al::getQuat(player);
+                sead::Vector3f playerEulerAngles = fl::QuatToEuler(&playerQuat);
+                sead::Vector3f playerRot = sead::Vector3f(DEG(playerEulerAngles.x),DEG(playerEulerAngles.y),DEG(playerEulerAngles.z));
+                sead::Vector3f playerRecoveryPoint = *player->mPlayerRecoverPoint->getSafetyPoint();
+                sead::Vector3f cappyTrans = *al::getTrans(player->mHackCap);
+                sead::Quatf cappyQuat = *al::getQuat(player->mHackCap);
+                sead::Vector3f cappyEulerAngles = fl::QuatToEuler(&cappyQuat);
+                sead::Vector3f cappyRot = sead::Vector3f(DEG(cappyEulerAngles.x),DEG(cappyEulerAngles.y),DEG(cappyEulerAngles.z));
+                const char* anim = player->mPlayerAnimator->mCurrentAnim;
+                float hSpeedAngle = atan2f(playerVel.x, playerVel.z);
+                if (hSpeedAngle < 0)
+                    hSpeedAngle += M_PI * 2;
+
+                fl::TasHolder& h = fl::TasHolder::instance();
+
+                if (h.isRunning)  {TRIGGER("Stop Script\n", 1, h.stop());}
+                else { TRIGGER("Start Script\n", 1, {
+                    if (h.frames) h.start();
+                });
+                }
+
+                if (h.scriptName) {
+                    u64 curFrame = 0; 
+                    if (h.isRunning)
+                        curFrame = h.curFrame;
+                    printf(" Script: %s (%lu/%lu frames)\n", h.scriptName, curFrame, h.frameCount);
+                }
+
+                printf("\n");
+
+                static bool quatRot = false;
+                TOGGLE("Quaternion Rotation: %s\n\n", quatRot, 2);              
+
+                printf(" Player Pos: (X: %.3f Y: %.3f Z: %.3f)\n", playerTrans.x, playerTrans.y, playerTrans.z);
+                printf(" Player Vel: (X: %.3f Y: %.3f Z: %.3f)\n", playerVel.x, playerVel.y, playerVel.z);
+                printf(" Player Vel Angle: %.3f\n", DEG(hSpeedAngle));
+                printf(" Player Speed: (H: %.3f V: %.3f S: %.3f)\n", playerSpeed.x, playerSpeed.y, playerSpeed.z);
+                if (quatRot)
+                {
+                    printf(" Player Rot: (W: %.3f X: %.3f Y: %.3f Z: %.3f)\n", playerQuat.w, playerQuat.x, playerQuat.y, playerQuat.z);
+                }
+                else
+                    printf(" Player Rot: (X: %.3f Y: %.3f Z: %.3f)\n", playerRot.x, playerRot.y, playerRot.z);
+                printf(" Cappy Pos: (X: %.3f Y: %.3f Z: %.3f)\n", cappyTrans.x, cappyTrans.y, cappyTrans.z);
+                if (quatRot)
                 {
+                    printf(" Cappy Rot: (W: %.3f X: %.3f Y: %.3f Z: %.3f)\n", cappyQuat.w, cappyQuat.x, cappyQuat.y, cappyQuat.z);
+                }
+                else
                     printf(" Cappy Rot: (X: %.3f Y: %.3f Z: %.3f)\n", cappyRot.x, cappyRot.y, cappyRot.z);
+                printf(" Bubble Pos: (X: %.3f Y: %.3f Z: %.3f)\n", playerRecoveryPoint.x, playerRecoveryPoint.y, playerRecoveryPoint.z);
+                printf(" Current Animation: %s (%.0f/%.0f)\n", anim, player->mPlayerAnimator->getAnimFrame() - 1.0f, player->mPlayerAnimator->getAnimFrameMax());
+
+                oldPlayerTrans = playerTrans;
+
+                break;
+            }
+            case Info3:
+            {
+                printf("Relative Axes\n");
+                MAX_LINE(1);
+                CURSOR(0);
+                CHANGE_PAGE();
+
+                sead::Vector3f* playerTrans = al::getTrans(player);
+                sead::Vector3f* playerVel = al::getVelocity(player);
+                sead::Quatf* playerQuat = al::getQuat(player);
+                sead::Vector3f playerEulerAngles = fl::QuatToEuler(playerQuat);
+                //sead::Vector3f* playerRecoveryPoint = player->mPlayerRecoverPoint->getSafetyPoint();
+                sead::Vector3f* cappyTrans = al::getTrans(player->mHackCap);
+                sead::Quatf* cappyQuat = al::getQuat(player->mHackCap);
+                sead::Vector3f cappyEulerAngles = fl::QuatToEuler(cappyQuat);
+
+                static bool fixedOrigin = false;
+                TOGGLE("Fixed Origin/Rotation: %s\n\n", fixedOrigin, 1);
+                if (!fixedOrigin) {
+                    setRelativeAxes(*playerTrans, playerEulerAngles.y);
                 }
-                printf(" Bubble Pos: (X: %.3f Y: %.3f Z: %.3f)\n", playerRecoveryPoint->x, playerRecoveryPoint->y, playerRecoveryPoint->z);
+
+                sead::Vector3f playerABCTrans = transformToRelativeAxes(*playerTrans, true);
+                sead::Vector3f playerABCDistances = calcMagnitudes(playerABCTrans);
+                sead::Vector3f playerABCVel = transformToRelativeAxes(*playerVel, false);
+                sead::Vector3f cappyABCTrans = transformToRelativeAxes(*cappyTrans, true);
+                sead::Vector3f cappyABCDistances = calcMagnitudes(cappyABCTrans);
+                sead::Vector3f playerABCEulerAngles = transformEulerAnglesToRelativeAxes(playerEulerAngles);
+                sead::Vector3f cappyABCEulerAngles = transformEulerAnglesToRelativeAxes(cappyEulerAngles);
+                sead::Vector3f playerABCRot = sead::Vector3f(DEG(playerABCEulerAngles.x),DEG(playerABCEulerAngles.y),DEG(playerABCEulerAngles.z));
+                sead::Vector3f cappyABCRot = sead::Vector3f(DEG(cappyABCEulerAngles.x),DEG(cappyABCEulerAngles.y),DEG(cappyABCEulerAngles.z));
+
+                const char* anim = player->mPlayerAnimator->mCurrentAnim;
+                float hSpeed = al::calcSpeedH(player), vSpeed = al::calcSpeedV(player), speed = al::calcSpeed(player);
+
+                printf(" Origin: (X: %.3f Y: %.3f Z: %.3f)\n", relativeTrans.x, relativeTrans.y, relativeTrans.z);
+                printf(" Rotation: %.3f\n\n", DEG(relativeAngle));
+                if (fixedOrigin) {
+                    printf(" Player Pos: (A: %.3f B: %.3f C: %.3f)\n", playerABCTrans.x, playerABCTrans.y, playerABCTrans.z);
+                    printf(" Player Dist to Origin: (H: %.3f S: %.3f)\n", playerABCDistances.x, playerABCDistances.z);
+                }
+                printf(" Player Vel: (A: %.3f B: %.3f C: %.3f)\n", playerABCVel.x, playerABCVel.y, playerABCVel.z);
+                printf(" Player Speed: (H: %.3f V: %.3f S: %.3f)\n", hSpeed, vSpeed, speed);
+                printf(" Player Rot: (A: %.3f B: %.3f C: %.3f)\n", playerABCRot.x, playerABCRot.y, playerABCRot.z);
+                printf(" Cappy Pos: (A: %.3f B: %.3f C: %.3f)\n", cappyABCTrans.x, cappyABCTrans.y, cappyABCTrans.z);
+                printf(" Cappy Dist to Origin: (H: %.3f S: %.3f)\n", cappyABCDistances.x, cappyABCDistances.z);
+                printf(" Cappy Rot: (A: %.3f B: %.3f C: %.3f)\n", cappyABCRot.x, cappyABCRot.y, cappyABCRot.z);
+                //printf("Bubble Pos: (X: %.3f Y: %.3f Z: %.3f)\n", playerRecoveryPoint->x, playerRecoveryPoint->y, playerRecoveryPoint->z);
                 printf(" Current Animation: %s (%.0f/%.0f)\n", anim, player->mPlayerAnimator->getAnimFrame() - 1.0f, player->mPlayerAnimator->getAnimFrameMax());
 
                 break;
diff --git a/source/fl/util.cpp b/source/fl/util.cpp
index de6c264..d9eb788 100644
--- a/source/fl/util.cpp
+++ b/source/fl/util.cpp
@@ -2,9 +2,9 @@
 
 sead::Vector3f fl::QuatToEuler(sead::Quatf *quat) {
 
-    f32 x = quat->z;
-    f32 y = quat->y;
-    f32 z = quat->x;
+    f32 x = quat->x;
+    f32 y = quat->z;
+    f32 z = quat->y;
     f32 w = quat->w;
 
     f32 t0 = 2.0 * (w * x + y * z);
@@ -19,8 +19,11 @@ sead::Vector3f fl::QuatToEuler(sead::Quatf *quat) {
     f32 t3 = 2.0 * (w * z + x * y);
     f32 t4 = 1.0 - 2.0 * (y * y + z * z);
     f32 yaw = atan2f(t3, t4);
+    f32 adjustedYaw = yaw;
+    if (adjustedYaw < 0)
+      adjustedYaw += M_PI * 2;
 
-    return sead::Vector3f(yaw, pitch, roll);
+    return sead::Vector3f(roll, adjustedYaw, pitch);
 }
 
 void* fl::memset (void *dest, int val, size_t len)