scip/openquell
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

shifted from proprietary ascii rawlevel to LDTK (using ldtkgo@master)

Browse Source
This commit is contained in:
Thomas von Dein
2024-03-10 13:05:31 +01:00
parent a2ed7782b2
commit af19ccb833
15 changed files with 819 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
game/level_scene.go
View File

@@ -28,10 +28,11 @@ func NewLevelScene(game *Game, startlevel int) Scene {
func (scene *LevelScene) GenerateLevels(game *Game) {
min := []int{}
for _, level := range assets.Levels {
for _, level := range assets.Project.Levels {
level := level
scene.Levels = append(scene.Levels, NewLevel(game, 32, &level))
min = append(min, level.MinMoves)
scene.Levels = append(scene.Levels, NewLevel(game, 32, level))
level.PropertyByIdentifier("min-moves")
min = append(min, level.PropertyByIdentifier("min-moves").AsInt())
}
scene.Game.Observer.SetupLevelScore(min)

62
game/levels.go
View File

@@ -2,18 +2,17 @@ package game
import (
"image"
"log"
"log/slog"
"openquell/assets"
"openquell/components"
"openquell/grid"
"openquell/observers"
"openquell/systems"
"openquell/util"
"strings"
"github.com/hajimehoshi/ebiten/v2"
"github.com/mlange-42/arche/ecs"
"github.com/solarlune/ldtkgo"
)
type Map map[image.Point]*assets.Tile
@@ -31,13 +30,14 @@ type Level struct {
Grid *grid.Grid
}
func NewLevel(game *Game, cellsize int, plan *assets.RawLevel) *Level {
func NewLevel(game *Game, cellsize int, plan *ldtkgo.Level) *Level {
systemlist := []systems.System{}
gridcontainer := &grid.GridContainer{}
systemlist = append(systemlist,
systems.NewGridSystem(game.World, game.ScreenWidth, game.ScreenHeight, cellsize, plan.Background))
systems.NewGridSystem(game.World, game.ScreenWidth, game.ScreenHeight, cellsize,
assets.Assets[plan.PropertyByIdentifier("background").AsString()]))
systemlist = append(systemlist, systems.NewCollectibleSystem(game.World))
@@ -63,8 +63,8 @@ func NewLevel(game *Game, cellsize int, plan *assets.RawLevel) *Level {
World: game.World,
Width: game.ScreenWidth,
Height: game.ScreenHeight,
Description: plan.Description,
Name: plan.Name,
Description: plan.PropertyByIdentifier("description").AsString(),
Name: plan.Identifier,
GridContainer: gridcontainer,
Systems: systemlist,
}
@@ -113,25 +113,51 @@ func (level *Level) SetupGrid(game *Game) {
}
// parses a RawLevel and generates a mapslice from it, which is being used as grid
func LevelToSlice(game *Game, level *assets.RawLevel, tilesize int) (Map, Map) {
func LevelToSlice(game *Game, level *ldtkgo.Level, tilesize int) (Map, Map) {
size := game.ScreenWidth * game.ScreenHeight
mapslice := make(Map, size)
backupmap := make(Map, size)
for y, line := range strings.Split(string(level.Data), "\n") {
if len(line) != game.ScreenWidth/tilesize && y < game.ScreenHeight/tilesize {
log.Fatalf("line %d doesn't contain %d tiles, but %d",
y, game.ScreenWidth/tilesize, len(line))
}
for _, layer := range level.Layers {
switch layer.Type {
case ldtkgo.LayerTypeTile:
// load tile from LDTK tile layer, use sprites from associated map.
for x, char := range line {
if !util.Exists(assets.Tiles, byte(char)) {
log.Fatalf("unregistered tile type %c encountered", char)
if tiles := layer.AllTiles(); len(tiles) > 0 {
for _, tileData := range tiles {
// Subimage the Tile from the already loaded map,
// but referenced from LDTK file, that way we
// could use multiple tileset images
tile := assets.Tiles["default"]
tile.Sprite = assets.Assets[strings.TrimSuffix(layer.Tileset.Path, ".png")].SubImage(
image.Rect(tileData.Src[0],
tileData.Src[1],
tileData.Src[0]+layer.GridSize,
tileData.Src[1]+layer.GridSize)).(*ebiten.Image)
mapslice[image.Point{tileData.Position[0], tileData.Position[1]}] = tile
backupmap[image.Point{tileData.Position[0], tileData.Position[1]}] = tile.Clone()
}
}
tile := assets.Tiles[byte(char)]
mapslice[image.Point{x, y}] = tile
backupmap[image.Point{x, y}] = tile.Clone()
case ldtkgo.LayerTypeEntity:
// load mobile tiles (they call them entities) using static map map.png.
tileset := assets.Assets["map"]
for _, entity := range layer.Entities {
if entity.TileRect != nil {
tile := assets.Tiles[entity.Identifier]
tileRect := entity.TileRect
tile.Sprite = tileset.SubImage(
image.Rect(tileRect.X, tileRect.Y,
tileRect.X+tileRect.W,
tileRect.Y+tileRect.H)).(*ebiten.Image)
mapslice[image.Point{entity.Position[0], entity.Position[1]}] = tile
backupmap[image.Point{entity.Position[0], entity.Position[1]}] = tile.Clone()
}
}
}
}