GOingTunneling/main.go

package main

import (
	"github.com/veandco/go-sdl2/sdl"
)

const (
	MapWidth    = 1000 // Width of the map
	MapHeight   = 1000 // Height of the map
	BlastRadius = 5

	MaxEnergy     = 3520
	MaxAmmunition = 6
	MaxShields    = 100

	NormalShotCost        = 7
	SuperShotCost         = 80
	ReloadCost            = 4
	MovementCost          = 1
	DiggingCost           = 3
	ShootDiggingCostBonus = 1

	ShootCooldown            = 8
	RechargeCooldownOwn      = 0
	DiggingCooldown          = 4
	RechargeCooldownOpponent = 6
	RepairCooldown           = 4
	MovementCooldown         = 2
	MovementCooldownNoEnergy = 4
	DiggingCooldownNoEnergy  = 8
	ReloadCooldown           = 16

	Debug             = false
	MapWindow         = true
	RenderGameObjects = true
	ProfilerOn        = true

	JoyStickDeadZone = 8000

	DoAllKeymapsPlayers = true
	DoJoyStickPlayers   = true
	DoKeymapPlayer      = true
)

var mapWindow *sdl.Window
var mapSurface *sdl.Surface
var mapRendererRect = &sdl.Rect{X: 0, Y: 0, W: MapWidth, H: MapHeight}

func main() {
	initializeSDL()
	defer sdl.Quit()

	gameMap := &GameMap{}
	gameMap.createGameMap(MapWidth, MapHeight)

	players := &[]*Player{}
	initPlayerColors()
	createPlayers(getNeededPlayers(), playerColors, keyMaps, joyMaps, gameMap, players)

	defer closeThings(players)

	bases := createBases(players, gameMap)

	bullets := &[]*Bullet{}
	bulletParticles := &[]*BulletParticle{}

	for playerIndex, player := range *players {
		initPlayer(uint8(playerIndex), player)
	}
	if MapWindow {
		mapWindow, mapSurface = setupMapWindowAndSurface()
	}
	running := true
	for running {
		frameStart := sdl.GetTicks64()
		for playerIndex, player := range *players {
			// Delay to achieve roughly 60 FPS
			if player.local {
				running = doPlayerFrame(uint8(playerIndex), player, players, gameMap, bases, bullets, bulletParticles)
				if !running {
					break
				}
			}
		}
		if MapWindow {
			gameMap.render(mapRendererRect, mapSurface)
			for _, bullet := range *bullets {
				(*bullet).render(mapRendererRect, mapSurface)
			}
			for _, base := range *bases {
				(*base).render(mapRendererRect, mapSurface)
			}
			for _, playerLoop := range *players {
				(*playerLoop).render(mapRendererRect, mapSurface)
			}
			for _, bulletParticle := range *bulletParticles {
				bulletParticle.render(mapRendererRect, mapSurface)
			}
			adjustWindow(mapWindow, mapSurface)
		}
		//now tick world
		for _, bullet := range *bullets {
			(*bullet).tick(gameMap, bulletParticles, bullets, players)
		}
		for _, base := range *bases {
			(*base).tick(players)
		}
		for _, bulletParticle := range *bulletParticles {
			bulletParticle.tick(bulletParticles)
		}

		enforceFrameRate(frameStart, 60)
	}
}

func initPlayer(playerIndex uint8, player *Player) {
	player.window, player.logicalSurface = setupWindowAndSurface(playerIndex)
	logicalColor := sdl.MapRGBA(player.logicalSurface.Format, 101, 101, 0, 255)
	player.logicalSurface.FillRect(nil, logicalColor)

	player.playSurface, player.playSurfaceRect, player.playSurfaceTargetRect = setupPlaySurface()
	playColor := sdl.MapRGBA(player.playSurface.Format, 101, 0, 101, 255)
	player.playSurface.FillRect(nil, playColor)

	player.HUDSurface, player.HUDSurfaceRect, player.HUDSurfaceTargetRect = setupHUDSurface()
	initHud(player.HUDSurface)
	player.camera = &sdl.Rect{X: 0, Y: 0, W: 76, H: 76}
}

func doPlayerFrame(playerIndex uint8, player *Player, players *[]*Player, gameMap *GameMap, bases *[]*Base, bullets *[]*Bullet, bulletParticles *[]*BulletParticle) bool {
	running := true
	var (
		totalHandleEventsTime, totalRenderTime, totalFrameTime uint64
		totalScalingTime, frameCount                           uint64
		isShooting, shouldContinue                             bool
	)
	frameStart := sdl.GetTicks64()

	// Profile handleEvents
	totalHandleEventsTime += profileSection(func() {
		running = handleEvents(player.window, player.logicalSurface)
		keyboard := sdl.GetKeyboardState()
		shouldContinue, isShooting = handleInput(keyboard, bullets, player, gameMap, player.playSurface.Format, players)
		running = running && shouldContinue
	})

	// Profile rendering (aggregate all renderings)
	totalRenderTime += profileSection(func() {
		player.track(player.camera)
		gameMap.render(player.camera, player.playSurface)

		for _, bullet := range *bullets {
			(*bullet).render(player.camera, player.playSurface)
		}
		for _, base := range *bases {
			(*base).render(player.camera, player.playSurface)
		}
		for _, playerLoop := range *players {
			(*playerLoop).render(player.camera, player.playSurface)
		}
		for _, bulletParticle := range *bulletParticles {
			bulletParticle.render(player.camera, player.playSurface)
		}

		player.tick(isShooting, bullets, player.playSurface.Format)
		renderHud(player, player.HUDSurface)
		player.playSurface.BlitScaled(player.playSurfaceRect, player.logicalSurface, player.playSurfaceTargetRect)
		player.HUDSurface.BlitScaled(player.HUDSurfaceRect, player.logicalSurface, player.HUDSurfaceTargetRect)
	})

	// Profile window adjustments
	totalScalingTime += profileSection(func() {
		adjustWindow(player.window, player.logicalSurface)
	})

	frameEnd := sdl.GetTicks64()
	totalFrameTime += frameEnd - frameStart
	frameCount++

	// Log profiling information every 1000 frames
	if frameCount%1000 == 0 && ProfilerOn && playerIndex == 0 {
		logProfilingInfo(totalHandleEventsTime, totalRenderTime, totalScalingTime, totalFrameTime, frameCount)
		resetProfilingCounters(&totalHandleEventsTime, &totalRenderTime, &totalScalingTime, &totalFrameTime, &frameCount)
	}
	return running
}