C# how to use offsets

using System;
using System.Text;
using System.Runtime.InteropServices;
using System.Diagnostics;

namespace Game.Memory
{
    class Memory
    {
        [DllImport("kernel32.dll")]
        static extern IntPtr OpenProcess(UInt32 dwDesiredAccess, Boolean bInheritHandle, UInt32 dwProcessId);
        [DllImport("kernel32.dll")]
        static extern bool ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress,
        byte[] lpBuffer, UIntPtr nSize, uint lpNumberOfBytesWritten);

        IntPtr Handle;

        public Memory(string sprocess)
        {
            Process[] Processes = Process.GetProcessesByName(sprocess);
            Process nProcess = Processes[0];
            Handle = OpenProcess(0x10, false, (uint)nProcess.Id);
        }

        public string ReadString(uint pointer) 
        {
            byte[] bytes = new byte[24];

            ReadProcessMemory(Handle, (IntPtr)pointer, bytes, (UIntPtr)24, 0);
            return Encoding.UTF8.GetString(bytes);
        }

        public int ReadOffset(uint pointer, uint offset)
        {
            byte[] bytes = new byte[24];

            uint adress = (uint)ReadPointer(pointer) + offset;
            ReadProcessMemory(Handle, (IntPtr)adress, bytes, (UIntPtr)sizeof(int), 0);
            return BitConverter.ToInt32(bytes, 0);
        }

        public int ReadPointer(uint pointer)
        {
            byte[] bytes = new byte[24];

            ReadProcessMemory(Handle, (IntPtr)pointer, bytes, (UIntPtr)sizeof(int), 0);
            return BitConverter.ToInt32(bytes, 0);
        }
    }
}

using System;
using System.Linq;
using System.Text;
using Game.Memory;

namespace main
{
    class Program
    {
        private static bool exit = false;
  
        static void Main(string[] args)
        {
            while (!exit)
                GetLine(Console.ReadLine());
        }

        private static void GetLine(string cmd)
        {
            Memory mem = new Memory("sro_client");

            switch (cmd)
            {
                case "curhp":
                    int curhp = mem.ReadOffset(0x00A8913C, 0x1D4);
                    Console.WriteLine("Current HP: {0}", curhp);
                    break;
                case "maxhp":
                    int maxhp = mem.ReadPointer(0x00AA0740);
                    Console.WriteLine("Maximum HP: {0}", maxhp);
                    break;
                case "name":
                    string name = mem.ReadString(0x00A9FB98);
                    Console.WriteLine("Charname: {0}", name);
                    break;
                case "exit":
                    exit = true;
                    break;
            }
        }      
    }
}

Global $OLD_char, $OLD_hp
Global $Process = _MemoryOpen(WinGetProcess("SRO_Client"))

Global $Pointer_char = 0x00A9FB98
Global $Pointer_Base = 0x00A8913C
Global $Pointer_maxhp = 0x00AA0740
Global $Offset_curhp = 0x1D4

GUICreate("Char Display", 200, 100)
GUICtrlCreateLabel("Charname:", 10, 20)
$Label_char = GUICtrlCreateLabel("", 70, 20, 100)
GUICtrlCreateLabel("HP:", 10, 40)
$Label_hp = GUICtrlCreateLabel("", 70, 40, 100)
GUISetState()

While 1
	Switch GUIGetMsg()
		Case -3
			Exit
	EndSwitch
	_CharUpdate()
WEnd

Func _CharUpdate()
	Local $READ_char, $READ_maxhp, $READ_Base, $READ_curhp
	$READ_char = _MemoryRead($Pointer_char, $Process, "char[40]")
	$READ_maxhp = _MemoryRead($Pointer_maxhp, $Process)
	$READ_Base = _MemoryRead($Pointer_Base, $Process)
	$READ_curhp = _MemoryRead($READ_Base + $Offset_curhp, $Process)

	If $READ_char <> $OLD_char Then
		$OLD_char = $READ_char
		GUICtrlSetData($Label_char, $READ_char)
	EndIf
	If $READ_curhp <> $OLD_hp Then
		$OLD_hp = $READ_curhp
		GUICtrlSetData($Label_hp, $READ_curhp & " / " & $READ_maxhp)
	EndIf
EndFunc

Func _MemoryOpen($iv_Pid, $iv_DesiredAccess = 0x1F0FFF, $iv_InheritHandle = 1)
	Local $ah_Handle[2] = [DllOpen('kernel32.dll')]
	Local $av_OpenProcess = DllCall($ah_Handle[0], 'int', 'OpenProcess', 'int', $iv_DesiredAccess, 'int', $iv_InheritHandle, 'int', $iv_Pid)
	$ah_Handle[1] = $av_OpenProcess[0]
	Return $ah_Handle
EndFunc   ;==>_MemoryOpen

Func _MemoryRead($iv_Address, $ah_Handle, $sv_Type = 'dword')
	Local $v_Buffer = DllStructCreate($sv_Type)
	DllCall($ah_Handle[0], 'int', 'ReadProcessMemory', 'int', $ah_Handle[1], 'int', $iv_Address, 'ptr', DllStructGetPtr($v_Buffer), 'int', DllStructGetSize($v_Buffer), 'int', '')
	Local $v_Value = DllStructGetData($v_Buffer, 1)
	Return $v_Value
EndFunc   ;==>_MemoryRead

using System;
using System.Linq;
using System.Text;

//include namespace Game.Memory
using Game.Memory;

namespace main
{
    class Program
    {
        //Creating var
        private static bool exit = false;
    
        //Main function (runs on program start)
        static void Main(string[] args)
        {
            //As long as exit is not true..
            while (!exit)
                //Call function GetLine with Console Input
                GetLine(Console.ReadLine());
        }

        //GetLine function
        private static void GetLine(string cmd)
        {
            //Create object of class Memory
            Memory mem = new Memory("sro_client");

            //Switch Console input
            switch (cmd)
            {
                //If Console input = curhp
                case "curhp":
                    //Call function ReadOffset of the mem object (returns int)
                    int curhp = mem.ReadOffset(0x00A8913C, 0x1D4);
                    //Output the result
                    Console.WriteLine("Current HP: {0}", curhp);
                    break;
                //If Console input = maxhp
                case "maxhp":
                    //Call function ReadOffset of the mem object (returns int)
                    int maxhp = mem.ReadPointer(0x00AA0740);
                    //Output the result
                    Console.WriteLine("Maximum HP: {0}", maxhp);
                    break;
                //If Console input = name 
                case "name":
                    //Call function ReadOffset of the mem object (returns string)
                    string name = mem.ReadString(0x00A9FB98);
                    //Output the result
                    Console.WriteLine("Charname: {0}", name);
                    break;
                //If Console input = exit
                case "exit":
                    //Set exit true (program terminates)
                    exit = true;
                    break;
            }
        }      
    }
}

using System;
using System.Text;
using System.Runtime.InteropServices;
using System.Diagnostics;

namespace Game.Memory
{
    class Memory
    {
        //import kernel32 and create OpenProcess and ReadProcess functions
        [DllImport("kernel32.dll")]
        static extern IntPtr OpenProcess(UInt32 dwDesiredAccess, Boolean bInheritHandle, UInt32 dwProcessId);
        [DllImport("kernel32.dll")]
        static extern bool ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress,
        byte[] lpBuffer, UIntPtr nSize, uint lpNumberOfBytesWritten);

        //Create handle
        IntPtr Handle;

        //constructor
        public Memory(string sprocess)
        {
            //Get the specific process
            Process[] Processes = Process.GetProcessesByName(sprocess);
            Process nProcess = Processes[0];
            //access to the process
            Handle = OpenProcess(0x10, false, (uint)nProcess.Id);
        }

        //function ReadString (returns string value)
        public string ReadString(uint pointer) 
        {
            //Create bytearray
            byte[] bytes = new byte[24];

            //Read the specific address within the process
            ReadProcessMemory(Handle, (IntPtr)pointer, bytes, (UIntPtr)24, 0);
            //Return the result as UTF8 String
            return Encoding.UTF8.GetString(bytes);
        }

        //function ReadOffset (returns int value)
        public int ReadOffset(uint pointer, uint offset)
        {
            //Create bytearray
            byte[] bytes = new byte[24];

            //Creating the address (reading the Base and add the offset)
            uint adress = (uint)ReadPointer(pointer) + offset;
            //Reading the specific address within the process
            ReadProcessMemory(Handle, (IntPtr)adress, bytes, (UIntPtr)sizeof(int), 0);
            //Return the result as 4 byte int
            return BitConverter.ToInt32(bytes, 0);
        }

        //function ReadPointer (returns int value)
        public int ReadPointer(uint pointer)
        {
            //Create bytearray
            byte[] bytes = new byte[24];

            //Reading the specific address within the process
            ReadProcessMemory(Handle, (IntPtr)pointer, bytes, (UIntPtr)sizeof(int), 0);
            //Return the result as 4 byte int
            return BitConverter.ToInt32(bytes, 0);
        }
    }
}

            //Create bytearray
            byte[] bytes = new byte[24];