PatcherYRpp/AbstractClass.cs at main · Xkein/PatcherYRpp · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
using DynamicPatcher;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace PatcherYRpp
{
    [StructLayout(LayoutKind.Explicit, Size = 36)]
    public struct AbstractClass
    {
        static public readonly IntPtr ArrayPointer = new IntPtr(0xA8E360);
        static public ref DynamicVectorClass<Pointer<ObjectClass>> Array { get => ref DynamicVectorClass<Pointer<ObjectClass>>.GetDynamicVector(ArrayPointer); }

        public unsafe void Init()
        {
            var func = (delegate* unmanaged[Thiscall]<ref AbstractClass, void>)this.GetVirtualFunctionPointer(9);
            func(ref this);
        }
        public unsafe void PointerExpired(Pointer<AbstractClass> pAbstract, bool removed)
        {
            var func = (delegate* unmanaged[Thiscall]<ref AbstractClass, IntPtr, Bool, void>)this.GetVirtualFunctionPointer(10);
            func(ref this, pAbstract, removed);
        }
        public unsafe AbstractType WhatAmI()
        {
            var func = (delegate* unmanaged[Thiscall]<ref AbstractClass, AbstractType>)this.GetVirtualFunctionPointer(11);
            return func(ref this);
        }
        public unsafe int Size()
        {
            var func = (delegate* unmanaged[Thiscall]<ref AbstractClass, int>)this.GetVirtualFunctionPointer(12);
            return func(ref this);
        }
        public unsafe void CalculateChecksum(Pointer<Checksummer> checksum)
        {
            var func = (delegate* unmanaged[Thiscall]<ref AbstractClass, IntPtr, void>)this.GetVirtualFunctionPointer(13);
            func(ref this, checksum);
        }
        public unsafe int GetOwningHouseIndex()
        {
            var func = (delegate* unmanaged[Thiscall]<ref AbstractClass, int>)this.GetVirtualFunctionPointer(14);
            return func(ref this);
        }
        public unsafe Pointer<HouseClass> GetOwningHouse()
        {
            var func = (delegate* unmanaged[Thiscall]<ref AbstractClass, IntPtr>)this.GetVirtualFunctionPointer(15);
            return func(ref this);
        }
        public unsafe int GetArrayIndex()
        {
            var func = (delegate* unmanaged[Thiscall]<ref AbstractClass, int>)this.GetVirtualFunctionPointer(16);
            return func(ref this);
        }
        public unsafe bool IsDead()
        {
            var func = (delegate* unmanaged[Thiscall]<ref AbstractClass, Bool>)this.GetVirtualFunctionPointer(17);
            return func(ref this);
        }
        public unsafe CoordStruct GetCoords()
        {
            var func = (delegate* unmanaged[Thiscall]<ref AbstractClass, IntPtr, IntPtr>)this.GetVirtualFunctionPointer(18);

            CoordStruct ret = default;
            func(ref this, Pointer<CoordStruct>.AsPointer(ref ret));
            return ret;
        }
        public unsafe CoordStruct GetDestination(Pointer<TechnoClass> pDocker = default)
        {
            var func = (delegate* unmanaged[Thiscall]<ref AbstractClass, IntPtr, IntPtr, IntPtr>)this.GetVirtualFunctionPointer(19);

            CoordStruct ret = default;
            func(ref this, Pointer<CoordStruct>.AsPointer(ref ret), pDocker);
            return ret;
        }
        public unsafe bool IsOnFloor()
        {
            var func = (delegate* unmanaged[Thiscall]<ref AbstractClass, Bool>)this.GetVirtualFunctionPointer(20);
            return func(ref this);
        }
        public unsafe bool IsInAir()
        {
            var func = (delegate* unmanaged[Thiscall]<ref AbstractClass, Bool>)this.GetVirtualFunctionPointer(21);
            return func(ref this);
        }

        public unsafe void Update()
        {
            var func = (delegate* unmanaged[Thiscall]<ref AbstractClass, void>)this.GetVirtualFunctionPointer(23);
            func(ref this);
        }


        public unsafe void AnnounceExpiredPointer(bool removed = true)
        {
            var func = (delegate* unmanaged[Thiscall]<int, ref AbstractClass, Bool, void>)ASM.FastCallTransferStation;
            func(0x7258D0, ref this, removed);
        }

        [FieldOffset(0)] public IntPtr Vfptr;

        [FieldOffset(16)] public int UniqueID;
        [FieldOffset(20)] public AbstractFlags AbstractFlags;
        [FieldOffset(24)] public int unknown_18;
        [FieldOffset(28)] public int RefCount;
        [FieldOffset(32)] public Bool Dirty;
    }
}