Write-Host "Launching OSD."

$procname = "StateOfDecay2-Win64-Shipping"
$bigendian = $false

[console]::CursorVisible = $false
$Host.UI.RawUI.BackgroundColor = 'Black'
$Host.UI.RawUI.ForegroundColor = 'Green'

Function RBytes
{
	Param (
		$addr,
		$sizetoread
	)
	$pos = $addr
	[Byte[]] $buff = New-Object Byte[]($sizetoread)
	$read = $rpm::ReadProcessMemory($proc,$pos,$buff,$buff.length,$null);
	$buff
}
Function RAsciiStr
{   
	Param (
        $addr
    )
	([System.Text.Encoding]::ASCII.GetString($(RBytes $addr 0x200))).Split([char]0)[0]
}
Function RUnicodeStr {
    Param (
        $addr
    )
    ([System.Text.Encoding]::Unicode.GetString($(RBytes $addr 0x200))).Split([char]0)[0]
}
Function ReadAndConvert {
    Param (
        [IntPtr]$addr,
        [int]$byteCount,
        [string]$convertType
    )
    $buff = RBytes $addr $byteCount
    if ($bigendian -eq $true) {
        [Array]::Reverse($buff)
    }

    switch ($convertType) {
        "Int16"   { return [BitConverter]::ToInt16($buff, 0) }
        "Int32"   { return [BitConverter]::ToInt32($buff, 0) }
        "Int64"   { return [BitConverter]::ToInt64($buff, 0) }
        "UInt8"   { return $buff[0] }
        "UInt16"  { return [BitConverter]::ToUInt16($buff, 0) }
        "UInt32"  { return [BitConverter]::ToUInt32($buff, 0) }
        "UInt64"  { return [BitConverter]::ToUInt64($buff, 0) }
        "Single"  { return [BitConverter]::ToSingle($buff, 0) }
        default   { throw "Unknown conversion type $convertType" }
    }
}
Function RInt16   { Param ([IntPtr]$addr) ReadAndConvert $addr 2 "Int16" }
Function RInt32   { Param ([IntPtr]$addr) ReadAndConvert $addr 4 "Int32" }
Function RInt64   { Param ([IntPtr]$addr) ReadAndConvert $addr 8 "Int64" }
Function RUInt8   { Param ([IntPtr]$addr) ReadAndConvert $addr 1 "UInt8" }
Function RUInt16  { Param ([IntPtr]$addr) ReadAndConvert $addr 2 "UInt16" }
Function RUInt32  { Param ([IntPtr]$addr) ReadAndConvert $addr 4 "UInt32" }
Function RUInt64  { Param ([IntPtr]$addr) ReadAndConvert $addr 8 "UInt64" }
Function RSingle  { Param ([IntPtr]$addr) ReadAndConvert $addr 4 "Single" }

Function WBytes {
    Param (
        [IntPtr]$addr,
        [Byte[]]$data
    )
    $size = $data.Length
    $written = 0
    $success = $rpm::WriteProcessMemory($proc, $addr, $data, $size, [ref]$written)
    if (-not $success -or $written -ne $size) {
        throw "Failed to write memory at $addr"
    }
}
Function WInt16   { Param ([IntPtr]$addr, [Int16]$val)   WBytes $addr ([BitConverter]::GetBytes($val)) }
Function WInt32   { Param ([IntPtr]$addr, [Int32]$val)   WBytes $addr ([BitConverter]::GetBytes($val)) }
Function WInt64   { Param ([IntPtr]$addr, [Int64]$val)   WBytes $addr ([BitConverter]::GetBytes($val)) }
Function WUInt8   { Param ([IntPtr]$addr, [Byte]$val)    WBytes $addr @($val) }
Function WUInt16  { Param ([IntPtr]$addr, [UInt16]$val)  WBytes $addr ([BitConverter]::GetBytes($val)) }
Function WUInt32  { Param ([IntPtr]$addr, [UInt32]$val)  WBytes $addr ([BitConverter]::GetBytes($val)) }
Function WUInt64  { Param ([IntPtr]$addr, [UInt64]$val)  WBytes $addr ([BitConverter]::GetBytes($val)) }
Function WSingle  { Param ([IntPtr]$addr, [Single]$val)  WBytes $addr ([BitConverter]::GetBytes($val)) }
Function WAsciiStr {
    Param (
        [IntPtr]$addr,
        [string]$str,
        [int]$maxLen = 0x50
    )
    $bytes = [System.Text.Encoding]::ASCII.GetBytes($str)
    if ($bytes.Length -ge $maxLen) {
        $bytes = $bytes[0..($maxLen-2)]
    }
    $padded = New-Object Byte[]($maxLen)
    [Array]::Copy($bytes, $padded, $bytes.Length)
    WBytes $addr $padded
}

Function WUnicodeStr {
    Param (
        [IntPtr]$addr,
        [string]$str,
        [int]$maxLen = 0x50
    )
    $bytes = [System.Text.Encoding]::Unicode.GetBytes($str)
    if ($bytes.Length -ge $maxLen) {
        $bytes = $bytes[0..($maxLen-2)]
    }
    $padded = New-Object Byte[]($maxLen)
    [Array]::Copy($bytes, $padded, $bytes.Length)
    WBytes $addr $padded
}

$signature = @"
[DllImport("kernel32.dll")] public static extern IntPtr OpenProcess(
    uint h,bool b ,uint p);
[DllImport("kernel32.dll")] public static extern bool ReadProcessMemory(
    IntPtr hp,IntPtr Base,[Out]Byte[] buff,int Size,[Out]int bread);
[DllImport("kernel32.dll")] public static extern bool WriteProcessMemory(
    IntPtr hp,IntPtr Base,[In]Byte[] buff,int Size,out int bwrite);
[DllImport("kernel32.dll")] public static extern bool VirtualProtectEx(
	IntPtr hProcess, IntPtr lpAddress, uint dwSize, uint flNewProtect, out uint lpflOldProtect);
"@
$PAGE_EXECUTE_READWRITE = 0x40
$oldProtection = 0

$rpm = Add-Type -MemberDefinition $signature -Name rpm -PassThru
$access = 0x001F0FFF

$ba = (get-Process $procname).MainModule.BaseAddress
$procid = (get-Process $procname).ID
$proc = $rpm::OpenProcess($access, $false, $procid)



Function GetNameFromNameOffset {
	Param (
		[Int32]$offset
	)
	
	[IntPtr]$table = RInt64 ($namesTablePtr)		
	if ($offset -lt 0x1000) {
		$offset = RInt32 ($ba + [Int64]0x44da8e0 + ($offset * 4))
		#FIX FOR STEAM
	}
	$name = RAsciiStr ($table + [Int64]$offset + 8)

	$name
}
Function GetObjFromObjId {
	Param (
		[Int32]$id
	)
	[IntPtr]$table = RInt64 ($objTablePtr)		
	$obj = RInt64  ($table + [Int64](0x18 * $id))
	$obj
}

#struct UObject {
    #void* VTable;         // 0x00
    #int32 FlagsOrIndex;   // 0x08
    #int32 ObjId;          // 0x0C  → Used in GUObjectArray
    #void* ClassPtr;       // 0x10
    #int32 NameOffset;     // 0x18  → Byte offset into name pool
    #int32 Unknown;        // 0x1C
    #void* OuterPtr;       // 0x20
#};











class UObject {
	[IntPtr]$BaseAddress
	UObject([IntPtr]$addr) {
		$this.BaseAddress = $addr
	}
	[string] Name() {
		$nameId = RInt32([IntPtr]($this.BaseAddress.ToInt64() + 0x18))
		return GetNameFromNameOffset $nameId
	}
}

class CharacterComponent {
    [IntPtr]$BaseAddress
	[UObject]$UObject
    CharacterComponent([IntPtr]$addr) {
        $this.BaseAddress = $addr
		$this.UObject = [UObject]::new($addr)
    }
	[DaytonCharacter] DaytonCharacter() {
		return [DaytonCharacter]::new((RInt64([IntPtr]($this.BaseAddress.ToInt64() + 0x190))))
    }
}

class DaytonCharacter {
    [IntPtr]$BaseAddress
	[UObject]$UObject
    DaytonCharacter([IntPtr]$addr) {
        $this.BaseAddress = $addr
		$this.UObject = [UObject]::new($addr)
    }
	[int] ID() {
		return RInt32([IntPtr]($this.BaseAddress.ToInt64() + 0x368))
	}
	[void] ID([int]$value) {
		WInt32 ([IntPtr]($this.BaseAddress.ToInt64() + 0x368)) $value
	}
    [string] HeroBonus() {
		$id = RInt32([IntPtr]($this.BaseAddress.ToInt64() + 0x418))
		return GetNameFromNameOffset $id
	}
	[string] LeaderType() {
		$id = RInt32([IntPtr]($this.BaseAddress.ToInt64() + 0x428))
		return GetNameFromNameOffset $id
	}
	[float] currStanding() {
        return RSingle([IntPtr]($this.BaseAddress.ToInt64() + 0x430))
    }
    [void] currStanding([float]$value) {
        WSingle ([IntPtr]($this.BaseAddress.ToInt64() + 0x430)) $value
    }
	[float] currHealth() {
        return RSingle([IntPtr]($this.BaseAddress.ToInt64() + 0x470))
    }
    [void] currHealth([float]$value) {
        WSingle ([IntPtr]($this.BaseAddress.ToInt64() + 0x470)) $value
    }
    [float] currStam() {
        return RSingle([IntPtr]($this.BaseAddress.ToInt64() + 0x474))
    }
    [void] currStam([float]$value) {
        WSingle ([IntPtr]($this.BaseAddress.ToInt64() + 0x474)) $value
    }
	[float] currFatigue() {
        return RSingle([IntPtr]($this.BaseAddress.ToInt64() + 0x478))
    }
    [void] currFatigue([float]$value) {
        WSingle ([IntPtr]($this.BaseAddress.ToInt64() + 0x478)) $value
    }
	[float] currSick() {
        return RSingle([IntPtr]($this.BaseAddress.ToInt64() + 0x480))
    }
    [void] currSick([float]$value) {
        WSingle ([IntPtr]($this.BaseAddress.ToInt64() + 0x480)) $value
    }
	[float] currPlague() {
        return RSingle([IntPtr]($this.BaseAddress.ToInt64() + 0x484))
    }
    [void] currPlague([float]$value) {
        WSingle ([IntPtr]($this.BaseAddress.ToInt64() + 0x484)) $value
    }
	
	[float] maxStaminaBase() {
        return RSingle([IntPtr]($this.BaseAddress.ToInt64() + 0xaf4))
    }
	[float] maxHealthBase() {
        return RSingle([IntPtr]($this.BaseAddress.ToInt64() + 0xb00))
    }
	
	[float] maxSick() {
        return RSingle([IntPtr]($this.BaseAddress.ToInt64() + 0xb38))
    }
    [void] maxSick([float]$value) {
        WSingle ([IntPtr]($this.BaseAddress.ToInt64() + 0xb38)) $value
    }
	[float] maxPlague() {
        return RSingle([IntPtr]($this.BaseAddress.ToInt64() + 0xb44))
    }
    [void] maxPlague([float]$value) {
        WSingle ([IntPtr]($this.BaseAddress.ToInt64() + 0xb44)) $value
    }
	
	[Enclave] Enclave() {
		return [Enclave]::new((RInt64($this.BaseAddress.ToInt64() + 0xe28)))
	}
	
	[float] xPos() {
        return RSingle([IntPtr]($this.BaseAddress.ToInt64() + 0xff0))
    }
	[float] yPos() {
        return RSingle([IntPtr]($this.BaseAddress.ToInt64() + 0xff4))
    }
	[float] zPos() {
        return RSingle([IntPtr]($this.BaseAddress.ToInt64() + 0xff8))
    }
}

class DaytonHumanCharacter {
    [IntPtr]$BaseAddress
	[UObject]$UObject
    DaytonHumanCharacter([IntPtr]$addr) {
        $this.BaseAddress = $addr
		$this.UObject = [UObject]::new($addr)
    }
	[CharacterComponent] CharacterComponent() {
		return [CharacterComponent]::new((RInt64([IntPtr]($this.BaseAddress.ToInt64() + 0xba0))))
    }
	[Single] CurrentEffectiveMaxHealth() {
		return (RSingle($this.BaseAddress.ToInt64() + 0xc58))
	}
	[Single] CurrentHealth() {
		return (RSingle($this.BaseAddress.ToInt64() + 0xc5c))
	}
}

class Enclave {
    [IntPtr]$BaseAddress
	[UObject]$UObject
    Enclave([IntPtr]$addr) {
        $this.BaseAddress = $addr
		$this.UObject = [UObject]::new($addr)
    }
}

class FollowerManager {
    [IntPtr]$BaseAddress
	[UObject]$UObject
    FollowerManager([IntPtr]$addr) {
        $this.BaseAddress = $addr
		$this.UObject = [UObject]::new($addr)
    }
	[DaytonCharacter]Follower() {
		return [DaytonCharacter]::new((RInt64(RInt64([IntPtr]($this.BaseAddress.ToInt64() + 0xa0)))))
	}
	[Int]numFollowers() {
		return RInt32 ([IntPtr]($this.BaseAddress.ToInt64() + 0xa8))
	}
}

class GameInstance {
    [IntPtr]$BaseAddress
	[UObject]$UObject
    GameInstance([IntPtr]$addr) {
        $this.BaseAddress = $addr
		$this.UObject = [UObject]::new($addr)
    }
	[LocalPlayer] LocalPlayer() {
		return [LocalPlayer]::new((RInt64(RInt64([IntPtr]($this.BaseAddress.ToInt64() + 0x38)))))
    }
}

class LocalPlayer {
    [IntPtr]$BaseAddress
	[UObject]$UObject
    LocalPlayer([IntPtr]$addr) {
        $this.BaseAddress = $addr
		$this.UObject = [UObject]::new($addr)
    }
	[PlayerController] PlayerController() {
		return [PlayerController]::new((RInt64([IntPtr]($this.BaseAddress.ToInt64() + 0x30))))
    }
}

class PlayerController {
    [IntPtr]$BaseAddress
	[UObject]$UObject
    PlayerController([IntPtr]$addr) {
        $this.BaseAddress = $addr
		$this.UObject = [UObject]::new($addr)
    }
	[DaytonHumanCharacter] DaytonHumanCharacter() {
        $ptr = RInt64([IntPtr]($this.BaseAddress.ToInt64() + 0x368))
		$id = RInt32([IntPtr]($ptr + 0x18))
		$name = GetNameFromNameOffset $id
		if ($name -eq "HumanCharacter_C") {
			return [DaytonHumanCharacter]::new($ptr)
		} 
		if ($name -eq "DaytonInteractionProxyPawn_BP_C") {
			$ptr = RInt64([IntPtr]($ptr + 0x3e0))
			return [DaytonHumanCharacter]::new($ptr)
		}
		$ptr = RInt64([IntPtr]($ptr + 0x4a0))
		return [DaytonHumanCharacter]::new($ptr)
    }
	[FollowerManager]FollowerManager() {
		$ptr = RInt64([IntPtr]($this.BaseAddress.ToInt64() + 0x7a8))
		return [FollowerManager]::new($ptr)
	}	
	[Int]ProximateZombieCount() {
		return (RInt32 ($this.BaseAddress.ToInt64() + 0x944))
	}
}

class RangedWeaponResourceStats {
	[IntPtr]$BaseAddress
	[UObject]$Uobject
	RangedWeaponResourceStats([IntPtr]$addr) {
		$this.BaseAddress = $addr
		$this.UObject = [UObject]::new($addr)
	}
	[string] WeapName() {
		return (RUnicodeStr(RInt64($this.BaseAddress.ToInt64() + 0x48)))
	}
	[string] WeapType() {
		return (RUnicodeStr(RInt64($this.BaseAddress.ToInt64() + 0x58)))
	}
	[string] Description() {
		return (RUnicodeStr(RInt64($this.BaseAddress.ToInt64() + 0x68)))
	}
	[Int]ProjectileCount() {
		return (RInt32($this.BaseAddress.ToInt64() + 0x15c))
	}
	[Int]MagazineSize() {
		return (RInt32($this.BaseAddress.ToInt64() + 0x164))
	}
	[Float]Impact() {
		return (RSingle($this.BaseAddress.ToInt64() + 0x230))
	}
	[Float]ImpactDelta() {
		return (RSingle($this.BaseAddress.ToInt64() + 0x238))
	}
	[Float]Knockdown() {
		return (RSingle($this.BaseAddress.ToInt64() + 0x240))
	}
	[Float]KnockdownDelta() {
		return (RSingle($this.BaseAddress.ToInt64() + 0x248))
	}
	[Float]Dismember() {
		return (RSingle($this.BaseAddress.ToInt64() + 0x250))
	}
	[Float]DismemberDelta() {
		return (RSingle($this.BaseAddress.ToInt64() + 0x258))
	}
	[Float]Penetration() {
		return (RSingle($this.BaseAddress.ToInt64() + 0x260))
	}
	[Float]Range() {
		return (RSingle($this.BaseAddress.ToInt64() + 0x278))
	}
	[Float]Weight() {
		return (RSingle($this.BaseAddress.ToInt64() + 0x288))
	}
	[Float]InfluenceValue() {
		return (RInt32($this.BaseAddress.ToInt64() + 0x290))
	}
	[Float]MaxDurability() {
		return (RSingle($this.BaseAddress.ToInt64() + 0x2a0))
	}
	[Float]PerceptionLoudness() {
		return (RSingle($this.BaseAddress.ToInt64() + 0x2d8))
	}
	[Float]MoveSpeedMultiplier() {
		return (RSingle($this.BaseAddress.ToInt64() + 0x2e0))
	}
}
	

class World {
    [IntPtr]$BaseAddress
	[UObject]$UObject
    World([IntPtr]$addr) {
        $this.BaseAddress = $addr
		$this.UObject = [UObject]::new($addr)
    }
	[GameInstance] GameInstance() {
		return [GameInstance]::new((RInt64([IntPtr]($this.BaseAddress.ToInt64() + 0x140))))
    }
}

















$verIdent = RInt32 ($ba + [Int64]0xe8)
$ver = "Dunno"
if ($verIdent -eq 0x49274e48) {
	$ver = "MS"
	$daytonVehicleVtPtr = $ba + [Int64]0x03418E40
	$namesTablePtr 		= $ba + [Int64]0x044DB248
	$objTablePtr 		= $ba + [Int64]0x044E3B30
	$worldPtr 			= $ba + [Int64]0x045D7C88
}
if ($verIdent -eq 0xd54624b7) {
	$ver = "Steam"
	$daytonVehicleVtPtr = $ba + [Int64]0x034E8930
	$namesTablePtr 		= $ba + [Int64]0x04629DC8
	$objTablePtr		= $ba + [Int64]0x046326b0
	$worldPtr 			= $ba + [Int64]0x04726808
}
if ($ver -eq "Dunno") {
	Write-Host "Matching bytes not found, incompatible version of game or process not found."
} else {
	Add-Type -AssemblyName System.Windows.Forms
	$ScreenWidth = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds.Width
	$ScreenHeight = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds.Height

	$form = New-Object System.Windows.Forms.Form
	$form.Text = ""
	$form.Width = 500
	$form.Height = 200
	$form.TopMost = $true
	$form.WindowState = [System.Windows.Forms.FormWindowState]::Maximized
	$form.FormBorderStyle = [System.Windows.Forms.FormBorderStyle]::None
	$form.BackColor = 'Gray'
	$form.TransparencyKey = 'Gray'
	$form.GetType().InvokeMember("SetStyle", [Reflection.BindingFlags]::InvokeMethod -bor [Reflection.BindingFlags]::NonPublic -bor [Reflection.BindingFlags]::Instance, $null, $form, @([System.Windows.Forms.ControlStyles]::DoubleBuffer, $true))

	$closeButton = New-Object System.Windows.Forms.Button
	$closeButton.Text = "X"
	$closeButton.Width = 30
	$closeButton.Height = 30
	$closeButton.Left = $ScreenWidth - 30
	$closeButton.Top = 0
	$closeButton.BackColor = [System.Drawing.Color]::FromArgb(100, 200, 200, 200)
	$closeButton.ForeColor = "Black"
	$closeButton.FlatStyle = "Flat"
	$closeButton.Add_Click({ $form.Close() })
	$form.Controls.Add($closeButton)

	$buttonPanel = New-Object Windows.Forms.Panel
	$buttonPanel.Left = $ScreenWidth - 250
	$buttonPanel.Top = $ScreenHeight * 0.05
	$buttonPanel.Width = 220
	$buttonPanel.Height = 250
	$buttonPanel.BackColor = [System.Drawing.Color]::FromArgb(60, 30, 30, 30)
	$form.Controls.Add($buttonPanel)
	$buttonPanel.Visible = $false



	###used for character display
	$bgPanel = New-Object Windows.Forms.Panel
	$bgPanel.Left = 10
	$bgPanel.Top = 10
	$bgPanel.Width = 600
	$bgPanel.Height = 170
	#$bgPanel.BackColor = [System.Drawing.Color]::FromArgb(60, 30, 30, 30)  # 60 = 23% opacity
	$bgPanel.BackColor = [System.Drawing.Color]::Transparent
	$form.Controls.Add($bgPanel)
	$bgPanel.Visible = $false





	$btnPanelToggleBtn = New-Object System.Windows.Forms.Button
	$btnPanelToggleBtn.Text = "<<<"
	$btnPanelToggleBtn.Width = 50
	$btnPanelToggleBtn.Height = 30
	$btnPanelToggleBtn.Left = $ScreenWidth - 60
	$btnPanelToggleBtn.Top = 40
	$btnPanelToggleBtn.BackColor = [System.Drawing.Color]::FromArgb(100, 180, 180, 180)
	$btnPanelToggleBtn.ForeColor = "Black"
	$btnPanelToggleBtn.FlatStyle = "Flat"
	$btnPanelToggleBtn.Add_Click({
		$buttonPanel.Visible = -not $buttonPanel.Visible
		if ($btnPanelToggleBtn.Text -eq "<<<") {
			$btnPanelToggleBtn.Text = ">>>"
		} else {
			$btnPanelToggleBtn.Text = "<<<"
		}
	})
	$form.Controls.Add($btnPanelToggleBtn)
	
	$bgPanelToggleBtn = New-Object System.Windows.Forms.Button
	$bgPanelToggleBtn.Text = "Chars"
	$bgPanelToggleBtn.Width = 100
	$bgPanelToggleBtn.Height = 30
	$bgPanelToggleBtn.Left = 5
	$bgPanelToggleBtn.Top = 5 + (10 + 30) * 0
	$bgPanelToggleBtn.BackColor = [System.Drawing.Color]::FromArgb(100, 180, 180, 180)
	$bgPanelToggleBtn.ForeColor = "Black"
	$bgPanelToggleBtn.FlatStyle = "Flat"
	$bgPanelToggleBtn.Add_Click({
		$bgPanel.Visible = -not $bgPanel.Visible
		$posLabel.Visible = -not $posLabel.Visible
	})
	$buttonPanel.Controls.Add($bgPanelToggleBtn)

	
	$followerToggleBtn = New-Object System.Windows.Forms.Button
	$followerToggleBtn.Text = "Follower"
	$followerToggleBtn.Width = 100
	$followerToggleBtn.Height = 30
	$followerToggleBtn.Left = 5
	$followerToggleBtn.Top = 5 + (10 + 30) * 1
	$followerToggleBtn.BackColor = [System.Drawing.Color]::FromArgb(100, 180, 180, 180)
	$followerToggleBtn.ForeColor = "Black"
	$followerToggleBtn.FlatStyle = "Flat"
	$followerToggleBtn.Add_Click({
		$followerLabel.Visible = -not $followerLabel.Visible
	})
	$buttonPanel.Controls.Add($followerToggleBtn)
	
	
	$skillToggleBtn = New-Object System.Windows.Forms.Button
	$skillToggleBtn.Text = "Skills"
	$skillToggleBtn.Width = 100
	$skillToggleBtn.Height = 30
	$skillToggleBtn.Left = 5
	$skillToggleBtn.Top = 5 + (10 + 30) * 2
	$skillToggleBtn.BackColor = [System.Drawing.Color]::FromArgb(100, 180, 180, 180)
	$skillToggleBtn.ForeColor = "Black"
	$skillToggleBtn.FlatStyle = "Flat"
	$skillToggleBtn.Add_Click({
		$skillLabel.Visible = -not $skillLabel.Visible
	})
	$buttonPanel.Controls.Add($skillToggleBtn)
	
	$vehicleToggleBtn = New-Object System.Windows.Forms.Button
	$vehicleToggleBtn.Text = "Vehicle"
	$vehicleToggleBtn.Width = 100
	$vehicleToggleBtn.Height = 30
	$vehicleToggleBtn.Left = 5
	$vehicleToggleBtn.Top = 5 + (10 + 30) * 3
	$vehicleToggleBtn.BackColor = [System.Drawing.Color]::FromArgb(100, 180, 180, 180)
	$vehicleToggleBtn.ForeColor = "Black"
	$vehicleToggleBtn.FlatStyle = "Flat"
	$vehicleToggleBtn.Add_Click({
		$vehicleLabel.Visible = -not $vehicleLabel.Visible
	})
	$buttonPanel.Controls.Add($vehicleToggleBtn)

	$phToggleBtn = New-Object System.Windows.Forms.Button
	$phToggleBtn.Text = "PHearts"
	$phToggleBtn.Width = 100
	$phToggleBtn.Height = 30
	$phToggleBtn.Left = 5
	$phToggleBtn.Top = 5 + (10 + 30) * 4
	$phToggleBtn.BackColor = [System.Drawing.Color]::FromArgb(100, 180, 180, 180)
	$phToggleBtn.ForeColor = "Black"
	$phToggleBtn.FlatStyle = "Flat"
	$phToggleBtn.Add_Click({
		$phLabel.Visible = -not $phLabel.Visible
	})
	$buttonPanel.Controls.Add($phToggleBtn)

	$timeToggleBtn = New-Object System.Windows.Forms.Button
	$timeToggleBtn.Text = "Time"
	$timeToggleBtn.Width = 100
	$timeToggleBtn.Height = 30
	$timeToggleBtn.Left = 5
	$timeToggleBtn.Top = 5 + (10 + 30) * 5
	$timeToggleBtn.BackColor = [System.Drawing.Color]::FromArgb(100, 180, 180, 180)
	$timeToggleBtn.ForeColor = "Black"
	$timeToggleBtn.FlatStyle = "Flat"
	$timeToggleBtn.Add_Click({
		$timeToggleBtn.Visible = -not $timeToggleBtn.Visible
	})
	$buttonPanel.Controls.Add($timeToggleBtn)



	$meleeToggleBtn = New-Object System.Windows.Forms.Button
	$meleeToggleBtn.Text = "Melee"
	$meleeToggleBtn.Width = 100
	$meleeToggleBtn.Height = 30
	$meleeToggleBtn.Left = 5 + (10 + 100 ) * 1
	$meleeToggleBtn.Top = 5 + (10 + 30) * 0
	$meleeToggleBtn.BackColor = [System.Drawing.Color]::FromArgb(100, 180, 180, 180)
	$meleeToggleBtn.ForeColor = "Black"
	$meleeToggleBtn.FlatStyle = "Flat"
	$meleeToggleBtn.Add_Click({
		$meleeLabel.Visible = -not $meleeLabel.Visible
	})
	$buttonPanel.Controls.Add($meleeToggleBtn)

	$rangedToggleBtn = New-Object System.Windows.Forms.Button
	$rangedToggleBtn.Text = "Ranged"
	$rangedToggleBtn.Width = 100
	$rangedToggleBtn.Height = 30
	$rangedToggleBtn.Left = 5 + (10 + 100 ) * 1
	$rangedToggleBtn.Top = 5 + (10 + 30) * 1
	$rangedToggleBtn.BackColor = [System.Drawing.Color]::FromArgb(100, 180, 180, 180)
	$rangedToggleBtn.ForeColor = "Black"
	$rangedToggleBtn.FlatStyle = "Flat"
	$rangedToggleBtn.Add_Click({
		$rangedLabel.Visible = -not $rangedLabel.Visible
	})
	$buttonPanel.Controls.Add($rangedToggleBtn)




	Function CreateLabel ($font, $fontSize, $color) {
		$label = New-Object System.Windows.Forms.Label
		$label.AutoSize = $true
		$label.BackColor = [System.Drawing.Color]::Transparent
		$label.ForeColor = $color
		$label.Font = New-Object System.Drawing.Font($font, $fontSize, [System.Drawing.FontStyle]::Bold)
		$form.Controls.Add($label)
		return $label
	}





	$mouseLabel = CreateLabel "Consolas" 16 "White"


	$hpLabel = CreateLabel "Consolas" 14 "White"
	$posLabel = CreateLabel "Consolas" 16 "White"
	$phLabel = CreateLabel "Consolas" 16 "White"
	$skillLabel = CreateLabel "Consolas" 16 "White"
	$vehicleLabel = CreateLabel "Consolas" 16 "White"
	$meleeLabel = CreateLabel "Consolas" 16 "White"
	$rangedLabel = CreateLabel "Consolas" 16 "White"
	$followerLabel = CreateLabel "Consolas" 16 "White"
	$timeLabel = CreateLabel "Consolas" 16 "White"

	$followerLabel.Visible = $false
	$posLabel.Visible = $false
	$phLabel.Visible = $false
	$skillLabel.Visible = $false
	$vehicleLabel.Visible = $false
	$meleeLabel.Visible = $false
	$rangedLabel.Visible = $false
	$timeLabel.Visible = $true

	$bgPanel.Controls.Add($hpLabel)


	$timer = New-Object System.Windows.Forms.Timer
	$timer.Interval = 200

	$timer.Add_Tick({
		$CursorPosition = [System.Windows.Forms.Cursor]::Position
		$NormalizedX = [Math]::Round($CursorPosition.X / $ScreenWidth, 3)
		$NormalizedY = [Math]::Round($CursorPosition.Y / $ScreenHeight, 3)
				
		if ($bgPanel.Visible) {
			$World = [World]::new((RInt64 ($worldPtr)))
			$GameInstance = $World.GameInstance()
			$LocalPlayer = $GameInstance.LocalPlayer()
			$PlayerController = $LocalPlayer.PlayerController()
			$DaytonHumanCharacter = $PlayerController.DaytonHumanCharacter()
			$CharacterComponent = $DaytonHumanCharacter.CharacterComponent()
			$DaytonCharacter = $CharacterComponent.DaytonCharacter()
			$Enclave = $DaytonCharacter.Enclave()



			$newHpLabel = ""
			if ($DaytonCharacter.UObject.Name() -eq "DaytonCharacter") {
				$newHpLabel += "NearZombs: {0,6:N0}`n" -f $PlayerController.ProximateZombieCount()
				$newHpLabel += $DaytonCharacter.LeaderType() + "`n"
				$newHpLabel += $DaytonCharacter.HeroBonus() + "`n"
				$newHpLabel += "Health:    {0,6:N2} / {1,6:N2}`n" -f $DaytonHumanCharacter.CurrentHealth(), $DaytonHumanCharacter.CurrentEffectiveMaxHealth()
				$newHpLabel += "Stamina:   {0,6:N2} / {1,6:N2}`n" -f $DaytonCharacter.currStam(), $DaytonCharacter.maxStaminaBase()
				$newHpLabel += "Sick:      {0,6:N2} / {1,6:N2}`n" -f $DaytonCharacter.currSick(), $DaytonCharacter.maxSick()
				$newHpLabel += "Plague:    {0,6:N2} / {1,6:N2}`n" -f $DaytonCharacter.currPlague(), $DaytonCharacter.maxPlague()
				$newHpLabel += "Fatigue:   {0,6:N2}`n"           -f $DaytonCharacter.currFatigue()
				$newHpLabel += "Standing:  {0,6:N2}`n"           -f $DaytonCharacter.currStanding()
				
				$cptr = $DaytonCharacter.BaseAddress
				$newHpLabel += "`n"
				
				$newposLabel  = "x: {0,8:F2}`n" -f $DaytonCharacter.xPos()
				$newposLabel += "y: {0,8:F2}`n" -f $DaytonCharacter.yPos()
				$newposLabel += "z: {0,8:F2}`n" -f $DaytonCharacter.zPos()
				
				$currid = $DaytonCharacter.ID()
				
				$eptr = $Enclave.BaseAddress		#Enclave
				
				$numchars = RInt32 ($eptr + [Int64]0x3a0)
				$newPanelHeight = 170
				if ($numchars -gt 0) {
					$newHpLabel += "  LastName        HP      Ftg    Sck      Plg`n"
					for ($i = 0; $i -le $numchars - 1; $i++) {
						$newPanelHeight += 32
						$cptr = RInt64 ($eptr + [Int64]0x398)
						$cptr = RInt64 ($cptr + [Int64]($i * 8))
						
						$char = [DaytonCharacter]::new($cptr)

						$lastName = ($cptr + [Int64]0x3a0)
						
						$lastName = RInt64 ($cptr + [Int64]0x398)
						$lastName = RInt64 ($lastName + [Int64]0x28)
						$lastName = RUnicodeStr ($lastName)

						$newHpLabel += "{0,-15} {1,6:F2}, {2,6:F2}, {3,6:F2}, {4,6:F2}"           -f $lastName, $char.currHealth(), $char.currFatigue(), $char.currSick(), $char.currPlague()
						if ($currId -eq $char.ID()) {
							$newHpLabel += " *"
						}
						$newHpLabel +="`n"
					}
				}
				if ($newPanelHeight -ne $oldpanelheight) {
					$bgPanel.Height = $newPanelHeight
				}
				$oldpanelheight = $bgPanel.Height
			} 
		}
		
		if ($timeLabel.Visible) {
			$tptr = RInt64 ($worldPtr)
			$tptr = RInt64 ($tptr + [Int64]0x110)		#GameMode
			$tptr = RInt64 ($tptr + [Int64]0x4c8)		#Spawner
			$tod = RSingle ($tptr + [Int64]0x558)
			
			$hourPart = [math]::Floor($tod / 100)
			$fracPart = ($tod % 100) / 100
			$totalSeconds = [math]::Round(3600 * $fracPart)
			$minutes = [math]::Floor($totalSeconds / 60)
			$seconds = $totalSeconds % 60
			if ($minutes -eq 60) {
				$minutes = 0
				$hourPart++
			}
			if ($seconds -eq 60) {
				$seconds = 0
				$minutes++
			}
			$result = ("{0:D2}:{1:D2}:{2:D2}" -f ([int]$hourPart), ([int]$minutes), ([int]$seconds))


			$newTimeLabel = $result
		}
		
		if ($followerLabel.Visible) {
			$World = [World]::new((RInt64 ($worldPtr)))
			$GameInstance = $World.GameInstance()
			$LocalPlayer = $GameInstance.LocalPlayer()
			$PlayerController = $LocalPlayer.PlayerController()
			$FollowerManager = $PlayerController.FollowerManager()
			$newFollowerLabel = ""
			If ($FollowerManager.numFollowers() -gt 0) {
				$Follower = $FollowerManager.Follower()
				$newFollowerLabel += "FOLLOWER`n"
				$newFollowerLabel += "Health:    {0,6:N2} / {1,6:N2}`n" -f $Follower.currHealth(), $Follower.maxHealthBase()
				$newFollowerLabel += "Stamina:   {0,6:N2} / {1,6:N2}`n" -f $Follower.currStam(), $Follower.maxStaminaBase()
				$newFollowerLabel += "Sick:      {0,6:N2} / {1,6:N2}`n" -f $Follower.currSick(), $Follower.maxSick()
				$newFollowerLabel += "Plague:    {0,6:N2} / {1,6:N2}`n" -f $Follower.currPlague(), $Follower.maxPlague()
				$newFollowerLabel += "Fatigue:   {0,6:N2}`n"           -f $Follower.currFatigue()
				$newFollowerLabel += "Standing:  {0,6:N2}`n"           -f $Follower.currStanding()
			}
		}
		
		
		
		if ($skillLabel.Visible) {
			$cptr = RInt64 ($worldPtr)	#world
			$cptr = RInt64 ($cptr + [Int64]0x140)	#GameInstance
			$cptr = RInt64 ($cptr + [Int64]0x38)	#localPlayer
			$cptr = RInt64 ($cptr)
			$cptr = RInt64 ($cptr + [Int64]0x30)	#playerController
			$cptr = RInt64 ($cptr + [Int64]0x368)	#DaytonHumanCharacter
			if ((RInt64 ($cptr)) -eq [Int64]($daytonVehicleVtPtr)) {	#if in vehicle
				$cptr = RInt64 ($cptr + [Int64]0x4a0)
			}
			$cptr = RInt64 ($cptr + [Int64]0xba0)	#charactercomponent
			$cptr = RInt64 ($cptr + [Int64]0x190)	#daytonCharacter
			
			$skillptr = $cptr + [Int64]0x368		#daytonCharacterRecord
			$numskills = RInt32 ($skillptr + [Int64]0xf0)
			$skillptr = RInt64 ($skillptr + [Int64]0xe8)
			if ($numskills -gt 0) {
				$newSkillLabel = ""
				for ($i = 0; $i -le $numskills -1; $i++) {
					$skillnameid = RInt32 $skillptr
					$skillname = GetNameFromNameOffset $skillnameid
					$skillLvl = RBytes ($skillptr + [Int64]0x8) 1
					$skillXp = RSingle ($skillptr + [Int64]0xc)
					$skillPtr += [Int64]0x18
					$newSkillLabel += "{0,8:F2}   {1,1:F0}*  {2,-10}`n" -f $skillXp, $skillLvl, $skillname
				}
			}
		}
		
		
		if ($meleeLabel.Visible) {
			$cptr = RInt64 ($worldPtr)	#world
			$cptr = RInt64 ($cptr + [Int64]0x140)	#GameInstance
			$cptr = RInt64 ($cptr + [Int64]0x38)	#localPlayer
			$cptr = RInt64 ($cptr)
			$cptr = RInt64 ($cptr + [Int64]0x30)	#playerController
			$cptr = RInt64 ($cptr + [Int64]0x368)	#DaytonHumanCharacter
			if ((RInt64 ($cptr)) -eq [Int64]($daytonVehicleVtPtr)) {		#if in vehicle
				$cptr = RInt64 ($cptr + [Int64]0x4a0)
			}
			$cptr = RInt64 ($cptr + [Int64]0xba0)	#charactercomponent
			$cptr = RInt64 ($cptr + [Int64]0x190)	#daytonCharacter
			$cptr = ($cptr + [Int64]0x368)			#DaytonCharacterRecord
			$cptr = RInt64 ($cptr + [Int64]0xd0)	#Equipment
			$cptr = RInt64 ($cptr + [Int64]0x38)	#EquipmentSlots
			$cptr = RInt64 ($cptr + [Int64]0x0)		#EquipmentSlot1, Melee
			$dura = RSingle ($cptr + [Int64]0x169c)	#Durability
			
			$cptr = RInt64 ($cptr + [Int64]0xf8)	#FinalStats
			$cptr = ($cptr + [Int64]0x28)			#MeleeWeaponResource
			
			$dismember = RSingle ($cptr + [Int64]0xc)
			$dismemberDelta = RSingle ($cptr + [Int64]0x14)
			$impact = RSingle ($cptr + [Int64]0x1c)
			$impactDelta = RSingle ($cptr + [Int64]0x24)
			$knockdown = RSingle ($cptr + [Int64]0x2c)
			$knockdownDelta = RSingle ($cptr + [Int64]0x34)
			$lethality = RSingle ($cptr + [Int64]0x3c)
			$lethalityDelta = RSingle ($cptr + [Int64]0x44)
			$Weight = RSingle ($cptr + [Int64]0x4c)
			$loudness = RSingle ($cptr + [Int64]0x54)
			$Speed = RSingle ($cptr + [Int64]0x5c)
			$swingCost = RSingle ($cptr + [Int64]0x64)
			$InfluenceValue = RSingle ($cptr + [Int64]0x6c)
			$PrestigeValue = RSingle ($cptr + [Int64]0x74)
			$Durability = RSingle ($cptr + [Int64]0x7c)
			$DurabilityLossPerHitMin = RSingle ($cptr + [Int64]0x84)
			$DurabilityLossPerHitMax = RSingle ($cptr + [Int64]0x8c)
			$DurabilityLossPerFinishMin = RSingle ($cptr + [Int64]0x94)
			$DurabilityLossPerFinishMax = RSingle ($cptr + [Int64]0x9c)
			
			$MeleeType = RInt64 ($cptr + [Int64]0xb0)
			$MeleeType = RUnicodeStr $MeleeType
			
			$weapName = RInt64 ($cptr + [Int64]0xa0)
			$weapName = RUnicodeStr $weapName
			
			$weapName = $weapName -replace '\{\[[^\]]+\][^\}]*\}', ''
			$weapName = $weapName -replace '{!v}', ''
			
			$newmeleeLabel = ""
			if ($cptr -gt 0) {
				$newmeleeLabel += "$weapName`n"
				$newmeleeLabel += "$MeleeType`n"
				$newmeleeLabel += "Impact:          {0,8:F4}`n" -f $impact
				$newmeleeLabel += "ImpactDelta:     {0,8:F4}`n" -f $impactDelta
				$newmeleeLabel += "Knockdown:       {0,8:F4}`n" -f $knockdown
				$newmeleeLabel += "KnockdownDelta:  {0,8:F4}`n" -f $knockdownDelta
				$newmeleeLabel += "Lethality:       {0,8:F4}`n" -f $lethality
				$newmeleeLabel += "LethalityDelta:  {0,8:F4}`n" -f $lethalityDelta
				$newmeleeLabel += "Weight:          {0,8:F4}`n" -f $weight
				$newmeleeLabel += "Loudness:        {0,8:F4}`n" -f $loudness
				$newmeleeLabel += "Speed:           {0,8:F4}`n" -f $Speed
				$newmeleeLabel += "SwingCost:       {0,8:F4}`n" -f $swingCost
				$newmeleeLabel += "InfluenceValue:  {0,8:F4}`n" -f $InfluenceValue
				$newmeleeLabel += "PrestigeValue:   {0,8:F4}`n" -f $PrestigeValue
				$newmeleeLabel += "Dura/Hit Min:    {0,8:F4}`n" -f $DurabilityLossPerHitMin
				$newmeleeLabel += "Dura/Hit Max:    {0,8:F4}`n" -f $DurabilityLossPerHitMax
				$newmeleeLabel += "Dura/Finish Min: {0,8:F4}`n" -f $DurabilityLossPerFinishMin
				$newmeleeLabel += "Dura/Finish Max: {0,8:F4}`n" -f $DurabilityLossPerFinishMax
				$newmeleeLabel += "Durability:      {0,8:F4} / {1,6:F2}`n" -f $dura, $Durability
			}
		}
		
		if ($rangedLabel.Visible) {
			$World = [World]::new((RInt64 ($worldPtr)))
			$GameInstance = $World.GameInstance()
			$LocalPlayer = $GameInstance.LocalPlayer()
			$PlayerController = $LocalPlayer.PlayerController()
			$DaytonHumanCharacter = $PlayerController.DaytonHumanCharacter()
			$CharacterComponent = $DaytonHumanCharacter.CharacterComponent()
			$DaytonCharacter = $CharacterComponent.DaytonCharacter()
			
			$eqptr = RInt64 ([Int64]$DaytonCharacter.BaseAddress  + 0x368 + 0xd0)
			$eqptr = RInt64 ([Int64]$eqptr + 0x38)
			$eqptr = RInt64 ([Int64]$eqptr + 0x8)
			$dura = RSingle ($eqptr + [Int64]0x60)	#Durability
			
			$eqptr = RInt64 ([Int64]$eqptr + 0x70)
			$eqptr = RInt64 ([Int64]$eqptr + 0x28)
			
			$weapstats = [RangedWeaponResourceStats]::new($eqptr)
			
			$newrangedLabel = ""
			if ($eqptr -gt 0) {
				#$weapName = RUnicodeStr(RInt64([Int64]$eqptr + 0x48))
				$weapName = $weapstats.WeapName()
				$weapName = $weapName -replace '\{\[[^\]]+\][^\}]*\}', ''
				$weapName = $weapName -replace '{!v}', ''
				
				
				$newrangedLabel += $weapName + "`n"
				$newrangedLabel += $weapStats.WeapType() + "`n"
				$newrangedLabel += "Impact:          {0,8:F4}`n" -f $weapStats.Impact()
				$newrangedLabel += "ImpactDelta:     {0,8:F4}`n" -f $weapStats.impactDelta()
				$newrangedLabel += "Knockdown:       {0,8:F4}`n" -f $weapStats.knockdown()
				$newrangedLabel += "KnockdownDelta:  {0,8:F4}`n" -f $weapStats.knockdownDelta()
				$newrangedLabel += "Dismember:       {0,8:F4}`n" -f $weapStats.Dismember()
				$newrangedLabel += "DismemberDelta:  {0,8:F4}`n" -f $weapStats.DismemberDelta()
				$newrangedLabel += "Weight:          {0,8:F4}`n" -f $weapStats.weight()
				$newrangedLabel += "Loudness:        {0,8:F4}`n" -f $weapStats.PerceptionLoudness()
				$newrangedLabel += "InfluenceValue:  {0,8:F4}`n" -f $weapStats.InfluenceValue()
				$newrangedLabel += "Durability:      {0,8:F4} / {1,6:F2}`n" -f $dura, $weapStats.MaxDurability()
			}
		}
		
		
		if ($vehicleLabel.Visible) {
			$vptr = RInt64 ($worldPtr)	#world
			$vptr = RInt64 ($vptr + [Int64]0x140)	#GameInstance
			$vptr = RInt64 ($vptr + [Int64]0x38)	#localPlayer
			$vptr = RInt64 ($vptr)
			$vptr = RInt64 ($vptr + [Int64]0x30)	#playerController
			$vptr = RInt64 ($vptr + [Int64]0x368)	#DaytonVehicle
			

			
			
			$newVehicleLabel = ""
			if ((RInt64 ($vptr)) -eq [Int64]($daytonVehicleVtPtr)) {	#if in vehicle
				$vdptr = RInt64 ($vptr + [Int64]0x438)	#Damage
				$vmcptr = RInt64 ($vptr + [Int64]0x3d8)	#movement
				
				$defptr = RInt64 ($vptr + [Int64]0x478)
				$defptr = RInt64 ($defptr + [Int64]0x100)

				$currFuel = RSingle ($vmcptr + [Int64]0x478)
				$currFuel *= 100
				
				$engineDamage = RSingle ($vdptr + [Int64]0x150)
				$frameDamage = RSingle ($vdptr + [Int64]0x154)
				$gasTankDamage = RSingle ($vdptr + [Int64]0x158)
				
				$carname = RInt64 ($defptr + 0xa8)
				$carname = RInt64 ($carname + 0x8)
				$carname = RInt64 ($carname)
				$carname = RUnicodeStr ($carname)
				
				$cartype = RInt64 ($defptr + 0xc0)
				$cartype = RInt64 ($cartype + 0x8)
				$cartype = RInt64 ($cartype)
				$cartype = RUnicodeStr ($cartype)
				
				$fueldefptr = RInt64 ($defptr + 0x40)
				$fueldefptr = RInt64 ($fueldefptr + 0x100)
				$fuelcapacity = RSingle ($fueldefptr + 0x28)
				$idlecon = RSingle ($fueldefptr + 0x2c)
				$conpm = RSingle ($fueldefptr + 0x30)
				
				$newVehicleLabel += $carname + "`n"
				$newVehicleLabel += $cartype + "`n"
				$newVehicleLabel += "Fuel Capacity:      {0,6:F2}`n"           -f $fuelcapacity
				$newVehicleLabel += "Fuel Idle Cons:     {0,6:F2}`n"           -f $idlecon
				$newVehicleLabel += "Fuel 7500rpm Cons:  {0,6:F2}`n"           -f $conpm
				$newVehicleLabel += "Fuel:               {0,6:N2}`n"           -f $currFuel
				$newVehicleLabel += "Engine Damage:      {0,6:N2}`n"           -f $engineDamage
				$newVehicleLabel += "Frame Damage:       {0,6:N2}`n"           -f $frameDamage
				$newVehicleLabel += "Gas Tank Damage:    {0,6:N2}`n"           -f $gasTankDamage
				$newVehicleLabel += "`n"
				
				$newVehicleLabel += "Damage Zones:`n"
				$numZones = RInt32 ($vdptr + [Int64]0x188)
				$damZones = RInt64 ($vdptr + [Int64]0x180)
				for ($i = 0; $i -le $numZones - 1; $i++) {
					$damval = RSingle ($damZones + [Int64]($i * 4))
					$newVehicleLabel += "{0,6:N2}    " -f $damval
					if (($i % 3) -eq 2) {
						$newVehicleLabel += "`n"
					}
				}
			}
		}
		
		
		
		#PhDamageMults
		#[[[<StateOfDecay2-Win64-Ship>+45d7c88]+110]+530]
		if ($phLabel.Visible) {
			$cmptr = RInt64 ($worldPtr)
			$cmptr = RInt64 ($cmptr + [Int64]0x110)		#GameMode
			$cmptr = RInt64 ($cmptr + [Int64]0x530)		#ChallengeModeComponent
			
			
			$newPhLabel = ""
			$dmgmult = RSingle ($cmptr + [Int64]0x638)
			$newPhLabel += "Melee:      {0,6:N4}`n"           -f $dmgmult
			$dmgmult = RSingle ($cmptr + [Int64]0x63c)
			$newPhLabel += "Ranged:     {0,6:N4}`n"           -f $dmgmult
			$dmgmult = RSingle ($cmptr + [Int64]0x640)
			$newPhLabel += "Explosive:  {0,6:N4}`n"           -f $dmgmult
			$dmgmult = RSingle ($cmptr + [Int64]0x644)
			$newPhLabel += "Fire:       {0,6:N4}`n"           -f $dmgmult
			$dmgmult = RSingle ($cmptr + [Int64]0x648)
			$newPhLabel += "Vehicle:    {0,6:N4}`n"           -f $dmgmult
			$newPhLabel += "`n"
			
			#[[[[<StateOfDecay2-Win64-Ship>+45d7c88]+58]+4a8]+140]
			$pnmptr = RInt64 ($worldPtr)
			$pnmptr = RInt64 ($pnmptr + [Int64]0x58)		#GameState
			$pnmptr = RInt64 ($pnmptr + [Int64]0x4a8)		#PlagueNodeManager
			$numph = RInt32 ($pnmptr + [Int64]0x148)
			$pnmptr = RInt64 ($pnmptr + [Int64]0x140)		#PlagueNodes
			if ($numph -gt 0) {
				$newPhLabel += "      Num       HP`n"
				for ($i = 0; $i -le $numph - 1; $i++) {
					$phptr = RInt64 ($pnmptr + [Int64](0x28 * $i))
					
					$id = $i
					$hp = RSingle ($phptr + [Int64]0x14b8)
					
					$newPhLabel += "   {0,4:F0}:  {1,8:F4}"           -f $id, $hp
					$newPhLabel +="`n"
				}
			}
		}

		
		
		if ($hpLabel.Text -ne $newHpLabel) {
			$hpLabel.Text = $newHpLabel
			$hpLabel.PerformLayout()
		}
		
		if ($timeLabel.Text -ne $newTimeLabel) {
			$timeLabel.Text = $newTimeLabel
			$timeLabel.PerformLayout()
		}
		
		if ($followerLabel.Text -ne $newfollowerLabel) {
			$followerLabel.Text = $newfollowerLabel
			$followerLabel.PerformLayout()
		}
		
		if ($phLabel.Text -ne $newPhLabel) {
			$phLabel.Text = $newPhLabel
			$phLabel.PerformLayout()
		}
		
		if ($skillLabel.Text -ne $newSkillLabel) {
			$skillLabel.Text = $newSkillLabel
			$skillLabel.PerformLayout()
		}
		
		if ($vehicleLabel.Text -ne $newVehicleLabel) {
			$vehicleLabel.Text = $newVehicleLabel
			$vehicleLabel.PerformLayout()
		}
		
		if ($meleeLabel.Text -ne $newmeleeLabel) {
			$meleeLabel.Text = $newmeleeLabel
			$meleeLabel.PerformLayout()
		}
		
		if ($rangedLabel.Text -ne $newrangedLabel) {
			$rangedLabel.Text = $newrangedLabel
			$rangedLabel.PerformLayout()
		}
		
		if ($posLabel.Text -ne $newposLabel) {
			$posLabel.Text = $newposLabel
			$posLabel.PerformLayout()
		}
		
		$mouseLabel.Text = "$NormalizedX, $NormalizedY"
		#make positive to display mouse position, for label positioning
		$x = $ScreenWidth * 0.9
		$y = $ScreenHeight * 0.95
		$mouseLabel.Location = New-Object System.Drawing.Point($x, $y)
		
		
		$x = $ScreenWidth * 0.025
		$y = $ScreenHeight * 0.35
		$bgPanel.Location = New-Object System.Drawing.Point($x, $y)
		
		
		$x = 5
		$y = 5
		$hpLabel.Location = New-Object System.Drawing.Point($x, $y)
		
		$x = $ScreenWidth * 0.07
		$y = $ScreenHeight * 0.93
		$timeLabel.Location = New-Object System.Drawing.Point($x, $y)
		
		$x = $ScreenWidth * 0.025
		$y = $ScreenHeight * 0.35
		$followerLabel.Location = New-Object System.Drawing.Point($x, $y)
		
		$x = $ScreenWidth * 0.9
		$y = $ScreenHeight * 0.35
		$phLabel.Location = New-Object System.Drawing.Point($x, $y)
		
		$x = $ScreenWidth * 0.285
		$y = $ScreenHeight * 0.8
		$skillLabel.Location = New-Object System.Drawing.Point($x, $y)
		
		$x = $ScreenWidth * 0.025
		$y = $ScreenHeight * 0.29
		$vehicleLabel.Location = New-Object System.Drawing.Point($x, $y)
		
		$x = $ScreenWidth * 0.025
		$y = $ScreenHeight * 0.29
		$meleeLabel.Location = New-Object System.Drawing.Point($x, $y)
		
		$x = $ScreenWidth * 0.025
		$y = $ScreenHeight * 0.29
		$rangedLabel.Location = New-Object System.Drawing.Point($x, $y)
		
		$x = $ScreenWidth * 0.025
		$y = $ScreenHeight * 0.29
		$posLabel.Location = New-Object System.Drawing.Point($x, $y)
	})

	$timer.Start()
	$form.ShowDialog()
	$form.Add_FormClosed({
		$timer.Dispose()
	})
}

pause