264 lines
6.4 KiB
Go
264 lines
6.4 KiB
Go
package scenes
|
|
|
|
import (
|
|
"image"
|
|
"image/color"
|
|
_ "image/jpeg"
|
|
_ "image/png"
|
|
"log"
|
|
|
|
"mountain/internal/entities"
|
|
|
|
"github.com/go-gl/mathgl/mgl64"
|
|
"github.com/hajimehoshi/ebiten/v2"
|
|
"github.com/hajimehoshi/ebiten/v2/ebitenutil"
|
|
)
|
|
|
|
const (
|
|
Gravity = 0.5
|
|
JumpForce = -8.0
|
|
MoveSpeed = 4.0
|
|
ViewSize = 380 // 800 width, we have 2 viewports (380 each with 20 padding)
|
|
)
|
|
|
|
type Player struct {
|
|
Pos mgl64.Vec3 // 3D Kordinater: X (vänster/höger), Y (upp/ner), Z (djup)
|
|
Vel mgl64.Vec3 // Hastighet
|
|
|
|
Width, Height float64 // För (AABB)
|
|
IsGrounded bool
|
|
|
|
// Sprites
|
|
SpriteRun *ebiten.Image
|
|
SpriteIdle *ebiten.Image
|
|
SpriteTop *ebiten.Image
|
|
AnimationFrame int
|
|
AnimationCounter int
|
|
|
|
FacingRight bool
|
|
}
|
|
|
|
type PlayScene struct {
|
|
world *entities.World
|
|
player *Player
|
|
leftView *ebiten.Image
|
|
rightView *ebiten.Image
|
|
}
|
|
|
|
func NewPlayScene() *PlayScene {
|
|
w, err := entities.LoadWorldFromTiled("mapp-maker/room1.tmj")
|
|
if err != nil {
|
|
log.Println("Kunde inte ladda room1:", err)
|
|
w = entities.NewWorld(100, 10, 100) // Fallback tom värd om JSON saknas
|
|
}
|
|
|
|
pRun, _, err := ebitenutil.NewImageFromFile("assets/images/Warrior_1/Run.png")
|
|
if err != nil {
|
|
log.Println("Run sprite error:", err)
|
|
pRun = ebiten.NewImage(96, 96)
|
|
}
|
|
pIdle, _, _ := ebitenutil.NewImageFromFile("assets/images/Warrior_1/Idle.png")
|
|
if pIdle == nil {
|
|
pIdle = pRun
|
|
}
|
|
|
|
pTop := ebiten.NewImage(96, 96)
|
|
pTop.Fill(color.RGBA{255, 255, 0, 255})
|
|
|
|
player := &Player{
|
|
Pos: mgl64.Vec3{50.0 * entities.TileSize, 6.0 * entities.TileSize, 50.0 * entities.TileSize},
|
|
Width: 96,
|
|
Height: 96,
|
|
SpriteRun: pRun,
|
|
SpriteIdle: pIdle,
|
|
SpriteTop: pTop,
|
|
FacingRight: true,
|
|
}
|
|
|
|
return &PlayScene{
|
|
world: w,
|
|
player: player,
|
|
leftView: ebiten.NewImage(ViewSize, ViewSize),
|
|
rightView: ebiten.NewImage(ViewSize, ViewSize),
|
|
}
|
|
}
|
|
|
|
func (s *PlayScene) Update() error {
|
|
p := s.player
|
|
|
|
p.Vel[0] = 0
|
|
p.Vel[2] = 0
|
|
isMoving := false
|
|
|
|
if ebiten.IsKeyPressed(ebiten.KeyLeft) || ebiten.IsKeyPressed(ebiten.KeyA) {
|
|
p.Vel[0] = -MoveSpeed
|
|
p.FacingRight = false
|
|
isMoving = true
|
|
}
|
|
if ebiten.IsKeyPressed(ebiten.KeyRight) || ebiten.IsKeyPressed(ebiten.KeyD) {
|
|
p.Vel[0] = MoveSpeed
|
|
p.FacingRight = true
|
|
isMoving = true
|
|
}
|
|
if ebiten.IsKeyPressed(ebiten.KeyUp) || ebiten.IsKeyPressed(ebiten.KeyW) {
|
|
p.Vel[2] = -MoveSpeed
|
|
isMoving = true
|
|
}
|
|
if ebiten.IsKeyPressed(ebiten.KeyDown) || ebiten.IsKeyPressed(ebiten.KeyS) {
|
|
p.Vel[2] = MoveSpeed
|
|
isMoving = true
|
|
}
|
|
|
|
if ebiten.IsKeyPressed(ebiten.KeySpace) && p.IsGrounded {
|
|
p.Vel[1] = JumpForce
|
|
p.IsGrounded = false
|
|
}
|
|
|
|
if !p.IsGrounded {
|
|
p.Vel[1] += Gravity
|
|
}
|
|
|
|
nextX := p.Pos[0] + p.Vel[0]
|
|
nextY := p.Pos[1] + p.Vel[1]
|
|
nextZ := p.Pos[2] + p.Vel[2]
|
|
|
|
gridY := int((nextY + p.Height) / entities.TileSize)
|
|
gridX := int((nextX + p.Width/2) / entities.TileSize)
|
|
gridZ := int((nextZ + p.Width/2) / entities.TileSize)
|
|
|
|
entY := s.world.GetEntityAt(gridX, gridY, gridZ)
|
|
if entY != nil && entY.IsBlocking() && p.Vel[1] >= 0 {
|
|
nextY = float64(gridY)*entities.TileSize - p.Height - 0.1
|
|
p.Vel[1] = 0
|
|
p.IsGrounded = true
|
|
} else {
|
|
p.IsGrounded = false
|
|
}
|
|
|
|
p.Pos[0] = nextX
|
|
p.Pos[1] = nextY
|
|
p.Pos[2] = nextZ
|
|
|
|
// Kolla ifall vi står på en portal
|
|
standEnt := s.world.GetEntityAt(gridX, gridY, gridZ)
|
|
if prt, ok := standEnt.(*entities.Portal); ok {
|
|
log.Println("Byter rum till: ", prt.TargetMap)
|
|
newW, err := entities.LoadWorldFromTiled("mapp-maker/" + prt.TargetMap + ".tmj")
|
|
if err == nil {
|
|
s.world = newW
|
|
// Reset player position for new map
|
|
if prt.TargetMap == "room1" {
|
|
p.Pos = mgl64.Vec3{80.0 * entities.TileSize, 6.0 * entities.TileSize, 10.0 * entities.TileSize}
|
|
} else {
|
|
p.Pos = mgl64.Vec3{40.0 * entities.TileSize, 6.0 * entities.TileSize, 65.0 * entities.TileSize}
|
|
}
|
|
}
|
|
}
|
|
|
|
if isMoving {
|
|
p.AnimationCounter++
|
|
if p.AnimationCounter > 5 {
|
|
p.AnimationFrame = (p.AnimationFrame + 1) % 6
|
|
p.AnimationCounter = 0
|
|
}
|
|
} else {
|
|
p.AnimationFrame = 0
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *PlayScene) Draw(screen *ebiten.Image) {
|
|
screen.Fill(color.RGBA{20, 20, 20, 255})
|
|
|
|
s.leftView.Fill(color.RGBA{135, 206, 235, 255})
|
|
s.rightView.Fill(color.RGBA{50, 150, 50, 255})
|
|
|
|
playerGridZ := int((s.player.Pos[2] + s.player.Width/2) / entities.TileSize)
|
|
playerGridY := int((s.player.Pos[1] + s.player.Height/2) / entities.TileSize)
|
|
|
|
camX := s.player.Pos[0] - float64(ViewSize)/2.0
|
|
camY := s.player.Pos[1] - float64(ViewSize)/2.0
|
|
camZ := s.player.Pos[2] - float64(ViewSize)/2.0
|
|
|
|
// Vänster vy: Sido-vy (renderar alla X och Y objekt vid spelarens Z)
|
|
for x := 0; x < s.world.Width; x++ {
|
|
for y := 0; y < s.world.Height; y++ {
|
|
ent := s.world.GetEntityAt(x, y, playerGridZ)
|
|
if ent != nil {
|
|
px := float64(x)*entities.TileSize - camX
|
|
py := float64(y)*entities.TileSize - camY
|
|
ent.DrawSide(s.leftView, px, py)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Höger vy: Ovan-vy (renderar alla X och Z objekt vid underliggande rad)
|
|
viewY := playerGridY
|
|
if s.player.IsGrounded {
|
|
viewY += 1
|
|
}
|
|
|
|
for x := 0; x < s.world.Width; x++ {
|
|
for z := 0; z < s.world.Depth; z++ {
|
|
ent := s.world.GetEntityAt(x, viewY, z)
|
|
if ent != nil {
|
|
px := float64(x)*entities.TileSize - camX
|
|
pz := float64(z)*entities.TileSize - camZ
|
|
ent.DrawTop(s.rightView, px, pz)
|
|
}
|
|
}
|
|
}
|
|
|
|
s.drawPlayerSide(s.leftView, camX, camY)
|
|
s.drawPlayerTop(s.rightView, camX, camZ)
|
|
|
|
opL := &ebiten.DrawImageOptions{}
|
|
opL.GeoM.Translate(10, 100)
|
|
screen.DrawImage(s.leftView, opL)
|
|
|
|
opR := &ebiten.DrawImageOptions{}
|
|
opR.GeoM.Translate(410, 100)
|
|
screen.DrawImage(s.rightView, opR)
|
|
|
|
ebitenutil.DebugPrint(screen, "VÄNSTER (Sido vy) HÖGER (Top vy: Slice av din Hojd)")
|
|
}
|
|
|
|
func (s *PlayScene) drawPlayerSide(screen *ebiten.Image, camX, camY float64) {
|
|
p := s.player
|
|
|
|
sx := p.AnimationFrame * 96
|
|
srcRect := image.Rect(sx, 0, sx+96, 96)
|
|
var activeSprite *ebiten.Image
|
|
|
|
if p.Vel[0] != 0 || p.Vel[2] != 0 { // Is moving X or Z
|
|
activeSprite = p.SpriteRun
|
|
} else {
|
|
activeSprite = p.SpriteIdle
|
|
}
|
|
|
|
subImg := activeSprite.SubImage(srcRect).(*ebiten.Image)
|
|
|
|
op := &ebiten.DrawImageOptions{}
|
|
if !p.FacingRight {
|
|
op.GeoM.Scale(-1, 1)
|
|
op.GeoM.Translate(96, 0)
|
|
}
|
|
|
|
drawX := p.Pos[0] - camX
|
|
drawY := p.Pos[1] - camY
|
|
|
|
op.GeoM.Translate(drawX, drawY)
|
|
screen.DrawImage(subImg, op)
|
|
}
|
|
|
|
func (s *PlayScene) drawPlayerTop(screen *ebiten.Image, camX, camZ float64) {
|
|
p := s.player
|
|
op := &ebiten.DrawImageOptions{}
|
|
|
|
drawX := p.Pos[0] - camX
|
|
drawZ := p.Pos[2] - camZ
|
|
op.GeoM.Translate(drawX, drawZ)
|
|
screen.DrawImage(p.SpriteTop, op)
|
|
}
|