carotidartillery/level.go

464 lines
9.8 KiB
Go
Raw Permalink Normal View History

2021-10-05 03:47:29 +00:00
package main
import (
"fmt"
2021-10-08 04:00:33 +00:00
"math"
2021-10-05 03:47:29 +00:00
"math/rand"
2021-10-30 22:25:11 +00:00
"time"
2021-10-22 01:07:26 +00:00
"github.com/Meshiest/go-dungeon/dungeon"
2021-10-05 03:47:29 +00:00
)
2021-10-22 01:07:26 +00:00
const dungeonScale = 4
2021-10-05 03:47:29 +00:00
// Level represents a game level.
type Level struct {
2021-10-31 18:30:42 +00:00
num int
2021-10-05 03:47:29 +00:00
w, h int
tiles [][]*Tile // (Y,X) array of tiles
tileSize int
2021-10-12 03:22:13 +00:00
2021-11-01 19:58:54 +00:00
topWalls [][]*Tile
sideWalls [][]*Tile
otherWalls [][]*Tile
2021-10-12 03:22:13 +00:00
items []*gameItem
2021-10-20 01:46:11 +00:00
creeps []*gameCreep
liveCreeps int
2021-10-12 03:22:13 +00:00
player *gamePlayer
2021-10-27 02:21:26 +00:00
torches []*gameCreep
2021-10-29 15:49:27 +00:00
enterX, enterY int
exitX, exitY int
2021-10-30 22:25:11 +00:00
exitOpenTime time.Time
2021-10-29 15:49:27 +00:00
requiredSouls int
2021-10-05 03:47:29 +00:00
}
// NewLevel returns a new randomly generated Level.
2021-10-27 02:21:26 +00:00
func NewLevel(levelNum int, p *gamePlayer) (*Level, error) {
2021-11-01 19:58:54 +00:00
levelSize := 100
if levelNum == 2 {
levelSize = 108
} else if levelNum == 3 {
levelSize = 116
} else if levelSize == 4 {
levelSize = 256
}
// Note: Level size must be divisible by the dungeon scale (4).
2021-10-05 03:47:29 +00:00
l := &Level{
2021-10-31 18:30:42 +00:00
num: levelNum,
2021-11-01 19:58:54 +00:00
w: levelSize,
h: levelSize,
2021-10-05 03:47:29 +00:00
tileSize: 32,
2021-10-27 02:21:26 +00:00
player: p,
2021-10-05 03:47:29 +00:00
}
2021-11-01 19:58:54 +00:00
l.requiredSouls = 33
2021-10-29 15:49:27 +00:00
if levelNum == 2 {
2021-11-01 19:58:54 +00:00
l.requiredSouls = 66
2021-10-29 15:49:27 +00:00
} else if levelNum == 3 {
2021-11-01 19:58:54 +00:00
l.requiredSouls = 99
2021-10-29 15:49:27 +00:00
}
2021-10-27 02:21:26 +00:00
var err error
sandstoneSS, err = LoadEnvironmentSpriteSheet()
2021-10-05 03:47:29 +00:00
if err != nil {
return nil, fmt.Errorf("failed to load embedded spritesheet: %s", err)
}
2021-11-01 19:58:54 +00:00
rooms := 13
if levelNum == 2 {
rooms = 26
} else if levelNum == 3 {
rooms = 33
}
d := dungeon.NewDungeon(l.w/dungeonScale, rooms)
2021-10-22 01:07:26 +00:00
dungeonFloor := 1
2021-10-05 03:47:29 +00:00
l.tiles = make([][]*Tile, l.h)
for y := 0; y < l.h; y++ {
l.tiles[y] = make([]*Tile, l.w)
for x := 0; x < l.w; x++ {
t := &Tile{}
if y < l.h-1 && d.Grid[x/dungeonScale][y/dungeonScale] == dungeonFloor {
2021-10-22 01:07:26 +00:00
if rand.Intn(13) == 0 {
t.AddSprite(sandstoneSS.FloorC)
2021-10-05 03:47:29 +00:00
} else {
2021-10-22 01:07:26 +00:00
t.AddSprite(sandstoneSS.FloorA)
2021-10-05 03:47:29 +00:00
}
2021-10-22 01:07:26 +00:00
t.floor = true
2021-10-05 03:47:29 +00:00
}
l.tiles[y][x] = t
}
}
2021-10-22 01:07:26 +00:00
neighbors := func(x, y int) [][2]int {
return [][2]int{
{x - 1, y - 1},
{x, y - 1},
{x + 1, y - 1},
{x + 1, y},
{x + 1, y + 1},
{x, y + 1},
{x - 1, y + 1},
{x - 1, y},
}
}
floorTile := func(x, y int) bool {
t := l.Tile(x, y)
if t == nil {
return false
}
return t.floor
}
2021-11-01 19:58:54 +00:00
l.topWalls = make([][]*Tile, l.h)
l.sideWalls = make([][]*Tile, l.h)
l.otherWalls = make([][]*Tile, l.h)
for y := 0; y < l.h; y++ {
l.topWalls[y] = make([]*Tile, l.w)
l.sideWalls[y] = make([]*Tile, l.w)
l.otherWalls[y] = make([]*Tile, l.w)
}
// Entrance and exit candidates.
2021-10-29 15:49:27 +00:00
var topWalls [][2]int
2021-11-01 19:58:54 +00:00
var bottomWalls [][2]int
2021-10-29 15:49:27 +00:00
2021-10-22 01:07:26 +00:00
// Add walls.
for x := 0; x < l.w; x++ {
for y := 0; y < l.h; y++ {
t := l.Tile(x, y)
if t == nil {
continue
}
if !t.floor {
continue
}
for _, n := range neighbors(x, y) {
nx, ny := n[0], n[1]
neighbor := l.Tile(nx, ny)
if neighbor == nil || neighbor.floor || neighbor.wall {
continue
}
neighbor.wall = true
// From perspective of neighbor tile.
bottom := floorTile(nx, ny+1)
top := floorTile(nx, ny-1)
right := floorTile(nx+1, ny)
left := floorTile(nx-1, ny)
topLeft := floorTile(nx-1, ny-1)
topRight := floorTile(nx+1, ny-1)
bottomLeft := floorTile(nx-1, ny+1)
bottomRight := floorTile(nx+1, ny+1)
// Determine which wall sprite to belongs here.
spriteTop := !top && bottom
spriteLeft := (left || bottomLeft) && !right && !bottomRight && !bottom
spriteRight := (right || bottomRight) && !left && !bottomLeft && !bottom
spriteBottomRight := !topLeft && !top && topRight && !bottomLeft && !bottom && !bottomRight
spriteBottomLeft := topLeft && !top && !topRight && !bottomLeft && !bottom && !bottomRight
spriteBottom := top && !bottom
// Add wall sprite.
switch {
case spriteTop:
if !bottomLeft || !bottomRight || left || right {
neighbor.AddSprite(sandstoneSS.WallPillar)
2021-10-27 02:21:26 +00:00
c := newCreep(TypeTorch, l, l.player)
c.x, c.y = float64(nx), float64(ny)
l.creeps = append(l.creeps, c)
l.torches = append(l.torches, c)
2021-10-22 01:07:26 +00:00
} else {
neighbor.AddSprite(sandstoneSS.WallTop)
2021-11-01 19:58:54 +00:00
farRight := floorTile(nx+2, ny)
farBottomRight := floorTile(nx+2, ny+1)
if bottomRight && farBottomRight && !right && !farRight && y > 2 {
topWalls = append(topWalls, [2]int{nx, ny})
}
2021-10-22 01:07:26 +00:00
}
2021-11-01 19:58:54 +00:00
l.topWalls[ny][nx] = neighbor
2021-10-22 01:07:26 +00:00
case spriteLeft:
if spriteBottom {
neighbor.AddSprite(sandstoneSS.WallBottom)
}
neighbor.AddSprite(sandstoneSS.WallLeft)
2021-11-01 19:58:54 +00:00
l.sideWalls[ny][nx] = neighbor
l.otherWalls[ny][nx] = neighbor
2021-10-22 01:07:26 +00:00
case spriteRight:
if spriteBottom {
neighbor.AddSprite(sandstoneSS.WallBottom)
}
neighbor.AddSprite(sandstoneSS.WallRight)
2021-11-01 19:58:54 +00:00
l.sideWalls[ny][nx] = neighbor
l.otherWalls[ny][nx] = neighbor
2021-10-22 01:07:26 +00:00
case spriteBottomLeft:
neighbor.AddSprite(sandstoneSS.WallBottomLeft)
2021-11-01 19:58:54 +00:00
l.sideWalls[ny][nx] = neighbor
l.otherWalls[ny][nx] = neighbor
2021-10-22 01:07:26 +00:00
case spriteBottomRight:
neighbor.AddSprite(sandstoneSS.WallBottomRight)
2021-11-01 19:58:54 +00:00
l.sideWalls[ny][nx] = neighbor
l.otherWalls[ny][nx] = neighbor
2021-10-22 01:07:26 +00:00
case spriteBottom:
neighbor.AddSprite(sandstoneSS.WallBottom)
2021-11-01 19:58:54 +00:00
l.otherWalls[ny][nx] = neighbor
farRight := floorTile(nx+2, ny)
farTopRight := floorTile(nx+2, ny-1)
if topRight && farTopRight && !right && !farRight && ny < l.h-3 {
bottomWalls = append(bottomWalls, [2]int{nx, ny})
}
2021-10-22 01:07:26 +00:00
}
}
}
}
2021-11-01 19:58:54 +00:00
for {
entrance := bottomWalls[rand.Intn(len(bottomWalls))]
l.enterX, l.enterY = entrance[0], entrance[1]
exit := topWalls[rand.Intn(len(topWalls))]
l.exitX, l.exitY = exit[0], exit[1]
dx, dy := deltaXY(float64(l.enterX), float64(l.enterY), float64(l.exitX), float64(l.exitY))
if dy >= 8 || dx >= 6 {
break
}
2021-10-29 15:49:27 +00:00
}
2021-11-01 19:58:54 +00:00
fadeA := 0.15
fadeB := 0.1
2021-10-29 15:49:27 +00:00
2021-11-01 19:58:54 +00:00
// Add entrance.
2021-10-29 15:49:27 +00:00
if levelNum > 1 {
2021-11-01 19:58:54 +00:00
t := l.Tile(l.enterX, l.enterY)
t.sprites = nil
t.AddSprite(sandstoneSS.FloorA)
t.AddSprite(sandstoneSS.BottomDoorClosedL)
t.AddSprite(sandstoneSS.WallLeft)
t = l.Tile(l.enterX+1, l.enterY)
t.sprites = nil
t.AddSprite(sandstoneSS.FloorA)
t.AddSprite(sandstoneSS.BottomDoorClosedR)
t.AddSprite(sandstoneSS.WallRight)
// Add fading entrance hall.
for i := 1; i < 3; i++ {
colorScale := fadeA
if i == 2 {
colorScale = fadeB
}
t = l.Tile(l.enterX, l.enterY+i)
if t != nil {
t.AddSprite(sandstoneSS.FloorA)
t.AddSprite(sandstoneSS.WallLeft)
t.forceColorScale = colorScale
}
t = l.Tile(l.enterX+1, l.enterY+i)
if t != nil {
t.AddSprite(sandstoneSS.FloorA)
t.AddSprite(sandstoneSS.WallRight)
t.forceColorScale = colorScale
}
}
2021-10-29 15:49:27 +00:00
}
2021-11-01 19:58:54 +00:00
// Add exit.
t := l.Tile(l.exitX, l.exitY)
t.sprites = nil
t.AddSprite(sandstoneSS.FloorA)
t.AddSprite(sandstoneSS.TopDoorClosedL)
t = l.Tile(l.exitX+1, l.exitY)
t.sprites = nil
t.AddSprite(sandstoneSS.FloorA)
t.AddSprite(sandstoneSS.TopDoorClosedR)
// Add fading exit hall.
for i := 1; i < 3; i++ {
colorScale := fadeA
if i == 2 {
colorScale = fadeB
}
t = l.Tile(l.exitX, l.exitY-i)
if t != nil {
t.AddSprite(sandstoneSS.FloorA)
t.AddSprite(sandstoneSS.WallLeft)
t.forceColorScale = colorScale
}
t = l.Tile(l.exitX+1, l.exitY-i)
if t != nil {
t.AddSprite(sandstoneSS.FloorA)
t.AddSprite(sandstoneSS.WallRight)
t.forceColorScale = colorScale
}
}
// TODO make it more obvious players should enter it (arrow on first level?)
// TODO two frame sprite arrow animation
2021-10-29 15:49:27 +00:00
// TODO special door for final exit
2021-10-27 02:21:26 +00:00
l.bakeLightmap()
2021-10-05 03:47:29 +00:00
return l, nil
}
2021-10-08 04:00:33 +00:00
2021-11-01 19:58:54 +00:00
// Tile returns the tile at the provided coordinates, or nil.
func (l *Level) Tile(x, y int) *Tile {
if x >= 0 && y >= 0 && x < l.w && y < l.h {
return l.tiles[y][x]
}
return nil
}
// Size returns the size of the Level.
func (l *Level) Size() (width, height int) {
return l.w, l.h
}
func (l *Level) isFloor(x float64, y float64) bool {
t := l.Tile(int(math.Floor(x+.5)), int(math.Floor(y+.5)))
if t == nil {
return false
}
if !t.floor {
return false
}
return true
}
func (l *Level) newSpawnLocation() (float64, float64) {
SPAWNLOCATION:
for {
x := float64(1 + rand.Intn(l.w-2))
y := float64(1 + rand.Intn(l.h-2))
if !l.isFloor(x, y) {
continue
}
// Too close to player.
playerSafeSpace := 11.0
dx, dy := deltaXY(x, y, l.player.x, l.player.y)
if dx <= playerSafeSpace && dy <= playerSafeSpace {
continue
}
// Too close to entrance.
exitSafeSpace := 9.0
dx, dy = deltaXY(x, y, float64(l.enterX), float64(l.enterY))
if dx <= exitSafeSpace && dy <= exitSafeSpace {
continue
}
// Too close to garlic or holy water.
garlicSafeSpace := 2.0
for _, item := range l.items {
if item.health == 0 {
continue
}
dx, dy = deltaXY(x, y, item.x, item.y)
if dx <= garlicSafeSpace && dy <= garlicSafeSpace {
continue SPAWNLOCATION
}
}
return x, y
}
}
2021-10-27 02:21:26 +00:00
func (l *Level) bakeLightmap() {
for x := 0; x < l.w; x++ {
for y := 0; y < l.h; y++ {
t := l.tiles[y][x]
2021-11-01 19:58:54 +00:00
v := t.forceColorScale
if v == 0 {
for _, torch := range l.torches {
if torch.health == 0 {
continue
}
torchV := colorScaleValue(float64(x), float64(y), torch.x, torch.y)
v += torchV
2021-10-27 02:21:26 +00:00
}
}
t.colorScale = v
}
}
}
func (l *Level) bakePartialLightmap(lx, ly int) {
radius := 16
for x := lx - radius; x < lx+radius; x++ {
for y := ly - radius; y < ly+radius; y++ {
t := l.Tile(x, y)
if t == nil {
continue
}
v := 0.0
for _, torch := range l.torches {
if torch.health == 0 {
continue
}
torchV := colorScaleValue(float64(x), float64(y), torch.x, torch.y)
v += torchV
}
t.colorScale = v
}
}
}
2021-10-29 15:49:27 +00:00
func (l *Level) addCreep(creepType int) *gameCreep {
2021-10-27 02:21:26 +00:00
c := newCreep(creepType, l, l.player)
l.creeps = append(l.creeps, c)
2021-10-29 15:49:27 +00:00
return c
2021-10-27 02:21:26 +00:00
}
2021-10-08 04:00:33 +00:00
func angle(x1, y1, x2, y2 float64) float64 {
return math.Atan2(y1-y2, x1-x2)
}
2021-10-27 02:21:26 +00:00
func colorScaleValue(x, y, bx, by float64) float64 {
dx, dy := deltaXY(x, y, bx, by)
sD := 7 / (dx + dy)
if sD > 1 {
sD = 1
}
sDB := sD
if dx > 4 {
sDB *= 0.6 / (dx / 4)
}
if dy > 4 {
sDB *= 0.6 / (dy / 4)
}
sD = sD * 2 * sDB
if sD > 1 {
sD = 1
}
return sD
}