diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..c18dd8d --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +__pycache__/ diff --git a/README.md b/README.md index 3c488bd..9c41b4b 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,10 @@ -# SMS-Shape-Notebook -多角形と多面体のクラスを実装したJupyter Notebookです。これを使って斜面をすり抜ける範囲を描画することができます。今後Dolphinと連携するといった機能を追加する予定です。 +# SMS-Geography サンシャイン地理学 +## Jupyter Notebooks +- [shape.ipynb](shape.ipynb): This notebook implements Polygon and Polyhedron class. You can use it to plot the area that you can clip through a slope. +- [wall.ipynb](wall.ipynb): This notebook gives a demonstration to read collision data from Dolphin and draw wall hitboxs with the shape library made by sup39. -This is a Jupyter Notebook that implements Polygon and Polyhedron class. -You can use this notebook to plot the area that you can clip through a slope. -I will add some functions in the future such as accessing Dolphin's memory. \ No newline at end of file +- [shape.ipynb](shape.ipynb): 多角形と多面体のクラスを実装したJupyter Notebookです。これを使って斜面をすり抜ける範囲を描画することができます。 +- [wall.ipynb](wall.ipynb): Dolphinから壁のデータを取得し、サポミクが実装した図形のライブラリを使って壁の判定を描画する方法を紹介します。 + +## Dependencies +These notebooks use [dolphin-memory-lib](https://github.com/RenolY2/dolphin-memory-lib/blob/main/memorylib.py) made by RenolY2. \ No newline at end of file diff --git a/memorylib.py b/memorylib.py new file mode 100644 index 0000000..aa6a208 --- /dev/null +++ b/memorylib.py @@ -0,0 +1,251 @@ +## This library is made by RenolY2 +## https://github.com/RenolY2/dolphin-memory-lib/blob/main/memorylib.py + +import ctypes +import struct +from struct import pack, unpack +from ctypes import wintypes, sizeof, addressof, POINTER, pointer +from ctypes.wintypes import DWORD, ULONG, LONG, WORD +from multiprocessing import shared_memory + +# Various Windows structs/enums needed for operation +NULL = 0 + +TH32CS_SNAPHEAPLIST = 0x00000001 +TH32CS_SNAPPROCESS = 0x00000002 +TH32CS_SNAPTHREAD = 0x00000004 +TH32CS_SNAPMODULE = 0x00000008 +TH32CS_SNAPALL = TH32CS_SNAPHEAPLIST | TH32CS_SNAPPROCESS | TH32CS_SNAPTHREAD | TH32CS_SNAPMODULE +assert TH32CS_SNAPALL == 0xF + + +PROCESS_QUERY_INFORMATION = 0x0400 +PROCESS_VM_OPERATION = 0x0008 +PROCESS_VM_READ = 0x0010 +PROCESS_VM_WRITE = 0x0020 + +MEM_MAPPED = 0x40000 + +ULONG_PTR = ctypes.c_ulonglong + +class PROCESSENTRY32(ctypes.Structure): + _fields_ = [ ( 'dwSize' , DWORD ) , + ( 'cntUsage' , DWORD) , + ( 'th32ProcessID' , DWORD) , + ( 'th32DefaultHeapID' , ctypes.POINTER(ULONG)) , + ( 'th32ModuleID' , DWORD) , + ( 'cntThreads' , DWORD) , + ( 'th32ParentProcessID' , DWORD) , + ( 'pcPriClassBase' , LONG) , + ( 'dwFlags' , DWORD) , + ( 'szExeFile' , ctypes.c_char * 260 ) ] + + +class MEMORY_BASIC_INFORMATION(ctypes.Structure): + _fields_ = [ ( 'BaseAddress' , ctypes.c_void_p), + ( 'AllocationBase' , ctypes.c_void_p), + ( 'AllocationProtect' , DWORD), + ( 'PartitionID' , WORD), + ( 'RegionSize' , ctypes.c_size_t), + ( 'State' , DWORD), + ( 'Protect' , DWORD), + ( 'Type' , DWORD)] + + +class PSAPI_WORKING_SET_EX_BLOCK(ctypes.Structure): + _fields_ = [ ( 'Flags', ULONG_PTR), + ( 'Valid', ULONG_PTR), + ( 'ShareCount', ULONG_PTR), + ( 'Win32Protection', ULONG_PTR), + ( 'Shared', ULONG_PTR), + ( 'Node', ULONG_PTR), + ( 'Locked', ULONG_PTR), + ( 'LargePage', ULONG_PTR), + ( 'Reserved', ULONG_PTR), + ( 'Bad', ULONG_PTR), + ( 'ReservedUlong', ULONG_PTR)] + + +#class PSAPI_WORKING_SET_EX_INFORMATION(ctypes.Structure): +# _fields_ = [ ( 'VirtualAddress' , ctypes.c_void_p), +# ( 'VirtualAttributes' , PSAPI_WORKING_SET_EX_BLOCK)] + +class PSAPI_WORKING_SET_EX_INFORMATION(ctypes.Structure): + _fields_ = [ ( 'VirtualAddress' , ctypes.c_void_p), + #( 'Flags', ULONG_PTR), + ( 'Valid', ULONG_PTR, 1)] + #( 'ShareCount', ULONG_PTR), + #( 'Win32Protection', ULONG_PTR), + #( 'Shared', ULONG_PTR), + #( 'Node', ULONG_PTR), + #( 'Locked', ULONG_PTR), + #( 'LargePage', ULONG_PTR), + #( 'Reserved', ULONG_PTR), + #( 'Bad', ULONG_PTR), + #( 'ReservedUlong', ULONG_PTR)] + + #def print_values(self): + # for i,v in self._fields_: + # print(i, getattr(self, i)) + + +# The find_dolphin function is based on WindowsDolphinProcess::findPID() from +# aldelaro5's Dolphin memory engine +# https://github.com/aldelaro5/Dolphin-memory-engine + +""" +MIT License + +Copyright (c) 2017 aldelaro5 + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE.""" + +class Dolphin(object): + def __init__(self): + self.pid = -1 + self.memory = None + + def reset(self): + self.pid = -1 + self.memory = None + + def find_dolphin(self, skip_pids=[]): + entry = PROCESSENTRY32() + + entry.dwSize = sizeof(PROCESSENTRY32) + snapshot = ctypes.windll.kernel32.CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL) + print(addressof(entry), hex(addressof(entry))) + a = ULONG(addressof(entry)) + + self.pid = -1 + + if ctypes.windll.kernel32.Process32First(snapshot, pointer(entry)): + if entry.th32ProcessID not in skip_pids and entry.szExeFile in (b"Dolphin.exe", b"DolphinQt2.exe", b"DolphinWx.exe"): + self.pid = entry.th32ProcessID + else: + while ctypes.windll.kernel32.Process32Next(snapshot, pointer(entry)): + if entry.th32ProcessID in skip_pids: + continue + if entry.szExeFile in (b"Dolphin.exe", b"DolphinQt2.exe", b"DolphinWx.exe"): + self.pid = entry.th32ProcessID + + + ctypes.windll.kernel32.CloseHandle(snapshot) + + if self.pid == -1: + return False + + return True + + def init_shared_memory(self): + try: + self.memory = shared_memory.SharedMemory('dolphin-emu.'+str(self.pid)) + return True + except FileNotFoundError: + return False + + def read_ram(self, offset, size): + return self.memory.buf[offset:offset+size] + + def write_ram(self, offset, data): + self.memory.buf[offset:offset+len(data)] = data + + def read_uint8(self, addr): + assert addr >= 0x80000000 + value = self.read_ram(addr-0x80000000, 1) + + return unpack(">B", value)[0] + + def write_uint8(self, addr, val): + assert addr >= 0x80000000 + return self.write_ram(addr - 0x80000000, pack(">B", val)) + + def read_uint16(self, addr): + assert addr >= 0x80000000 + value = self.read_ram(addr-0x80000000, 2) + + return unpack(">H", value)[0] + + def write_uint16(self, addr, val): + assert addr >= 0x80000000 + return self.write_ram(addr - 0x80000000, pack(">H", val)) + + def read_uint32(self, addr): + assert addr >= 0x80000000 + value = self.read_ram(addr-0x80000000, 4) + + return unpack(">I", value)[0] + + def write_uint32(self, addr, val): + assert addr >= 0x80000000 + return self.write_ram(addr - 0x80000000, pack(">I", val)) + + def read_float(self, addr): + assert addr >= 0x80000000 + value = self.read_ram(addr - 0x80000000, 4) + + return unpack(">f", value)[0] + + def write_float(self, addr, val): + assert addr >= 0x80000000 + return self.write_ram(addr - 0x80000000, pack(">f", val)) + + +"""with open("ctypes.txt", "w") as f: + for a in ctypes.__dict__: + f.write(str(a)) + f.write("\n")""" + +if __name__ == "__main__": + dolphin = Dolphin() + import multiprocessing + + if dolphin.find_dolphin(): + + print("Found Dolphin!") + else: + print("Didn't find Dolphin") + + print(dolphin.pid) + + dolphin.init_shared_memory() + if dolphin.init_shared_memory(): + print("We found MEM1 and/or MEM2!") + else: + print("We didn't find it...") + + import random + randint = random.randint + from timeit import default_timer + + start = default_timer() + + print("Testing Shared Memory Method") + start = default_timer() + count = 500000 + for i in range(count): + value = randint(0, 2**32-1) + dolphin.write_uint32(0x80000000, value) + + result = dolphin.read_uint32(0x80000000) + assert result == value + diff = default_timer()-start + print(count/diff, "per sec") + print("time: ", diff) + \ No newline at end of file diff --git a/shape.ipynb b/shape.ipynb index 983f4a8..445b1af 100644 --- a/shape.ipynb +++ b/shape.ipynb @@ -30,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "bb2b194e-b451-4a35-ba17-f74619d658c5", "metadata": {}, "outputs": [], @@ -88,7 +88,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "21603f5b-59ad-45d3-945e-58978b8b3099", "metadata": {}, "outputs": [], @@ -293,7 +293,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "a2316c48-2614-4f93-b152-f0d8ab379c9b", "metadata": {}, "outputs": [], @@ -384,7 +384,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 23, "id": "f0c3daf3-4b26-4a4e-a7bf-ad6a7e7e89a0", "metadata": {}, "outputs": [ @@ -396,14 +396,14 @@ " [-174.36700439, 2357.66601562, 1443.62805176]])" ] }, - "execution_count": 4, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "raw = 'C3 A5 92 F2 45 01 08 7F 44 DB A6 14 43 2E 5D F4 45 13 5A A8 44 B4 74 19 C3 2E 5D F4 45 13 5A A8 44 B4 74 19'\n", - "tri = np.frombuffer(bytes.fromhex(raw), '>f').astype('d').reshape(3, 3)\n", + "tri = np.frombuffer(bytes.fromhex(raw), '>f').astype('d').reshape(-1, 3)[:3, :]\n", "tri" ] }, @@ -431,7 +431,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "4a7cc39b-1506-46ba-a6d9-2f9714d6b747", "metadata": {}, "outputs": [], @@ -502,7 +502,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 24, "id": "2f14f7cf-0187-4fdb-9d18-0e9ef08ff423", "metadata": {}, "outputs": [ @@ -528,7 +528,8 @@ " # 境界上の一点 a point on the border\n", " B = tri[1],\n", " # 境界の法線ベクトル normal vector of the border\n", - " nB = array([0, 0, -1]),\n", + " # -(n.x, 0, n.z); n = cross(P1-P0, P2-P1) in game\n", + " nB = np.cross(tri[0]-tri[1], tri[2]-tri[1])*(1, 0, 1),\n", " # すり抜ける地面の高さ\n", " # height of the triangle that Mario clips through\n", " yB = tri[1][1],\n", @@ -552,7 +553,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 25, "id": "0b64860d-b36b-4b5c-bb03-3e00daca9014", "metadata": {}, "outputs": [ @@ -590,8 +591,8 @@ "# ラベルのフォーマットを設定(xは目盛の値、iは番号)\n", "# set the format of the labels\n", "# (x is the value of the tick, and i is the index)\n", - "ax.xaxis.set_major_formatter(lambda x, i: '%.2f'%x)\n", - "ax.yaxis.set_major_formatter(lambda x, i: '%.2f'%x)\n", + "ax.xaxis.set_major_formatter(plticker.FormatStrFormatter('%.2f'))\n", + "ax.yaxis.set_major_formatter(plticker.FormatStrFormatter('%.2f'))\n", "\n", "# x軸のラベルを30度回転\n", "# rotate x label 30 deg\n", @@ -606,7 +607,7 @@ { "cell_type": "code", "execution_count": null, - "id": "efec5e1f-16d2-4d66-b596-11016f934f1d", + "id": "9163f1a0-9c6b-45ea-a856-ba98a6c9303c", "metadata": {}, "outputs": [], "source": [] @@ -1094,6 +1095,14 @@ "OTHER DEALINGS IN THE SOFTWARE." ] }, + { + "cell_type": "raw", + "id": "0412e7fe-ec24-43d4-bac0-ff42ab11bcd0", + "metadata": {}, + "source": [ + "なおさん(@naosan_RTA2)が一部の数式を追加し、Formatterのバグを修正してくださいました。ありがとうございます!" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/shape.py b/shape.py new file mode 100644 index 0000000..bb0aef1 --- /dev/null +++ b/shape.py @@ -0,0 +1,220 @@ +''' +MIT License + +Copyright (c) 2022 sup39[サポミク] + +Permission is hereby granted, free of charge, to any person +obtaining a copy of this software and associated documentation +files (the "Software"), to deal in the Software without +restriction, including without limitation the rights to use, +copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. +''' + +import numpy as np +array = np.array +import matplotlib.pyplot as plt +from matplotlib.path import Path +from matplotlib import patches +normalize = lambda x: x/np.linalg.norm(x) + +# 多角形 +class Polygon(): + def __init__(self, verts): + ''' + * self.verts: + 頂点の配列 + Array of vertices + ''' + self.verts = np.array(verts) + def clipLine(self, p, n, c): + ''' + 半平面 (x-p)・n >= c との共通部分を取る + Take intersection with half plane (x-p)・n >= c + * p: + 直線上の一点 + Any point on the line + * n: + 直線の法線ベクトル + Normal vector of the line + * c: + 定数 + Constant + ''' + p, n, c = map(array, (p, n, c)) + r = np.dot(self.verts-p, n)-c + verts = [] + for i in range(len(r)): + v0, r0 = self.verts[i-1], r[i-1] + v1, r1 = self.verts[i], r[i] + if r1 >= 0: + if r0 < 0: # (- +) + verts.append((r1*v0-r0*v1)/(-r0+r1)) + verts.append(v1) + elif r0 >= 0: # (+ -) + verts.append((-r1*v0+r0*v1)/(r0-r1)) + self.verts = np.array(verts) if len(verts) else self.verts[:0] + @property # getter + def path(self): + if self.verts.shape[0] == 0: return None + verts = self.verts + assert verts.shape[-1] == 2, 'verts should be 2D' + return Path([*verts, (0, 0)], [ + Path.MOVETO, + *(Path.LINETO for _ in range(1, verts.shape[0])), + Path.CLOSEPOLY, + ]) + def plot(self, margin=0.05, facecolor='#2ee5b8', lw=1): + ''' + この多角形を描画し、figとaxを返す + Plot this polygon and return ``fig'' and ``ax'' + * margin: + Set margin of the plot + * facecolor: + 面の色 + Face color + * lw: + 線の太さ + Line width + ''' + fig, ax = plt.subplots() + if self.verts.shape[0] == 0: return ax + # path + path = self.path + patch = patches.PathPatch(path, facecolor=facecolor, lw=lw) + ax.add_patch(patch) + verts = self.verts + xMax, yMax = verts.max(axis=0) + xMin, yMin = verts.min(axis=0) + xMg, yMg = verts.ptp(axis=0)*margin + ax.set_xlim(xMin-xMg, xMax+xMg) + ax.set_ylim(yMin-yMg, yMax+yMg) + return fig, ax + def __repr__(self): + return 'Polygon with %d vertices:\n%s'%( + len(self.verts), + array(self.verts, 'f'), + ) + +# 多面体 +class Polyhedron: + def __init__(self, verts, edges): + ''' + * self.verts: + 頂点の配列 + Array of vertices + * self.edges: + 辺(2頂点の番号)の配列 + Array of edges (indices of 2 vertices) + ''' + self.verts = np.array(verts) + self.edges = edges + def clipPlane(self, p, n, c=0): + ''' + 半空間 (x-p)・n >= c との共通部分を取る + Take intersection with half space (x-p)・n >= c + * p: + 平面上の一点 + Any point on the plane + * n: + 直線の法線ベクトル + Normal vector of the plane + * c: + 定数 + Constant + ''' + p, n, c = map(array, (p, n, c)) + r = np.dot(self.verts-p, n)-c + rb = [s>=0 for s in r] + # map vertex indices old to new + io2n = { + iO: iN + for iN, iO in enumerate(iO for iO, sb in enumerate(rb) if sb) + } + # handle old vert + verts = [v for v, sb in zip(self.verts, rb) if sb] + edges = [] + for i0, i1 in self.edges: + if rb[i0] and rb[i1]: + # remain + edges.append((io2n[i0], io2n[i1])) + elif rb[i0] or rb[i1]: + # new vert + v0, r0 = self.verts[i0], abs(r[i0]) + v1, r1 = self.verts[i1], abs(r[i1]) + vN = (r1*v0+r0*v1)/(r0+r1) + edges.append((io2n[i0 if rb[i0] else i1], len(verts))) + verts.append(vN) + # else drop edge + # add new face + nOld = len(io2n) + vNews = verts[nOld:] + if len(vNews): + assert len(vNews) >= 3 + p0, p1 = vNews[:2] + # choose p1-p0 as e1 + e1 = normalize(p1-p0) + # choose e2 that ⊥ n, e1 + e2 = normalize(np.cross(n, e1)) + # set (p0+p1)/2 as new origin, and use {e1, e2} as new basis + cNews = np.dot(vNews-(p0+p1)/2, array([e1, e2]).transpose()) + # indices of new verts CCW + jNews = nOld+np.arctan2(cNews[:,0], cNews[:,1]).argsort() + # add to edge + for i in range(len(vNews)): + edges.append((jNews[i-1], jNews[i])) + # final + self.verts = array(verts) + self.edges = edges + def slicePlane(self, p, n): + ''' + 平面 (x-p)・n=0 との共通部分(多角形)の頂点を返す + Return vertices of intersection(polygon) with plane (x-p)・n=0 + * p: + 平面上の一点 + Any point on the plane + * n: + 平面の法線ベクトル + Normal vector of the plane + ''' + p, n = map(array, (p, n)) + r = np.dot(self.verts-p, n) + vNews = [] + # handle old verts + for i0, i1 in self.edges: + # two vertices on other side of the plane + if np.sign(r[i0]) != np.sign(r[i1]): + v0, r0 = self.verts[i0], abs(r[i0]) + v1, r1 = self.verts[i1], abs(r[i1]) + vN = (r1*v0+r0*v1)/(r0+r1) + vNews.append(vN) + # new verts + if len(vNews): + assert len(vNews) >= 2 + p0, p1 = vNews[:2] + e1 = normalize(p1-p0) + e2 = normalize(np.cross(n, e1)) + cNews = np.dot(vNews-(p0+p1)/2, array([e1, e2]).transpose()) + jNews = np.arctan2(cNews[:,0], cNews[:,1]).argsort() + return array([vNews[j] for j in jNews]) + else: + return self.verts[:0] + def __repr__(self): + return 'Polyhedron with %d vertices and %d edges:\n%s'%( + len(self.verts), len(self.edges), + array([self.verts[[i0, i1]] for i0, i1 in self.edges], 'f') + ) \ No newline at end of file diff --git a/wall.ipynb b/wall.ipynb new file mode 100644 index 0000000..4c993f6 --- /dev/null +++ b/wall.ipynb @@ -0,0 +1,302 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "3bb5cd79-48af-47ba-b0c7-6ddb645fdead", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import struct\n", + "from memorylib import Dolphin\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import patches\n", + "import itertools\n", + "from collections import defaultdict, Counter\n", + "from shape import Polygon, Polyhedron\n", + "array = np.array\n", + "normalize = lambda x: x/np.linalg.norm(x)\n", + "read_struct = lambda addr, fmt: struct.unpack(fmt, d.read_ram(addr-0x80000000, struct.calcsize(fmt)))\n", + "\n", + "def hook():\n", + " global d, dolphin\n", + " d = dolphin = Dolphin()\n", + " assert dolphin.find_dolphin(), 'Dolphin not found'\n", + " assert dolphin.init_shared_memory(), 'MEM1 not found'\n", + " assert dolphin.read_ram(0, 3).tobytes() == b'GMS', 'Current game is not Sunshine'" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b2dd3225-7f18-45b8-87f6-bb42279fb2e7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1868634166512 0x1b3134694f0\n" + ] + } + ], + "source": [ + "hook()" + ] + }, + { + "cell_type": "markdown", + "id": "194bce4c-80df-41ab-afa5-90616c2b0ca3", + "metadata": {}, + "source": [ + "## Classes and Functions" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2f71120c-696f-4eec-b7cc-10f30f1547d1", + "metadata": {}, + "outputs": [], + "source": [ + "class Surface:\n", + " def __init__(self, surtype, surpara, trntype, unk7, verts, vidxs=None, n=None, c=None):\n", + " self.surtype, self.surpara, self.trntype, self.unk7 = \\\n", + " surtype, surpara, trntype, unk7\n", + " self.vidxs = vidxs\n", + " self.verts = verts\n", + " self.minY = verts[:,1].min()\n", + " self.maxY = verts[:,1].max()\n", + " self.n = normalize(np.cross(verts[1]-verts[0], verts[2]-verts[1])) if n is None else n\n", + " self.c = -np.dot(verts[0], self.n) if c is None else c\n", + " def __repr__(self):\n", + " return 'minY=%.0f maxY=%.0f n=(%5.2f, %5.2f, %5.2f)'%(\n", + " self.minY, self.maxY, *self.n,\n", + " )\n", + " \n", + "def checkList2list(ptr):\n", + " ans = []\n", + " while True:\n", + " ptr, data = read_struct(ptr+4, '>II')\n", + " ans.append(Surface(\n", + " *read_struct(data, '>HHBB'),\n", + " np.array(read_struct(data+0x10, '>9f'), 'f').reshape(3, 3),\n", + " n=np.array(read_struct(data+0x34, '>3f'), 'f'),\n", + " c=d.read_float(data+0x40),\n", + " ))\n", + " if ptr == 0: return ans" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2c901433-7ee7-4771-9e89-1adc634ea889", + "metadata": {}, + "outputs": [], + "source": [ + "makeTriPrism = lambda tri0, tri1: Polyhedron([\n", + " *tri0,\n", + " *tri1,\n", + "], [e for i in range(3) for e in [(i, (i+1)%3), (i, i+3), (i+3, (i+1)%3+3)]])\n", + "\n", + "def makeGround(tri, hG=0):\n", + " poly = makeTriPrism(tri.verts+(0,hG,0), tri.verts-(0,108,0))\n", + " poly.clipPlane(p=(0, tri.minY, 0), n=(0, 1, 0))\n", + " return poly\n", + "def makeRoof(tri, hR=82):\n", + " poly = makeTriPrism(tri.verts-(0,hR,0), tri.verts-(0,160,0))\n", + " return poly\n", + "def makeWall(tri, rW=50, dy=30):\n", + " verts = tri.verts - (0, dy, 0)\n", + " n = tri.n\n", + " off = (2*rW,0,0) if abs(n[0])>0.707 else (0,0,2*rW)\n", + " poly = makeTriPrism(verts-off, verts+off)\n", + " poly.clipPlane(p=verts[0], n=n, c=-rW)\n", + " poly.clipPlane(p=verts[0], n=-n, c=-rW)\n", + " return poly\n", + "\n", + "# make collision: Polyhedron[]\n", + "def makeCol(tri, airborne=True):\n", + " ny = tri.n[1]\n", + " if ny > 0.2:\n", + " return [makeGround(tri, 0 if airborne else 100)]\n", + " elif ny < -0.2:\n", + " return [makeRoof(tri, 82 if airborne else 2)]\n", + " else:\n", + " return [\n", + " makeWall(tri, 50, 150),\n", + " makeWall(tri, 50, 30),\n", + " ] if airborne else [\n", + " makeWall(tri, 25, 30),\n", + " makeWall(tri, 50, 60),\n", + " ]" + ] + }, + { + "cell_type": "markdown", + "id": "17de8a60-e9eb-4507-9aaa-10e2deeba749", + "metadata": {}, + "source": [ + "## Get data from Dolphin" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e2b4da62-691e-44ec-bb03-4893d644ec6b", + "metadata": {}, + "outputs": [], + "source": [ + "# mario\n", + "gpMarioOriginal = 0x8040A378\n", + "ptrMario = d.read_uint32(gpMarioOriginal)\n", + "x, y, z = read_struct(ptrMario+0x10, '>3f')\n", + "\n", + "# get collision data (static collision)\n", + "gpMap = 0x8040A570\n", + "ptrMap = d.read_uint32(gpMap)\n", + "ptrCol = d.read_uint32(ptrMap+0x10)\n", + "xLimit, zLimit, xBlockCount, ptrStCLR = read_struct(ptrCol, '>ffI4x4xI')\n", + "## TBGCheckListRoot[zBlockCount][xBlockCount]\n", + "colOff = int((z+zLimit)//1024*xBlockCount + (x+xLimit)//1024)*36\n", + "## root->ground(12*2).next(4)\n", + "stWalls = checkList2list(d.read_uint32(ptrStCLR+colOff+4+12*2))" + ] + }, + { + "cell_type": "markdown", + "id": "cbb5f4b3-c5c8-4b95-ba11-5de3b8e05f1c", + "metadata": {}, + "source": [ + "## Draw wall hitbox" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5a6ef0d3-76e0-427d-9fb0-c3e5360c9199", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "yy, airborne = 183, False\n", + "#yy, airborne = y, True\n", + "\n", + "# paras\n", + "margin = 0.05\n", + "\n", + "# vars\n", + "fig, ax = plt.subplots(figsize=(8,8))\n", + "xyMax = np.full(2, -np.inf)\n", + "xyMin = np.full(2, np.inf)\n", + "\n", + "# draw 2 hitboxs (draw in reverse order)\n", + "for ii in [1, 0]:\n", + " polys = [\n", + " (c, wall.n)\n", + " for wall in stWalls\n", + " for c in [makeCol(wall, airborne=airborne)[ii]]\n", + " # FIXME: filtering walls\n", + " if c.verts[:,2].min()<14050\n", + " ]\n", + " # arrow size scale (0.5 if radius is 25)\n", + " amul = 1.0 if airborne or ii == 1 else 0.5\n", + " # draw wall hitboxs (draw in reverse order)\n", + " for poly, n in polys[::-1]:\n", + " # clip at y=yy and take (x, z) coordinate\n", + " verts = poly.slicePlane((0, yy, 0), (0, 1, 0))[:,[0,2]]\n", + " p2 = Polygon(verts)\n", + " path = p2.path # path to plot\n", + " if path is None: continue # skip if no intersection\n", + " # plot hitbox area\n", + " patch = patches.PathPatch(path, facecolor='#88ff88e8', lw=1)\n", + " ax.add_patch(patch)\n", + " ## update x, y range\n", + " xyMax = array([xyMax, *verts]).max(axis=0)\n", + " xyMin = array([xyMin, *verts]).min(axis=0)\n", + " # plot arrow (TODO: can be improved)\n", + " ## center of the clipped polygon\n", + " vc = np.mean(verts, axis=0)\n", + " ## normal of the wall\n", + " n2 = normalize(n[[0,2]])\n", + " ## direction vector (perpendicular to normal vector)\n", + " l2 = np.array([-n2[1], n2[0]])\n", + " loff = np.matmul(verts-vc, [n2[1], -n2[0]])\n", + " loffp = loff[loff>0].min() if len(loff[loff>0]) else 0\n", + " loffm = loff[loff<0].max() if len(loff[loff<0]) else 0\n", + " loffdis = loffp-loffm\n", + " arsize0 = 30 # arrow size (base)\n", + " arsize = (arsize0 if loffdis<=arsize0*5 else loffdis/5)*amul\n", + " if loffdis <= arsize0: continue # if too small\n", + " ## offset parallel to direction vector\n", + " for loff in np.linspace(loffm+arsize*0.64, loffp-arsize*0.64, int(loffdis//arsize)) if loffdis>=arsize*2 else [0]:\n", + " ## offset parallel to normal vector\n", + " for off, l in [(-40, 37.5), (5.0, 37.5)]:\n", + " plt.arrow(\n", + " *vc+loff*l2+n2*off*amul, *n2*l*amul,\n", + " width=arsize*0.27, head_width=arsize*0.72, head_length=15*amul,\n", + " length_includes_head=True, color='#080'\n", + " )\n", + "\n", + "# set x, y range of the figure\n", + "xMg, yMg = (xyMax-xyMin)*margin\n", + "xMax, yMax = xyMax\n", + "xMin, yMin = xyMin\n", + "ax.set_xlim(xMin-xMg, xMax+xMg)\n", + "ax.set_ylim(yMin-yMg, yMax+yMg)\n", + "\n", + "# if needed\n", + "ax.invert_xaxis()\n", + "#ax.invert_yaxis()\n", + "ax.grid()\n", + "\n", + "plt.title(f'y = %s (%s)'%(yy, 'airborne' if airborne else 'grounded'))\n", + "#fig.patch.set_facecolor('white')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6de1a895-e624-4fe4-a6e6-bc8a820ca88f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}