project-rpg/main.go

package main

import (
	"fmt"
	"image"
	"math"
	"os"
	"time"

	_ "image/png"

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

func loadPicture(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 run() {
	cfg := pixelgl.WindowConfig{
		Title:  "Project RPG",
		Bounds: pixel.R(0, 0, 1024, 768),
		VSync:  true,
	}
	win, err := pixelgl.NewWindow(cfg)
	if err != nil {
		panic(err)
	}

	spritesheet, err := loadPicture("sprites.png")
	if err != nil {
		panic(err)
	}
	//batch := pixel.NewBatch(&pixel.TrianglesData{}, spritesheet)

	background, err := loadPicture("background.png")

	if err != nil {
		panic(err)
	}
	bg := pixel.NewSprite(background, background.Bounds())
	//batch := pixel.NewBatch(&pixel.TrianglesData{}, spritesheet)

	
	/* setting-character-sprite

		basically changed it around so the 12 frames of the character with yellow hair 
		are added to spritesFrames.

	*/

	var spritesFrames []pixel.Rect
	var frameWidth, frameHeight float64 = 96, 96
	for y := spritesheet.Bounds().Min.Y; y < frameHeight*4; y += 96 {
		for x := spritesheet.Bounds().Min.X; x < frameWidth*3; x += 96 {
			spritesFrames = append(spritesFrames, pixel.R(x, y, x+96, y+96)) // (x, y, width, height) of frame
		}
	}
	Sprite := pixel.NewSprite(spritesheet, spritesFrames[9])

	var (
		camPos = pixel.ZV
		//camSpeed     = 500.0
		camZoom      = 0.3
		camZoomSpeed = 1.2
	)

	var (
		frames = 0
		second = time.Tick(time.Second)
	)
	playerX := win.Bounds().Max.X / 2
	playerY := win.Bounds().Max.Y / 2

	var (
		playerXY = pixel.Vec{
			playerX,
			playerY,
		}
	)

	var fps int64 = 60
	timePerFrame := 1000000000 / fps
	var lastTime int64 = time.Now().UnixNano()
	var now int64
	var dt int64

	// Game Loop
	for !win.Closed() {
		now = time.Now().UnixNano()
		dt += (now - lastTime)
		lastTime = time.Now().UnixNano()

		//Execute a frame.
		if dt >= timePerFrame {

			// *** Update begins *** //

			playerXY = pixel.Vec{
				playerX,
				playerY,
			}
			cam := pixel.IM.Scaled(camPos, camZoom).Moved(win.Bounds().Center().Sub(camPos))

			win.SetMatrix(cam)
			/*
				This is where Sprite and bg was originally. Creating them over and over inside
				the main loop is not very good resource management. When i added my own dt, the game was
				only going about 22 fps, when it should've been going 60. I moved them
				out of the loop and created them up top. It fixed it and now runs faster.

				the tutorial only has it in the loop with the exception that it creates it only
				if you click the button to make a tree. It only created it once and added it.
			*/

			//mouse := cam.Unproject(win.MousePosition())

			speed := 10.0
			if win.Pressed(pixelgl.KeyA) { //left
				playerX -= speed
				Sprite.Set(spritesheet, spritesFrames[6])
			}
			if win.Pressed(pixelgl.KeyD) { //Right
				playerX += speed
				Sprite.Set(spritesheet, spritesFrames[3])
			}
			if win.Pressed(pixelgl.KeyS) { //Down
				playerY -= speed
				Sprite.Set(spritesheet, spritesFrames[9])
			}
			if win.Pressed(pixelgl.KeyW) { //up
				playerY += speed
				Sprite.Set(spritesheet, spritesFrames[0])
			}
			camPos.X = playerX
			camPos.Y = playerY
			camZoom *= math.Pow(camZoomSpeed, win.MouseScroll().Y)

			// *** Update Ends *** //

			// *** Render begin *** //
			win.Clear(colornames.Forestgreen)
			bg.Draw(win, pixel.IM.Moved(win.Bounds().Center()))
			Sprite.Draw(win, pixel.IM.Scaled(pixel.ZV, 4).Moved(playerXY))

			//batch.Draw(win)
			win.Update()

			// *** Render End *** //

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

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