What happens to the &Game you put in ebiten.RunGame is it being used?

[Esa824]

What happens to the &game you pass in ebiten.RunGame is it the pointer that gets updated or is it just there for the methods?

[hajimehoshi]

I don't understand your question.

[Esa824]

Here in this code

if err := ebiten.RunGame(&Game{}); err != nil {
		log.Fatal(err)
	}

Here what happens to the &game you put in.

[hajimehoshi]

The game's methods like Update and Draw are called...

[Esa824]

Let say when we have cords in the Game is it updated? So if I had something that was running on a go routine a infinite for loop will those cords be updated?

[hajimehoshi]

Ebitengine calls the game's Update/Draw/Layout. There is nothing more. Even if you have your own goroutine loop, Ebitengine doesn't care about this.

[Esa824]

Okay thank you

[Esa824]

I have a question I have this code as before and updateNetwork is an infinite loop running on a goroutine and I pass the pointer that it is using is that gonna affect updateNetwork

package main

import (
	"bytes"
	"image"
	_ "image/png"
	"io"
	"net"
	"os"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/sirupsen/logrus"

	"github.com/hajimehoshi/ebiten/v2"
)

const (
	screenWidth  = 320
	screenHeight = 240

	frameOX     = 0
	frameOY     = 32
	frameWidth  = 32
	frameHeight = 32
	frameCount  = 8
)

var (
	runnerImage     *ebiten.Image
	swordImage      *ebiten.Image
	grassBlockImage *ebiten.Image
	cloudBlockImage *ebiten.Image
	swordAnimations [4]*ebiten.Image

	log *logrus.Logger

	conn net.Conn

	ticker = time.NewTicker(time.Second / 50)
)

type Sword struct {
	x, y                     int
	throwSword               bool
	xThrowSword, yThrowSword int
}

type Player struct {
	x            int
	y            float64
	dir, dirJump bool
}

type Game struct {
	mu                        sync.Mutex
	firstPlayer, secondPlayer Player
	firstSword, secondSword   Sword
}

func imageToByteArray(filePath string) ([]byte, error) {
	file, err := os.Open(filePath)
	if err != nil {
		return nil, err
	}
	defer file.Close()

	byteArray, err := io.ReadAll(file)
	if err != nil {
		return nil, err
	}

	return byteArray, nil
}

func (g *Game) Update() error {
	g.mu.Lock()
	defer g.mu.Unlock()
	var err error
	err = g.handlePlayerInput()
	g.updatePlayerAndSwordPosition()
	return err
}

func (g *Game) updateNetwork() {
	for {
		g.mu.Lock()
		x, y := g.firstPlayer.x, g.firstPlayer.y
		g.mu.Unlock()
		_, err := conn.Write([]byte(strconv.Itoa(x) + "-" + strconv.Itoa(int(y)) + "\n"))
		if err != nil {
			log.Errorf("Write error: %v", err)
			return
		}
		log.Infof("x: %d, y: %d", x, int(y))

		// Receive player coordinates from the server.
		buffer := make([]byte, 1024)
		n, err := conn.Read(buffer)
		if err != nil {
			log.Errorf("Receive error: %v", err)
			return
		}

		xy := strings.Split(string(buffer[:n]), "-")
		xSent, err := strconv.Atoi(xy[0])
		if err != nil {
			log.Errorf("X conversion error: %v", err)
			return
		}
		ySent, err := strconv.Atoi(xy[1])
		if err != nil {
			log.Errorf("Y conversion error: %v", err)
			return
		}

		// Update the second player's position.
		g.mu.Lock()
		g.secondPlayer.x = xSent
		g.secondPlayer.y = float64(ySent)
		g.mu.Unlock()
	}
}

func (g *Game) handlePlayerInput() error {
	if ebiten.IsKeyPressed(ebiten.KeyD) {
		g.firstPlayer.x++
		g.firstPlayer.dir = false
	}
	if ebiten.IsKeyPressed(ebiten.KeyE) {
		g.firstSword.throwSword = true
		g.firstSword.xThrowSword = g.firstPlayer.x
		g.firstSword.yThrowSword = int(g.firstPlayer.y)
	}
	if ebiten.IsKeyPressed(ebiten.KeySlash) {
		g.secondSword.throwSword = true
		g.secondSword.xThrowSword = screenWidth - g.secondPlayer.x
		g.secondSword.yThrowSword = int(g.secondPlayer.y)
	}
	if ebiten.IsKeyPressed(ebiten.KeyA) {
		g.firstPlayer.x--
		g.firstPlayer.dir = true
	}
	if ebiten.IsKeyPressed(ebiten.KeyArrowRight) {
		g.secondPlayer.x--
		g.secondPlayer.dir = false
	}
	if ebiten.IsKeyPressed(ebiten.KeyArrowLeft) {
		g.secondPlayer.x++
		g.secondPlayer.dir = true
	}
	if ebiten.IsKeyPressed(ebiten.KeyEscape) {
		return ebiten.Termination
	}
	if ebiten.IsKeyPressed(ebiten.KeyW) && g.firstPlayer.y <= 0 {
		g.firstPlayer.dirJump = true
	}
	if ebiten.IsKeyPressed(ebiten.KeyArrowUp) && g.secondPlayer.y <= 0 {
		g.secondPlayer.dirJump = true
	}
	return nil
}

func (g *Game) updatePlayerAndSwordPosition() {
	select {
	case <-ticker.C:
		g.updatePlayerAndSword()
	}
}

func (g *Game) updatePlayerAndSword() {
	if g.firstPlayer.y >= 0 && !g.firstPlayer.dirJump {
		g.firstPlayer.y -= 1.9
	}
	if g.secondPlayer.y >= 0 && !g.secondPlayer.dirJump {
		g.secondPlayer.y -= 1.9
	}
	if g.firstPlayer.dirJump && g.firstPlayer.y != 30 {
		g.firstPlayer.y += 1.9
	}
	if g.secondPlayer.dirJump && g.secondPlayer.y != 30 {
		g.secondPlayer.y += 1.9
	}
	if g.secondPlayer.y >= 30 {
		g.secondPlayer.dirJump = false
	}
	if g.firstPlayer.y >= 30 {
		g.firstPlayer.dirJump = false
	}
	if g.firstSword.throwSword {
		g.firstSword.xThrowSword++
	}
	if g.firstSword.xThrowSword == 226 {
		g.firstSword.throwSword = false
		g.firstSword.xThrowSword = 0
	}
	if g.secondSword.throwSword {
		g.secondSword.xThrowSword--
	}
	if g.secondSword.xThrowSword == 0 {
		g.secondSword.throwSword = false
		g.secondSword.xThrowSword = 226
	}
}

func (g *Game) getPlayerHitbox(xPos int, yPos float64) image.Rectangle {
	return image.Rect(xPos, int(yPos), xPos+frameWidth, int(yPos+frameHeight))
}

func (g *Game) drawSword(screen *ebiten.Image, op *ebiten.DrawImageOptions, xPos int, yPos float64) {
	op.GeoM.Translate(float64(xPos), float64(194-yPos))
	screen.DrawImage(swordImage, op)
}

func (g *Game) drawFirstSword(screen *ebiten.Image) {
	op := ebiten.DrawImageOptions{}
	if g.firstPlayer.dir {
		op.GeoM.Scale(-1, 1) // Flip the image horizontally
		g.drawSword(screen, &op, g.firstPlayer.x-24, g.firstPlayer.y-13)
		g.firstSword.x, g.firstSword.y = int(g.firstPlayer.y-13), g.firstPlayer.x-24
	} else {
		g.drawSword(screen, &op, g.firstPlayer.x+24, g.firstPlayer.y-13)
		g.firstSword.x, g.firstSword.y = int(g.firstPlayer.y-13), g.firstPlayer.x+24
	}
}

func (g *Game) drawSecondSword(screen *ebiten.Image) {
	op := ebiten.DrawImageOptions{}
	if g.secondPlayer.dir {
		op.GeoM.Scale(-1, 1) // Flip the image horizontally
		g.drawSword(screen, &op, screenWidth-g.secondPlayer.x-24, g.secondPlayer.y-13)
		g.secondSword.x, g.secondSword.y = int(g.firstPlayer.y-13), g.firstPlayer.x-24
	} else {
		g.drawSword(screen, &op, screenWidth-g.secondPlayer.x+24, g.secondPlayer.y-13)
		g.secondSword.x, g.secondSword.y = int(g.firstPlayer.y-13), g.firstPlayer.x+24
	}
}

func (g *Game) drawRunner(screen *ebiten.Image, op *ebiten.DrawImageOptions, xPos int, yPos float64, imageFramePos int) {
	// Draw the runner image
	op.GeoM.Translate(float64(xPos), float64(194-yPos))
	i := (imageFramePos / 5) % frameCount
	sx, sy := frameOX+i*frameWidth, frameOY
	screen.DrawImage(runnerImage.SubImage(image.Rect(sx, sy, sx+frameWidth, sy+frameHeight)).(*ebiten.Image), op)
}

func (g *Game) drawFirstRunner(screen *ebiten.Image) {
	op := ebiten.DrawImageOptions{}
	if g.firstPlayer.dir {
		op.GeoM.Scale(-1, 1) // Flip the image horizontally
	}
	g.drawRunner(screen, &op, g.firstPlayer.x, g.firstPlayer.y, g.firstPlayer.x)
}

func (g *Game) drawSecondRunner(screen *ebiten.Image) {
	op := ebiten.DrawImageOptions{}
	if g.secondPlayer.dir {
		op.GeoM.Scale(-1, 1) // Flip the image horizontally
	}
	g.drawRunner(screen, &op, screenWidth-g.secondPlayer.x, g.secondPlayer.y, g.secondPlayer.x) // Adjust the X-coordinate to reverse the image
}

func (g *Game) drawGrass(screen *ebiten.Image) {
	grassBlockWidth := grassBlockImage.Bounds().Dx()
	for i := 0; i < 226; i++ {
		op := &ebiten.DrawImageOptions{}
		op.GeoM.Translate(float64(i*grassBlockWidth), float64(226))
		screen.DrawImage(grassBlockImage, op)
	}
}

func (g *Game) drawClouds(screen *ebiten.Image) {
	cloudBlockWidth := cloudBlockImage.Bounds().Dx()
	cloudBlockHeight := cloudBlockImage.Bounds().Dy()

	// Define the number of rows, columns, and clouds for the cloud grid
	rows := 2
	columns := 4
	clouds := 3
	spacing := cloudBlockWidth // Initial spacing between clouds

	for i := 0; i < clouds; i++ {
		for j := 0; j < rows; j++ {
			for k := 0; k < columns; k++ {
				op := &ebiten.DrawImageOptions{}
				op.GeoM.Translate(float64(k*cloudBlockWidth+spacing), float64(j*cloudBlockHeight)) // Adjust the Y-coordinate for rows
				screen.DrawImage(cloudBlockImage, op)
			}
		}
		// Increase the spacing for the next cloud
		spacing += cloudBlockWidth
	}
}

func (g *Game) drawThrowingFirstSword(screen *ebiten.Image) {
	if g.firstSword.throwSword {
		var img ebiten.Image
		op := ebiten.DrawImageOptions{}
		i := (g.firstSword.xThrowSword / 4) % 4
		log.Infof("i: %d xPos: %d", i, g.firstSword.xThrowSword)
		switch i {
		case 0:
			log.Info("Got into case 0")
			img = *swordAnimations[0]
		case 1:
			log.Info("Got into case 1")
			img = *swordAnimations[1]
		case 2:
			log.Info("Got into case 2")
			img = *swordAnimations[2]
		case 3:
			log.Info("Got into case 3")
			img = *swordAnimations[3]
		}
		op.GeoM.Translate(float64(g.firstSword.xThrowSword), 194-float64(g.firstSword.yThrowSword))
		screen.DrawImage(&img, &op)
	}
}

func (g *Game) drawThrowingSecondSword(screen *ebiten.Image) {
	if g.secondSword.throwSword {
		var img ebiten.Image
		op := ebiten.DrawImageOptions{}
		i := (g.secondSword.xThrowSword / 4) % 4
		log.Infof("i: %d xPos: %d", i, g.secondSword.xThrowSword)
		switch i {
		case 0:
			log.Info("Got into case 0")
			img = *swordAnimations[0]
		case 1:
			log.Info("Got into case 1")
			img = *swordAnimations[1]
		case 2:
			log.Info("Got into case 2")
			img = *swordAnimations[2]
		case 3:
			log.Info("Got into case 3")
			img = *swordAnimations[3]
		}
		op.GeoM.Translate(float64(g.secondSword.xThrowSword), 194-float64(g.secondSword.yThrowSword))
		screen.DrawImage(&img, &op)
	}
}

func (g *Game) Draw(screen *ebiten.Image) {
	g.drawFirstRunner(screen)
	g.drawSecondRunner(screen)
	g.drawFirstSword(screen)
	g.drawSecondSword(screen)
	g.drawGrass(screen)
	g.drawClouds(screen)
	g.drawThrowingFirstSword(screen)
	g.drawThrowingSecondSword(screen)
}

func (g *Game) Layout(outsideWidth, outsideHeight int) (int, int) {
	return screenWidth, screenHeight
}

func loadImage(imagePath string) *ebiten.Image {
	data, err := imageToByteArray(imagePath)
	if err != nil {
		log.Fatalf("could not log image from path %s: %v", imagePath, err)
	}
	image, _, err := image.Decode(bytes.NewReader(data))
	if err != nil {
		log.Fatalf("could not decode image from path %s: %v", imagePath, err)
	}
	return ebiten.NewImageFromImage(image)
}

func main() {
	log = logrus.New()
	log.SetLevel(logrus.InfoLevel)
	log.SetFormatter(&logrus.JSONFormatter{})
	logFile, err := os.OpenFile("log.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
	if err == nil {
		log.SetOutput(logFile)
	} else {
		log.Error("Failed to open log file: ", err)
	}
	conn, err = net.Dial("tcp", "localhost:8080")
	if err != nil {
		log.Errorf("Dial error: %v", err)
		return
	}
	defer conn.Close()
	defer logFile.Close()
	grassBlockImage = loadImage("images/grassBlock.png")
	cloudBlockImage = loadImage("images/cloudBlock.png")

	swordAnimations[0] = loadImage("images/swordAnimations/rsword.png")
	swordAnimations[1] = loadImage("images/swordAnimations/usword.png")
	swordAnimations[2] = loadImage("images/swordAnimations/lsword.png")
	swordAnimations[3] = loadImage("images/swordAnimations/dsword.png")

	runnerImage = loadImage("images/runner.png")
	swordImage = loadImage("images/sword.png")
	ebiten.SetFullscreen(true)
	ebiten.SetWindowTitle("Bin Bog")
	g := &Game{}
	go g.updateNetwork()
	if err := ebiten.RunGame(g); err != nil {
		log.Fatal(err)
	}
}

[hajimehoshi]

I have a question

What's the question?

[Esa824]

I have a question

What's the question?

In updateNetworks there is a problem because it gets the coordinates but it puts in the g but the game in the drawRunners and all of that isn't getting affected why?