From 707d04ec366c9be501e22f917bf04d145ddbdbd5 Mon Sep 17 00:00:00 2001
From: xiivler <51525828+xiivler@users.noreply.github.com>
Date: Sun, 23 Jan 2022 09:36:48 -0800
Subject: [PATCH 1/9] Store old args, script command shorthand

---
 smo-tas-server/include/server.cpp | 288 ++++++++++++++++++++++++++++++
 1 file changed, 288 insertions(+)
 create mode 100644 smo-tas-server/include/server.cpp

diff --git a/smo-tas-server/include/server.cpp b/smo-tas-server/include/server.cpp
new file mode 100644
index 0000000..37fcc8c
--- /dev/null
+++ b/smo-tas-server/include/server.cpp
@@ -0,0 +1,288 @@
+#include "common.h"
+#include "script.h"
+#include "tas.h"
+#include "types.h"
+#include <chrono>
+#include <ratio>
+#include <server.h>
+#include <packet.h>
+
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <stdexcept>
+#include <sys/socket.h>
+
+#include <thread>
+#include <iostream>
+#include <fstream>
+#include <unordered_map>
+#include <functional>
+#include <sstream>
+#include <vector>
+#include <deque>
+#include <filesystem>
+
+#define MAX_PACKET_SIZE 0x400
+
+#define IN_PACKET(TYPE) case smo::InPacketType::TYPE: {\
+                InPacket##TYPE p;\
+                p.parse(data + 1, length - 1);\
+                p.on(*this, *parent);\
+                break;}
+
+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;
+        ip.s_addr = uid;
+        std::cout << "Client connected from " << inet_ntoa(ip) << std::endl;
+    }
+
+    void smo::Client::handlePacket(Server* parent, u8* data, s32 length)
+    {
+        if (length < 1) return;
+        switch ((InPacketType) data[0])
+        {
+            case smo::InPacketType::DummyInit:
+            {
+                break;
+            }
+            case smo::InPacketType::Init:
+            {
+                connect();
+                //OutPacketPlayerTeleport p;
+                //p.pos = {0, 1000, 0};
+                //sendPacket(parent, p, smo::OutPacketType::PlayerTeleport);
+                break;
+            }
+            IN_PACKET(Log)
+            default: break;
+        }
+    }
+
+    void smo::Client::sendPacket(Server* parent, smo::OutPacket& packet, smo::OutPacketType type)
+    {
+        u32 len = packet.calcLen();
+        u8* packetData = new u8[len + 1];
+        packet.construct(packetData + 1);
+        packetData[0] = (u8) type;
+        sendto(parent->getSocket(), packetData, len + 1, 0, (struct sockaddr*) &client, sizeof(client));
+        delete[] packetData;
+    }
+
+    bool smo::Server::disconnect(u64 uid)
+    {return false;}
+
+    u8 smo::Server::start(u16 port)
+    {
+        struct sockaddr_in addr, cli;
+
+        socketfd = socket(AF_INET, SOCK_DGRAM, 0);
+
+        if (socketfd == -1) return 1;
+
+        setsockopt(socketfd, SOL_SOCKET, SO_REUSEADDR, nullptr, sizeof(int));
+
+        addr.sin_family = AF_INET;
+        addr.sin_addr.s_addr = htonl(INADDR_ANY);
+        addr.sin_port = htons(port);
+
+        int rval = bind(socketfd, (struct sockaddr*) &addr, sizeof(addr));
+        if (rval != 0) return 2;
+
+        listen(socketfd, 2);
+
+        u8 buf[12288];
+        s32 size = 0;
+
+        std::thread loop(&smo::Server::loopThread, this);
+        loop.detach();
+
+        while (true)
+        {
+            s32 length = sizeof(cli);
+
+            struct sockaddr_in client;
+            socklen_t addrSize;
+
+            if ((size = recvfrom(socketfd, buf, sizeof(buf), 0, (struct sockaddr *) &client, &addrSize)) < 0) continue;
+            u64 uid = client.sin_addr.s_addr + client.sin_port;
+            
+            c.uid = uid;
+            c.addr = client.sin_addr.s_addr;
+            c.client = client;
+            c.handlePacket(this, buf, size);
+        }
+
+        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 (tpArgs.empty()) {
+                        std::cout << "tp <X> <Y> <Z>" << std::endl;
+                        return;
+                    }
+                    else
+                        args = tpArgs;
+                }
+                Vector3f pos;
+                try
+                {
+                    pos.x = std::stof(args[0]);
+                    pos.y = std::stof(args[1]);
+                    pos.z = std::stof(args[2]);
+                }
+                catch (std::invalid_argument e)
+                {
+                    std::cout << "Invalid Number" << std::endl;
+                    return;
+                }
+                OutPacketPlayerTeleport p;
+                p.pos = pos;
+                tpArgs = args;
+                c.sendPacket(this, p, smo::OutPacketType::PlayerTeleport);
+            }},
+            {"go", [this](std::deque<std::string>& args)
+            {
+                if (args.size() == 0)
+                {
+                    if (goArgs.empty()) {
+                        std::cout << "go <stage name> <scenario> <entrance>" << std::endl;
+                        return;
+                    }
+                    else
+                        args = goArgs;
+                }
+                std::string entrance = "start";
+                s8 scenario = -1;
+                if (args.size() >= 2)
+                {
+                    try
+                    {
+                        scenario = std::stoi(args[1]);
+                    } catch(std::invalid_argument e)
+                    {
+                        std::cout << "Invalid Number" << std::endl;
+                        return;
+                    }
+                    if (scenario == 0)
+                    {
+                        std::cout << "Scenario cannot be 0" << std::endl;
+                        return;
+                    }
+                }
+                if (args.size() == 3) entrance = args[2];
+                const std::vector<std::string>& stages = getStages();
+                if (std::find(stages.begin(), stages.end(), args[0]) == stages.end())
+                {
+                    std::cout << "Stage doesn't exist" << std::endl;
+                    return;
+                }
+                OutPacketPlayerGo p;
+                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)
+            {
+                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 << "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;
+        while (true)
+        {
+            std::cout << "> " << std::flush;
+            std::string command;
+            getline(std::cin, command);
+            std::deque<std::string> args = fl::split(command, ' ');
+            if (args[0] == "l") args = lastCommand;
+            else lastCommand = args;
+            if (cmd.find(args[0]) != cmd.end())
+            {
+                std::function<void(std::deque<std::string>&)> fun = cmd.at(args[0]);
+                args.pop_front();
+                fun(args);
+            }
+            else if (command != "")
+            {
+                std::cout << "Unknown Command. Type \"help\" for a list of commands." << std::endl;
+            }
+        }
+    }
+
+    s32 smo::Server::getSocket() {return socketfd;}
+}
\ No newline at end of file

From 8be77377fb28de03ca3af7f46563c4e09f4830aa Mon Sep 17 00:00:00 2001
From: Xiivler <xiivler1@gmail.com>
Date: Sun, 23 Jan 2022 10:26:19 -0800
Subject: [PATCH 2/9] use last args, script command shorthand

When inputting a command without any arguments, it uses the last valid arguments, saving typing when using multiple commands. Script command can now also be run using "s".
---
 smo-tas-server/include/server.cpp | 288 ------------------------------
 smo-tas-server/include/server.h   |   2 +
 smo-tas-server/src/server.cpp     | 120 ++++++++-----
 3 files changed, 78 insertions(+), 332 deletions(-)
 delete mode 100644 smo-tas-server/include/server.cpp

diff --git a/smo-tas-server/include/server.cpp b/smo-tas-server/include/server.cpp
deleted file mode 100644
index 37fcc8c..0000000
--- a/smo-tas-server/include/server.cpp
+++ /dev/null
@@ -1,288 +0,0 @@
-#include "common.h"
-#include "script.h"
-#include "tas.h"
-#include "types.h"
-#include <chrono>
-#include <ratio>
-#include <server.h>
-#include <packet.h>
-
-#include <arpa/inet.h>
-#include <netinet/in.h>
-#include <stdexcept>
-#include <sys/socket.h>
-
-#include <thread>
-#include <iostream>
-#include <fstream>
-#include <unordered_map>
-#include <functional>
-#include <sstream>
-#include <vector>
-#include <deque>
-#include <filesystem>
-
-#define MAX_PACKET_SIZE 0x400
-
-#define IN_PACKET(TYPE) case smo::InPacketType::TYPE: {\
-                InPacket##TYPE p;\
-                p.parse(data + 1, length - 1);\
-                p.on(*this, *parent);\
-                break;}
-
-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;
-        ip.s_addr = uid;
-        std::cout << "Client connected from " << inet_ntoa(ip) << std::endl;
-    }
-
-    void smo::Client::handlePacket(Server* parent, u8* data, s32 length)
-    {
-        if (length < 1) return;
-        switch ((InPacketType) data[0])
-        {
-            case smo::InPacketType::DummyInit:
-            {
-                break;
-            }
-            case smo::InPacketType::Init:
-            {
-                connect();
-                //OutPacketPlayerTeleport p;
-                //p.pos = {0, 1000, 0};
-                //sendPacket(parent, p, smo::OutPacketType::PlayerTeleport);
-                break;
-            }
-            IN_PACKET(Log)
-            default: break;
-        }
-    }
-
-    void smo::Client::sendPacket(Server* parent, smo::OutPacket& packet, smo::OutPacketType type)
-    {
-        u32 len = packet.calcLen();
-        u8* packetData = new u8[len + 1];
-        packet.construct(packetData + 1);
-        packetData[0] = (u8) type;
-        sendto(parent->getSocket(), packetData, len + 1, 0, (struct sockaddr*) &client, sizeof(client));
-        delete[] packetData;
-    }
-
-    bool smo::Server::disconnect(u64 uid)
-    {return false;}
-
-    u8 smo::Server::start(u16 port)
-    {
-        struct sockaddr_in addr, cli;
-
-        socketfd = socket(AF_INET, SOCK_DGRAM, 0);
-
-        if (socketfd == -1) return 1;
-
-        setsockopt(socketfd, SOL_SOCKET, SO_REUSEADDR, nullptr, sizeof(int));
-
-        addr.sin_family = AF_INET;
-        addr.sin_addr.s_addr = htonl(INADDR_ANY);
-        addr.sin_port = htons(port);
-
-        int rval = bind(socketfd, (struct sockaddr*) &addr, sizeof(addr));
-        if (rval != 0) return 2;
-
-        listen(socketfd, 2);
-
-        u8 buf[12288];
-        s32 size = 0;
-
-        std::thread loop(&smo::Server::loopThread, this);
-        loop.detach();
-
-        while (true)
-        {
-            s32 length = sizeof(cli);
-
-            struct sockaddr_in client;
-            socklen_t addrSize;
-
-            if ((size = recvfrom(socketfd, buf, sizeof(buf), 0, (struct sockaddr *) &client, &addrSize)) < 0) continue;
-            u64 uid = client.sin_addr.s_addr + client.sin_port;
-            
-            c.uid = uid;
-            c.addr = client.sin_addr.s_addr;
-            c.client = client;
-            c.handlePacket(this, buf, size);
-        }
-
-        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 (tpArgs.empty()) {
-                        std::cout << "tp <X> <Y> <Z>" << std::endl;
-                        return;
-                    }
-                    else
-                        args = tpArgs;
-                }
-                Vector3f pos;
-                try
-                {
-                    pos.x = std::stof(args[0]);
-                    pos.y = std::stof(args[1]);
-                    pos.z = std::stof(args[2]);
-                }
-                catch (std::invalid_argument e)
-                {
-                    std::cout << "Invalid Number" << std::endl;
-                    return;
-                }
-                OutPacketPlayerTeleport p;
-                p.pos = pos;
-                tpArgs = args;
-                c.sendPacket(this, p, smo::OutPacketType::PlayerTeleport);
-            }},
-            {"go", [this](std::deque<std::string>& args)
-            {
-                if (args.size() == 0)
-                {
-                    if (goArgs.empty()) {
-                        std::cout << "go <stage name> <scenario> <entrance>" << std::endl;
-                        return;
-                    }
-                    else
-                        args = goArgs;
-                }
-                std::string entrance = "start";
-                s8 scenario = -1;
-                if (args.size() >= 2)
-                {
-                    try
-                    {
-                        scenario = std::stoi(args[1]);
-                    } catch(std::invalid_argument e)
-                    {
-                        std::cout << "Invalid Number" << std::endl;
-                        return;
-                    }
-                    if (scenario == 0)
-                    {
-                        std::cout << "Scenario cannot be 0" << std::endl;
-                        return;
-                    }
-                }
-                if (args.size() == 3) entrance = args[2];
-                const std::vector<std::string>& stages = getStages();
-                if (std::find(stages.begin(), stages.end(), args[0]) == stages.end())
-                {
-                    std::cout << "Stage doesn't exist" << std::endl;
-                    return;
-                }
-                OutPacketPlayerGo p;
-                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)
-            {
-                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 << "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;
-        while (true)
-        {
-            std::cout << "> " << std::flush;
-            std::string command;
-            getline(std::cin, command);
-            std::deque<std::string> args = fl::split(command, ' ');
-            if (args[0] == "l") args = lastCommand;
-            else lastCommand = args;
-            if (cmd.find(args[0]) != cmd.end())
-            {
-                std::function<void(std::deque<std::string>&)> fun = cmd.at(args[0]);
-                args.pop_front();
-                fun(args);
-            }
-            else if (command != "")
-            {
-                std::cout << "Unknown Command. Type \"help\" for a list of commands." << std::endl;
-            }
-        }
-    }
-
-    s32 smo::Server::getSocket() {return socketfd;}
-}
\ No newline at end of file
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/src/server.cpp b/smo-tas-server/src/server.cpp
index 14b386c..d520c28 100644
--- a/smo-tas-server/src/server.cpp
+++ b/smo-tas-server/src/server.cpp
@@ -32,6 +32,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;
@@ -51,6 +55,9 @@ namespace smo
             case smo::InPacketType::Init:
             {
                 connect();
+                //OutPacketPlayerTeleport p;
+                //p.pos = {0, 1000, 0};
+                //sendPacket(parent, p, smo::OutPacketType::PlayerTeleport);
                 break;
             }
             IN_PACKET(Log)
@@ -115,6 +122,54 @@ 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;
@@ -123,8 +178,12 @@ namespace smo
             {
                 if (args.size() != 3)
                 {
-                    std::cout << "tp <X> <Y> <Z>" << std::endl;
-                    return;
+                    if (tpArgs.empty()) {
+                        std::cout << "tp <X> <Y> <Z>" << std::endl;
+                        return;
+                    }
+                    else
+                        args = tpArgs;
                 }
                 Vector3f pos;
                 try
@@ -140,14 +199,19 @@ namespace smo
                 }
                 OutPacketPlayerTeleport p;
                 p.pos = pos;
+                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 +245,24 @@ 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 << "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;

From 8a03e69379144fc316a531065ac3f43e291da919 Mon Sep 17 00:00:00 2001
From: Xiivler <xiivler1@gmail.com>
Date: Mon, 24 Jan 2022 10:35:58 -0800
Subject: [PATCH 3/9] Relative axes

---
 .gitignore         |   3 +-
 include/fl/ui.h    |   2 +-
 source/fl/ui.cpp   | 138 +++++++++++++++++++++++++++++++++++++--------
 source/fl/util.cpp |  11 ++--
 4 files changed, 124 insertions(+), 30 deletions(-)

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/ui.h b/include/fl/ui.h
index d965145..88aa40c 100644
--- a/include/fl/ui.h
+++ b/include/fl/ui.h
@@ -60,7 +60,7 @@ class PracticeUI
     
     enum Page : u8
     {
-        About, Options, Stage, Misc, Info, Tas, MoonInfo, Modes, Debug
+        About, Options, Stage, Misc, Info, Info2, Tas, MoonInfo, Modes, Debug
     };
 
     Page curPage = About;
diff --git a/source/fl/ui.cpp b/source/fl/ui.cpp
index 7fa6284..402f708 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 10
 #define NUM_STAGES 200
 
 #if(SMOVER==100)
@@ -50,6 +50,47 @@ 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;
+
+//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 = atan2(vec.x, vec.z);
+    double caAngle = zxAngle - relativeAngle;
+    double magnitude = sqrt(vec.z * vec.z + vec.x * vec.x);
+    vec.z = magnitude * cos(caAngle);
+    vec.x = magnitude * sin(caAngle);
+    return vec;
+}
+
+sead::Vector3f transformEulerAnglesToRelativeAxes(sead::Vector3f vec) {
+    sead::Vector3f newVec;
+    newVec.z = atan(sin(vec.z) * cos(relativeAngle + M_PI_2) + sin(vec.x) * sin(relativeAngle + M_PI_2));
+    newVec.x = atan(sin(vec.z) * cos(relativeAngle) + sin(vec.x) * sin(relativeAngle));
+    newVec.y = vec.y - relativeAngle;
+    if (newVec.y < M_PI * 2)
+        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 +206,8 @@ 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 = Tas;
                 else if (curPage == Tas) curPage = MoonInfo;
                 else if (curPage == MoonInfo) curPage = Modes;
                 else if (curPage == Modes) curPage = Debug;
@@ -177,7 +219,8 @@ 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 = 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;
@@ -337,50 +380,97 @@ void fl::PracticeUI::menu()
             }
             case Info:
             {
-                TITLE("Info");
+                printf("Info\n");
                 MAX_LINE(1);
+                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);
 
-                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 Speed: (H: %.3f V: %.3f S: %.3f)\n", hSpeed, vSpeed, speed);
+                static bool quatRot = false;
+                TOGGLE("Quaternion Rotation: %s\n\n", quatRot, 1);              
+
+                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 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);
+                    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("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);
+                    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("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("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);
+                }
+
+                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(" 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());
+                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)

From e5d236ca9373283c9c38ee04533028646762b65c Mon Sep 17 00:00:00 2001
From: Xiivler <xiivler1@gmail.com>
Date: Mon, 24 Jan 2022 10:40:25 -0800
Subject: [PATCH 4/9] Remove unneeded commented lines

---
 smo-tas-server/src/server.cpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/smo-tas-server/src/server.cpp b/smo-tas-server/src/server.cpp
index d520c28..cfe7ac5 100644
--- a/smo-tas-server/src/server.cpp
+++ b/smo-tas-server/src/server.cpp
@@ -55,9 +55,6 @@ namespace smo
             case smo::InPacketType::Init:
             {
                 connect();
-                //OutPacketPlayerTeleport p;
-                //p.pos = {0, 1000, 0};
-                //sendPacket(parent, p, smo::OutPacketType::PlayerTeleport);
                 break;
             }
             IN_PACKET(Log)

From 233461e46b79cfb335346334b1dbfe312d833b5d Mon Sep 17 00:00:00 2001
From: Xiivler <xiivler1@gmail.com>
Date: Mon, 24 Jan 2022 10:44:00 -0800
Subject: [PATCH 5/9] Add spaces

---
 source/fl/ui.cpp | 42 +++++++++++++++++++++---------------------
 1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/source/fl/ui.cpp b/source/fl/ui.cpp
index 402f708..297f784 100644
--- a/source/fl/ui.cpp
+++ b/source/fl/ui.cpp
@@ -401,24 +401,24 @@ void fl::PracticeUI::menu()
                 static bool quatRot = false;
                 TOGGLE("Quaternion Rotation: %s\n\n", quatRot, 1);              
 
-                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 Speed: (H: %.3f V: %.3f S: %.3f)\n", hSpeed, vSpeed, speed);
+                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 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);
+                    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);
+                    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);
+                    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());
+                    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;
             }
@@ -457,20 +457,20 @@ void fl::PracticeUI::menu()
                 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));
+                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 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(" 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());
+                printf(" Current Animation: %s (%.0f/%.0f)\n", anim, player->mPlayerAnimator->getAnimFrame() - 1.0f, player->mPlayerAnimator->getAnimFrameMax());
 
                 break;
             }

From 7df6dd21809e35e4af585a792c1fcdc3ee290132 Mon Sep 17 00:00:00 2001
From: Xiivler <xiivler1@gmail.com>
Date: Thu, 17 Feb 2022 13:25:47 -0800
Subject: [PATCH 6/9] Fix relative axes and add rotation to teleportation

---
 include/fl/packet.h           |  1 +
 smo-tas-server/src/packet.cpp |  6 +++++-
 smo-tas-server/src/server.cpp | 40 ++++++++++++++++++++++++++++++++---
 smo-tas-server/src/util.cpp   | 20 ++++++++++++++++++
 source/fl/packet.cpp          |  5 +++++
 source/fl/ui.cpp              | 16 ++++++++------
 6 files changed, 78 insertions(+), 10 deletions(-)
 create mode 100644 smo-tas-server/src/util.cpp

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/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 cfe7ac5..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>
@@ -173,21 +174,50 @@ namespace smo
         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)
                 {
                     if (tpArgs.empty()) {
-                        std::cout << "tp <X> <Y> <Z>" << std::endl;
+                        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)
                 {
@@ -196,6 +226,7 @@ namespace smo
                 }
                 OutPacketPlayerTeleport p;
                 p.pos = pos;
+                p.rot = rot;
                 tpArgs = args;
                 c.sendPacket(this, p, smo::OutPacketType::PlayerTeleport);
             }},
@@ -255,7 +286,10 @@ namespace smo
             }},
             {"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;
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 0550ee4..6cde294 100644
--- a/source/fl/ui.cpp
+++ b/source/fl/ui.cpp
@@ -65,20 +65,20 @@ sead::Vector3f transformToRelativeAxes(sead::Vector3f vec, bool isTransVector) {
         vec.y -= relativeTrans.y;
         vec.z -= relativeTrans.z;
     }
-    double zxAngle = atan2(vec.x, vec.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 * cos(caAngle);
-    vec.x = magnitude * sin(caAngle);
+    vec.z = magnitude * cosf(caAngle);
+    vec.x = magnitude * sinf(caAngle);
     return vec;
 }
 
 sead::Vector3f transformEulerAnglesToRelativeAxes(sead::Vector3f vec) {
     sead::Vector3f newVec;
-    newVec.z = atan(sin(vec.z) * cos(relativeAngle + M_PI_2) + sin(vec.x) * sin(relativeAngle + M_PI_2));
-    newVec.x = atan(sin(vec.z) * cos(relativeAngle) + sin(vec.x) * sin(relativeAngle));
+    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 < M_PI * 2)
+    if (newVec.y < 0)
         newVec.y += M_PI * 2;
     return newVec;
 }
@@ -405,12 +405,16 @@ void fl::PracticeUI::menu()
                 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;
 
                 static bool quatRot = false;
                 TOGGLE("Quaternion Rotation: %s\n\n", quatRot, 1);              
 
                 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)
                 {

From 2c065a1deba6a5c52d6654dc72470eb27c819bcd Mon Sep 17 00:00:00 2001
From: Xiivler <xiivler1@gmail.com>
Date: Mon, 8 Aug 2022 12:51:00 -0700
Subject: [PATCH 7/9] New page for observed velocities

---
 include/fl/ui.h  |  12 +++---
 source/fl/ui.cpp | 105 ++++++++++++++++++++++++++++++++++++++++++++---
 2 files changed, 106 insertions(+), 11 deletions(-)

diff --git a/include/fl/ui.h b/include/fl/ui.h
index 3941b24..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, Info2, Tas, MoonInfo, Modes, Debug
+        About, Options, Stage, Misc, Info, Info2, Info3, Tas, MoonInfo, Modes, Debug
     };
 
     enum MofumofuPattern : s8
diff --git a/source/fl/ui.cpp b/source/fl/ui.cpp
index 6cde294..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 10
+#define NUM_PAGES 11
 #define NUM_STAGES 200
 
 #if(SMOVER==100)
@@ -52,6 +52,15 @@ const char* stageNames[] = {"CapWorldHomeStage", "WaterfallWorldHomeStage", "San
 
 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) {
@@ -207,7 +216,8 @@ void fl::PracticeUI::menu()
                 else if (curPage == Stage) curPage = Misc;
                 else if (curPage == Misc) curPage = Info;
                 else if (curPage == Info) curPage = Info2;
-                else if (curPage == Info2) curPage = Tas;
+                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;
@@ -219,7 +229,8 @@ 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 = Info2;
+                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;
@@ -389,7 +400,7 @@ void fl::PracticeUI::menu()
             case Info:
             {
                 printf("Info\n");
-                MAX_LINE(1);
+                MAX_LINE(2);
                 CURSOR(0);
                 CHANGE_PAGE();
 
@@ -409,8 +420,25 @@ void fl::PracticeUI::menu()
                 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, 1);              
+                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);
@@ -435,6 +463,73 @@ void fl::PracticeUI::menu()
                 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);

From c82b31249af1c0b0c025493760e7f8e939056dc8 Mon Sep 17 00:00:00 2001
From: xiivler <51525828+xiivler@users.noreply.github.com>
Date: Mon, 1 Jan 2024 23:15:45 -0500
Subject: [PATCH 8/9] fix the include files

---
 smo-tas-server/include/common.h | 2 ++
 smo-tas-server/include/packet.h | 1 +
 smo-tas-server/include/util.h   | 6 ++++++
 3 files changed, 9 insertions(+)
 create mode 100644 smo-tas-server/include/util.h

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/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

From 995f298b6b7699f5f587b7bb0858d6a7f93a1c88 Mon Sep 17 00:00:00 2001
From: xiivler <51525828+xiivler@users.noreply.github.com>
Date: Mon, 1 Jan 2024 23:16:33 -0500
Subject: [PATCH 9/9] fix the src files