fixed hiddendoor tiles, now uses destruct shader no spriteset

TODO.md

@@ -29,12 +29,9 @@
 -  Player can  collect collectible  hidden under  obstacle (should  be
   fixed when above is fixed)
   
-- With new tileset images, hidden doors visually not working
-  anymore. So I need entit-tiles containing the wall tiles AND I need
-  to add a shader for a wall destruct animation. Otherwise I'd have to
-  store lots of images pairs, and I can't do that in LDTK.
-  
-- https://www.quasilyte.dev/blog/post/ebitengine-shaders/#round-1-applying-the-damage-mask
+- Star Obstacle doesn't do any damage!
+
+- Remove Sprite from Tile{}, not used anymore
 
 ## Collider Rework [abandoned: see branch collider-system, fails]
 

assets/loader-levels.go

@@ -33,6 +33,8 @@ type Tile struct {
 	TileNames   []string        // same thing, only the names
 	Obstacle    bool            // is an obstacle/enemy
 	Direction   int             // obstacle business end shows into this direction
+	Shader      *ebiten.Shader
+	Alpha       *ebiten.Image
 }
 
 func (tile *Tile) Clone() *Tile {
@@ -53,6 +55,8 @@ func (tile *Tile) Clone() *Tile {
 		TileNames:   tile.TileNames,
 		Obstacle:    tile.Obstacle,
 		Direction:   tile.Direction,
+		Alpha:       tile.Alpha,
+		Shader:      tile.Shader,
 	}
 
 	return newtile
@@ -158,24 +162,16 @@ func NewTileTranswall(class []string) *Tile {
 	}
 }
 
-func NewTileHiddenDoor(class []string) *Tile {
-	sprites := []*ebiten.Image{}
-	names := []string{}
-
-	for _, sprite := range class {
-		sprites = append(sprites, Assets[sprite])
-		names = append(names, sprite)
-	}
-
+func NewTileHiddenDoor(class, alpha string) *Tile {
 	return &Tile{
 		Id:          'W',
 		Class:       "hiddendoor",
 		Solid:       false,
 		Renderable:  true,
 		Destroyable: true,
-		Tiles:       sprites,
-		Sprite:      sprites[0], // initially use the first
-		TileNames:   names,
+		Sprite:      Assets[class],
+		Alpha:       Assets[alpha],
+		Shader:      Shaders["destruct"],
 	}
 }
 
@@ -196,15 +192,21 @@ func InitTiles() TileRegistry {
 		"ObstacleWest":    NewTileObstacle("obstacle-west", config.West),
 		"ObstacleEast":    NewTileObstacle("obstacle-east", config.East),
 		"Particle": NewTileParticle([]string{
-			//"particle-ring-1",
+			"particle-ring-1",
 			"particle-ring-2",
 			"particle-ring-3",
 			"particle-ring-4",
 			"particle-ring-5",
 			"particle-ring-6",
 		}),
-		"Transient":  NewTileTranswall([]string{"transwall", "block-orange-32"}),
-		"HiddenDoor": NewTileHiddenDoor([]string{"block-greycolored", "block-greycolored-damaged"}),
+		"Transient":   NewTileTranswall([]string{"transwall", "block-orange-32"}),
+		"HiddenDoor":  NewTileHiddenDoor("block-greycolored", "damage"),
+		"HiddenDoor2": NewTileHiddenDoor("block-greycolored", "damage"),
+		"HiddenDoor3": NewTileHiddenDoor("block-greycolored", "damage"),
+		"HiddenDoor4": NewTileHiddenDoor("block-greycolored", "damage"),
+		"HiddenDoor5": NewTileHiddenDoor("block-greycolored", "damage"),
+		"HiddenDoor6": NewTileHiddenDoor("block-greycolored", "damage"),
+		"HiddenDoor7": NewTileHiddenDoor("block-greycolored", "damage"),
 	}
 }
 

assets/loader-shaders.go

@@ -0,0 +1,49 @@
+package assets
+
+import (
+	"bytes"
+	"log"
+	"log/slog"
+	"path/filepath"
+	"strings"
+
+	"github.com/hajimehoshi/ebiten/v2"
+)
+
+type ShaderRegistry map[string]*ebiten.Shader
+
+var Shaders = LoadShaders("shaders")
+
+func LoadShaders(dir string) ShaderRegistry {
+	shaders := ShaderRegistry{}
+
+	entries, err := assetfs.ReadDir(dir)
+	if err != nil {
+		log.Fatalf("failed to read shaders dir %s: %s", dir, err)
+	}
+
+	for _, file := range entries {
+		path := filepath.Join(dir, file.Name())
+		fd, err := assetfs.Open(path)
+		if err != nil {
+			log.Fatalf("failed to open shader file %s: %s", file.Name(), err)
+		}
+		defer fd.Close()
+
+		name := strings.TrimSuffix(file.Name(), ".kg")
+
+		buf := new(bytes.Buffer)
+		buf.ReadFrom(fd)
+
+		shader, err := ebiten.NewShader([]byte(buf.Bytes()))
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		shaders[name] = shader
+
+		slog.Debug("loaded shader asset", "path", path)
+	}
+
+	return shaders
+}

assets/loader-sprites.go

@@ -15,7 +15,7 @@ import (
 // Maps image name to image data
 type AssetRegistry map[string]*ebiten.Image
 
-//go:embed sprites/*.png fonts/*.ttf levels/*.ldtk
+//go:embed sprites/*.png fonts/*.ttf levels/*.ldtk shaders/*.kg
 var assetfs embed.FS
 
 var Assets = LoadImages("sprites")

assets/shaders/destruct.kg

@@ -0,0 +1,36 @@
+// Copyright 2020 The Ebiten Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:build ignore
+
+//kage:unit pixels
+
+package main
+
+var Damaged int
+
+const HP float = 0
+
+func Fragment(_ vec4, texCoord vec2, _ vec4) vec4 {
+	wallpx := imageSrc0At(texCoord) // A pixel from the wall tile
+	mask := imageSrc1At(texCoord)   // A pixel from the damage mask image
+
+	if Damaged == 1 && (wallpx.a != 0.0 && mask.a != 0.0) {
+		alpha := clamp(HP+(1.0-mask.a), 0.0, 1.0)
+		// Create a darker pixel if it's inside a damage mask.
+		return vec4(wallpx.r*alpha, wallpx.g*alpha, wallpx.b*alpha, wallpx.a)
+	}
+
+	return wallpx // Otherwise, leave a pixel color as is
+}

components/components.go

@@ -7,7 +7,10 @@ import (
 // virtual location, aka tile address
 
 type Renderable struct {
-	Image *ebiten.Image
+	Image       *ebiten.Image
+	DamageImage *ebiten.Image
+	Damaged     int
+	Shader      *ebiten.Shader
 }
 
 type Particle struct {

game/levels.go

@@ -52,7 +52,8 @@ func NewLevel(game *Game, cellsize int, plan *ldtkgo.Level) *Level {
 
 	systemlist = append(systemlist, systems.NewTransientSystem(game.World, gridcontainer))
 
-	systemlist = append(systemlist, systems.NewDestroyableSystem(game.World, gridcontainer))
+	systemlist = append(systemlist, systems.NewDestroyableSystem(game.World, gridcontainer,
+		game.Cellsize))
 
 	systemlist = append(systemlist, systems.NewHudSystem(game.World, plan))
 
@@ -146,7 +147,7 @@ func LevelToSlice(game *Game, level *ldtkgo.Level, tilesize int) (Map, Map) {
 					tile := assets.Tiles["default"]
 
 					// FIXME: load from LDTK file
-					tile.Sprite = assets.Assets["tilemap"].SubImage(
+					tile.Sprite = assets.Assets["primarymap"].SubImage(
 						image.Rect(tileData.Src[0],
 							tileData.Src[1],
 							tileData.Src[0]+layer.GridSize,
@@ -163,14 +164,15 @@ func LevelToSlice(game *Game, level *ldtkgo.Level, tilesize int) (Map, Map) {
 
 		case ldtkgo.LayerTypeEntity:
 			// load mobile tiles (they call them entities) using static map map.png.
-			tileset := assets.Assets["map"]
+			tileset := assets.Assets["primarymap"]
 
 			for _, entity := range layer.Entities {
 				if entity.TileRect != nil {
 					tile := assets.Tiles[entity.Identifier]
 
+					slog.Debug("LOAD TILE", "tile", entity.TileRect)
+
 					tileRect := entity.TileRect
-					//slog.Debug("tilerect", "x", tileRect.X, "y", tileRect.Y, "which", entity.Identifier)
 
 					tile.Sprite = tileset.SubImage(
 						image.Rect(tileRect.X, tileRect.Y,

grid/grid.go

@@ -109,10 +109,17 @@ func NewGrid(world *ecs.World,
 				entity := doormapper.New()
 				pos, render, destroyable = doormapper.Get(entity)
 				destroyable.Sprites = tile.Tiles
+				render.DamageImage = tile.Alpha
+				render.Shader = tile.Shader
+				render.Damaged = 0
 			default:
 				log.Fatalln("unsupported tile type encountered")
 			}
 
+			// FIXME:  this image  is never being  used because  it is
+			// being overwritten in game/levels.go:LevelToSlice(). The
+			// image is  taken from the LDTK map, not  from the Tile{}
+			// definition anymore
 			render.Image = tile.Sprite
 
 		default: