astercal/main.go

// main.go
package main

import (
	"fmt"
	"image"
	_ "image/png"
	"math"
	"os"
	"time"

	"github.com/faiface/pixel"
	"github.com/faiface/pixel/pixelgl"
	"golang.org/x/image/colornames"
)

func loadSprite(path string) (pixel.Picture, error) {
	file, err := os.Open(path)
	if err != nil {
		return nil, err
	}
	defer file.Close()
	img, _, err := image.Decode(file)
	if err != nil {
		return nil, err
	}
	return pixel.PictureDataFromImage(img), nil
}

func createSpriteSheet(SpriteSheetImg pixel.Picture, spriteSizeX, spriteSizeY float64) []pixel.Rect {
	var frames []pixel.Rect

	for x := SpriteSheetImg.Bounds().Min.X; x < SpriteSheetImg.Bounds().Max.X; x += spriteSizeX {
		for y := SpriteSheetImg.Bounds().Min.Y; y < SpriteSheetImg.Bounds().Max.Y; y += spriteSizeY {
			frames = append(frames, pixel.R(x, y, x+256, y+256))
		}
	}
	return frames
}

func run() {

	cfgMain := pixelgl.WindowConfig{
		Title:  "AsterCal",
		Bounds: pixel.R(0, 0, 1024, 768),
		VSync:  true,
	}

	win, err := pixelgl.NewWindow(cfgMain)
	if err != nil {
		panic(err)
	}

	spritesheet, err := loadSprite("assets/ship_sprite_sheet.png")

	if err != nil {
		panic(err)
	}
	shipFrames := createSpriteSheet(spritesheet, 256, 256)

	player := pixel.NewSprite(spritesheet, shipFrames[0])

	var angle float64 = 0.0
	var angleInDegrees float64 = 0

	var (
		frames = 0
		second = time.Tick(time.Second)
	)

	playerX := win.Bounds().Max.X / 2
	playerY := win.Bounds().Max.Y / 8

	var playerTopSpeed float64 = 350
	var playerAcceleration float64 = 0.15 * playerTopSpeed
	var playerCurrentSpeed float64 = 0
	var playerDrag float64 = 1
	var playerXVelocity float64 = 0
	var playerYVelocity float64 = 0
	var myVec = pixel.Vec{playerX, playerY}

	last := time.Now()
	for !win.Closed() {
		dt := time.Since(last).Seconds()
		last = time.Now()

		win.Clear(colornames.Whitesmoke)

		myVec = pixel.Vec{playerX, playerY}

		mat := pixel.IM
		mat = mat.Rotated(pixel.ZV, angle)
		mat = mat.Scaled(pixel.ZV, 0.25)
		mat = mat.Moved(myVec)

		player.Draw(win, mat)

		if win.Pressed(pixelgl.KeyLeft) {

			angle += 3 * dt
		}
		if win.Pressed(pixelgl.KeyRight) {
			angle -= 3 * dt

		}

		if win.Pressed(pixelgl.KeyEscape) {
			win.SetClosed(true)
		}

		if win.Pressed(pixelgl.KeyUp) {
			if playerCurrentSpeed < playerTopSpeed {
				playerCurrentSpeed += playerAcceleration
			}

			playerXVelocity +=
				math.Cos(angle-(270*math.Pi)/180) * playerCurrentSpeed * dt
			playerYVelocity +=
				math.Sin(angle-(270*math.Pi)/180) * playerCurrentSpeed * dt

			if playerXVelocity > playerTopSpeed {
				playerXVelocity = playerTopSpeed
			}
			if playerXVelocity < playerTopSpeed*-1 {
				playerXVelocity = playerTopSpeed * -1
			}

			if playerYVelocity > playerTopSpeed {
				playerYVelocity = playerTopSpeed
			}
			if playerYVelocity < playerTopSpeed*-1 {
				playerYVelocity = playerTopSpeed * -1
			}

		}
		if win.Pressed(pixelgl.KeyDown) {

		}

		if angle == 0 {
			angleInDegrees = 0
		} else {

			angleInDegrees = (angle) * 180 / math.Pi
		}

		if angleInDegrees == 360 || angleInDegrees == -360 {
			angle = 0
		}

		if angleInDegrees > 360 {
			angle = angle - (360*math.Pi)/180
		}
		if angleInDegrees < -360 {
			angle = angle + (360*math.Pi)/180
		}

		if playerCurrentSpeed > 0 {
			playerCurrentSpeed -= playerDrag * dt
		}

		if playerCurrentSpeed < 0 {
			playerCurrentSpeed = 0
		}

		if playerX >= win.Bounds().Max.X-10 {
			playerXVelocity = -25
		}
		if playerX <= win.Bounds().Min.X+10 {
			playerXVelocity = 25
		}

		if playerY >= win.Bounds().Max.Y-10 {
			playerYVelocity = -25
		}
		if playerY <= win.Bounds().Min.Y+10 {
			playerYVelocity = 25
		}

		playerX += playerXVelocity * dt
		playerY += playerYVelocity * dt

		if playerYVelocity > 0 {
			playerYVelocity -= playerDrag
			if playerYVelocity < 0 {
				playerYVelocity = 0
			}
		}

		if playerYVelocity < 0 {
			playerYVelocity += playerDrag
			if playerYVelocity > 0 {
				playerYVelocity = 0
			}
		}

		if playerXVelocity > 0 {
			playerXVelocity -= playerDrag
			if playerXVelocity < 0 {
				playerXVelocity = 0
			}
		}

		if playerXVelocity < 0 {
			playerXVelocity += playerDrag
			if playerXVelocity > 0 {
				playerXVelocity = 0
			}
		}

		win.Update()

		frames++
		select {
		case <-second:
			win.SetTitle(fmt.Sprintf("%s | FPS: %d | playerYSpeed: %f", cfgMain.Title,
				frames, playerYVelocity))
			frames = 0
		default:
		}

	}

}

func main() {
	pixelgl.Run(run)
}