Working materials with two modes - binary and continuous

Assets/Art/Materials/TrashMaze.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 59f400cf78b0d3949a1280b33dd96e3c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Art/Materials/TrashMaze/MazeBackground.mat

@@ -0,0 +1,59 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: MazeBackground
+  m_Shader: {fileID: 4800000, guid: b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords: []
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AlphaTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _LitTex:
+        m_Texture: {fileID: 2800000, guid: 2355d01d9d23cfe49a3e05ea9b4958e6, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _UnlitTex:
+        m_Texture: {fileID: 2800000, guid: 979d8dc9d4d55f043b7426e437365c30, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _EnableExternalAlpha: 0
+    - _TransitionSoftness: 0
+    - _ZWrite: 0
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _RendererColor: {r: 1, g: 1, b: 1, a: 1}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1

Assets/Art/Materials/TrashMaze/MazeBackground.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 943d8f5cb68e5d64ea448054ba6c28f0
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Art/Materials/TrashMaze/MazeObjectProgressiveTemplate.mat

@@ -0,0 +1,59 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: MazeObjectProgressiveTemplate
+  m_Shader: {fileID: 4800000, guid: 732fa975ac924d89bb0078279d2cdb0b, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords: []
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AlphaTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OutlineTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _RevealMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _EnableExternalAlpha: 0
+    - _IsInVision: 0
+    - _ZWrite: 0
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _RendererColor: {r: 1, g: 1, b: 1, a: 1}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1

Assets/Art/Materials/TrashMaze/MazeObjectProgressiveTemplate.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6e053220514a0c64883d9484863533fe
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Art/Materials/TrashMaze/MazeObjectTemplate.mat

@@ -0,0 +1,56 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: MazeObjectTemplate
+  m_Shader: {fileID: 4800000, guid: c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords: []
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AlphaTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OutlineTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _EnableExternalAlpha: 0
+    - _IsInVision: 0
+    - _IsRevealed: 0
+    - _ZWrite: 0
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _RendererColor: {r: 1, g: 1, b: 1, a: 1}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1

Assets/Art/Materials/TrashMaze/MazeObjectTemplate.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 07b06abfc5d910b4a8c525979cd29f29
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Placeholders/dark_maze.png.meta

@@ -0,0 +1,195 @@
+fileFormatVersion: 2
+guid: 979d8dc9d4d55f043b7426e437365c30
+TextureImporter:
+  internalIDToNameTable:
+  - first:
+      213: 5438675420682048811
+    second: dark_maze_0
+  externalObjects: {}
+  serializedVersion: 13
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 2
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites:
+    - serializedVersion: 2
+      name: dark_maze_0
+      rect:
+        serializedVersion: 2
+        x: 0
+        y: 0
+        width: 2048
+        height: 2048
+      alignment: 0
+      pivot: {x: 0, y: 0}
+      border: {x: 0, y: 0, z: 0, w: 0}
+      customData: 
+      outline: []
+      physicsShape: []
+      tessellationDetail: -1
+      bones: []
+      spriteID: b25d662da7e0a7b40800000000000000
+      internalID: 5438675420682048811
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable:
+      dark_maze_0: 5438675420682048811
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Placeholders/item_normal.png.meta

@@ -0,0 +1,195 @@
+fileFormatVersion: 2
+guid: 22bb2c64be7aa8e438277c533ecb8bee
+TextureImporter:
+  internalIDToNameTable:
+  - first:
+      213: -9213196934004512817
+    second: item_normal_0
+  externalObjects: {}
+  serializedVersion: 13
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 2
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites:
+    - serializedVersion: 2
+      name: item_normal_0
+      rect:
+        serializedVersion: 2
+        x: 0
+        y: 0
+        width: 385
+        height: 257
+      alignment: 0
+      pivot: {x: 0, y: 0}
+      border: {x: 0, y: 0, z: 0, w: 0}
+      customData: 
+      outline: []
+      physicsShape: []
+      tessellationDetail: -1
+      bones: []
+      spriteID: fc761feb336242080800000000000000
+      internalID: -9213196934004512817
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable:
+      item_normal_0: -9213196934004512817
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Placeholders/item_outline.png.meta

@@ -0,0 +1,195 @@
+fileFormatVersion: 2
+guid: 0559a1e87cd8a434f9647206f5ea237e
+TextureImporter:
+  internalIDToNameTable:
+  - first:
+      213: 8669786265954709882
+    second: item_outline_0
+  externalObjects: {}
+  serializedVersion: 13
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 2
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites:
+    - serializedVersion: 2
+      name: item_outline_0
+      rect:
+        serializedVersion: 2
+        x: 0
+        y: 0
+        width: 385
+        height: 257
+      alignment: 0
+      pivot: {x: 0, y: 0}
+      border: {x: 0, y: 0, z: 0, w: 0}
+      customData: 
+      outline: []
+      physicsShape: []
+      tessellationDetail: -1
+      bones: []
+      spriteID: a717ac4aca4415870800000000000000
+      internalID: 8669786265954709882
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable:
+      item_outline_0: 8669786265954709882
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/External/Placeholders/light_maze.png.meta

@@ -0,0 +1,195 @@
+fileFormatVersion: 2
+guid: 2355d01d9d23cfe49a3e05ea9b4958e6
+TextureImporter:
+  internalIDToNameTable:
+  - first:
+      213: 8777077890197170708
+    second: light_maze_0
+  externalObjects: {}
+  serializedVersion: 13
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 2
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites:
+    - serializedVersion: 2
+      name: light_maze_0
+      rect:
+        serializedVersion: 2
+        x: 0
+        y: 0
+        width: 2048
+        height: 2048
+      alignment: 0
+      pivot: {x: 0, y: 0}
+      border: {x: 0, y: 0, z: 0, w: 0}
+      customData: 
+      outline: []
+      physicsShape: []
+      tessellationDetail: -1
+      bones: []
+      spriteID: 41a232396d17ec970800000000000000
+      internalID: 8777077890197170708
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable:
+      light_maze_0: 8777077890197170708
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Prefabs/Levels/Dump/MazeBackground.prefab

@@ -0,0 +1,93 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &20851209822974582
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 8861526539906903110}
+  - component: {fileID: 6548959094921542577}
+  m_Layer: 0
+  m_Name: MazeBackground
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &8861526539906903110
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 20851209822974582}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 10.8, z: 0}
+  m_LocalScale: {x: 2, y: 2, z: 2}
+  m_ConstrainProportionsScale: 1
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!212 &6548959094921542577
+SpriteRenderer:
+  serializedVersion: 2
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 20851209822974582}
+  m_Enabled: 1
+  m_CastShadows: 0
+  m_ReceiveShadows: 0
+  m_DynamicOccludee: 1
+  m_StaticShadowCaster: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 0
+  m_RayTraceProcedural: 0
+  m_RayTracingAccelStructBuildFlagsOverride: 0
+  m_RayTracingAccelStructBuildFlags: 1
+  m_SmallMeshCulling: 1
+  m_ForceMeshLod: -1
+  m_MeshLodSelectionBias: 0
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 943d8f5cb68e5d64ea448054ba6c28f0, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 1
+  m_SelectedEditorRenderState: 0
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_GlobalIlluminationMeshLod: 0
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_MaskInteraction: 0
+  m_Sprite: {fileID: 8777077890197170708, guid: 2355d01d9d23cfe49a3e05ea9b4958e6, type: 3}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_FlipX: 0
+  m_FlipY: 0
+  m_DrawMode: 0
+  m_Size: {x: 20.48, y: 20.48}
+  m_AdaptiveModeThreshold: 0.5
+  m_SpriteTileMode: 0
+  m_WasSpriteAssigned: 1
+  m_SpriteSortPoint: 0

Assets/Prefabs/Levels/Dump/MazeBackground.prefab.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: fe50f047edb550d4986d997281ffc47a
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Prefabs/Levels/Dump/Pulver.prefab

@@ -0,0 +1,222 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &7654873269754452578
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 2771277034307921359}
+  - component: {fileID: 1299144459295276776}
+  - component: {fileID: 2461082630725827914}
+  - component: {fileID: 6236765161241564569}
+  - component: {fileID: -8191421428015321370}
+  - component: {fileID: 1741228342480194746}
+  m_Layer: 0
+  m_Name: Pulver
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &2771277034307921359
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 7654873269754452578}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!212 &1299144459295276776
+SpriteRenderer:
+  serializedVersion: 2
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 7654873269754452578}
+  m_Enabled: 1
+  m_CastShadows: 0
+  m_ReceiveShadows: 0
+  m_DynamicOccludee: 1
+  m_StaticShadowCaster: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 0
+  m_RayTraceProcedural: 0
+  m_RayTracingAccelStructBuildFlagsOverride: 0
+  m_RayTracingAccelStructBuildFlags: 1
+  m_SmallMeshCulling: 1
+  m_ForceMeshLod: -1
+  m_MeshLodSelectionBias: 0
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 9dfc825aed78fcd4ba02077103263b40, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 1
+  m_SelectedEditorRenderState: 0
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_GlobalIlluminationMeshLod: 0
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_MaskInteraction: 0
+  m_Sprite: {fileID: 1814454124, guid: 8af0253099943e84e960c630bafbbdb4, type: 3}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_FlipX: 0
+  m_FlipY: 0
+  m_DrawMode: 0
+  m_Size: {x: 4.15, y: 4.58}
+  m_AdaptiveModeThreshold: 0.5
+  m_SpriteTileMode: 0
+  m_WasSpriteAssigned: 1
+  m_SpriteSortPoint: 0
+--- !u!114 &2461082630725827914
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 7654873269754452578}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: AppleHillsScripts::Minigames.TrashMaze.Core.PulverController
+  moveSpeed: 5
+  obstacleMask:
+    serializedVersion: 2
+    m_Bits: 64
+  colliderRadius: 0.5
+  visionRadius: 5
+--- !u!70 &6236765161241564569
+CapsuleCollider2D:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 7654873269754452578}
+  m_Enabled: 1
+  serializedVersion: 3
+  m_Density: 1
+  m_Material: {fileID: 0}
+  m_IncludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ExcludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_LayerOverridePriority: 0
+  m_ForceSendLayers:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_ForceReceiveLayers:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_ContactCaptureLayers:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_CallbackLayers:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_IsTrigger: 0
+  m_UsedByEffector: 0
+  m_CompositeOperation: 0
+  m_CompositeOrder: 0
+  m_Offset: {x: 0, y: 0}
+  m_Size: {x: 4.15, y: 4.58}
+  m_Direction: 0
+--- !u!114 &-8191421428015321370
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 7654873269754452578}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 373b52eb9bf8c40f785bb6947a1aee66, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: AstarPathfindingProject::Pathfinding.Seeker
+  version: 1
+  drawGizmos: 1
+  detailedGizmos: 0
+  startEndModifier:
+    addPoints: 0
+    exactStartPoint: 3
+    exactEndPoint: 3
+    useRaycasting: 0
+    mask:
+      serializedVersion: 2
+      m_Bits: 4294967295
+    useGraphRaycasting: 0
+  traversableTags: -1
+  tagPenalties: 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+  graphMask:
+    value: -1
+--- !u!114 &1741228342480194746
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 7654873269754452578}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: f6eb1402c17e84a9282a7f0f62eb584f, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: AstarPathfindingProject::Pathfinding.AIPath
+  version: 5
+  radius: 2
+  height: 1
+  canMove: 1
+  maxSpeed: 25
+  gravity: {x: 0, y: 0, z: 0}
+  groundMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  centerOffsetCompatibility: NaN
+  repathRateCompatibility: NaN
+  canSearchCompability: 0
+  orientation: 1
+  enableRotation: 0
+  autoRepath:
+    mode: 2
+    interval: 0.5
+    sensitivity: 10
+    maximumInterval: 5
+    visualizeSensitivity: 0
+  targetCompatibility: {fileID: 0}
+  maxAcceleration: 10000
+  rotationSpeed: 360
+  slowdownDistance: 0.6
+  pickNextWaypointDist: 2
+  endReachedDistance: 0.5
+  alwaysDrawGizmos: 1
+  slowWhenNotFacingTarget: 1
+  whenCloseToDestination: 0
+  constrainInsideGraph: 0

Assets/Prefabs/Levels/Dump/Pulver.prefab.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 182ee38fc449c6342b8a401844067b5b
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Prefabs/Levels/Dump/RevealableObject.prefab

@@ -0,0 +1,157 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &6259373434446242904
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 7983424933738472089}
+  - component: {fileID: 6487644332527623320}
+  - component: {fileID: 397845239581813408}
+  - component: {fileID: 3115580033298799659}
+  m_Layer: 0
+  m_Name: RevealableObject
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &7983424933738472089
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6259373434446242904}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!212 &6487644332527623320
+SpriteRenderer:
+  serializedVersion: 2
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6259373434446242904}
+  m_Enabled: 1
+  m_CastShadows: 0
+  m_ReceiveShadows: 0
+  m_DynamicOccludee: 1
+  m_StaticShadowCaster: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 0
+  m_RayTraceProcedural: 0
+  m_RayTracingAccelStructBuildFlagsOverride: 0
+  m_RayTracingAccelStructBuildFlags: 1
+  m_SmallMeshCulling: 1
+  m_ForceMeshLod: -1
+  m_MeshLodSelectionBias: 0
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 07b06abfc5d910b4a8c525979cd29f29, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 1
+  m_SelectedEditorRenderState: 0
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_GlobalIlluminationMeshLod: 0
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_MaskInteraction: 0
+  m_Sprite: {fileID: -9213196934004512817, guid: 22bb2c64be7aa8e438277c533ecb8bee, type: 3}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_FlipX: 0
+  m_FlipY: 0
+  m_DrawMode: 0
+  m_Size: {x: 3.85, y: 2.57}
+  m_AdaptiveModeThreshold: 0.5
+  m_SpriteTileMode: 0
+  m_WasSpriteAssigned: 1
+  m_SpriteSortPoint: 0
+--- !u!114 &397845239581813408
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6259373434446242904}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: AppleHillsScripts::Minigames.TrashMaze.Objects.RevealableObject
+  normalSprite: {fileID: -9213196934004512817, guid: 22bb2c64be7aa8e438277c533ecb8bee, type: 3}
+  outlineSprite: {fileID: 8669786265954709882, guid: 0559a1e87cd8a434f9647206f5ea237e, type: 3}
+  isBoosterPack: 0
+  isExit: 0
+--- !u!61 &3115580033298799659
+BoxCollider2D:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 6259373434446242904}
+  m_Enabled: 1
+  serializedVersion: 3
+  m_Density: 1
+  m_Material: {fileID: 0}
+  m_IncludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ExcludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_LayerOverridePriority: 0
+  m_ForceSendLayers:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_ForceReceiveLayers:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_ContactCaptureLayers:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_CallbackLayers:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_IsTrigger: 1
+  m_UsedByEffector: 0
+  m_CompositeOperation: 0
+  m_CompositeOrder: 0
+  m_Offset: {x: 0, y: 0}
+  m_SpriteTilingProperty:
+    border: {x: 0, y: 0, z: 0, w: 0}
+    pivot: {x: 0.5, y: 0.5}
+    oldSize: {x: 3.85, y: 2.57}
+    newSize: {x: 3.85, y: 2.57}
+    adaptiveTilingThreshold: 0.5
+    drawMode: 0
+    adaptiveTiling: 0
+  m_AutoTiling: 0
+  m_Size: {x: 3.85, y: 2.57}
+  m_EdgeRadius: 0

Assets/Prefabs/Levels/Dump/RevealableObject.prefab.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 07f826f001311e04984c3efc9ee2b897
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scenes/TestingStuff/MichalTesting_TrashMaze.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 42351c9e3e21b3040848acd45b1d7626
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/CardSystem/UI/Pages/AlbumViewPage.cs

@@ -452,7 +452,6 @@ namespace UI.CardSystem
             if (cardData == null) return null;
             
             var allSlots = FindObjectsByType<AlbumCardSlot>(FindObjectsSortMode.None);
-            
             foreach (var slot in allSlots)
             {
                 if (slot.TargetCardDefinition != null && 

Assets/Scripts/Core/GameManager.cs

@@ -182,7 +182,7 @@ namespace Core
             // Register settings with service locator
             if (playerSettings != null)
             {
-                ServiceLocator.Register<IPlayerFollowerSettings>(playerSettings);
+                ServiceLocator.Register<IPlayerMovementConfigs>(playerSettings);
                 Logging.Debug("PlayerFollowerSettings registered successfully");
             }
             else

Assets/Scripts/Core/Settings/PlayerFollowerSettings.cs

@@ -3,37 +3,79 @@
 namespace AppleHills.Core.Settings
 {
     /// <summary>
-    /// Settings related to player and follower behavior
+    /// Settings related to player and follower behavior.
+    /// Implements IPlayerMovementConfigs to provide separate configurations for different movement contexts.
     /// </summary>
     [CreateAssetMenu(fileName = "PlayerFollowerSettings", menuName = "AppleHills/Settings/Player & Follower", order = 1)]
-    public class PlayerFollowerSettings : BaseSettings, IPlayerFollowerSettings
+    public class PlayerFollowerSettings : BaseSettings, IPlayerMovementConfigs
+    {
+        [Header("Default Player Movement (Overworld)")]
+        [SerializeField] private PlayerMovementSettingsData defaultPlayerMovement = new PlayerMovementSettingsData();
+        
+        [Header("Trash Maze - Pulver Movement")]
+        [SerializeField] private PlayerMovementSettingsData trashMazeMovement = new PlayerMovementSettingsData();
+
+        [Header("Follower Settings")]
+        [SerializeField] private FollowerSettingsData followerMovement = new FollowerSettingsData();
+
+        // IPlayerMovementConfigs implementation
+        public IPlayerMovementSettings DefaultPlayerMovement => defaultPlayerMovement;
+        public IPlayerMovementSettings TrashMazeMovement => trashMazeMovement;
+        public IFollowerSettings FollowerMovement => followerMovement;
+
+        public override void OnValidate()
+        {
+            base.OnValidate();
+            defaultPlayerMovement?.Validate();
+            trashMazeMovement?.Validate();
+            followerMovement?.Validate();
+        }
+    }
+    
+    /// <summary>
+    /// Serializable data for player movement settings
+    /// </summary>
+    [System.Serializable]
+    public class PlayerMovementSettingsData : IPlayerMovementSettings
     {
-        [Header("Player Settings")]
         [SerializeField] private float moveSpeed = 5f;
-        [SerializeField] private float moveAcceleration = 10000f;
+        [SerializeField] private float maxAcceleration = 10000f;
         [SerializeField] private float stopDistance = 0.1f;
         [SerializeField] private bool useRigidbody = true;
         [SerializeField] private HoldMovementMode defaultHoldMovementMode = HoldMovementMode.Pathfinding;
 
-        [Header("Follower Settings")]
+        public float MoveSpeed => moveSpeed;
+        public float MaxAcceleration => maxAcceleration;
+        public float StopDistance => stopDistance;
+        public bool UseRigidbody => useRigidbody;
+        public HoldMovementMode DefaultHoldMovementMode => defaultHoldMovementMode;
+        
+        public void Validate()
+        {
+            moveSpeed = Mathf.Max(0.1f, moveSpeed);
+            maxAcceleration = Mathf.Max(0.1f, maxAcceleration);
+            stopDistance = Mathf.Max(0.01f, stopDistance);
+        }
+    }
+    
+    /// <summary>
+    /// Serializable data for follower settings
+    /// </summary>
+    [System.Serializable]
+    public class FollowerSettingsData : IFollowerSettings
+    {
         [SerializeField] private float followDistance = 1.5f;
         [SerializeField] private float manualMoveSmooth = 8f;
         [SerializeField] private float thresholdFar = 2.5f;
         [SerializeField] private float thresholdNear = 0.5f;
         [SerializeField] private float stopThreshold = 0.1f;
-
-        [Header("Backend Settings")]
-        [Tooltip("Technical parameters, not for design tuning")]
         [SerializeField] private float followUpdateInterval = 0.1f;
         [SerializeField] private float followerSpeedMultiplier = 1.2f;
         [SerializeField] private float heldIconDisplayHeight = 2.0f;
         
-        // IPlayerFollowerSettings implementation
+        [Header("Trash Maze Vision")]
-        public float MoveSpeed => moveSpeed;
+        [SerializeField] private float trashMazeVisionRadius = 8f;
-        public float MaxAcceleration => moveAcceleration;
+
-        public float StopDistance => stopDistance;
-        public bool UseRigidbody => useRigidbody;
-        public HoldMovementMode DefaultHoldMovementMode => defaultHoldMovementMode;
         public float FollowDistance => followDistance;
         public float ManualMoveSmooth => manualMoveSmooth;
         public float ThresholdFar => thresholdFar;
@@ -42,14 +84,19 @@ namespace AppleHills.Core.Settings
         public float FollowUpdateInterval => followUpdateInterval;
         public float FollowerSpeedMultiplier => followerSpeedMultiplier;
         public float HeldIconDisplayHeight => heldIconDisplayHeight;
+        public float TrashMazeVisionRadius => trashMazeVisionRadius;
         
-        public override void OnValidate()
+        public void Validate()
         {
-            base.OnValidate();
-            // Validate values
-            moveSpeed = Mathf.Max(0.1f, moveSpeed);
             followDistance = Mathf.Max(0.1f, followDistance);
+            manualMoveSmooth = Mathf.Max(0.1f, manualMoveSmooth);
+            thresholdFar = Mathf.Max(0.1f, thresholdFar);
+            thresholdNear = Mathf.Max(0.01f, thresholdNear);
+            stopThreshold = Mathf.Max(0.01f, stopThreshold);
+            followUpdateInterval = Mathf.Max(0.01f, followUpdateInterval);
             followerSpeedMultiplier = Mathf.Max(0.1f, followerSpeedMultiplier);
+            heldIconDisplayHeight = Mathf.Max(0f, heldIconDisplayHeight);
+            trashMazeVisionRadius = Mathf.Max(1f, trashMazeVisionRadius);
         }
     }
 }

Assets/Scripts/Core/Settings/SettingsInterfaces.cs

@@ -14,18 +14,33 @@ namespace AppleHills.Core.Settings
     }
 
     /// <summary>
-    /// Interface for player and follower settings
+    /// Interface for player movement settings (used by all player controllers)
     /// </summary>
-    public interface IPlayerFollowerSettings
+    public interface IPlayerMovementSettings
     {
-        // Player settings
         float MoveSpeed { get; }
-        float MaxAcceleration { get; }  // Added new property for player acceleration
+        float MaxAcceleration { get; }
         float StopDistance { get; }
         bool UseRigidbody { get; }
         HoldMovementMode DefaultHoldMovementMode { get; }
+    }
     
-        // Follower settings
+    /// <summary>
+    /// Container interface that holds multiple player movement configurations.
+    /// Allows different controllers to use the same base settings interface with different values.
+    /// </summary>
+    public interface IPlayerMovementConfigs
+    {
+        IPlayerMovementSettings DefaultPlayerMovement { get; }
+        IPlayerMovementSettings TrashMazeMovement { get; }
+        IFollowerSettings FollowerMovement { get; }
+    }
+    
+    /// <summary>
+    /// Interface for follower-specific settings (completely separate from player movement)
+    /// </summary>
+    public interface IFollowerSettings
+    {
         float FollowDistance { get; }
         float ManualMoveSmooth { get; }
         float ThresholdFar { get; }
@@ -34,6 +49,7 @@ namespace AppleHills.Core.Settings
         float FollowUpdateInterval { get; }
         float FollowerSpeedMultiplier { get; }
         float HeldIconDisplayHeight { get; }
+        float TrashMazeVisionRadius { get; }
     }
 
     /// <summary>

Assets/Scripts/Input/BasePlayerMovementController.cs

@@ -0,0 +1,330 @@
+using UnityEngine;
+using Pathfinding;
+using AppleHills.Core.Settings;
+using Core;
+using Core.Lifecycle;
+
+namespace Input
+{
+    /// <summary>
+    /// Base class for player movement controllers.
+    /// Handles tap-to-move and hold-to-move input with pathfinding or direct movement.
+    /// Derived classes can override to add specialized behavior (e.g., shader updates).
+    /// </summary>
+    public abstract class BasePlayerMovementController : ManagedBehaviour, ITouchInputConsumer
+    {
+        [Header("Movement")]
+        [SerializeField] protected float moveSpeed = 5f;
+        
+        [Header("Collision Simulation")]
+        [SerializeField] protected LayerMask obstacleMask;
+        [SerializeField] protected float colliderRadius = 0.5f;
+        
+        // Movement state
+        protected Vector3 _targetPosition;
+        protected Vector3 _directMoveVelocity;
+        protected bool _isHolding;
+        protected Vector2 _lastHoldPosition;
+        protected Coroutine _pathfindingDragCoroutine;
+        protected float _pathfindingDragUpdateInterval = 0.1f;
+        
+        // Settings reference (populated by derived classes in LoadSettings)
+        protected IPlayerMovementSettings _movementSettings;
+        protected IPlayerMovementSettings Settings => _movementSettings;
+        
+        // Abstract method for derived classes to load their specific settings
+        protected abstract void LoadSettings();
+        
+        // Movement tracking
+        protected bool _isMoving;
+        public bool IsMoving => _isMoving;
+        public bool IsHolding => _isHolding;
+        public event System.Action OnMovementStarted;
+        public event System.Action OnMovementStopped;
+        
+        // Components
+        protected AIPath _aiPath;
+        protected Animator _animator;
+        protected Transform _artTransform;
+        protected SpriteRenderer _spriteRenderer;
+        
+        // Animation tracking
+        protected Vector3 _lastDirectMoveDir = Vector3.right;
+        public Vector3 LastDirectMoveDir => _lastDirectMoveDir;
+        protected float _lastDirX;
+        protected float _lastDirY = -1f;
+        
+        protected LogVerbosity _logVerbosity = LogVerbosity.Warning;
+        
+        internal override void OnManagedAwake()
+        {
+            base.OnManagedAwake();
+            LoadSettings(); // Let derived class load appropriate settings
+            InitializeComponents();
+        }
+        
+        internal override void OnManagedStart()
+        {
+            base.OnManagedStart();
+            
+            // Register with InputManager
+            if (InputManager.Instance != null)
+            {
+                InputManager.Instance.SetDefaultConsumer(this);
+                Logging.Debug($"[{GetType().Name}] Registered as default input consumer");
+            }
+            
+            _logVerbosity = DeveloperSettingsProvider.Instance.GetSettings<DebugSettings>().inputLogVerbosity;
+        }
+        
+        protected virtual void InitializeComponents()
+        {
+            _aiPath = GetComponent<AIPath>();
+            _artTransform = transform.Find("CharacterArt");
+            if (_artTransform != null)
+                _animator = _artTransform.GetComponent<Animator>();
+            else
+                _animator = GetComponentInChildren<Animator>();
+                
+            if (_artTransform != null)
+                _spriteRenderer = _artTransform.GetComponent<SpriteRenderer>();
+            if (_spriteRenderer == null)
+                _spriteRenderer = GetComponentInChildren<SpriteRenderer>();
+        }
+        
+        protected virtual void Update()
+        {
+            UpdateMovementState();
+            UpdateAnimation();
+        }
+        
+        #region ITouchInputConsumer Implementation
+        
+        public virtual void OnTap(Vector2 worldPosition)
+        {
+            Logging.Debug($"[{GetType().Name}] OnTap at {worldPosition}");
+            if (_aiPath != null)
+            {
+                _aiPath.enabled = true;
+                _aiPath.canMove = true;
+                _aiPath.isStopped = false;
+                SetTargetPosition(worldPosition);
+                _directMoveVelocity = Vector3.zero;
+                _isHolding = false;
+            }
+        }
+        
+        public virtual void OnHoldStart(Vector2 worldPosition)
+        {
+            Logging.Debug($"[{GetType().Name}] OnHoldStart at {worldPosition}");
+            _lastHoldPosition = worldPosition;
+            _isHolding = true;
+            
+            if (Settings.DefaultHoldMovementMode == HoldMovementMode.Pathfinding && _aiPath != null)
+            {
+                _aiPath.enabled = true;
+                if (_pathfindingDragCoroutine != null) StopCoroutine(_pathfindingDragCoroutine);
+                _pathfindingDragCoroutine = StartCoroutine(PathfindingDragUpdateCoroutine());
+            }
+            else // Direct movement
+            {
+                if (_aiPath != null) _aiPath.enabled = false;
+                _directMoveVelocity = Vector3.zero;
+            }
+        }
+        
+        public virtual void OnHoldUpdate(Vector2 worldPosition)
+        {
+            if (!_isHolding) return;
+            _lastHoldPosition = worldPosition;
+            
+            if (Settings.DefaultHoldMovementMode == HoldMovementMode.Direct)
+            {
+                if (_aiPath != null && _aiPath.enabled) _aiPath.enabled = false;
+                MoveDirectlyTo(worldPosition);
+            }
+        }
+        
+        public virtual void OnHoldMove(Vector2 worldPosition)
+        {
+            // Alias for OnHoldUpdate for interface compatibility
+            OnHoldUpdate(worldPosition);
+        }
+        
+        public virtual void OnHoldEnd(Vector2 worldPosition)
+        {
+            Logging.Debug($"[{GetType().Name}] OnHoldEnd at {worldPosition}");
+            _isHolding = false;
+            _directMoveVelocity = Vector3.zero;
+            
+            if (_aiPath != null && Settings.DefaultHoldMovementMode == HoldMovementMode.Pathfinding)
+            {
+                if (_pathfindingDragCoroutine != null)
+                {
+                    StopCoroutine(_pathfindingDragCoroutine);
+                    _pathfindingDragCoroutine = null;
+                }
+            }
+            
+            if (_aiPath != null && Settings.DefaultHoldMovementMode == HoldMovementMode.Direct)
+            {
+                _aiPath.enabled = false;
+            }
+        }
+        
+        #endregion
+        
+        #region Movement Methods
+        
+        protected virtual void SetTargetPosition(Vector2 worldPosition)
+        {
+            if (_aiPath != null)
+            {
+                _aiPath.destination = worldPosition;
+                _aiPath.maxSpeed = Settings.MoveSpeed;
+                _aiPath.maxAcceleration = Settings.MaxAcceleration;
+                _aiPath.canMove = true;
+                _aiPath.isStopped = false;
+            }
+        }
+        
+        protected virtual void MoveDirectlyTo(Vector2 worldPosition)
+        {
+            if (_aiPath == null) return;
+            
+            Vector3 current = transform.position;
+            Vector3 target = new Vector3(worldPosition.x, worldPosition.y, current.z);
+            Vector3 toTarget = (target - current);
+            Vector3 direction = toTarget.normalized;
+            
+            float maxSpeed = Settings.MoveSpeed;
+            float acceleration = Settings.MaxAcceleration;
+            
+            _directMoveVelocity = Vector3.MoveTowards(_directMoveVelocity, direction * maxSpeed, acceleration * Time.deltaTime);
+            if (_directMoveVelocity.magnitude > maxSpeed)
+            {
+                _directMoveVelocity = _directMoveVelocity.normalized * maxSpeed;
+            }
+            
+            Vector3 move = _directMoveVelocity * Time.deltaTime;
+            if (move.magnitude > toTarget.magnitude)
+            {
+                move = toTarget;
+            }
+            
+            // Collision simulation
+            Vector3 adjustedVelocity = AdjustVelocityForObstacles(current, _directMoveVelocity);
+            Vector3 adjustedMove = adjustedVelocity * Time.deltaTime;
+            if (adjustedMove.magnitude > toTarget.magnitude)
+            {
+                adjustedMove = toTarget;
+            }
+            
+            transform.position += adjustedMove;
+            _lastDirectMoveDir = _directMoveVelocity.normalized;
+        }
+        
+        protected virtual Vector3 AdjustVelocityForObstacles(Vector3 position, Vector3 velocity)
+        {
+            if (velocity.sqrMagnitude < 0.0001f)
+                return velocity;
+                
+            float moveDistance = velocity.magnitude * Time.deltaTime;
+            Vector2 origin = new Vector2(position.x, position.y);
+            Vector2 dir = velocity.normalized;
+            float rayLength = colliderRadius + moveDistance;
+            
+            RaycastHit2D hit = Physics2D.Raycast(origin, dir, rayLength, obstacleMask);
+            
+            if (hit.collider != null)
+            {
+                Vector2 tangent = new Vector2(-hit.normal.y, hit.normal.x);
+                float slideAmount = Vector2.Dot(velocity, tangent);
+                Vector3 slideVelocity = tangent * slideAmount;
+                return slideVelocity;
+            }
+            
+            return velocity;
+        }
+        
+        protected virtual System.Collections.IEnumerator PathfindingDragUpdateCoroutine()
+        {
+            while (_isHolding && _aiPath != null)
+            {
+                SetTargetPosition(_lastHoldPosition);
+                yield return new WaitForSeconds(_pathfindingDragUpdateInterval);
+            }
+        }
+        
+        #endregion
+        
+        #region State and Animation
+        
+        protected virtual void UpdateMovementState()
+        {
+            bool isCurrentlyMoving = false;
+            
+            if (_isHolding && Settings.DefaultHoldMovementMode == HoldMovementMode.Direct)
+            {
+                isCurrentlyMoving = _directMoveVelocity.sqrMagnitude > 0.001f;
+            }
+            else if (_aiPath != null && _aiPath.enabled)
+            {
+                isCurrentlyMoving = _aiPath.velocity.sqrMagnitude > 0.001f;
+            }
+            
+            if (isCurrentlyMoving && !_isMoving)
+            {
+                _isMoving = true;
+                OnMovementStarted?.Invoke();
+                Logging.Debug($"[{GetType().Name}] Movement started");
+            }
+            else if (!isCurrentlyMoving && _isMoving)
+            {
+                _isMoving = false;
+                OnMovementStopped?.Invoke();
+                Logging.Debug($"[{GetType().Name}] Movement stopped");
+            }
+        }
+        
+        protected virtual void UpdateAnimation()
+        {
+            if (_animator == null || _aiPath == null) return;
+            
+            float normalizedSpeed = 0f;
+            Vector3 velocity = Vector3.zero;
+            float maxSpeed = Settings.MoveSpeed;
+            
+            if (_isHolding && Settings.DefaultHoldMovementMode == HoldMovementMode.Direct)
+            {
+                normalizedSpeed = _directMoveVelocity.magnitude / maxSpeed;
+                velocity = _directMoveVelocity;
+            }
+            else if (_aiPath.enabled)
+            {
+                normalizedSpeed = _aiPath.velocity.magnitude / maxSpeed;
+                velocity = _aiPath.velocity;
+            }
+            
+            _animator.SetFloat("Speed", Mathf.Clamp01(normalizedSpeed));
+            
+            if (velocity.sqrMagnitude > 0.01f)
+            {
+                Vector3 normalizedVelocity = velocity.normalized;
+                _lastDirX = normalizedVelocity.x;
+                _lastDirY = normalizedVelocity.y;
+                
+                _animator.SetFloat("DirX", _lastDirX);
+                _animator.SetFloat("DirY", _lastDirY);
+            }
+            else
+            {
+                _animator.SetFloat("DirX", _lastDirX);
+                _animator.SetFloat("DirY", _lastDirY);
+            }
+        }
+        
+        #endregion
+    }
+}
+

Assets/Scripts/Input/BasePlayerMovementController.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 059db1587c2c42389f98a1d3a52bec4b
+timeCreated: 1765206060

Assets/Scripts/Input/PlayerTouchController.cs

@@ -1,8 +1,6 @@
 using UnityEngine;
-using Pathfinding;
 using AppleHills.Core.Settings;
 using Core;
-using Core.Lifecycle;
 
 namespace Input
 {
@@ -19,341 +17,43 @@ namespace Input
     /// <summary>
     /// Handles player movement in response to tap and hold input events.
     /// Supports both direct and pathfinding movement modes, and provides event/callbacks for arrival/cancellation.
+    /// Extends BasePlayerMovementController with save/load and MoveToAndNotify functionality.
     /// </summary>
-    public class PlayerTouchController : ManagedBehaviour, ITouchInputConsumer
+    public class PlayerTouchController : BasePlayerMovementController
     {
-        // --- Movement State ---
+        // --- PlayerTouchController-specific features (MoveToAndNotify) ---
-        private Vector3 targetPosition;
-        private Vector3 directMoveVelocity; // default is Vector3.zero
-        internal bool isHolding;
-        private Vector2 lastHoldPosition;
-        private Coroutine pathfindingDragCoroutine;
-        private float pathfindingDragUpdateInterval = 0.1f; // Interval in seconds
-        [Header("Collision Simulation")]
-        public LayerMask obstacleMask;
-        public float colliderRadius = 0.5f;
-
-        // --- Settings Reference ---
-        private IPlayerFollowerSettings _settings;
-
-        // --- Movement Events ---
-        private bool _isMoving = false;
-        public bool IsMoving => _isMoving;
-        public event System.Action OnMovementStarted;
-        public event System.Action OnMovementStopped;
-
-        // --- Unity/Component References ---
-        private AIPath aiPath;
-
-        // Note: String-based property lookup is flagged as inefficient, but is common in Unity for dynamic children.
-        private Animator animator;
-        private Transform artTransform;
-        private SpriteRenderer spriteRenderer;
-
-        // --- Last direct movement direction ---
-        private Vector3 _lastDirectMoveDir = Vector3.right;
-        public Vector3 LastDirectMoveDir => _lastDirectMoveDir;
-
-        // --- Last movement directions for animation blend tree ---
-        private float _lastDirX = 0f; // -1 (left) to 1 (right)
-        private float _lastDirY = -1f; // -1 (down) to 1 (up)
-
-        // --- MoveToAndNotify State ---
         public delegate void ArrivedAtTargetHandler();
-        private Coroutine moveToCoroutine;
+        private Coroutine _moveToCoroutine;
         public event ArrivedAtTargetHandler OnArrivedAtTarget;
         public event System.Action OnMoveToCancelled;
-        private bool interruptMoveTo;
+        private bool _interruptMoveTo;
-        private LogVerbosity _logVerbosity = LogVerbosity.Warning;
 
         // Save system configuration
         public override bool AutoRegisterForSave => true;
         // Scene-specific SaveId - each level has its own player state
         public override string SaveId => $"{gameObject.scene.name}/PlayerController";
         
-        internal override void OnManagedStart()
+        protected override void LoadSettings()
         {
-            aiPath = GetComponent<AIPath>();
+            var configs = GameManager.GetSettingsObject<IPlayerMovementConfigs>();
-            artTransform = transform.Find("CharacterArt");
+            _movementSettings = configs.DefaultPlayerMovement;
-            if (artTransform != null)
-                animator = artTransform.GetComponent<Animator>();
-            else
-                animator = GetComponentInChildren<Animator>();
-            // Cache SpriteRenderer for flipping
-            if (artTransform != null)
-                spriteRenderer = artTransform.GetComponent<SpriteRenderer>();
-            if (spriteRenderer == null)
-                spriteRenderer = GetComponentInChildren<SpriteRenderer>();
-
-            // Initialize settings reference using GetSettingsObject
-            _settings = GameManager.GetSettingsObject<IPlayerFollowerSettings>();
-            
-            // Set default input consumer
-            InputManager.Instance?.SetDefaultConsumer(this);
-            
-            _logVerbosity = DeveloperSettingsProvider.Instance.GetSettings<DebugSettings>().inputLogVerbosity;
         }
 
-        /// <summary>
+        #region ITouchInputConsumer Overrides (Add InterruptMoveTo)
-        /// Handles tap input. Always uses pathfinding to move to the tapped location.
+        
-        /// Cancels any in-progress MoveToAndNotify.
+        public override void OnTap(Vector2 worldPosition)
-        /// </summary>
-        public void OnTap(Vector2 worldPosition)
         {
             InterruptMoveTo();
-            Logging.Debug($"OnTap at {worldPosition}");
+            base.OnTap(worldPosition);
-            if (aiPath != null)
-            {
-                aiPath.enabled = true;
-                aiPath.canMove = true;
-                aiPath.isStopped = false;
-                SetTargetPosition(worldPosition);
-                directMoveVelocity = Vector3.zero;
-                isHolding = false;
-            }
         }
         
-        /// <summary>
+        public override void OnHoldStart(Vector2 worldPosition)
-        /// Handles the start of a hold input. Begins tracking the finger and uses the correct movement mode.
-        /// Cancels any in-progress MoveToAndNotify.
-        /// </summary>
-        public void OnHoldStart(Vector2 worldPosition)
         {
             InterruptMoveTo();
-            Logging.Debug($"OnHoldStart at {worldPosition}");
+            base.OnHoldStart(worldPosition);
-            lastHoldPosition = worldPosition;
-            isHolding = true;
-            if (_settings.DefaultHoldMovementMode == HoldMovementMode.Pathfinding &&
-                aiPath != null)
-            {
-                aiPath.enabled = true;
-                if (pathfindingDragCoroutine != null) StopCoroutine(pathfindingDragCoroutine);
-                pathfindingDragCoroutine = StartCoroutine(PathfindingDragUpdateCoroutine());
-            }
-            else // Direct movement
-            {
-                if (aiPath != null) aiPath.enabled = false;
-                directMoveVelocity = Vector3.zero;
-            }
         }
         
-        /// <summary>
+        #endregion
-        /// Handles hold move input. Updates the target position for direct or pathfinding movement.
-        /// /// </summary>
-        public void OnHoldMove(Vector2 worldPosition)
-        {
-            if (!isHolding) return;
-            lastHoldPosition = worldPosition;
-            if (_settings.DefaultHoldMovementMode == HoldMovementMode.Direct)
-            {
-                if (aiPath != null && aiPath.enabled) aiPath.enabled = false;
-                MoveDirectlyTo(worldPosition);
-            }
-            // If pathfinding, coroutine will update destination
-        }
-
-        /// <summary>
-        /// Handles the end of a hold input. Stops tracking and disables movement as needed.
-        /// </summary>
-        public void OnHoldEnd(Vector2 worldPosition)
-        {
-            Logging.Debug($"OnHoldEnd at {worldPosition}");
-            isHolding = false;
-            directMoveVelocity = Vector3.zero;
-            if (aiPath != null && _settings.DefaultHoldMovementMode ==
-                HoldMovementMode.Pathfinding)
-            {
-                if (pathfindingDragCoroutine != null)
-                {
-                    StopCoroutine(pathfindingDragCoroutine);
-                    pathfindingDragCoroutine = null;
-                }
-            }
-
-            if (aiPath != null && _settings.DefaultHoldMovementMode == HoldMovementMode.Direct)
-            {
-                aiPath.enabled = false;
-            }
-        }
-
-        /// <summary>
-        /// Sets the target position for pathfinding movement.
-        /// </summary>
-        private void SetTargetPosition(Vector2 worldPosition)
-        {
-            if (aiPath != null)
-            {
-                aiPath.destination = worldPosition;
-                // Apply both speed and acceleration from settings
-                aiPath.maxSpeed = _settings.MoveSpeed;
-                aiPath.maxAcceleration = _settings.MaxAcceleration;
-                aiPath.canMove = true;
-                aiPath.isStopped = false;
-            }
-        }
-
-        /// <summary>
-        /// Moves the player directly towards the specified world position.
-        /// </summary>
-        public void MoveDirectlyTo(Vector2 worldPosition)
-        {
-            if (aiPath == null)
-            {
-                return;
-            }
-            Vector3 current = transform.position;
-            Vector3 target = new Vector3(worldPosition.x, worldPosition.y, current.z);
-            Vector3 toTarget = (target - current);
-            Vector3 direction = toTarget.normalized;
-            
-            // Get speed and acceleration directly from settings 
-            float maxSpeed = _settings.MoveSpeed;
-            float acceleration = _settings.MaxAcceleration;
-            
-            directMoveVelocity = Vector3.MoveTowards(directMoveVelocity, direction * maxSpeed, acceleration * Time.deltaTime);
-            if (directMoveVelocity.magnitude > maxSpeed)
-            {
-                directMoveVelocity = directMoveVelocity.normalized * maxSpeed;
-            }
-            Vector3 move = directMoveVelocity * Time.deltaTime;
-            if (move.magnitude > toTarget.magnitude)
-            {
-                move = toTarget;
-            }
-            // --- Collision simulation ---
-            Vector3 adjustedVelocity = AdjustVelocityForObstacles(current, directMoveVelocity);
-            Vector3 adjustedMove = adjustedVelocity * Time.deltaTime;
-            if (adjustedMove.magnitude > toTarget.magnitude)
-            {
-                adjustedMove = toTarget;
-            }
-            transform.position += adjustedMove;
-
-            // Cache the last direct movement direction
-            _lastDirectMoveDir = directMoveVelocity.normalized;
-        }
-
-        /// <summary>
-        /// Simulates collision with obstacles by raycasting in the direction of velocity and projecting the velocity if a collision is detected.
-        /// </summary>
-        /// <param name="position">Player's current position.</param>
-        /// <param name="velocity">Intended velocity for this frame.</param>
-        /// <returns>Adjusted velocity after collision simulation.</returns>
-        private Vector3 AdjustVelocityForObstacles(Vector3 position, Vector3 velocity)
-        {
-            if (velocity.sqrMagnitude < 0.0001f)
-                return velocity;
-            float moveDistance = velocity.magnitude * Time.deltaTime;
-            Vector2 origin = new Vector2(position.x, position.y);
-            Vector2 dir = velocity.normalized;
-            float rayLength = colliderRadius + moveDistance;
-            RaycastHit2D hit = Physics2D.Raycast(origin, dir, rayLength, obstacleMask);
-            Debug.DrawLine(origin, origin + dir * rayLength, Color.red, 0.1f);
-            if (hit.collider != null)
-            {
-                // Draw normal and tangent for debug
-                Debug.DrawLine(hit.point, hit.point + hit.normal, Color.green, 0.2f);
-                Vector2 tangent = new Vector2(-hit.normal.y, hit.normal.x);
-                Debug.DrawLine(hit.point, hit.point + tangent, Color.blue, 0.2f);
-                // Project velocity onto tangent to simulate sliding
-                float slideAmount = Vector2.Dot(velocity, tangent);
-                Vector3 slideVelocity = tangent * slideAmount;
-                return slideVelocity;
-            }
-            return velocity;
-        }
-
-        void Update()
-        {
-            UpdateMovementState();
-            
-            if (animator != null && aiPath != null)
-            {
-                float normalizedSpeed = 0f;
-                Vector3 velocity = Vector3.zero;
-                float maxSpeed = _settings.MoveSpeed;
-                
-                if (isHolding && _settings.DefaultHoldMovementMode == HoldMovementMode.Direct)
-                {
-                    normalizedSpeed = directMoveVelocity.magnitude / maxSpeed;
-                    velocity = directMoveVelocity;
-                }
-                else if (aiPath.enabled)
-                {
-                    normalizedSpeed = aiPath.velocity.magnitude / maxSpeed;
-                    velocity = aiPath.velocity;
-                }
-                
-                // Set speed parameter as before
-                animator.SetFloat("Speed", Mathf.Clamp01(normalizedSpeed));
-                
-                // Calculate and set X and Y directions for 2D blend tree
-                if (velocity.sqrMagnitude > 0.01f)
-                {
-                    // Normalize the velocity vector to get direction
-                    Vector3 normalizedVelocity = velocity.normalized;
-                    
-                    // Update the stored directions when actively moving
-                    _lastDirX = normalizedVelocity.x;
-                    _lastDirY = normalizedVelocity.y;
-                    
-                    // Set the animator parameters
-                    animator.SetFloat("DirX", _lastDirX);
-                    animator.SetFloat("DirY", _lastDirY);
-                }
-                else
-                {
-                    // When not moving, keep using the last direction
-                    animator.SetFloat("DirX", _lastDirX);
-                    animator.SetFloat("DirY", _lastDirY);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Checks if the player is currently moving and fires appropriate events when movement state changes.
-        /// </summary>
-        private void UpdateMovementState()
-        {
-            bool isCurrentlyMoving = false;
-            
-            // Check direct movement
-            if (isHolding && _settings.DefaultHoldMovementMode == HoldMovementMode.Direct)
-            {
-                isCurrentlyMoving = directMoveVelocity.sqrMagnitude > 0.001f;
-            }
-            // Check pathfinding movement
-            else if (aiPath != null && aiPath.enabled)
-            {
-                isCurrentlyMoving = aiPath.velocity.sqrMagnitude > 0.001f;
-            }
-            
-            // Fire events only when state changes
-            if (isCurrentlyMoving && !_isMoving)
-            {
-                _isMoving = true;
-                OnMovementStarted?.Invoke();
-                Logging.Debug("Movement started");
-            }
-            else if (!isCurrentlyMoving && _isMoving)
-            {
-                _isMoving = false;
-                OnMovementStopped?.Invoke();
-                Logging.Debug("Movement stopped");
-            }
-        }
-
-        /// <summary>
-        /// Coroutine for updating the AIPath destination during pathfinding hold movement.
-        /// </summary>
-        private System.Collections.IEnumerator PathfindingDragUpdateCoroutine()
-        {
-            while (isHolding && aiPath != null)
-            {
-                aiPath.destination = new Vector3(lastHoldPosition.x, lastHoldPosition.y, transform.position.z);
-                yield return new WaitForSeconds(pathfindingDragUpdateInterval);
-            }
-        }
 
         /// <summary>
         /// Moves the player to a specific target position and notifies via events when arrived or cancelled.
@@ -362,20 +62,20 @@ namespace Input
         public void MoveToAndNotify(Vector3 target)
         {
             // Cancel any previous move-to coroutine
-            if (moveToCoroutine != null)
+            if (_moveToCoroutine != null)
             {
-                StopCoroutine(moveToCoroutine);
+                StopCoroutine(_moveToCoroutine);
             }
 
-            interruptMoveTo = false;
+            _interruptMoveTo = false;
             // Ensure pathfinding is enabled for MoveToAndNotify
-            if (aiPath != null)
+            if (_aiPath != null)
             {
-                aiPath.enabled = true;
+                _aiPath.enabled = true;
-                aiPath.canMove = true;
+                _aiPath.canMove = true;
-                aiPath.isStopped = false;
+                _aiPath.isStopped = false;
             }
-            moveToCoroutine = StartCoroutine(MoveToTargetCoroutine(target));
+            _moveToCoroutine = StartCoroutine(MoveToTargetCoroutine(target));
         }
 
         /// <summary>
@@ -383,11 +83,11 @@ namespace Input
         /// </summary>
         public void InterruptMoveTo()
         {
-            interruptMoveTo = true;
+            _interruptMoveTo = true;
-            isHolding = false;
+            _isHolding = false;
-            directMoveVelocity = Vector3.zero;
+            _directMoveVelocity = Vector3.zero;
-            if (_settings.DefaultHoldMovementMode == HoldMovementMode.Direct && aiPath != null)
+            if (Settings.DefaultHoldMovementMode == HoldMovementMode.Direct && _aiPath != null)
-                aiPath.enabled = false;
+                _aiPath.enabled = false;
             OnMoveToCancelled?.Invoke();
         }
 
@@ -396,19 +96,19 @@ namespace Input
         /// </summary>
         private System.Collections.IEnumerator MoveToTargetCoroutine(Vector3 target)
         {
-            if (aiPath != null)
+            if (_aiPath != null)
             {
-                aiPath.destination = target;
+                _aiPath.destination = target;
-                aiPath.maxSpeed = _settings.MoveSpeed;
+                _aiPath.maxSpeed = Settings.MoveSpeed;
-                aiPath.maxAcceleration = _settings.MaxAcceleration;
+                _aiPath.maxAcceleration = Settings.MaxAcceleration;
             }
 
-            while (!interruptMoveTo)
+            while (!_interruptMoveTo)
             {
                 Vector2 current2D = new Vector2(transform.position.x, transform.position.y);
                 Vector2 target2D = new Vector2(target.x, target.y);
                 float dist = Vector2.Distance(current2D, target2D);
-                if (dist <= _settings.StopDistance + 0.2f)
+                if (dist <= Settings.StopDistance + 0.2f)
                 {
                     break;
                 }
@@ -416,8 +116,8 @@ namespace Input
                 yield return null;
             }
 
-            moveToCoroutine = null;
+            _moveToCoroutine = null;
-            if (!interruptMoveTo)
+            if (!_interruptMoveTo)
             {
                 OnArrivedAtTarget?.Invoke();
             }

Assets/Scripts/Interactions/ItemSlot.cs

@@ -64,7 +64,6 @@ namespace Interactions
 
         // Settings reference
         private IInteractionSettings interactionSettings;
-        private IPlayerFollowerSettings playerFollowerSettings;
 
         /// <summary>
         /// Read-only access to the current slotted item state.
@@ -180,7 +179,6 @@ namespace Interactions
             
             // Initialize settings references
             interactionSettings = GameManager.GetSettingsObject<IInteractionSettings>();
-            playerFollowerSettings = GameManager.GetSettingsObject<IPlayerFollowerSettings>();
         }
 
 #if UNITY_EDITOR
@@ -580,7 +578,8 @@ namespace Interactions
                         slotRenderer.sprite = slottedData.mapSprite;
                         
                         // Scale sprite to desired height, preserve aspect ratio, compensate for parent scale
-                        float desiredHeight = playerFollowerSettings?.HeldIconDisplayHeight ?? 2.0f;
+                        var configs = GameManager.GetSettingsObject<IPlayerMovementConfigs>();
+                        float desiredHeight = configs?.FollowerMovement?.HeldIconDisplayHeight ?? 2.0f;
                         var sprite = slottedData.mapSprite;
                         float spriteHeight = sprite.bounds.size.y;
                         Vector3 parentScale = slotRenderer.transform.parent != null

Assets/Scripts/Minigames/TrashMaze.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+

Assets/Scripts/Minigames/TrashMaze/Core.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+

Assets/Scripts/Minigames/TrashMaze/Core/PulverController.cs

@@ -0,0 +1,91 @@
+using Core;
+using UnityEngine;
+using Input;
+using AppleHills.Core.Settings;
+
+namespace Minigames.TrashMaze.Core
+{
+    /// <summary>
+    /// Controls Pulver character movement in the Trash Maze.
+    /// Inherits from BasePlayerMovementController for tap-to-move and hold-to-move.
+    /// Updates global shader properties for vision radius system.
+    /// </summary>
+    public class PulverController : BasePlayerMovementController
+    {
+        public static PulverController Instance { get; private set; }
+        
+        // Cached shader property IDs for performance
+        private static readonly int PlayerWorldPosID = Shader.PropertyToID("_PlayerWorldPos");
+        private static readonly int VisionRadiusID = Shader.PropertyToID("_VisionRadius");
+        
+        // Vision radius loaded from settings
+        private float _visionRadius;
+        
+        // Public accessors for other systems
+        public static Vector2 PlayerPosition => Instance != null ? Instance.transform.position : Vector2.zero;
+        public static float VisionRadius => Instance != null ? Instance._visionRadius : 8f;
+        
+        internal override void OnManagedAwake()
+        {
+            // Singleton pattern
+            if (Instance != null && Instance != this)
+            {
+                Logging.Warning("[PulverController] Duplicate instance detected. Destroying duplicate.");
+                Destroy(gameObject);
+                return;
+            }
+            
+            Instance = this;
+            
+            base.OnManagedAwake();
+            
+            Logging.Debug("[PulverController] Initialized");
+        }
+        
+        protected override void LoadSettings()
+        {
+            var configs = GameManager.GetSettingsObject<IPlayerMovementConfigs>();
+            _movementSettings = configs.TrashMazeMovement;
+            
+            // Load vision radius from follower settings
+            _visionRadius = configs.FollowerMovement.TrashMazeVisionRadius;
+            Logging.Debug($"[PulverController] Loaded vision radius from settings: {_visionRadius}");
+        }
+        
+        protected override void Update()
+        {
+            base.Update(); // Call base for movement and animation
+            
+            // Update global shader properties for vision system
+            UpdateShaderGlobals();
+        }
+        
+        /// <summary>
+        /// Updates global shader properties used by visibility shaders
+        /// </summary>
+        private void UpdateShaderGlobals()
+        {
+            Shader.SetGlobalVector(PlayerWorldPosID, transform.position);
+            Shader.SetGlobalFloat(VisionRadiusID, _visionRadius);
+        }
+        
+        internal override void OnManagedDestroy()
+        {
+            base.OnManagedDestroy();
+            
+            if (Instance == this)
+            {
+                Instance = null;
+            }
+        }
+        
+        /// <summary>
+        /// Set vision radius at runtime
+        /// </summary>
+        public void SetVisionRadius(float radius)
+        {
+            _visionRadius = Mathf.Max(0.1f, radius);
+        }
+    }
+}
+

Assets/Scripts/Minigames/TrashMaze/Core/PulverController.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+

Assets/Scripts/Minigames/TrashMaze/Core/TrashMazeController.cs

@@ -0,0 +1,168 @@
+using Core;
+using Core.Lifecycle;
+using UnityEngine;
+
+namespace Minigames.TrashMaze.Core
+{
+    /// <summary>
+    /// Main controller for the Trash Maze minigame.
+    /// Initializes the vision system and manages game flow.
+    /// </summary>
+    public class TrashMazeController : ManagedBehaviour
+    {
+        public static TrashMazeController Instance { get; private set; }
+        
+        [Header("Player")]
+        [SerializeField] private PulverController pulverPrefab;
+        [SerializeField] private Transform startPosition;
+        
+        [Header("Background")]
+        [Tooltip("Background sprite renderer - world size and center are inferred from its bounds")]
+        [SerializeField] private SpriteRenderer backgroundRenderer;
+        
+        [Header("Exit")]
+        [SerializeField] private Transform exitPosition;
+        
+        // Cached shader property IDs for performance
+        private static readonly int WorldSizeID = Shader.PropertyToID("_WorldSize");
+        private static readonly int WorldCenterID = Shader.PropertyToID("_WorldCenter");
+        
+        private PulverController _pulverInstance;
+        private bool _mazeCompleted;
+        
+        internal override void OnManagedAwake()
+        {
+            base.OnManagedAwake();
+            
+            // Singleton pattern
+            if (Instance != null && Instance != this)
+            {
+                Logging.Warning("[TrashMazeController] Duplicate instance detected. Destroying duplicate.");
+                Destroy(gameObject);
+                return;
+            }
+            
+            Instance = this;
+        }
+        
+        internal override void OnManagedStart()
+        {
+            base.OnManagedStart();
+            
+            Logging.Debug("[TrashMazeController] Initializing Trash Maze");
+            
+            InitializeMaze();
+        }
+        
+        private void InitializeMaze()
+        {
+            // Infer world bounds from background renderer and set shader globals
+            ApplyBackgroundBoundsToShader();
+            
+            // Spawn player
+            SpawnPulver();
+            
+            Logging.Debug("[TrashMazeController] Trash Maze initialized");
+        }
+        
+        /// <summary>
+        /// Automatically infers world size and center from the background sprite renderer bounds
+        /// and applies them to shader global properties.
+        /// This handles scaled, rotated, or transformed backgrounds correctly.
+        /// </summary>
+        private void ApplyBackgroundBoundsToShader()
+        {
+            if (backgroundRenderer == null)
+            {
+                Logging.Error("[TrashMazeController] Background renderer not assigned! World bounds cannot be inferred.");
+                Logging.Warning("[TrashMazeController] Using fallback bounds: size=(100,100), center=(0,0)");
+                
+                // Fallback values
+                Shader.SetGlobalVector(WorldSizeID, new Vector4(100f, 100f, 0f, 0f));
+                Shader.SetGlobalVector(WorldCenterID, new Vector4(0f, 0f, 0f, 0f));
+                return;
+            }
+            
+            // Get the material instance (avoid modifying shared asset)
+            Material material = backgroundRenderer.material;
+            if (material == null)
+            {
+                Logging.Warning("[TrashMazeController] Background material missing on renderer.");
+                return;
+            }
+            
+            // Use renderer.bounds (world-space, accounts for scale/rotation/parent transforms)
+            Bounds bounds = backgroundRenderer.bounds;
+            Vector3 worldSize = bounds.size;
+            Vector3 worldCenter = bounds.center;
+            
+            // Apply to shader globals (used by both background and object shaders)
+            Shader.SetGlobalVector(WorldSizeID, new Vector4(worldSize.x, worldSize.y, 0f, 0f));
+            Shader.SetGlobalVector(WorldCenterID, new Vector4(worldCenter.x, worldCenter.y, 0f, 0f));
+            
+            // Also apply directly to background material for its shader
+            material.SetVector(WorldSizeID, new Vector4(worldSize.x, worldSize.y, 0f, 0f));
+            material.SetVector(WorldCenterID, new Vector4(worldCenter.x, worldCenter.y, 0f, 0f));
+            
+            Logging.Debug($"[TrashMazeController] World bounds inferred from background: " +
+                         $"Size=({worldSize.x:F2}, {worldSize.y:F2}), Center=({worldCenter.x:F2}, {worldCenter.y:F2})");
+        }
+        
+        private void SpawnPulver()
+        {
+            if (pulverPrefab == null)
+            {
+                Logging.Error("[TrashMazeController] Pulver prefab not assigned!");
+                return;
+            }
+            
+            Vector3 spawnPosition = startPosition != null ? startPosition.position : Vector3.zero;
+            _pulverInstance = Instantiate(pulverPrefab, spawnPosition, Quaternion.identity);
+            
+            Logging.Debug($"[TrashMazeController] Pulver spawned at {spawnPosition}");
+        }
+        
+        /// <summary>
+        /// Called when player reaches the maze exit
+        /// </summary>
+        public void OnExitReached()
+        {
+            if (_mazeCompleted)
+            {
+                Logging.Debug("[TrashMazeController] Maze already completed");
+                return;
+            }
+            
+            _mazeCompleted = true;
+            
+            Logging.Debug("[TrashMazeController] Maze completed! Player reached exit.");
+            
+            // TODO: Trigger completion events
+            // - Award booster packs collected
+            // - Open gate for Trafalgar
+            // - Switch control to Trafalgar
+        }
+        
+        /// <summary>
+        /// Called when player collects a booster pack
+        /// </summary>
+        public void OnBoosterPackCollected()
+        {
+            Logging.Debug("[TrashMazeController] Booster pack collected");
+            
+            // TODO: Integrate with card album system
+            // CardAlbum.AddBoosterPack();
+        }
+        
+        internal override void OnManagedDestroy()
+        {
+            base.OnManagedDestroy();
+            
+            if (Instance == this)
+            {
+                Instance = null;
+            }
+        }
+    }
+}
+

Assets/Scripts/Minigames/TrashMaze/Core/TrashMazeController.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+

Assets/Scripts/Minigames/TrashMaze/Objects.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+

Assets/Scripts/Minigames/TrashMaze/Objects/Editor.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 3a935f5e791c46df8920c2c33f1c24c0
+timeCreated: 1765361215

Assets/Scripts/Minigames/TrashMaze/Objects/Editor/RevealableObjectEditor.cs

@@ -0,0 +1,99 @@
+using UnityEngine;
+using UnityEditor;
+using Minigames.TrashMaze.Objects;
+
+namespace Minigames.TrashMaze.Editor
+{
+    [CustomEditor(typeof(RevealableObject))]
+    public class RevealableObjectEditor : UnityEditor.Editor
+    {
+        private RenderTexture _cachedStampTexture;
+        private Texture2D _previewTexture;
+        
+        public override void OnInspectorGUI()
+        {
+            DrawDefaultInspector();
+            
+            // Only show debug info in play mode
+            if (!Application.isPlaying)
+            {
+                return;
+            }
+            
+            EditorGUILayout.Space(10);
+            EditorGUILayout.LabelField("Progressive Reveal Debug (Play Mode Only)", EditorStyles.boldLabel);
+            EditorGUILayout.HelpBox("Shows the current stamp texture for Progressive reveal mode.", MessageType.Info);
+            
+            RevealableObject revealableObject = (RevealableObject)target;
+            
+            // Use reflection to get private _revealStampTexture field
+            var field = typeof(RevealableObject).GetField("_revealStampTexture", 
+                System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+            
+            if (field != null)
+            {
+                RenderTexture stampTexture = field.GetValue(revealableObject) as RenderTexture;
+                
+                if (stampTexture != null)
+                {
+                    // Display stamp texture info
+                    EditorGUILayout.LabelField("Stamp Texture:", $"{stampTexture.width}x{stampTexture.height}");
+                    
+                    // Show preview of stamp texture
+                    GUILayout.Label("Reveal Mask Preview (White = Revealed):");
+                    
+                    // Create preview texture if needed
+                    if (_cachedStampTexture != stampTexture || _previewTexture == null)
+                    {
+                        _cachedStampTexture = stampTexture;
+                        
+                        if (_previewTexture != null)
+                        {
+                            DestroyImmediate(_previewTexture);
+                        }
+                        
+                        _previewTexture = new Texture2D(stampTexture.width, stampTexture.height, TextureFormat.R8, false);
+                        _previewTexture.filterMode = FilterMode.Point;
+                    }
+                    
+                    // Copy RenderTexture to Texture2D for preview
+                    RenderTexture.active = stampTexture;
+                    _previewTexture.ReadPixels(new Rect(0, 0, stampTexture.width, stampTexture.height), 0, 0);
+                    _previewTexture.Apply();
+                    RenderTexture.active = null;
+                    
+                    // Display preview with fixed size
+                    float previewSize = 256f;
+                    float aspectRatio = (float)stampTexture.height / stampTexture.width;
+                    Rect previewRect = GUILayoutUtility.GetRect(previewSize, previewSize * aspectRatio);
+                    EditorGUI.DrawPreviewTexture(previewRect, _previewTexture, null, ScaleMode.ScaleToFit);
+                    
+                    // Auto-refresh in play mode
+                    if (Application.isPlaying)
+                    {
+                        Repaint();
+                    }
+                }
+                else
+                {
+                    EditorGUILayout.HelpBox("No stamp texture found. Make sure object is in Progressive reveal mode.", MessageType.Warning);
+                }
+            }
+            else
+            {
+                EditorGUILayout.HelpBox("Could not access stamp texture via reflection.", MessageType.Error);
+            }
+        }
+        
+        private void OnDisable()
+        {
+            // Clean up preview texture
+            if (_previewTexture != null)
+            {
+                DestroyImmediate(_previewTexture);
+                _previewTexture = null;
+            }
+        }
+    }
+}
+

Assets/Scripts/Minigames/TrashMaze/Objects/Editor/RevealableObjectEditor.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1d081993ee424269bf8eae99db36a54c
+timeCreated: 1765361215

Assets/Scripts/Minigames/TrashMaze/Objects/RevealableObject.cs

@@ -0,0 +1,559 @@
+using Core;
+using Minigames.TrashMaze.Core;
+using UnityEngine;
+using System.Collections;
+using AppleHills.Core.Settings;
+
+namespace Minigames.TrashMaze.Objects
+{
+    /// <summary>
+    /// Reveal mode for object visibility
+    /// </summary>
+    public enum RevealMode
+    {
+        Binary,        // Simple on/off reveal (current system)
+        Progressive    // Pixel-by-pixel progressive reveal with stamp texture
+    }
+    
+    /// <summary>
+    /// Component for objects that need reveal memory (obstacles, booster packs, treasures).
+    /// Tracks if object has been revealed and updates material properties accordingly.
+    /// </summary>
+    [RequireComponent(typeof(SpriteRenderer))]
+    public class RevealableObject : MonoBehaviour
+    {
+        [Header("Reveal Settings")]
+        [SerializeField] private RevealMode revealMode = RevealMode.Binary;
+        
+        [Header("Textures")]
+        [SerializeField] private Sprite normalSprite;
+        [SerializeField] private Sprite outlineSprite;
+        
+        [Header("Progressive Reveal Settings")]
+        [SerializeField, Range(0.5f, 3f)] private float stampWorldRadius = 1.5f;
+        [Tooltip("Size of each stamp in world units. Smaller = more gradual reveal. Should be smaller than vision radius.")]
+        
+        [Header("Object Type")]
+        [SerializeField] private bool isBoosterPack = false;
+        [SerializeField] private bool isExit = false;
+        
+        private SpriteRenderer _spriteRenderer;
+        private Material _instanceMaterial;
+        private bool _hasBeenRevealed = false;
+        private bool _isCollected = false;
+        
+        // Material property IDs (cached for performance)
+        private static readonly int IsRevealedID = Shader.PropertyToID("_IsRevealed");
+        private static readonly int IsInVisionID = Shader.PropertyToID("_IsInVision");
+        private static readonly int RevealMaskID = Shader.PropertyToID("_RevealMask");
+        
+        // Progressive reveal system
+        private RenderTexture _revealStampTexture;
+        private Coroutine _stampCoroutine;
+        private Bounds _objectBounds;
+        private float _activationDistance;
+        
+        // Binary reveal system
+        private Coroutine _binaryRevealCoroutine;
+        
+        private void Awake()
+        {
+            _spriteRenderer = GetComponent<SpriteRenderer>();
+            
+            if (_spriteRenderer.material == null)
+            {
+                Logging.Error($"[RevealableObject] No material assigned to {gameObject.name}");
+                return;
+            }
+            
+            // Create instance material
+            _instanceMaterial = new Material(_spriteRenderer.material);
+            _spriteRenderer.material = _instanceMaterial;
+            
+            // Call mode-specific initialization - COMPLETELY SEPARATE
+            if (revealMode == RevealMode.Binary)
+            {
+                InitializeBinaryMode();
+            }
+            else if (revealMode == RevealMode.Progressive)
+            {
+                InitializeProgressiveMode();
+            }
+        }
+        
+        // ========================================
+        // BINARY MODE INITIALIZATION
+        // ========================================
+        
+        private void InitializeBinaryMode()
+        {
+            // Validate Binary shader
+            string shaderName = _instanceMaterial.shader.name;
+            if (!shaderName.Contains("ObjectVisibility") || shaderName.Contains("Progressive"))
+            {
+                Logging.Error($"[RevealableObject] {gameObject.name} Binary mode needs shader 'TrashMaze/ObjectVisibility', currently: {shaderName}");
+            }
+            
+            // Set initial Binary mode properties
+            _instanceMaterial.SetFloat(IsRevealedID, 0f);
+            _instanceMaterial.SetFloat(IsInVisionID, 0f);
+            
+            // Set textures
+            if (normalSprite != null)
+            {
+                _instanceMaterial.SetTexture("_MainTex", normalSprite.texture);
+            }
+            if (outlineSprite != null)
+            {
+                _instanceMaterial.SetTexture("_OutlineTex", outlineSprite.texture);
+            }
+            
+            Logging.Debug($"[RevealableObject] {gameObject.name} Binary mode initialized");
+        }
+        
+        // ========================================
+        // PROGRESSIVE MODE INITIALIZATION
+        // ========================================
+        
+        private void InitializeProgressiveMode()
+        {
+            // Validate Progressive shader
+            string shaderName = _instanceMaterial.shader.name;
+            if (!shaderName.Contains("ObjectVisibilityProgressive"))
+            {
+                Logging.Error($"[RevealableObject] {gameObject.name} Progressive mode needs shader 'TrashMaze/ObjectVisibilityProgressive', currently: {shaderName}");
+            }
+            
+            // Initialize progressive reveal system
+            InitializeProgressiveReveal();
+        }
+        
+        /// <summary>
+        /// Initialize progressive reveal system with dynamic texture sizing
+        /// </summary>
+        private void InitializeProgressiveReveal()
+        {
+            // Get object bounds for UV calculations
+            _objectBounds = _spriteRenderer.bounds;
+            
+            // Load activation distance from settings (use vision radius from follower settings)
+            var configs = GameManager.GetSettingsObject<IPlayerMovementConfigs>();
+            _activationDistance = configs.FollowerMovement.TrashMazeVisionRadius;
+            
+            Logging.Debug($"[RevealableObject] {gameObject.name} loaded activation distance from settings: {_activationDistance}");
+            
+            // Dynamically determine texture size from sprite
+            int textureWidth = 128;
+            int textureHeight = 128;
+            
+            if (normalSprite != null && normalSprite.texture != null)
+            {
+                // Use sprite's texture resolution (match 1:1 for pixel-perfect)
+                textureWidth = normalSprite.texture.width;
+                textureHeight = normalSprite.texture.height;
+            }
+            else
+            {
+                Logging.Warning($"[RevealableObject] {gameObject.name} in Progressive mode but normalSprite not assigned! Using default 128x128 texture. Assign Normal Sprite in inspector!");
+            }
+            
+            // Create reveal stamp texture (R8 format = 8-bit grayscale, minimal memory)
+            _revealStampTexture = new RenderTexture(textureWidth, textureHeight, 0, RenderTextureFormat.R8);
+            _revealStampTexture.filterMode = FilterMode.Point; // Sharp edges for binary reveals
+            _revealStampTexture.wrapMode = TextureWrapMode.Clamp;
+            _revealStampTexture.Create(); // Explicitly create the texture
+            
+            // Clear to black (nothing revealed initially)
+            RenderTexture previousActive = RenderTexture.active;
+            RenderTexture.active = _revealStampTexture;
+            GL.Clear(false, true, Color.black);
+            RenderTexture.active = previousActive;
+            
+            Logging.Debug($"[RevealableObject] {gameObject.name} cleared reveal texture to black - should be invisible initially");
+            
+            // Set Progressive shader properties
+            _instanceMaterial.SetTexture(RevealMaskID, _revealStampTexture);
+            
+            // Progressive shader uses global _PlayerWorldPos and _VisionRadius (set by PulverController)
+            // No need to set _IsInVision - shader does per-pixel distance checks
+            
+            // Set textures
+            if (normalSprite != null)
+            {
+                _instanceMaterial.SetTexture("_MainTex", normalSprite.texture);
+            }
+            if (outlineSprite != null)
+            {
+                _instanceMaterial.SetTexture("_OutlineTex", outlineSprite.texture);
+            }
+            
+            Logging.Debug($"[RevealableObject] {gameObject.name} Progressive mode initialized: {textureWidth}x{textureHeight} reveal texture");
+        }
+        
+        private void Start()
+        {
+            if (PulverController.Instance == null)
+            {
+                Logging.Error($"[RevealableObject] {gameObject.name} cannot start - PulverController not found!");
+                return;
+            }
+            
+            // Start mode-specific runtime logic - COMPLETELY SEPARATE
+            if (revealMode == RevealMode.Binary)
+            {
+                StartBinaryModeTracking();
+            }
+            else if (revealMode == RevealMode.Progressive)
+            {
+                StartProgressiveModeTracking();
+            }
+        }
+        
+        // ========================================
+        // BINARY MODE: Start tracking
+        // ========================================
+        
+        private void StartBinaryModeTracking()
+        {
+            _binaryRevealCoroutine = StartCoroutine(BinaryRevealTrackingCoroutine());
+            Logging.Debug($"[RevealableObject] {gameObject.name} Binary mode tracking started");
+        }
+        
+        // ========================================
+        // PROGRESSIVE MODE: Start tracking
+        // ========================================
+        
+        private void StartProgressiveModeTracking()
+        {
+            // Subscribe to movement events for stamping
+            PulverController.Instance.OnMovementStarted += OnPlayerMovementStarted;
+            PulverController.Instance.OnMovementStopped += OnPlayerMovementStopped;
+            
+            // NO vision tracking coroutine - Progressive shader does per-pixel distance checks using global _PlayerWorldPos
+            
+            Logging.Debug($"[RevealableObject] {gameObject.name} Progressive mode tracking started");
+        }
+        
+
+        // ========================================
+        // BINARY MODE: Vision-based reveal coroutine
+        // ========================================
+        
+        /// <summary>
+        /// Binary mode coroutine - tracks player distance and updates vision/reveal flags
+        /// Runs continuously, checks every 0.1s for performance
+        /// </summary>
+        private IEnumerator BinaryRevealTrackingCoroutine()
+        {
+            while (!_isCollected && _instanceMaterial != null)
+            {
+                // Calculate distance to player
+                float distance = Vector2.Distance(transform.position, PulverController.PlayerPosition);
+                bool isInRadius = distance < PulverController.VisionRadius;
+                
+                // Set real-time vision flag (controls shader color vs outline)
+                _instanceMaterial.SetFloat(IsInVisionID, isInRadius ? 1f : 0f);
+                
+                // Set reveal flag (once revealed, stays revealed)
+                if (isInRadius && !_hasBeenRevealed)
+                {
+                    _hasBeenRevealed = true;
+                    _instanceMaterial.SetFloat(IsRevealedID, 1f);
+                    Logging.Debug($"[RevealableObject] {gameObject.name} revealed!");
+                }
+                
+                // Wait before next check (reduces CPU load)
+                yield return new WaitForSeconds(0.1f);
+            }
+        }
+        
+        // ========================================
+        // PROGRESSIVE MODE: Event-based stamp reveal
+        // ========================================
+        
+        /// <summary>
+        /// Called when player starts moving - begin stamping if near object
+        /// </summary>
+        private void OnPlayerMovementStarted()
+        {
+            if (_isCollected || revealMode != RevealMode.Progressive) return;
+            
+            // Check if player's vision circle could overlap with object bounds
+            // Use closest point on bounds to check distance
+            Vector2 playerPos = PulverController.PlayerPosition;
+            Vector2 closestPoint = _objectBounds.ClosestPoint(playerPos);
+            float distanceToBounds = Vector2.Distance(playerPos, closestPoint);
+            
+            // Start stamping if vision radius could reach the object
+            // Add padding to account for vision radius overlap
+            float activationThreshold = _activationDistance + _objectBounds.extents.magnitude;
+            
+            if (distanceToBounds < activationThreshold && _stampCoroutine == null)
+            {
+                _stampCoroutine = StartCoroutine(StampRevealCoroutine());
+                Logging.Debug($"[RevealableObject] {gameObject.name} started stamping coroutine (distanceToBounds: {distanceToBounds:F2}, threshold: {activationThreshold:F2})");
+            }
+        }
+        
+        /// <summary>
+        /// Called when player stops moving - stop stamping
+        /// </summary>
+        private void OnPlayerMovementStopped()
+        {
+            if (_stampCoroutine != null)
+            {
+                StopCoroutine(_stampCoroutine);
+                _stampCoroutine = null;
+            }
+        }
+        
+        /// <summary>
+        /// Coroutine that stamps reveal texture while player is moving and near object
+        /// </summary>
+        private IEnumerator StampRevealCoroutine()
+        {
+            while (!_isCollected)
+            {
+                // Check if player's vision circle overlaps with object bounds
+                Vector2 playerPos = PulverController.PlayerPosition;
+                Vector2 closestPoint = _objectBounds.ClosestPoint(playerPos);
+                float distanceToBounds = Vector2.Distance(playerPos, closestPoint);
+                
+                // Calculate activation threshold with padding
+                float activationThreshold = _activationDistance + _objectBounds.extents.magnitude;
+                
+                // If player moved too far away, stop stamping
+                if (distanceToBounds >= activationThreshold)
+                {
+                    Logging.Debug($"[RevealableObject] {gameObject.name} stopping stamping coroutine (too far)");
+                    _stampCoroutine = null;
+                    yield break;
+                }
+                
+                // Stamp if player's vision radius reaches any part of the object
+                if (distanceToBounds < PulverController.VisionRadius)
+                {
+                    StampPlayerPosition();
+                }
+                
+                // Wait before next stamp (reduces GPU writes)
+                yield return new WaitForSeconds(0.1f);
+            }
+        }
+        
+        /// <summary>
+        /// Stamp the player's current position onto the reveal texture
+        /// Direct CPU-based stamping - calculates circle-rectangle intersection in world space
+        /// </summary>
+        private void StampPlayerPosition()
+        {
+            if (_revealStampTexture == null)
+            {
+                Logging.Warning($"[RevealableObject] {gameObject.name} cannot stamp: texture is null");
+                return;
+            }
+            
+            // Get player position and vision radius in world space
+            Vector2 playerWorldPos = PulverController.PlayerPosition;
+            float visionRadius = PulverController.VisionRadius;
+            
+            // Get object bounds in world space
+            Vector2 boundsMin = _objectBounds.min;
+            Vector2 boundsSize = _objectBounds.size;
+            
+            // Get texture dimensions
+            int texWidth = _revealStampTexture.width;
+            int texHeight = _revealStampTexture.height;
+            
+            // Calculate the bounding box of the circle in world space
+            Vector2 circleMin = playerWorldPos - Vector2.one * visionRadius;
+            Vector2 circleMax = playerWorldPos + Vector2.one * visionRadius;
+            
+            // Calculate intersection of circle bounding box with object bounds
+            Vector2 intersectMin = new Vector2(
+                Mathf.Max(circleMin.x, boundsMin.x),
+                Mathf.Max(circleMin.y, boundsMin.y)
+            );
+            Vector2 intersectMax = new Vector2(
+                Mathf.Min(circleMax.x, boundsMin.x + boundsSize.x),
+                Mathf.Min(circleMax.y, boundsMin.y + boundsSize.y)
+            );
+            
+            // Check if there's any intersection
+            if (intersectMin.x >= intersectMax.x || intersectMin.y >= intersectMax.y)
+            {
+                return; // No intersection, nothing to stamp
+            }
+            
+            // Convert world space intersection to texture pixel coordinates
+            int pixelMinX = Mathf.FloorToInt((intersectMin.x - boundsMin.x) / boundsSize.x * texWidth);
+            int pixelMaxX = Mathf.CeilToInt((intersectMax.x - boundsMin.x) / boundsSize.x * texWidth);
+            int pixelMinY = Mathf.FloorToInt((intersectMin.y - boundsMin.y) / boundsSize.y * texHeight);
+            int pixelMaxY = Mathf.CeilToInt((intersectMax.y - boundsMin.y) / boundsSize.y * texHeight);
+            
+            // Clamp to texture bounds
+            pixelMinX = Mathf.Max(0, pixelMinX);
+            pixelMaxX = Mathf.Min(texWidth, pixelMaxX);
+            pixelMinY = Mathf.Max(0, pixelMinY);
+            pixelMaxY = Mathf.Min(texHeight, pixelMaxY);
+            
+            // Read current texture data
+            RenderTexture.active = _revealStampTexture;
+            Texture2D tempTex = new Texture2D(texWidth, texHeight, TextureFormat.R8, false);
+            tempTex.ReadPixels(new Rect(0, 0, texWidth, texHeight), 0, 0);
+            tempTex.Apply();
+            
+            // Stamp pixels within the circle
+            bool anyPixelStamped = false;
+            float radiusSquared = visionRadius * visionRadius;
+            
+            for (int py = pixelMinY; py < pixelMaxY; py++)
+            {
+                for (int px = pixelMinX; px < pixelMaxX; px++)
+                {
+                    // Convert pixel coordinates back to world space
+                    float worldX = boundsMin.x + (px / (float)texWidth) * boundsSize.x;
+                    float worldY = boundsMin.y + (py / (float)texHeight) * boundsSize.y;
+                    
+                    // Check if this pixel is within the circle
+                    float dx = worldX - playerWorldPos.x;
+                    float dy = worldY - playerWorldPos.y;
+                    float distSquared = dx * dx + dy * dy;
+                    
+                    if (distSquared <= radiusSquared)
+                    {
+                        // Stamp this pixel (set to white)
+                        tempTex.SetPixel(px, py, Color.white);
+                        anyPixelStamped = true;
+                    }
+                }
+            }
+            
+            if (anyPixelStamped)
+            {
+                // Upload modified texture back to GPU
+                tempTex.Apply();
+                Graphics.CopyTexture(tempTex, _revealStampTexture);
+                
+                Logging.Debug($"[RevealableObject] {gameObject.name} stamped pixels at world pos ({playerWorldPos.x:F2}, {playerWorldPos.y:F2}), radius {visionRadius:F2}");
+            }
+            
+            RenderTexture.active = null;
+            Destroy(tempTex);
+        }
+        
+        private void OnTriggerEnter2D(Collider2D other)
+        {
+            // Check if player is interacting
+            if (other.CompareTag("Player") && _hasBeenRevealed && !_isCollected)
+            {
+                HandleInteraction();
+            }
+        }
+        
+        private void HandleInteraction()
+        {
+            if (isBoosterPack)
+            {
+                CollectBoosterPack();
+            }
+            else if (isExit)
+            {
+                ActivateExit();
+            }
+        }
+        
+        private void CollectBoosterPack()
+        {
+            _isCollected = true;
+            
+            Logging.Debug($"[RevealableObject] Booster pack collected: {gameObject.name}");
+            
+            // Notify controller
+            if (TrashMazeController.Instance != null)
+            {
+                TrashMazeController.Instance.OnBoosterPackCollected();
+            }
+            
+            // Destroy object
+            Destroy(gameObject);
+        }
+        
+        private void ActivateExit()
+        {
+            Logging.Debug($"[RevealableObject] Exit activated: {gameObject.name}");
+            
+            // Notify controller
+            if (TrashMazeController.Instance != null)
+            {
+                TrashMazeController.Instance.OnExitReached();
+            }
+        }
+        
+        private void OnDestroy()
+        {
+            // Stop Binary mode coroutine
+            if (_binaryRevealCoroutine != null)
+            {
+                StopCoroutine(_binaryRevealCoroutine);
+            }
+            
+            // Unsubscribe from Progressive mode movement events
+            if (revealMode == RevealMode.Progressive && PulverController.Instance != null)
+            {
+                PulverController.Instance.OnMovementStarted -= OnPlayerMovementStarted;
+                PulverController.Instance.OnMovementStopped -= OnPlayerMovementStopped;
+            }
+            
+            // Stop Progressive mode stamping coroutine
+            if (_stampCoroutine != null)
+            {
+                StopCoroutine(_stampCoroutine);
+            }
+            
+            // Clean up progressive reveal resources
+            if (_revealStampTexture != null)
+            {
+                _revealStampTexture.Release();
+                Destroy(_revealStampTexture);
+            }
+            
+
+            // Clean up instance material
+            if (_instanceMaterial != null)
+            {
+                Destroy(_instanceMaterial);
+            }
+        }
+        
+        /// <summary>
+        /// Check if object is currently visible to player
+        /// </summary>
+        public bool IsVisible()
+        {
+            float distance = Vector2.Distance(transform.position, PulverController.PlayerPosition);
+            return distance < PulverController.VisionRadius;
+        }
+        
+        /// <summary>
+        /// Check if object has been revealed at any point
+        /// </summary>
+        public bool HasBeenRevealed()
+        {
+            return _hasBeenRevealed;
+        }
+        
+        /// <summary>
+        /// Force reveal the object (for debugging or special cases)
+        /// </summary>
+        public void ForceReveal()
+        {
+            _hasBeenRevealed = true;
+            if (_instanceMaterial != null)
+            {
+                _instanceMaterial.SetFloat(IsRevealedID, 1f);
+            }
+        }
+    }
+}
+

Assets/Scripts/Minigames/TrashMaze/Objects/RevealableObject.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+

Assets/Scripts/Movement/FollowerController.cs

@@ -38,7 +38,7 @@ public class FollowerController : ManagedBehaviour
     public float manualMoveSmooth = 8f;
 
     // Settings reference
-    private IPlayerFollowerSettings _settings;
+    private IFollowerSettings _settings;
     private IInteractionSettings _interactionSettings;
 
     private GameObject _playerRef;
@@ -123,7 +123,8 @@ public class FollowerController : ManagedBehaviour
         }
 
         // Initialize settings references
-        _settings = GameManager.GetSettingsObject<IPlayerFollowerSettings>();
+        var configs = GameManager.GetSettingsObject<IPlayerMovementConfigs>();
+        _settings = configs.FollowerMovement;
         _interactionSettings = GameManager.GetSettingsObject<IInteractionSettings>();
     }
 
@@ -295,7 +296,7 @@ public class FollowerController : ManagedBehaviour
                 moveDir = _playerAIPath.velocity.normalized;
                 _lastMoveDir = moveDir;
             }
-            else if (_playerTouchController != null && _playerTouchController.isHolding && _playerTouchController.LastDirectMoveDir.sqrMagnitude > 0.01f)
+            else if (_playerTouchController != null && _playerTouchController.IsHolding && _playerTouchController.LastDirectMoveDir.sqrMagnitude > 0.01f)
             {
                 moveDir = _playerTouchController.LastDirectMoveDir;
                 _lastMoveDir = moveDir;

Assets/Scripts/Utils/Measurements.cs

@@ -0,0 +1,148 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Utils
+{
+    public class Measurements : MonoBehaviour
+    {
+        public enum MeasurementUnit
+        {
+            UnityUnits,
+            Centimeters,
+            Meters,
+            Kilometers,
+            Inches,
+            Feet,
+            Yards,
+            Miles
+        }
+
+        public enum MeasurementSource
+        {
+            Collider,
+            Renderer,
+            Mesh
+        }
+
+        public MeasurementUnit measurementUnit = MeasurementUnit.Feet;
+        public MeasurementSource measurementSource = MeasurementSource.Collider;
+        public GameObject distanceObject;
+
+        internal Vector3 Dimensions;
+        internal float CenterToCenter;
+        internal float EdgeToEdge;
+
+        void Update()
+        {
+            CalculateDimensions();
+            if (distanceObject != null)
+            {
+                CalculateDistances();
+            }
+        }
+
+        void CalculateDimensions()
+        {
+            Bounds bounds = new Bounds();
+
+            switch (measurementSource)
+            {
+                case MeasurementSource.Collider:
+                    Collider objectCollider = GetComponent<Collider>();
+                    if (objectCollider != null) bounds = objectCollider.bounds;
+                    break;
+                case MeasurementSource.Renderer:
+                    Renderer objectRenderer = GetComponent<Renderer>();
+                    if (objectRenderer != null) bounds = objectRenderer.bounds;
+                    break;
+                case MeasurementSource.Mesh:
+                    MeshFilter meshFilter = GetComponent<MeshFilter>();
+                    if (meshFilter != null && meshFilter.mesh != null) bounds = meshFilter.mesh.bounds;
+                    break;
+            }
+
+            Dimensions = ConvertToSelectedUnit(bounds.size);
+        }
+
+        void CalculateDistances()
+        {
+            Vector3 thisPosition = transform.position;
+            Vector3 otherPosition = distanceObject.transform.position;
+
+            CenterToCenter = ConvertToSelectedUnit(Vector3.Distance(thisPosition, otherPosition));
+
+            Bounds thisBounds = GetComponent<Collider>().bounds;
+            Bounds otherBounds = distanceObject.GetComponent<Collider>().bounds;
+
+            Vector3 closestPoint1 = thisBounds.ClosestPoint(otherPosition);
+            Vector3 closestPoint2 = otherBounds.ClosestPoint(thisPosition);
+
+            EdgeToEdge = ConvertToSelectedUnit(Vector3.Distance(closestPoint1, closestPoint2));
+        }
+
+        float ConvertToSelectedUnit(float unityUnits)
+        {
+            switch (measurementUnit)
+            {
+                case MeasurementUnit.Centimeters:
+                    return unityUnits * 100f;
+                case MeasurementUnit.Meters:
+                    return unityUnits;
+                case MeasurementUnit.Kilometers:
+                    return unityUnits / 1000f;
+                case MeasurementUnit.Inches:
+                    return unityUnits * 39.3701f;
+                case MeasurementUnit.Feet:
+                    return unityUnits * 3.28084f;
+                case MeasurementUnit.Yards:
+                    return unityUnits * 1.09361f;
+                case MeasurementUnit.Miles:
+                    return unityUnits * 0.000621371f;
+                default:
+                    return unityUnits;
+            }
+        }
+
+        Vector3 ConvertToSelectedUnit(Vector3 unityUnits)
+        {
+            return new Vector3(
+                ConvertToSelectedUnit(unityUnits.x),
+                ConvertToSelectedUnit(unityUnits.y),
+                ConvertToSelectedUnit(unityUnits.z)
+            );
+        }
+    }
+
+    #if UNITY_EDITOR
+    [CustomEditor(typeof(Measurements))]
+    public class MeasurementsEditor : Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            DrawDefaultInspector();
+
+            Measurements measurements = (Measurements)target;
+
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField("Dimensions", EditorStyles.boldLabel);
+            EditorGUILayout.LabelField($"Width\t\t\t<b>{measurements.Dimensions.x:F6} {measurements.measurementUnit}</b>", new GUIStyle(EditorStyles.label) { richText = true });
+            EditorGUILayout.LabelField($"Height\t\t\t<b>{measurements.Dimensions.y:F6} {measurements.measurementUnit}</b>", new GUIStyle(EditorStyles.label) { richText = true });
+            EditorGUILayout.LabelField($"Depth\t\t\t<b>{measurements.Dimensions.z:F6} {measurements.measurementUnit}</b>", new GUIStyle(EditorStyles.label) { richText = true });
+
+            if (measurements.distanceObject != null)
+            {
+                EditorGUILayout.Space();
+                EditorGUILayout.LabelField($"Distance to {measurements.distanceObject.name}", EditorStyles.boldLabel);
+                EditorGUILayout.LabelField($"Center to Center\t\t<b>{measurements.CenterToCenter:F6} {measurements.measurementUnit}</b>", new GUIStyle(EditorStyles.label) { richText = true });
+                EditorGUILayout.LabelField($"Edge to Edge\t\t<b>{measurements.EdgeToEdge:F6} {measurements.measurementUnit}</b>", new GUIStyle(EditorStyles.label) { richText = true });
+            }
+
+            // This will update the inspector view every frame
+            if (Application.isPlaying)
+            {
+                Repaint();
+            }
+        }
+    }
+    #endif
+}

Assets/Scripts/Utils/Measurements.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: efe9f7f2c8df3c0408ff67a95354f616
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 294420
+  packageName: MeasureMaster
+  packageVersion: 1.0
+  assetPath: Assets/MeasureMaster/Scripts/Measurements.cs
+  uploadId: 691048

Assets/Settings/PlayerFollowerSettings.asset

@@ -12,16 +12,24 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: 32cd6d14d9304d5ba0fd590da1346654, type: 3}
   m_Name: PlayerFollowerSettings
   m_EditorClassIdentifier: 
+  defaultPlayerMovement:
     moveSpeed: 15
-  moveAcceleration: 10000
+    maxAcceleration: 10000
-  stopDistance: 2
+    stopDistance: 0.1
-  useRigidbody: 1
+    useRigidbody: 0
     defaultHoldMovementMode: 1
-  followDistance: 5
+  trashMazeMovement:
-  manualMoveSmooth: 2
+    moveSpeed: 15
-  thresholdFar: 10
+    maxAcceleration: 10000
-  thresholdNear: 7
+    stopDistance: 0.1
-  stopThreshold: 0.5
+    useRigidbody: 0
+    defaultHoldMovementMode: 1
+  followerMovement:
+    followDistance: 1.5
+    manualMoveSmooth: 8
+    thresholdFar: 2.5
+    thresholdNear: 0.5
+    stopThreshold: 0.1
     followUpdateInterval: 0.1
     followerSpeedMultiplier: 1.2
     heldIconDisplayHeight: 2

Assets/Shaders.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3d826fecc684bae4f94e7928c9c95d83
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Shaders/TrashMaze.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+

Assets/Shaders/TrashMaze/BackgroundVisibility.shader

@@ -0,0 +1,82 @@
+Shader "TrashMaze/BackgroundVisibility"
+{
+    Properties
+    {
+        _LitTex ("Lit Texture (Color)", 2D) = "white" {}
+        _UnlitTex ("Unlit Texture (Dark)", 2D) = "white" {}
+        _TransitionSoftness ("Transition Softness", Range(0, 2)) = 0.5
+    }
+    
+    SubShader
+    {
+        Tags 
+        { 
+            "Queue"="Background" 
+            "RenderType"="Opaque" 
+        }
+        
+        LOD 100
+        
+        Pass
+        {
+            HLSLPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
+            
+            struct Attributes
+            {
+                float4 positionOS : POSITION;
+                float2 uv : TEXCOORD0;
+            };
+            
+            struct Varyings
+            {
+                float2 uv : TEXCOORD0;
+                float3 positionWS : TEXCOORD1;
+                float4 positionCS : SV_POSITION;
+            };
+            
+            TEXTURE2D(_LitTex);
+            SAMPLER(sampler_LitTex);
+            TEXTURE2D(_UnlitTex);
+            SAMPLER(sampler_UnlitTex);
+            float4 _LitTex_ST;
+            float _TransitionSoftness;
+            
+            // Global properties set by PulverController
+            float3 _PlayerWorldPos;
+            float _VisionRadius;
+            
+            Varyings vert(Attributes input)
+            {
+                Varyings output;
+                VertexPositionInputs vertexInput = GetVertexPositionInputs(input.positionOS.xyz);
+                output.positionCS = vertexInput.positionCS;
+                output.positionWS = vertexInput.positionWS;
+                output.uv = TRANSFORM_TEX(input.uv, _LitTex);
+                return output;
+            }
+            
+            half4 frag(Varyings input) : SV_Target
+            {
+                // Calculate distance from pixel to player
+                float dist = distance(input.positionWS.xy, _PlayerWorldPos.xy);
+                
+                // Create smooth transition between lit and unlit
+                float t = smoothstep(_VisionRadius - _TransitionSoftness, _VisionRadius, dist);
+                
+                // Sample both textures
+                half4 litColor = SAMPLE_TEXTURE2D(_LitTex, sampler_LitTex, input.uv);
+                half4 unlitColor = SAMPLE_TEXTURE2D(_UnlitTex, sampler_UnlitTex, input.uv);
+                
+                // Blend based on distance
+                return lerp(litColor, unlitColor, t);
+            }
+            ENDHLSL
+        }
+    }
+    
+    FallBack "Diffuse"
+}
+

Assets/Shaders/TrashMaze/BackgroundVisibility.shader.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+

Assets/Shaders/TrashMaze/ObjectVisibility.shader

@@ -0,0 +1,91 @@
+Shader "TrashMaze/ObjectVisibility"
+{
+    Properties
+    {
+        _MainTex ("Normal Texture (Color)", 2D) = "white" {}
+        _OutlineTex ("Outline Texture (White)", 2D) = "white" {}
+        [PerRendererData] _IsRevealed ("Is Revealed", Float) = 0
+        [PerRendererData] _IsInVision ("Is In Vision", Float) = 0
+    }
+    
+    SubShader
+    {
+        Tags 
+        { 
+            "Queue"="Transparent" 
+            "RenderType"="Transparent"
+            "IgnoreProjector"="True"
+        }
+        
+        Blend SrcAlpha OneMinusSrcAlpha
+        ZWrite Off
+        Cull Off
+        
+        Pass
+        {
+            HLSLPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
+            
+            struct Attributes
+            {
+                float4 positionOS : POSITION;
+                float2 uv : TEXCOORD0;
+            };
+            
+            struct Varyings
+            {
+                float2 uv : TEXCOORD0;
+                float4 positionCS : SV_POSITION;
+            };
+            
+            TEXTURE2D(_MainTex);
+            SAMPLER(sampler_MainTex);
+            TEXTURE2D(_OutlineTex);
+            SAMPLER(sampler_OutlineTex);
+            float4 _MainTex_ST;
+            
+            // Per-instance properties (set by RevealableObject component)
+            float _IsRevealed;
+            float _IsInVision;
+            
+            Varyings vert(Attributes input)
+            {
+                Varyings output;
+                VertexPositionInputs vertexInput = GetVertexPositionInputs(input.positionOS.xyz);
+                output.positionCS = vertexInput.positionCS;
+                output.uv = TRANSFORM_TEX(input.uv, _MainTex);
+                return output;
+            }
+            
+            half4 frag(Varyings input) : SV_Target
+            {
+                // Three-state logic:
+                // 1. In vision radius -> show normal texture (color)
+                // 2. Revealed but outside vision -> show outline texture (white)
+                // 3. Never revealed -> transparent (hidden)
+                
+                if (_IsInVision > 0.5)
+                {
+                    // Inside vision radius - show color
+                    return SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, input.uv);
+                }
+                else if (_IsRevealed > 0.5)
+                {
+                    // Revealed but outside vision - show outline
+                    return SAMPLE_TEXTURE2D(_OutlineTex, sampler_OutlineTex, input.uv);
+                }
+                else
+                {
+                    // Never revealed - transparent (hidden)
+                    return half4(0, 0, 0, 0);
+                }
+            }
+            ENDHLSL
+        }
+    }
+    
+    FallBack "Transparent/Diffuse"
+}
+

Assets/Shaders/TrashMaze/ObjectVisibility.shader.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+

Assets/Shaders/TrashMaze/ObjectVisibilityProgressive.shader

@@ -0,0 +1,106 @@
+Shader "TrashMaze/ObjectVisibilityProgressive"
+{
+    Properties
+    {
+        _MainTex ("Normal Texture (Color)", 2D) = "white" {}
+        _OutlineTex ("Outline Texture (White)", 2D) = "white" {}
+        _RevealMask ("Reveal Mask", 2D) = "black" {}
+        [PerRendererData] _IsInVision ("Is In Vision", Float) = 0
+    }
+
+    SubShader
+    {
+        Tags 
+        { 
+            "Queue"="Transparent" 
+            "RenderType"="Transparent"
+            "IgnoreProjector"="True"
+        }
+        
+        Blend SrcAlpha OneMinusSrcAlpha
+        ZWrite Off
+        Cull Off
+        
+        Pass
+        {
+            HLSLPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
+            
+            struct Attributes
+            {
+                float4 positionOS : POSITION;
+                float2 uv : TEXCOORD0;
+            };
+            
+            struct Varyings
+            {
+                float2 uv : TEXCOORD0;
+                float4 positionCS : SV_POSITION;
+                float3 positionWS : TEXCOORD1;
+            };
+            
+            TEXTURE2D(_MainTex);
+            SAMPLER(sampler_MainTex);
+            TEXTURE2D(_OutlineTex);
+            SAMPLER(sampler_OutlineTex);
+            TEXTURE2D(_RevealMask);
+            SAMPLER(sampler_RevealMask);
+            float4 _MainTex_ST;
+            
+            // Global shader properties (set by PulverController)
+            float2 _PlayerWorldPos;
+            float _VisionRadius;
+            
+            Varyings vert(Attributes input)
+            {
+                Varyings output;
+                VertexPositionInputs vertexInput = GetVertexPositionInputs(input.positionOS.xyz);
+                output.positionCS = vertexInput.positionCS;
+                output.positionWS = vertexInput.positionWS;
+                output.uv = TRANSFORM_TEX(input.uv, _MainTex);
+                return output;
+            }
+            
+            half4 frag(Varyings input) : SV_Target
+            {
+                // Sample reveal mask (0 = not revealed, 1 = revealed)
+                float revealAmount = SAMPLE_TEXTURE2D(_RevealMask, sampler_RevealMask, input.uv).r;
+                
+                // Binary decision: is this pixel revealed?
+                bool isRevealed = revealAmount > 0.5;
+                
+                // If pixel was never revealed, hide it completely
+                if (!isRevealed)
+                {
+                    return half4(0, 0, 0, 0);
+                }
+                
+                // Calculate per-pixel distance to player in world space
+                float2 pixelWorldPos = input.positionWS.xy;
+                float distanceToPlayer = distance(pixelWorldPos, _PlayerWorldPos);
+                
+                // Three-state logic per pixel:
+                // 1. Never revealed -> hide (handled above)
+                // 2. Revealed + currently in player vision radius -> show color
+                // 3. Revealed + outside player vision radius -> show outline
+                
+                if (distanceToPlayer < _VisionRadius)
+                {
+                    // Pixel is revealed AND currently in vision - show color
+                    return SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, input.uv);
+                }
+                else
+                {
+                    // Pixel is revealed but NOT currently in vision - show outline
+                    return SAMPLE_TEXTURE2D(_OutlineTex, sampler_OutlineTex, input.uv);
+                }
+            }
+            ENDHLSL
+        }
+    }
+    
+    FallBack "Transparent/Diffuse"
+}
+

Assets/Shaders/TrashMaze/ObjectVisibilityProgressive.shader.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 732fa975ac924d89bb0078279d2cdb0b
+timeCreated: 1765358086

Assets/Shaders/TrashMaze/RevealStamp.shader

@@ -0,0 +1,64 @@
+Shader "Hidden/TrashMaze/RevealStamp"
+{
+    Properties
+    {
+        _StampPos ("Stamp Position", Vector) = (0.5, 0.5, 0, 0)
+        _StampRadius ("Stamp Radius", Float) = 0.2
+    }
+    
+    SubShader
+    {
+        Tags { "Queue"="Overlay" "RenderType"="Opaque" }
+        
+        // Additive blend to accumulate stamps
+        Blend One One
+        ZTest Always
+        ZWrite Off
+        Cull Off
+        
+        Pass
+        {
+            HLSLPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
+            
+            struct Attributes
+            {
+                float4 positionOS : POSITION;
+                float2 uv : TEXCOORD0;
+            };
+            
+            struct Varyings
+            {
+                float4 positionCS : SV_POSITION;
+                float2 uv : TEXCOORD0;
+            };
+            
+            float4 _StampPos;
+            float _StampRadius;
+            
+            Varyings vert(Attributes input)
+            {
+                Varyings output;
+                output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
+                output.uv = input.uv;
+                return output;
+            }
+            
+            half4 frag(Varyings input) : SV_Target
+            {
+                // Calculate distance from stamp center
+                float dist = distance(input.uv, _StampPos.xy);
+                
+                // Binary circle: 1.0 inside radius, 0.0 outside
+                float alpha = dist < _StampRadius ? 1.0 : 0.0;
+                
+                // Return white with calculated alpha (additive blend accumulates)
+                return half4(alpha, alpha, alpha, alpha);
+            }
+            ENDHLSL
+        }
+    }
+}
+

Assets/Shaders/TrashMaze/RevealStamp.shader.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 33afb80a55e64e53b8552498ad61acfa
+timeCreated: 1765358067