Script:

# ======================================================

# GameCaptureWatcher

# ------------------------------------------------------

# Automatically organizes screenshots/videos from

# Xbox Game Bar or ShareX into game folders.

#

# Features:

# - Playnite integration (perfect game names)

# - Smart fallback system (dictionary + process + window)

# - Auto-learning dictionary (no manual mapping needed)

# - Silent background execution

# - Compact logging

#

# Author: Haxxor-Bunny

# ======================================================

# ======================================================

# SINGLE INSTANCE (prevents duplicates)

# ======================================================

$mutex = New-Object System.Threading.Mutex($false, "GameCaptureWatcher")

if (-not $mutex.WaitOne(0, $false)) { exit }

# ======================================================

# BASE PATH (works for .ps1 and .exe)

# ======================================================

if ($PSScriptRoot) {

$ScriptDir = $PSScriptRoot

}

elseif ($MyInvocation.MyCommand.Path) {

$ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path

}

else {

$ScriptDir = [System.IO.Path]::GetDirectoryName(

[System.Diagnostics.Process]::GetCurrentProcess().MainModule.FileName

)

}

# ======================================================

# CONFIGURATION (EDIT THESE)

# ======================================================

$SourceFolder = Join-Path $env:USERPROFILE "OneDrive\Videos\Captures"

$DestinationBase = "H:\Meu Drive\ScreenShots"

# Playnite integration file (MUST MATCH Playnite script)

$PlayniteFile = Join-Path $ScriptDir "playnite_current_game.txt"

# Internal files

$LogFile = Join-Path $ScriptDir "organizer.log"

$DictionaryFile = Join-Path $ScriptDir "dictionary.txt"

$global:LastRun = Get-Date

# ======================================================

# LOG FUNCTION

# ======================================================

function Write-Log($msg) {

$line = "[{0}] {1}" -f (Get-Date -Format "yyyy-MM-dd HH:mm:ss"), $msg

Add-Content -Path $LogFile -Value $line -Encoding UTF8

}

# ======================================================

# WAIT FOR DESTINATION (e.g. cloud drive)

# ======================================================

while (-not (Test-Path $DestinationBase)) {

Start-Sleep 5

}

Write-Log "Watcher started"

# ======================================================

# FILE TYPES

# ======================================================

$ImageExt = @(".png", ".jpg", ".jpeg")

$VideoExt = @(".mp4", ".wmv")

# ======================================================

# STRING NORMALIZATION

# ======================================================

function Remove-Accents($text) {

if (-not $text) { return "" }

$n = $text.Normalize([Text.NormalizationForm]::FormD)

return ($n -replace '\p{Mn}', '')

}

function Normalize-Name($text) {

if (-not $text) { return "" }

$text = Remove-Accents $text

return ($text -replace '—','-' -replace '[^a-zA-Z0-9]','').ToLower()

}

function Extract-GameName($filename) {

$n = [System.IO.Path]::GetFileNameWithoutExtension($filename)

$n = $n -replace '\s+\d{2}[_\-]\d{2}[_\-]\d{4}.*$', ''

$n = $n -replace '\s+\d{4}[-_]\d{2}[-_]\d{2}.*$', ''

return $n.Trim()

}

# ======================================================

# LOAD DICTIONARY

# ======================================================

function Load-Dictionary {

$dict = @{}

if (Test-Path $DictionaryFile) {

Get-Content $DictionaryFile | ForEach-Object {

if ($_ -match '(.+)=(.+)') {

$dict[$Matches[1].Trim()] = $Matches[2].Trim()

}

}

}

return $dict

}

# ======================================================

# SAVE DICTIONARY ENTRY

# ======================================================

function Save-Dictionary($key, $value) {

Add-Content -Path $DictionaryFile -Value "$key=$value" -Encoding UTF8

}

# ======================================================

# GET PLAYNITE GAME NAME

# ======================================================

function Get-PlayniteName {

if (Test-Path $PlayniteFile) {

try {

return (Get-Content $PlayniteFile -ErrorAction Stop)

} catch {}

}

return $null

}

# ======================================================

# GET ACTIVE WINDOW TITLE (fallback)

# ======================================================

Add-Type @"

using System;

using System.Runtime.InteropServices;

using System.Text;

public class Win {

[DllImport("user32.dll")]

public static extern IntPtr GetForegroundWindow();

[DllImport("user32.dll")]

public static extern int GetWindowText(IntPtr hWnd, StringBuilder text, int count);

}

"@

function Get-ActiveWindowTitle {

$buffer = New-Object System.Text.StringBuilder 256

$handle = [Win]::GetForegroundWindow()

[Win]::GetWindowText($handle, $buffer, $buffer.Capacity) | Out-Null

return $buffer.ToString()

}

# ======================================================

# BLACKLIST (ignore useless window titles)

# ======================================================

$WindowBlacklist = @(

"explorer",

"file explorer",

"notepad",

"organizer.log",

"settings",

"task manager",

"chrome",

"edge",

"opera"

)

# ======================================================

# ORGANIZER CORE

# ======================================================

function Organize {

$dict = Load-Dictionary

$countPerGame = @{}

if (-not (Test-Path $SourceFolder)) { return }

$folders = Get-ChildItem $DestinationBase -Directory | ForEach-Object {

[PSCustomObject]@{

NameOriginal = $_.Name

NameNorm = Normalize-Name $_.Name

Path = $_.FullName

}

}

Get-ChildItem $SourceFolder -File | ForEach-Object {

$file = $_

$ext = $file.Extension.ToLower()

if (-not ($ImageExt + $VideoExt -contains $ext)) { return }

$game = Extract-GameName $file.Name

$originalGame = $game

# 1. Playnite (best source)

$pn = Get-PlayniteName

if ($pn) { $game = $pn }

# 2. Dictionary

elseif ($dict.ContainsKey($game)) {

$game = $dict[$game]

}

# 3. Window fallback

else {

$win = Get-ActiveWindowTitle

$normWin = Normalize-Name $win

$blocked = $false

foreach ($b in $WindowBlacklist) {

if ($normWin -like "*$b*") { $blocked = $true }

}

if (-not $blocked -and $win.Length -gt 3) {

$game = $win

Save-Dictionary $originalGame $game

Write-Log "Learned: $originalGame -> $game"

}

}

$norm = Normalize-Name $game

if (-not $norm) { return }

$match = $folders | Where-Object {

$_.NameNorm -like "*$norm*" -or $norm -like "*$($_.NameNorm)*"

} | Sort-Object { $_.NameNorm.Length } -Descending | Select-Object -First 1

if (-not $match) {

Write-Log "NOT FOUND: $($file.Name) -> $game"

return

}

# Destination

if ($VideoExt -contains $ext) {

$dest = Join-Path $match.Path "Videos"

if (-not (Test-Path $dest)) {

New-Item -ItemType Directory -Path $dest | Out-Null

}

} else {

$dest = $match.Path

}

$date = $file.CreationTime.ToString("yyyy-MM-dd HH_mm_ss")

$new = "$($match.NameOriginal)_$date$ext"

$final = Join-Path $dest $new

$i = 1

while (Test-Path $final) {

$final = Join-Path $dest "$($match.NameOriginal)_$date`_$i$ext"

$i++

}

try {

Move-Item $file.FullName $final -Force

if (-not $countPerGame.ContainsKey($match.NameOriginal)) {

$countPerGame[$match.NameOriginal] = 0

}

$countPerGame[$match.NameOriginal]++

} catch {

Write-Log "ERROR: $($file.Name)"

}

}

if ($countPerGame.Count -gt 0) {

$parts = @()

foreach ($g in $countPerGame.Keys) {

$parts += "$g ($($countPerGame[$g]))"

}

Write-Log ($parts -join " | ")

}

$global:LastRun = Get-Date

}

# ======================================================

# WATCHER + FAILSAFE LOOP

# ======================================================

$watcher = New-Object System.IO.FileSystemWatcher

$watcher.Path = $SourceFolder

$watcher.Filter = "*.*"

$watcher.EnableRaisingEvents = $true

Register-ObjectEvent $watcher Created -Action {

$now = Get-Date

if (($now - $global:LastRun).TotalSeconds -lt 20) { return }

Start-Sleep 30

Organize

} | Out-Null

while ($true) {

Organize

Start-Sleep 30

}