Merge pull request #34 from MikeIsAStar/ensure-that-invalid-items-can…

…-not-be-used-nor-thrown [MKW] Ensure that invalid items can not be used nor thrown
WiiLink24 · Jan 17, 2024 · 507b86b · 507b86b
2 parents 9fe6741 + 3000d81
commit 507b86b
Show file tree

Hide file tree

Showing 2 changed files with 128 additions and 8 deletions.
diff --git a/payload/import/mkwItem.hpp b/payload/import/mkwItem.hpp
@@ -48,8 +48,14 @@ enum class ItemObject {
     NoObject = 0x10,
 };
 
+enum class UseType {
+    Use = 0,
+    Throw = 1,
+};
+
 struct ItemBehaviourEntry {
-    /* 0x00 */ u8 _00[0x18 - 0x00];
+    /* 0x00 */ u8 _00[0x14 - 0x00];
+    /* 0x14 */ UseType useType;
     /* 0x18 */ void (*useFunction)(void* kartItem);
 };
 
@@ -59,11 +65,37 @@ extern ItemBehaviourEntry itemBehaviourTable[0x13] AT(
     RMCXD_PORT(0x809C36A0, 0x809BEE98, 0x809C2700, 0x809B1CE0)
 );
 
+static bool CanUseItem(ItemBox item)
+{
+    if (item == ItemBox::NoItem) {
+        return false;
+    }
+
+    u8 itemToUse = static_cast<u8>(item);
+
+    return itemBehaviourTable[itemToUse].useType == UseType::Use;
+}
+
+static bool CanThrowItem(ItemBox item)
+{
+    if (item == ItemBox::NoItem) {
+        return false;
+    }
+
+    u8 itemToThrow = static_cast<u8>(item);
+
+    return itemBehaviourTable[itemToThrow].useType == UseType::Throw;
+}
+
 static bool CanTrailItem(ItemBox item)
 {
-    u8 trailedItem = static_cast<u8>(item);
+    if (item == ItemBox::NoItem) {
+        return false;
+    }
+
+    u8 itemToTrail = static_cast<u8>(item);
 
-    return !itemBehaviourTable[trailedItem].useFunction;
+    return !itemBehaviourTable[itemToTrail].useFunction;
 }
 
 static bool IsHeldItemValidVS(ItemBox item)
@@ -161,4 +193,58 @@ static bool IsItemObjectValid(ItemObject itemObject)
     }
 }
 
+static ItemBox ItemObjectToItemBox(ItemObject itemObject)
+{
+    switch (itemObject) {
+    case ItemObject::GreenShell: {
+        return ItemBox::GreenShell;
+    }
+    case ItemObject::RedShell: {
+        return ItemBox::RedShell;
+    }
+    case ItemObject::Banana: {
+        return ItemBox::Banana;
+    }
+    case ItemObject::Mushroom: {
+        return ItemBox::Mushroom;
+    }
+    case ItemObject::Star: {
+        return ItemBox::Star;
+    }
+    case ItemObject::BlueShell: {
+        return ItemBox::BlueShell;
+    }
+    case ItemObject::Lightning: {
+        return ItemBox::Lightning;
+    }
+    case ItemObject::FakeItemBox: {
+        return ItemBox::FakeItemBox;
+    }
+    case ItemObject::MegaMushroom: {
+        return ItemBox::MegaMushroom;
+    }
+    case ItemObject::Bob_omb: {
+        return ItemBox::Bob_omb;
+    }
+    case ItemObject::Blooper: {
+        return ItemBox::Blooper;
+    }
+    case ItemObject::POWBlock: {
+        return ItemBox::POWBlock;
+    }
+    case ItemObject::GoldenMushroom: {
+        return ItemBox::GoldenMushroom;
+    }
+    case ItemObject::BulletBill: {
+        return ItemBox::BulletBill;
+    }
+    case ItemObject::ThunderCloud: {
+        return ItemBox::ThunderCloud;
+    }
+    default: {
+        return ItemBox::NoItem;
+    }
+    }
+}
+
 } // namespace mkw::Item
diff --git a/payload/import/mkwNet.hpp b/payload/import/mkwNet.hpp
@@ -228,19 +228,51 @@ class EVENTHandler
 public:
     struct Packet {
         struct EventInfo {
+            enum class EventType : u8 {
+                NoEvent = 0,
+                ItemUsed = 1,
+                ItemThrown = 2,
+            };
+
             bool isItemObjectValid() const
             {
                 using namespace mkw::Item;
 
                 return IsItemObjectValid(static_cast<ItemObject>(itemObject));
             }
 
+            bool isValid() const
+            {
+                using namespace mkw::Item;
+
+                if (!isItemObjectValid()) {
+                    return false;
+                }
+
+                ItemObject item = static_cast<ItemObject>(itemObject);
+
+                switch (eventType) {
+                case EventType::NoEvent: {
+                    return item == ItemObject::NoObject;
+                }
+                case EventType::ItemUsed: {
+                    return CanUseItem(ItemObjectToItemBox(item));
+                }
+                case EventType::ItemThrown: {
+                    return CanThrowItem(ItemObjectToItemBox(item));
+                }
+                default: {
+                    return true;
+                }
+                }
+            }
+
             u8 getEventDataSize() const
             {
                 return GetEventDataSize(itemObject, eventType);
             }
 
-            /* 0x00 */ u8 eventType : 3;
+            /* 0x00 */ EventType eventType : 3;
             /* 0x00 */ u8 itemObject : 5;
         };
 
@@ -251,7 +283,7 @@ class EVENTHandler
             u32 expectedPacketSize = sizeof(eventInfo);
 
             for (size_t n = 0; n < sizeof(eventInfo); n++) {
-                if (!eventInfo[n].isItemObjectValid()) {
+                if (!eventInfo[n].isValid()) {
                     return false;
                 }
 
@@ -267,10 +299,12 @@ class EVENTHandler
 
     static_assert(sizeof(Packet) == 0xF8);
 
-    static u8 GetEventDataSize(u8 itemObject, u8 eventType)
+    static u8
+    GetEventDataSize(u8 itemObject, Packet::EventInfo::EventType eventType)
     {
-        LONGCALL u8 GetEventDataSize(u8 itemObject, u8 eventType)
-            AT(RMCXD_PORT(0x8079D76C, 0x80794760, 0x8079CDD8, 0x8078BB2C));
+        LONGCALL u8 GetEventDataSize(
+            u8 itemObject, Packet::EventInfo::EventType eventType
+        ) AT(RMCXD_PORT(0x8079D76C, 0x80794760, 0x8079CDD8, 0x8078BB2C));
 
         return GetEventDataSize(itemObject, eventType);
     }