package main

import (
	"bufio"
	"bytes"
	"encoding/binary"
	"github.com/veandco/go-sdl2/sdl"
	tunnelerProto "goingtunneling/proto"
	"google.golang.org/protobuf/proto"
	"image/color"
	"io"
	"log"
	"math/rand"
	"net"
	"os"
	"sync"
)

var lastPlayerID = uint32(0)

type Player struct {
	local        bool
	connection   *net.TCPConn
	playerColors PlayerColors
	keyMap       KeyMap
	joyMap       JoyMap
	joyStick     *sdl.Joystick
	camera       *sdl.Rect
	energy       uint32
	ammunition   uint32
	shields      uint32

	digCooldown      uint32
	shootCooldown    uint32
	repairCooldown   uint32
	rechargeCooldown uint32
	movementCooldown uint32
	reloadCooldown   uint32

	gameObject *GameObject
	playerID   uint32

	knownGameMap         *GameMap
	gameMapUpdates       []TileUpdate
	knownBullets         map[uint32]*Bullet
	knownBulletParticles map[uint32]*BulletParticle
	knownBases           map[uint32]*Base
	knownPlayers         map[uint32]*Player
	previousEnergy       uint32
	previousAmmunition   uint32
	previousShields      uint32

	window *sdl.Window

	logicalSurface *sdl.Surface
	playSurface    *sdl.Surface
	HUDSurface     *sdl.Surface

	playSurfaceRect *sdl.Rect
	HUDSurfaceRect  *sdl.Rect

	playSurfaceTargetRect *sdl.Rect
	HUDSurfaceTargetRect  *sdl.Rect

	totalHandleEventsTime uint64
	totalRenderTime       uint64
	totalFrameTime        uint64
	totalScalingTime      uint64
	frameCount            uint64
}

type TileUpdate struct {
	PosX uint32
	PosY uint32
	Kind uint8
}

func (player *Player) track(camera *sdl.Rect) {
	camera.X = player.gameObject.baseRect.X - 37
	camera.Y = player.gameObject.baseRect.Y - 38
}

func (player *Player) render(camera *sdl.Rect, surface *sdl.Surface, players map[uint32]*Player) {

	// Common part: Rendering player
	player.gameObject.baseRect = sdl.Rect{X: player.gameObject.baseRect.X, Y: player.gameObject.baseRect.Y, W: 7, H: 7}

	if player.shields > 0 &&
		player.shields <= serverConfig.MaxShields &&
		player.gameObject.baseRect.X >= 0 &&
		player.gameObject.baseRect.Y >= 0 {
		player.gameObject.render(camera, surface)
		if !player.gameObject.inView && !config.Server {
			delete(players, player.playerID)
		}
	}

}

func (player *Player) digBlock(posX, posY int32, gameMap *GameMap, isShooting bool) uint8 {
	collisionAtDigSite := gameMap.checkCollision(posX, posY)
	if collisionAtDigSite == 0 {
		return 0
	} else if collisionAtDigSite == 1 && (player.digCooldown == 0 || isShooting) {
		player.digCooldown = serverConfig.DiggingCooldown
		if config.Client {
			player.sendDigToServer(uint32(posX), uint32(posY), isShooting)
			return 2
		}
		gameMap.tiles[posX][posY] = 0
		return 1
	}
	return 2
}

func (player *Player) tick(bullets map[uint32]*Bullet) {
	if player.digCooldown > 0 {
		player.digCooldown--
	}
	if player.shootCooldown > 0 {
		player.shootCooldown--
	}
	if player.repairCooldown > 0 {
		player.repairCooldown--
	}
	if player.rechargeCooldown > 0 {
		player.rechargeCooldown--
	}
	if player.movementCooldown > 0 {
		player.movementCooldown--
	}
	if player.reloadCooldown > 0 {
		player.reloadCooldown--
	} else if player.ammunition < serverConfig.MaxAmmunition && player.shootCooldown == 0 && player.energy > serverConfig.ReloadCost {
		player.ammunition++
		player.reloadCooldown = serverConfig.ReloadCooldown
		player.energy -= serverConfig.ReloadCost
	}
	if player.shields <= 0 {
		player.shields = serverConfig.MaxShields + 1
		player.explode(bullets)
	}
}

func (player *Player) tryMove(gameMap *GameMap, isShooting bool, players map[uint32]*Player) (moved bool) {
	if player.movementCooldown > 0 {
		return false
	}
	ranOutOfEnergy := (isShooting && player.energy <= serverConfig.DiggingCost+serverConfig.ShootDiggingCostBonus) || player.energy <= serverConfig.DiggingCost
	if ranOutOfEnergy {
		isShooting = false
	}
	shouldPenalizeDigging := false
	stopped := false

	switch player.gameObject.orientation {
	case 0: // Up
		collisionRect := sdl.Rect{
			X: player.gameObject.baseRect.X,
			Y: player.gameObject.baseRect.Y - 1,
			W: 5,
			H: 7,
		}
		for _, opponent := range players {
			if opponent != player && opponent.gameObject.baseRect.HasIntersection(&collisionRect) && opponent.shields <= serverConfig.MaxShields {
				return false
			}
		}
		for x := player.gameObject.baseRect.X; x < player.gameObject.baseRect.X+5 && !stopped; x++ {
			for y := player.gameObject.baseRect.Y - 1; y < player.gameObject.baseRect.Y+7; y++ {
				digResult := player.digBlock(x, y, gameMap, isShooting)
				if digResult == 1 {
					shouldPenalizeDigging = true
					if !isShooting {
						stopped = true
						break
					}
				} else if digResult != 0 {
					stopped = true
					break
				}
			}
		}
		if !stopped {
			moved = true
			player.gameObject.baseRect.Y--
		}

	case 1: // Right
		collisionRect := sdl.Rect{
			X: player.gameObject.baseRect.X + 1,
			Y: player.gameObject.baseRect.Y,
			W: 7,
			H: 5,
		}
		for _, opponent := range players {
			if opponent != player && opponent.gameObject.baseRect.HasIntersection(&collisionRect) {
				return false
			}
		}
		for y := player.gameObject.baseRect.Y + 1; y < player.gameObject.baseRect.Y+6 && !stopped; y++ {
			for x := player.gameObject.baseRect.X + 1; x < player.gameObject.baseRect.X+8; x++ {
				digResult := player.digBlock(x, y, gameMap, isShooting)
				if digResult == 1 {
					shouldPenalizeDigging = true
					if !isShooting {
						stopped = true
						break
					}
				} else if digResult != 0 {
					stopped = true
					break
				}
			}
		}
		if !stopped {
			moved = true
			player.gameObject.baseRect.X++
		}

	case 2: // Down
		collisionRect := sdl.Rect{
			X: player.gameObject.baseRect.X,
			Y: player.gameObject.baseRect.Y + 1,
			W: 5,
			H: 7,
		}
		for _, opponent := range players {
			if opponent != player && opponent.gameObject.baseRect.HasIntersection(&collisionRect) {
				return false
			}
		}
		for x := player.gameObject.baseRect.X; x < player.gameObject.baseRect.X+5 && !stopped; x++ {
			for y := player.gameObject.baseRect.Y + 1; y < player.gameObject.baseRect.Y+8; y++ {
				digResult := player.digBlock(x, y, gameMap, isShooting)
				if digResult == 1 {
					shouldPenalizeDigging = true
					if !isShooting {
						stopped = true
						break
					}
				} else if digResult != 0 {
					stopped = true
					break
				}
			}
		}
		if !stopped {
			moved = true
			player.gameObject.baseRect.Y++
		}

	case 3: // Left
		collisionRect := sdl.Rect{
			X: player.gameObject.baseRect.X - 1,
			Y: player.gameObject.baseRect.Y,
			W: 7,
			H: 5,
		}
		for _, opponent := range players {
			if opponent != player && opponent.gameObject.baseRect.HasIntersection(&collisionRect) {
				return false
			}
		}
		for y := player.gameObject.baseRect.Y + 1; y < player.gameObject.baseRect.Y+6 && !stopped; y++ {
			for x := player.gameObject.baseRect.X - 1; x < player.gameObject.baseRect.X+6; x++ {
				digResult := player.digBlock(x, y, gameMap, isShooting)
				if digResult == 1 {
					shouldPenalizeDigging = true
					if !isShooting {
						stopped = true
						break
					}
				} else if digResult != 0 {
					stopped = true
					break
				}
			}
		}
		if !stopped {
			moved = true
			player.gameObject.baseRect.X--
		}

	case 4: // Up-Right
		collisionRect := sdl.Rect{
			X: player.gameObject.baseRect.X + 1,
			Y: player.gameObject.baseRect.Y - 1,
			W: 7,
			H: 7,
		}
		for _, opponent := range players {
			if opponent != player && opponent.gameObject.baseRect.HasIntersection(&collisionRect) {
				return false
			}
		}
		for x := player.gameObject.baseRect.X + 1; x < player.gameObject.baseRect.X+8 && !stopped; x++ {
			for y := player.gameObject.baseRect.Y - 1; y < player.gameObject.baseRect.Y+6; y++ {
				digResult := player.digBlock(x, y, gameMap, isShooting)
				if digResult == 1 {
					shouldPenalizeDigging = true
					if !isShooting {
						stopped = true
						break
					}
				} else if digResult != 0 {
					stopped = true
					break
				}
			}
		}
		if !stopped {
			moved = true
			player.gameObject.baseRect.X++
			player.gameObject.baseRect.Y--
		}

	case 5: // Up-Left
		collisionRect := sdl.Rect{
			X: player.gameObject.baseRect.X - 1,
			Y: player.gameObject.baseRect.Y - 1,
			W: 7,
			H: 7,
		}
		for _, opponent := range players {
			if opponent != player && opponent.gameObject.baseRect.HasIntersection(&collisionRect) {
				return false
			}
		}
		for x := player.gameObject.baseRect.X - 1; x < player.gameObject.baseRect.X+6 && !stopped; x++ {
			for y := player.gameObject.baseRect.Y - 1; y < player.gameObject.baseRect.Y+6; y++ {
				digResult := player.digBlock(x, y, gameMap, isShooting)
				if digResult == 1 {
					shouldPenalizeDigging = true
					if !isShooting {
						stopped = true
						break
					}
				} else if digResult != 0 {
					stopped = true
					break
				}
			}
		}
		if !stopped {
			moved = true
			player.gameObject.baseRect.X--
			player.gameObject.baseRect.Y--
		}

	case 6: // Down-Right
		collisionRect := sdl.Rect{
			X: player.gameObject.baseRect.X + 1,
			Y: player.gameObject.baseRect.Y + 1,
			W: 7,
			H: 7,
		}
		for _, opponent := range players {
			if opponent != player && opponent.gameObject.baseRect.HasIntersection(&collisionRect) {
				return false
			}
		}
		for x := player.gameObject.baseRect.X + 1; x < player.gameObject.baseRect.X+8 && !stopped; x++ {
			for y := player.gameObject.baseRect.Y + 1; y < player.gameObject.baseRect.Y+8; y++ {
				digResult := player.digBlock(x, y, gameMap, isShooting)
				if digResult == 1 {
					shouldPenalizeDigging = true
					if !isShooting {
						stopped = true
						break
					}
				} else if digResult != 0 {
					stopped = true
					break
				}
			}
		}
		if !stopped {
			moved = true
			player.gameObject.baseRect.X++
			player.gameObject.baseRect.Y++
		}

	case 7: // Down-Left
		collisionRect := sdl.Rect{
			X: player.gameObject.baseRect.X - 1,
			Y: player.gameObject.baseRect.Y + 1,
			W: 7,
			H: 7,
		}
		for _, opponent := range players {
			if opponent != player && opponent.gameObject.baseRect.HasIntersection(&collisionRect) {
				return false
			}
		}
		for x := player.gameObject.baseRect.X - 1; x < player.gameObject.baseRect.X+6 && !stopped; x++ {
			for y := player.gameObject.baseRect.Y + 1; y < player.gameObject.baseRect.Y+8; y++ {
				digResult := player.digBlock(x, y, gameMap, isShooting)
				if digResult == 1 {
					shouldPenalizeDigging = true
					if !isShooting {
						stopped = true
						break
					}
				} else if digResult != 0 {
					stopped = true
					break
				}
			}
		}
		if !stopped {
			moved = true
			player.gameObject.baseRect.X--
			player.gameObject.baseRect.Y++
		}
	}

	if config.Client {
		player.sendPositionToServer()
	}

	// Penalties and cooldown handling
	if shouldPenalizeDigging {
		if isShooting && player.ammunition < serverConfig.MaxAmmunition && rand.Intn(2) == 0 {
			player.ammunition++
		}
		if ranOutOfEnergy {
			player.digCooldown = serverConfig.DiggingCooldownNoEnergy
		}
		player.energy -= serverConfig.DiggingCost
		if isShooting {
			player.energy -= serverConfig.ShootDiggingCostBonus
		}
	}
	if moved {
		if ranOutOfEnergy {
			player.movementCooldown = serverConfig.MovementCooldownNoEnergy
		} else {
			player.movementCooldown = serverConfig.MovementCooldown
		}
	}
	return
}

func (player *Player) getRGBAColor(colorIndex uint8, format *sdl.PixelFormat) uint32 {
	var selectedColor color.Color
	switch colorIndex {
	case 0:
		selectedColor = player.playerColors.tracks
	case 1:
		selectedColor = player.playerColors.body
	case 2:
		selectedColor = player.playerColors.cannon
	}
	var r, g, b, a uint8
	if selectedColor != nil {
		rt, gt, bt, at := selectedColor.RGBA()
		r, g, b, a = uint8(rt), uint8(gt), uint8(bt), uint8(at)
	}
	return sdl.MapRGBA(format, r, g, b, a)

}

func (player *Player) shoot(super bool, bullets map[uint32]*Bullet) {
	if (super && (player.energy <= serverConfig.SuperShotCost || player.ammunition < serverConfig.MaxAmmunition)) || (!super && (player.energy <= serverConfig.NormalShotCost || player.ammunition < 1)) {
		return
	}
	if player.shootCooldown == 0 {
		var shootX, shootY int32

		switch player.gameObject.orientation {
		case 0: // Up
			shootY = player.gameObject.baseRect.Y - 1
			shootX = player.gameObject.baseRect.X + 2
			break
		case 1: // Right
			shootY = player.gameObject.baseRect.Y + 3
			shootX = player.gameObject.baseRect.X + 8
			break
		case 2: // Down
			shootX = player.gameObject.baseRect.X + 2
			shootY = player.gameObject.baseRect.Y + 8
			break
		case 3: // Left
			shootY = player.gameObject.baseRect.Y + 3
			shootX = player.gameObject.baseRect.X - 2
			break
		case 4: // Up-Right
			shootY = player.gameObject.baseRect.Y
			shootX = player.gameObject.baseRect.X + 5
			break
		case 5: // Up-Left
			shootY = player.gameObject.baseRect.Y
			shootX = player.gameObject.baseRect.X - 1
			break
		case 6: // Down-Right
			shootY = player.gameObject.baseRect.Y + 5
			shootX = player.gameObject.baseRect.X + 5
			break
		case 7: // Down-Left
			shootY = player.gameObject.baseRect.Y + 5
			shootX = player.gameObject.baseRect.X - 1
			break
		}

		player.shootCooldown = serverConfig.ShootCooldown
		// Set cooldown and decrease energy
		if super {
			player.energy -= serverConfig.SuperShotCost
			player.ammunition = 0
		} else {
			player.energy -= serverConfig.NormalShotCost
			player.ammunition--
		}
		if config.Client {
			player.sendShootToServer(super)
		} else {
			// Set bullet color
			bulletColor := player.playerColors.body

			// Create and add the bullet
			bullets[bulletLastID] = &Bullet{
				posX:      shootX,
				posY:      shootY,
				direction: player.gameObject.orientation,
				color:     bulletColor,
				super:     super,
				id:        bulletLastID,
			}
			bulletLastID++
		}
	}
}

func (player *Player) explode(bullets map[uint32]*Bullet) {
	// Set bullet color
	bulletColor := player.playerColors.body

	for x := player.gameObject.baseRect.X - int32(serverConfig.BlastRadius); x < int32(serverConfig.BlastRadius)*2+1; x++ {
		for y := player.gameObject.baseRect.Y - int32(serverConfig.BlastRadius); y < int32(serverConfig.BlastRadius)*2+1; y++ {
			// Create and add the bullet
			bullets[bulletLastID] = &Bullet{
				posX:      x,
				posY:      y,
				direction: uint8(rand.Intn(8)),
				color:     bulletColor,
				super:     true,
				id:        bulletLastID,
			}
			bulletLastID++

		}
	}
}

func createPlayers(amount uint8, playerColors []PlayerColors, keyMaps []KeyMap, joyMaps []JoyMap, gameMap *GameMap, players map[uint32]*Player) {
	joyStickCount := sdl.NumJoysticks()
	if amount > uint8(len(keyMaps)+len(joyMaps)) || amount > uint8(len(keyMaps)+joyStickCount) {
		panic("Too many players, not enough inputs")
	}
	if amount >= uint8(len(playerColors)) {
		panic("Too many players, not enough colors")
	}
	addedKeyboardPlayers := 0
	for i := uint8(0); i < amount; i++ {
		var keyMap KeyMap
		var joyMap JoyMap
		var joyStick *sdl.Joystick

		if (config.DoAllKeymapsPlayers && i <= uint8(len(keyMaps))) || (config.DoKeymapPlayer && i == 0) || (uint8(joyStickCount) <= i) {
			keyMap = keyMaps[addedKeyboardPlayers]
			addedKeyboardPlayers++
		} else {
			joyStickIndex := i - uint8(addedKeyboardPlayers)
			joyMap = joyMaps[joyStickIndex]
			joyStick = sdl.JoystickOpen(int(joyStickIndex))
		}
		createPlayer(
			true,
			playerColors[len(players)%len(playerColors)],
			nil,
			keyMap,
			joyMap,
			joyStick,
			gameMap,
			players,
		)
	}
}

func closeThings(players map[uint32]*Player) {
	for _, player := range players {
		if player.joyStick != nil {
			player.joyStick.Close()
		}
		if player.window != nil {
			player.window.Destroy()
		}
		if player.logicalSurface != nil {
			player.logicalSurface.Free()
		}
		if player.playSurface != nil {
			player.playSurface.Free()
		}
		if player.HUDSurface != nil {
			player.HUDSurface.Free()
		}
	}
}

func createPlayer(local bool, thisPlayerColors PlayerColors, conn *net.TCPConn, keyMap KeyMap, joyMap JoyMap, joyStick *sdl.Joystick, gameMap *GameMap, players map[uint32]*Player) uint32 {
	coordsAreValid := false
	var posX, posY int32
	maxTries := 1000
	for !coordsAreValid && maxTries >= 0 {
		maxTries--
		posX = int32(16 + rand.Intn(int(gameMap.width-43)))
		posY = int32(16 + rand.Intn(int(gameMap.height-43)))

		coordsAreValid = true
		for _, player := range players {
			distance := (player.gameObject.baseRect.X-posX)*(player.gameObject.baseRect.X-posX) +
				(player.gameObject.baseRect.Y-posY)*(player.gameObject.baseRect.Y-posY)
			if distance < 300*300 { // Check if distance is less than 300 units
				coordsAreValid = false
				break
			}
		}
		if posX < 16 || posX > int32(gameMap.width-36-7) || posY < 16 || posY > int32(gameMap.height-36-7) {
			coordsAreValid = false
			break
		}
	}
	if maxTries < 0 {
		panic("Could not place all players, increase map size")
	}

	gameObject := &GameObject{}

	gameObject.baseRect = sdl.Rect{
		X: posX,
		Y: posY,
		W: 7,
		H: 7,
	}

	gameObject.addColor(thisPlayerColors.tracks)
	gameObject.addColor(thisPlayerColors.body)
	gameObject.addColor(thisPlayerColors.cannon)

	gameObject.orientation = 0 // Up
	gameObject.addColoredRect(0, 1, 1, 6, 0)
	gameObject.addColoredRect(4, 1, 1, 6, 0)
	gameObject.addColoredRect(1, 2, 3, 4, 1)
	gameObject.addColoredRect(2, 0, 1, 4, 2)

	gameObject.orientation = 1 // Right
	gameObject.addColoredRect(1, 1, 6, 1, 0)
	gameObject.addColoredRect(1, 5, 6, 1, 0)
	gameObject.addColoredRect(2, 2, 4, 3, 1)
	gameObject.addColoredRect(4, 3, 4, 1, 2)

	gameObject.orientation = 2 // Down
	gameObject.addColoredRect(0, 1, 1, 6, 0)
	gameObject.addColoredRect(4, 1, 1, 6, 0)
	gameObject.addColoredRect(1, 2, 3, 4, 1)
	gameObject.addColoredRect(2, 4, 1, 4, 2)

	gameObject.orientation = 3 // Left
	gameObject.addColoredRect(1, 1, 6, 1, 0)
	gameObject.addColoredRect(1, 5, 6, 1, 0)
	gameObject.addColoredRect(2, 2, 4, 3, 1)
	gameObject.addColoredRect(0, 3, 4, 1, 2)

	gameObject.orientation = 4 // Up-Right
	gameObject.addColoredRect(3, 0, 1, 1, 0)
	gameObject.addColoredRect(2, 1, 1, 1, 0)
	gameObject.addColoredRect(1, 2, 1, 1, 0)
	gameObject.addColoredRect(0, 3, 1, 1, 0)
	gameObject.addColoredRect(6, 3, 1, 1, 0)
	gameObject.addColoredRect(5, 4, 1, 1, 0)
	gameObject.addColoredRect(4, 5, 1, 1, 0)
	gameObject.addColoredRect(3, 6, 1, 1, 0)

	gameObject.addColoredRect(3, 1, 1, 1, 1)
	gameObject.addColoredRect(2, 2, 2, 1, 1)
	gameObject.addColoredRect(1, 3, 2, 1, 1)

	gameObject.addColoredRect(4, 3, 2, 1, 1)
	gameObject.addColoredRect(2, 4, 3, 1, 1)
	gameObject.addColoredRect(3, 5, 1, 1, 1)

	gameObject.addColoredRect(5, 1, 1, 1, 2)
	gameObject.addColoredRect(4, 2, 1, 1, 2)
	gameObject.addColoredRect(3, 3, 1, 1, 2)

	// Up-Left orientation (Y-axis reflection)
	gameObject.orientation = 5 // Up-Left
	gameObject.addColoredRect(3, 0, 1, 1, 0)
	gameObject.addColoredRect(4, 1, 1, 1, 0)
	gameObject.addColoredRect(5, 2, 1, 1, 0)
	gameObject.addColoredRect(6, 3, 1, 1, 0)
	gameObject.addColoredRect(0, 3, 1, 1, 0)
	gameObject.addColoredRect(1, 4, 1, 1, 0)
	gameObject.addColoredRect(2, 5, 1, 1, 0)
	gameObject.addColoredRect(3, 6, 1, 1, 0)

	gameObject.addColoredRect(3, 1, 1, 1, 1)
	gameObject.addColoredRect(3, 2, 2, 1, 1)
	gameObject.addColoredRect(4, 3, 2, 1, 1)

	gameObject.addColoredRect(1, 3, 2, 1, 1)
	gameObject.addColoredRect(2, 4, 3, 1, 1)
	gameObject.addColoredRect(3, 5, 1, 1, 1)

	gameObject.addColoredRect(1, 1, 1, 1, 2)
	gameObject.addColoredRect(2, 2, 1, 1, 2)
	gameObject.addColoredRect(3, 3, 1, 1, 2)

	// Down-Right orientation (X-axis reflection)
	gameObject.orientation = 6 // Down-Right
	gameObject.addColoredRect(3, 6, 1, 1, 0)
	gameObject.addColoredRect(2, 5, 1, 1, 0)
	gameObject.addColoredRect(1, 4, 1, 1, 0)
	gameObject.addColoredRect(0, 3, 1, 1, 0)
	gameObject.addColoredRect(6, 3, 1, 1, 0)
	gameObject.addColoredRect(5, 2, 1, 1, 0)
	gameObject.addColoredRect(4, 1, 1, 1, 0)
	gameObject.addColoredRect(3, 0, 1, 1, 0)

	gameObject.addColoredRect(3, 5, 1, 1, 1)
	gameObject.addColoredRect(2, 4, 2, 1, 1)
	gameObject.addColoredRect(1, 3, 2, 1, 1)

	gameObject.addColoredRect(4, 3, 2, 1, 1)
	gameObject.addColoredRect(2, 2, 3, 1, 1)
	gameObject.addColoredRect(3, 1, 1, 1, 1)

	gameObject.addColoredRect(5, 5, 1, 1, 2)
	gameObject.addColoredRect(4, 4, 1, 1, 2)
	gameObject.addColoredRect(3, 3, 1, 1, 2)

	// Down-Left orientation (XY reflection)
	gameObject.orientation = 7 // Down-Left
	gameObject.addColoredRect(3, 6, 1, 1, 0)
	gameObject.addColoredRect(4, 5, 1, 1, 0)
	gameObject.addColoredRect(5, 4, 1, 1, 0)
	gameObject.addColoredRect(6, 3, 1, 1, 0)
	gameObject.addColoredRect(0, 3, 1, 1, 0)
	gameObject.addColoredRect(1, 2, 1, 1, 0)
	gameObject.addColoredRect(2, 1, 1, 1, 0)
	gameObject.addColoredRect(3, 0, 1, 1, 0)

	gameObject.addColoredRect(3, 1, 1, 1, 1)
	gameObject.addColoredRect(2, 2, 3, 1, 1)
	gameObject.addColoredRect(1, 3, 2, 1, 1)

	gameObject.addColoredRect(4, 3, 2, 1, 1)
	gameObject.addColoredRect(3, 4, 2, 1, 1)
	gameObject.addColoredRect(3, 5, 1, 1, 1)

	gameObject.addColoredRect(1, 5, 1, 1, 2)
	gameObject.addColoredRect(2, 4, 1, 1, 2)
	gameObject.addColoredRect(3, 3, 1, 1, 2)

	gameObject.orientation = 0

	if !local && (keyMap.exit != keyMap.shoot || joyMap.exitButton != joyMap.shootButton) {
		panic("Input assigned to remote player")
	}

	knownGameMap := GameMap{width: gameMap.width, height: gameMap.height, tiles: make([][]uint8, serverConfig.MapWidth)}
	for i := uint32(0); i < serverConfig.MapWidth; i++ {
		knownGameMap.tiles[i] = make([]uint8, serverConfig.MapHeight)
	}

	players[lastPlayerID] = &Player{
		playerColors:         thisPlayerColors,
		keyMap:               keyMap,
		joyMap:               joyMap,
		joyStick:             joyStick,
		shields:              serverConfig.MaxShields,
		energy:               serverConfig.MaxEnergy,
		gameObject:           gameObject,
		local:                local,
		connection:           conn,
		playerID:             lastPlayerID,
		knownBulletParticles: make(map[uint32]*BulletParticle),
		knownBases:           make(map[uint32]*Base),
		knownPlayers:         make(map[uint32]*Player),
		knownBullets:         make(map[uint32]*Bullet),
		knownGameMap:         &knownGameMap,
	}
	lastPlayerID++
	return lastPlayerID - 1
}

func sendMessageRaw(data []byte, conn *net.TCPConn) (fail bool) {
	if conn != nil {
		// Send the length of the message first
		length := uint32(len(data))
		lengthBuf := new(bytes.Buffer)
		if err := binary.Write(lengthBuf, binary.BigEndian, length); err != nil {
			if config.Server {
				log.Printf("Failed to write message length: %v", err)
				fail = true
			} else {
				log.Fatalf("Failed to write message length: %v", err)
			}
		}

		// Send the length followed by the message itself
		if _, err := (*conn).Write(lengthBuf.Bytes()); err != nil {
			if config.Server {
				log.Printf("Failed to write message length to connection: %v", err)
				fail = true
			} else {
				log.Fatalf("Failed to write message length to connection: %v", err)
			}
		}
		if _, err := (*conn).Write(data); err != nil {
			if config.Server {
				log.Printf("Failed to write message to connection: %v", err)
				fail = true
			} else {
				log.Fatalf("Failed to write message to connection: %v", err)
			}
		}
	}
	return
}

func (player *Player) sendMessage(data []byte) bool {
	return sendMessageRaw(data, player.connection)
}

func (player *Player) updateRemotePlayerMap() {
	playerUpdateMutex.Lock()
	defer playerUpdateMutex.Unlock()
	fromX := player.gameObject.baseRect.X - (config.CameraW / 2) - 1
	fromY := player.gameObject.baseRect.Y - (config.CameraH / 2) - 1
	toX := player.gameObject.baseRect.X + (config.CameraW / 2) + 2
	toY := player.gameObject.baseRect.Y + (config.CameraH / 2) + 1
	if uint32(toX) > serverConfig.MapWidth {
		toX = int32(serverConfig.MapWidth)
	}
	if uint32(toY) > serverConfig.MapHeight {
		toY = int32(serverConfig.MapHeight)
	}
	if fromX < 0 {
		fromX = 0
	}
	if fromY < 0 {
		fromY = 0
	}

	// Create a WaitGroup to wait for all goroutines to finish
	var wg sync.WaitGroup
	var lck sync.Mutex

	// Process columns instead of individual pixels
	for x := fromX; x < toX; x++ {
		// Increment the WaitGroup counter
		wg.Add(1)

		// Launch a goroutine for each column
		go func(x int32) {
			defer wg.Done() // Decrement the counter when the goroutine completes

			for y := fromY; y < toY; y++ {
				if player.knownGameMap.tiles[x][y] != gameMap.tiles[x][y] {
					lck.Lock()
					player.gameMapUpdates = append(player.gameMapUpdates, TileUpdate{
						PosX: uint32(x),
						PosY: uint32(y),
						Kind: gameMap.tiles[x][y],
					})
					player.knownGameMap.tiles[x][y] = gameMap.tiles[x][y]
					lck.Unlock()
				}
			}
		}(x)
	}

	// Wait for all goroutines to finish
	wg.Wait()
}

func (player *Player) updateRemotePlayerPlayers(players map[uint32]*Player) {
	playerUpdateMutex.Lock()
	defer playerUpdateMutex.Unlock()
	player.knownPlayers = make(map[uint32]*Player)
	for _, playerLoop := range players {
		player.camera = &sdl.Rect{
			X: player.gameObject.baseRect.X - (config.CameraW / 2),
			Y: player.gameObject.baseRect.Y - (config.CameraH / 2),
			W: config.CameraW,
			H: config.CameraH,
		}

		for _, playerLoopRect := range playerLoop.gameObject.getCurrentRects() {
			if player.camera.HasIntersection(playerLoop.gameObject.adjustRectWorld(playerLoopRect.rect)) && playerLoop.shields <= serverConfig.MaxShields {
				player.knownPlayers[playerLoop.playerID] = playerLoop
				break
			}
		}
	}
}

func (player *Player) updateRemotePlayerBullets(bullets map[uint32]*Bullet) {
	playerUpdateMutex.Lock()
	defer playerUpdateMutex.Unlock()
	player.knownBullets = make(map[uint32]*Bullet)
	for _, bullet := range bullets {
		bulletRect := &sdl.Rect{
			X: bullet.posX,
			Y: bullet.posY,
			W: 1,
			H: 1,
		}
		player.camera = &sdl.Rect{
			X: player.gameObject.baseRect.X - (config.CameraW / 2),
			Y: player.gameObject.baseRect.Y - (config.CameraH / 2),
			W: config.CameraW,
			H: config.CameraH,
		}
		if player.camera.HasIntersection(bulletRect) {
			player.knownBullets[bullet.id] = bullet
		}
	}
}

func (player *Player) updateRemotePlayerBulletParticles(bulletParticles map[uint32]*BulletParticle) {
	playerUpdateMutex.Lock()
	defer playerUpdateMutex.Unlock()
	player.knownBulletParticles = make(map[uint32]*BulletParticle)
	for _, bulletParticle := range bulletParticles {
		bulletRect := &sdl.Rect{
			X: bulletParticle.posX,
			Y: bulletParticle.posY,
			W: 1,
			H: 1,
		}
		player.camera = &sdl.Rect{
			X: player.gameObject.baseRect.X - (config.CameraW / 2),
			Y: player.gameObject.baseRect.Y - (config.CameraH / 2),
			W: config.CameraW,
			H: config.CameraH,
		}
		if player.camera.HasIntersection(bulletRect) {
			player.knownBulletParticles[bulletParticle.id] = bulletParticle
		}
	}
}

func (player *Player) updateRemotePlayerBases(bases map[uint32]*Base) {
	playerUpdateMutex.Lock()
	defer playerUpdateMutex.Unlock()
	player.knownBases = make(map[uint32]*Base)
	for _, base := range bases {
		player.camera = &sdl.Rect{
			X: player.gameObject.baseRect.X - (config.CameraW / 2),
			Y: player.gameObject.baseRect.Y - (config.CameraH / 2),
			W: config.CameraW,
			H: config.CameraH,
		}
		for _, baseRect := range base.gameObject.getCurrentRects() {
			if player.camera.HasIntersection(base.gameObject.adjustRectWorld(baseRect.rect)) {
				player.knownBases[base.ownerID] = base
				break
			}
		}
	}
}

func (player *Player) sendVersionBackToPlayer() bool {
	if player.connection != nil && config.Server {
		response := tunnelerProto.ClientBound{
			ClientBoundMessage: &tunnelerProto.ClientBound_PlayerStartResponse{
				PlayerStartResponse: &tunnelerProto.PlayerStartResponse{
					Version: config.Version,
				},
			},
		}
		out, err := proto.Marshal(&response)
		if err != nil {
			panic("Error serializing version")
		}
		return player.sendMessage(out)
	}
	return false
}

func (player *Player) sendServerInfoToPlayer(players map[uint32]*Player) bool {
	if player.connection != nil && config.Server {
		response := tunnelerProto.ClientBound{
			ClientBoundMessage: &tunnelerProto.ClientBound_ServerInfo{
				ServerInfo: &tunnelerProto.ServerInfo{
					MaxEnergy:                serverConfig.MaxEnergy,
					MaxAmmunition:            serverConfig.MaxAmmunition,
					MaxShields:               serverConfig.MaxShields,
					MapWidth:                 serverConfig.MapWidth,
					MapHeight:                serverConfig.MapHeight,
					NormalShotCost:           serverConfig.NormalShotCost,
					SuperShotCost:            serverConfig.SuperShotCost,
					ReloadCost:               serverConfig.ReloadCost,
					MovementCost:             serverConfig.MovementCost,
					DiggingCost:              serverConfig.DiggingCost,
					ShootDiggingBonus:        serverConfig.ShootDiggingCostBonus,
					ShootCooldown:            serverConfig.ShootCooldown,
					RechargeCooldown:         serverConfig.RechargeCooldownOwn,
					RechargeOpponentCooldown: serverConfig.RechargeCooldownOpponent,
					RepairCooldown:           serverConfig.RepairCooldown,
					DiggingCooldown:          serverConfig.DiggingCooldown,
					MovementCooldown:         serverConfig.MovementCooldown,
					MovementCooldownNoEnergy: serverConfig.MovementCooldownNoEnergy,
					DiggingCooldownNoEnergy:  serverConfig.DiggingCooldownNoEnergy,
					ReloadCooldown:           serverConfig.ReloadCooldown,
					BlastRadius:              serverConfig.BlastRadius,
					PlayerID:                 player.playerID,
					PlayerColorID:            uint32((len(players) - 1) % len(playerColors)),
				},
			},
		}
		out, err := proto.Marshal(&response)
		if err != nil {
			panic("Error serializing server info")
		}
		return player.sendMessage(out)
	}
	return false
}

func (player *Player) sendInfoToPlayer() bool {
	if player.connection != nil && config.Server {
		response := tunnelerProto.ClientBound{
			ClientBoundMessage: &tunnelerProto.ClientBound_PlayerUpdate{
				PlayerUpdate: &tunnelerProto.PlayerUpdate{
					Energy:  player.energy,
					Ammo:    player.ammunition,
					Shields: player.shields,
				},
			},
		}
		out, err := proto.Marshal(&response)
		if err != nil {
			panic("Error serializing info")
		}
		return player.sendMessage(out)
	}
	return false
}

func (player *Player) sendLocationToPlayer() bool {
	if player.connection != nil && config.Server {
		response := tunnelerProto.ClientBound{
			ClientBoundMessage: &tunnelerProto.ClientBound_PlayerLocationUpdate{
				PlayerLocationUpdate: &tunnelerProto.PlayerLocation{
					Position: &tunnelerProto.Position{
						PosX: player.gameObject.baseRect.X,
						PosY: player.gameObject.baseRect.Y,
					},
					Orientation: uint32(player.gameObject.orientation),
				},
			},
		}
		out, err := proto.Marshal(&response)
		if err != nil {
			panic("Error serializing location")
		}
		return player.sendMessage(out)
	}
	return false
}

var playerUpdateMutex sync.Mutex

func (player *Player) sendUpdatesToPlayer(players map[uint32]*Player) bool {
	playerUpdateMutex.Lock()
	defer playerUpdateMutex.Unlock()
	if player.connection != nil && config.Server {

		var playersToSend []*tunnelerProto.Player
		var basesToSend []*tunnelerProto.BaseLocation
		var bulletsToSend []*tunnelerProto.Bullet
		var bulletParticlesToSend []*tunnelerProto.BulletParticle
		var tileUpdatesToSend []*tunnelerProto.TileUpdate

		for playerID, knownPlayer := range player.knownPlayers {
			if playerID == player.playerID {
				continue
			}
			playersToSend = append(playersToSend, &tunnelerProto.Player{
				PlayerID: playerID,
				Location: &tunnelerProto.PlayerLocation{
					Position: &tunnelerProto.Position{
						PosX: knownPlayer.gameObject.baseRect.X,
						PosY: knownPlayer.gameObject.baseRect.Y,
					},
					Orientation: uint32(knownPlayer.gameObject.orientation),
				},
			})
		}

		for _, knownBase := range player.knownBases {
			r, g, b, a := players[knownBase.ownerID].playerColors.body.RGBA()
			basesToSend = append(basesToSend, &tunnelerProto.BaseLocation{
				Position: &tunnelerProto.Position{
					PosX: knownBase.gameObject.baseRect.X,
					PosY: knownBase.gameObject.baseRect.Y,
				},
				Owner: &tunnelerProto.Player{
					PlayerID: knownBase.ownerID,
					Location: nil,
				},
				Color: &tunnelerProto.Color{
					Red:   r,
					Green: g,
					Blue:  b,
					Alpha: a,
				},
			})
		}

		for _, knownBullet := range player.knownBullets {
			bulletRed, bulletGreen, bulletBlue, bulletAlpha := knownBullet.color.RGBA()
			bulletsToSend = append(bulletsToSend, &tunnelerProto.Bullet{
				Position: &tunnelerProto.Position{
					PosX: knownBullet.posX,
					PosY: knownBullet.posY,
				},
				Direction: uint32(knownBullet.direction),
				Color: &tunnelerProto.Color{
					Red:   bulletRed,
					Green: bulletGreen,
					Blue:  bulletBlue,
					Alpha: bulletAlpha,
				},
				Id: knownBullet.id,
			})
		}

		for _, knownBulletParticle := range player.knownBulletParticles {
			bulletParticleRed, bulletParticleGreen, bulletParticleBlue, bulletParticleAlpha := knownBulletParticle.color.RGBA()
			bulletParticlesToSend = append(bulletParticlesToSend, &tunnelerProto.BulletParticle{
				Position: &tunnelerProto.Position{
					PosX: knownBulletParticle.posX,
					PosY: knownBulletParticle.posY,
				},
				ExpirationTimer: knownBulletParticle.expirationTimer,
				Color: &tunnelerProto.Color{
					Red:   bulletParticleRed,
					Green: bulletParticleGreen,
					Blue:  bulletParticleBlue,
					Alpha: bulletParticleAlpha,
				},
				Id: knownBulletParticle.id,
			})
		}

		for _, tileUpdate := range player.gameMapUpdates {
			tileUpdatesToSend = append(tileUpdatesToSend, &tunnelerProto.TileUpdate{
				Position: &tunnelerProto.Position{
					PosX: int32(tileUpdate.PosX),
					PosY: int32(tileUpdate.PosY),
				},
				Kind: uint32(tileUpdate.Kind),
			})
		}

		response := tunnelerProto.ClientBound{
			ClientBoundMessage: &tunnelerProto.ClientBound_WorldUpdate{
				WorldUpdate: &tunnelerProto.WorldUpdate{
					Players:         playersToSend,
					Base:            basesToSend,
					Bullets:         bulletsToSend,
					BulletParticles: bulletParticlesToSend,
					TileUpdate:      tileUpdatesToSend,
				},
			},
		}
		out, err := proto.Marshal(&response)
		if err != nil {
			panic("Error serializing updates")
		}
		return player.sendMessage(out)
	}
	return false
}

func (player *Player) sendPositionToServer() bool {
	if player.connection != nil && config.Client {
		response := tunnelerProto.ServerBound{
			ServerBoundMessage: &tunnelerProto.ServerBound_PlayerPosition{
				PlayerPosition: &tunnelerProto.PlayerLocation{
					Position: &tunnelerProto.Position{
						PosX: player.gameObject.baseRect.X,
						PosY: player.gameObject.baseRect.Y,
					},
					Orientation: uint32(player.gameObject.orientation),
				},
			},
		}
		out, err := proto.Marshal(&response)
		if err != nil {
			panic("Error serializing location")
		}
		return player.sendMessage(out)
	}
	return false
}

func sendVersionToServer(connection *net.TCPConn) {
	if connection != nil && config.Client {
		response := tunnelerProto.ServerBound{
			ServerBoundMessage: &tunnelerProto.ServerBound_PlayerStartRequest{
				PlayerStartRequest: &tunnelerProto.PlayerStartRequest{
					Version: config.Version,
				},
			},
		}
		out, err := proto.Marshal(&response)
		if err != nil {
			panic("Error serializing version")
		}
		sendMessageRaw(out, connection)
	}
}

func (player *Player) sendDigToServer(posX, posY uint32, isShooting bool) {
	if player.connection != nil && config.Client {
		response := tunnelerProto.ServerBound{
			ServerBoundMessage: &tunnelerProto.ServerBound_PlayerAction{
				PlayerAction: &tunnelerProto.PlayerAction{
					PlayerAction: &tunnelerProto.PlayerAction_DigBlock{
						DigBlock: &tunnelerProto.DigBlock{
							Position: &tunnelerProto.Position{
								PosX: int32(posX),
								PosY: int32(posY),
							},
							IsShooting: isShooting,
						},
					},
				},
			},
		}
		out, err := proto.Marshal(&response)
		if err != nil {
			panic("Error serializing dig")
		}
		player.sendMessage(out)
	}
}

func (player *Player) sendShootToServer(isSuper bool) {
	if player.connection != nil && config.Client {
		response := tunnelerProto.ServerBound{
			ServerBoundMessage: &tunnelerProto.ServerBound_PlayerAction{
				PlayerAction: &tunnelerProto.PlayerAction{
					PlayerAction: &tunnelerProto.PlayerAction_Shoot{
						Shoot: &tunnelerProto.Shoot{
							Super: isSuper,
						},
					},
				},
			},
		}
		out, err := proto.Marshal(&response)
		if err != nil {
			panic("Error serializing shot")
		}
		player.sendMessage(out)
	}
}

func handleRequest(conn *net.TCPConn, players map[uint32]*Player, bullets map[uint32]*Bullet, bases map[uint32]*Base) {
	defer conn.Close()
	r := bufio.NewReader(conn)
	for {
		// Read the length of the incoming message (4 bytes)
		lengthBuf := make([]byte, 4)
		_, err := io.ReadFull(r, lengthBuf)
		if err != nil {
			log.Printf("Failed to read message length: %v", err)
			return
		}

		// Convert length to an integer
		length := binary.BigEndian.Uint32(lengthBuf)

		// Read the actual message data
		messageBuf := make([]byte, length)
		_, err = io.ReadFull(r, messageBuf)
		if err != nil {
			log.Printf("Failed to read message data: %v", err)
			return
		}

		// Unmarshal the protobuf message
		var msg tunnelerProto.ServerBound
		if err := proto.Unmarshal(messageBuf, &msg); err != nil {
			log.Printf("Failed to unmarshal protobuf message: %v", err)
			return
		}

		switch msg.GetServerBoundMessage().(type) {
		case *tunnelerProto.ServerBound_PlayerStartRequest:
			clientVersion := msg.GetPlayerStartRequest().Version
			if clientVersion != config.Version {
				log.Fatalf("Wrong client version, a client connected with %s to %s", clientVersion, config.Version)
				return
			}

			newPlayerID := createPlayer(false, playerColors[len(players)%len(playerColors)], conn, KeyMap{}, JoyMap{}, nil, gameMap, players)
			defer delete(players, newPlayerID)
			player := players[newPlayerID]
			bases[newPlayerID] = createBase(gameMap,
				player.playerColors.body,
				uint32(player.gameObject.baseRect.X-14),
				uint32(player.gameObject.baseRect.Y-14),
				player.playerID,
				uint32(float64(player.gameObject.baseRect.W)*1.5))

			defer bases[newPlayerID].delete(bases)
			netPlayerMapper[conn] = player

			fail := player.sendVersionBackToPlayer()
			if fail {
				return
			}
			log.Printf("Sent version to %d", newPlayerID)
			fail = player.sendServerInfoToPlayer(players)
			if fail {
				return
			}
			log.Printf("Sent server info to %d", newPlayerID)
			fail = player.sendInfoToPlayer()
			if fail {
				return
			}
			log.Printf("Sent info to %d", newPlayerID)
			fail = player.sendLocationToPlayer()
			if fail {
				return
			}
			log.Printf("Sent location to %d", newPlayerID)

		case *tunnelerProto.ServerBound_PlayerPosition:
			player := netPlayerMapper[conn]
			if player == nil {
				return
			}
			newPosition := msg.GetPlayerPosition()
			newX := newPosition.Position.PosX
			newY := newPosition.Position.PosY
			oldX := player.gameObject.baseRect.X
			oldY := player.gameObject.baseRect.Y
			if ((newX > oldX && newX-oldX <= 2) || (newX < oldX && oldX-newX <= 2) || newX == oldX) &&
				(newY > oldY && newY-oldY <= 2) || (newY < oldY && oldY-newY <= 2 || newY == oldY) {
				player.gameObject.baseRect = sdl.Rect{
					X: newX,
					Y: newY,
					W: player.gameObject.baseRect.W,
					H: player.gameObject.baseRect.H,
				}
			}
			player.gameObject.orientation = uint8(newPosition.Orientation)
		case *tunnelerProto.ServerBound_PlayerAction:
			player := netPlayerMapper[conn]
			if player == nil {
				return
			}
			playerAction := msg.GetPlayerAction()
			if playerAction == nil {
				return
			}
			switch action := playerAction.PlayerAction.(type) {
			case *tunnelerProto.PlayerAction_DigBlock:
				position := action.DigBlock.Position
				isShooting := action.DigBlock.IsShooting //TODO:FIX && player.ammunition < serverConfig.MaxAmmunition
				player.digBlock(position.PosX, position.PosY, gameMap, isShooting)

			case *tunnelerProto.PlayerAction_Shoot:
				isSuper := action.Shoot.Super
				player.shoot(isSuper, bullets)
			}

		}
	}
}

func handleConnectionClient(conn *net.TCPConn, players map[uint32]*Player, bases map[uint32]*Base, bullets map[uint32]*Bullet, bulletParticles map[uint32]*BulletParticle) {
	var player *Player
	sendVersionToServer(conn)
	r := bufio.NewReader(conn)
	for {
		// Read the length of the incoming message (4 bytes)
		lengthBuf := make([]byte, 4)
		_, err := io.ReadFull(r, lengthBuf)
		if err != nil {
			log.Printf("Failed to read message length: %v", err)
			os.Exit(0)
		}

		// Convert length to an integer
		length := binary.BigEndian.Uint32(lengthBuf)

		// Read the actual message data
		messageBuf := make([]byte, length)
		_, err = io.ReadFull(r, messageBuf)
		if err != nil {
			log.Printf("Failed to read message data: %v", err)
			os.Exit(0)
		}
		var msg tunnelerProto.ClientBound
		if err := proto.Unmarshal(messageBuf, &msg); err != nil {
			log.Printf("Failed to unmarshal protobuf message: %v", err)
		}
		switch msg.GetClientBoundMessage().(type) {
		case *tunnelerProto.ClientBound_PlayerStartResponse:
			serverVersion := msg.GetPlayerStartResponse().Version
			if serverVersion != config.Version {
				log.Fatalf("Wrong server version, connected with %s to %s", config.Version, serverVersion)
				return
			} else {
				log.Printf("Connected to %s, running version %s with version %s\n", config.Address, serverVersion, config.Version)
			}
		case *tunnelerProto.ClientBound_ServerInfo:
			serverInfo := msg.GetServerInfo()
			serverConfig = ServerConfig{
				MapWidth:                 serverInfo.MapWidth,
				MapHeight:                serverInfo.MapHeight,
				BlastRadius:              serverInfo.BlastRadius,
				MaxEnergy:                serverInfo.MaxEnergy,
				MaxAmmunition:            serverInfo.MaxAmmunition,
				MaxShields:               serverInfo.MaxShields,
				NormalShotCost:           serverInfo.NormalShotCost,
				SuperShotCost:            serverInfo.SuperShotCost,
				ReloadCost:               serverInfo.ReloadCost,
				MovementCost:             serverInfo.MovementCost,
				DiggingCost:              serverInfo.DiggingCost,
				ShootDiggingCostBonus:    serverInfo.ShootDiggingBonus,
				ShootCooldown:            serverInfo.ShootCooldown,
				RechargeCooldownOwn:      serverInfo.RechargeCooldown,
				DiggingCooldown:          serverInfo.DiggingCooldown,
				RechargeCooldownOpponent: serverInfo.RechargeOpponentCooldown,
				RepairCooldown:           serverInfo.RepairCooldown,
				MovementCooldown:         serverInfo.MovementCooldown,
				MovementCooldownNoEnergy: serverInfo.MovementCooldownNoEnergy,
				DiggingCooldownNoEnergy:  serverInfo.DiggingCooldownNoEnergy,
				ReloadCooldown:           serverInfo.ReloadCooldown,
			}
			gameMap.createGameMap(false)
			lastPlayerID = serverInfo.PlayerID
			createPlayer(true, playerColors[serverInfo.PlayerColorID], conn, keyMaps[0], JoyMap{}, nil, gameMap, players)
			player = players[serverInfo.PlayerID]
			log.Printf("Got server info, now initializing\n")
			clientInitialized = true
		case *tunnelerProto.ClientBound_PlayerUpdate:
			if clientInitialized {
				playerUpdate := msg.GetPlayerUpdate()
				player.energy = playerUpdate.Energy
				player.ammunition = playerUpdate.Ammo
				player.shields = playerUpdate.Shields
			}

		case *tunnelerProto.ClientBound_PlayerLocationUpdate:
			if clientInitialized {
				playerLocationUpdate := msg.GetPlayerLocationUpdate()
				player.gameObject.baseRect.X = playerLocationUpdate.Position.PosX
				player.gameObject.baseRect.Y = playerLocationUpdate.Position.PosY
				player.gameObject.orientation = uint8(playerLocationUpdate.Orientation)
			}

		case *tunnelerProto.ClientBound_WorldUpdate:
			if clientInitialized {
				worldUpdate := msg.GetWorldUpdate()
				worldLock.Lock()
				for _, playerLoop := range worldUpdate.Players {
					playerID := playerLoop.PlayerID
					existingPlayer := players[playerID]
					if existingPlayer == nil {
						lastPlayerID = playerID
						createPlayer(false, playerColors[playerID%uint32(len(playerColors))], nil, KeyMap{}, JoyMap{}, nil, gameMap, players)
						newPlayer := players[playerID]
						newPlayer.gameObject.orientation = uint8(playerLoop.Location.Orientation)
						newPlayer.gameObject.baseRect.X = playerLoop.Location.Position.PosX
						newPlayer.gameObject.baseRect.Y = playerLoop.Location.Position.PosY
					} else {
						existingPlayer.gameObject.orientation = uint8(playerLoop.Location.Orientation)
						existingPlayer.gameObject.baseRect.X = playerLoop.Location.Position.PosX
						existingPlayer.gameObject.baseRect.Y = playerLoop.Location.Position.PosY
					}
				}
				for _, base := range worldUpdate.Base {
					baseID := base.Owner.PlayerID
					existingBase := bases[baseID]
					inColor := color.RGBA{
						R: uint8(base.Color.Red),
						G: uint8(base.Color.Green),
						B: uint8(base.Color.Blue),
						A: uint8(base.Color.Alpha),
					}
					if existingBase == nil {
						bases[baseID] = createBase(gameMap,
							inColor,
							uint32(base.Position.PosX),
							uint32(base.Position.PosY),
							base.Owner.PlayerID,
							uint32(int32(float64(player.gameObject.baseRect.W)*1.5)),
						)
					} else {
						existingBase.gameObject.baseRect.X = base.Position.PosX
						existingBase.gameObject.baseRect.Y = base.Position.PosY
						existingBase.gameObject.colors[0] = inColor
					}
				}
				for _, bullet := range worldUpdate.Bullets {
					bulletID := bullet.Id
					inColor := color.RGBA{
						R: uint8(bullet.Color.Red),
						G: uint8(bullet.Color.Green),
						B: uint8(bullet.Color.Blue),
						A: uint8(bullet.Color.Alpha),
					}
					existingBullet := bullets[bulletID]
					if existingBullet == nil {
						bullets[bulletID] = &Bullet{
							posX:      bullet.Position.PosX,
							posY:      bullet.Position.PosY,
							direction: uint8(bullet.Direction),
							color:     inColor,
							super:     bullet.Super,
							id:        bulletID,
						}
					} else {
						existingBullet.direction = uint8(bullet.Direction)
						existingBullet.color = inColor
						existingBullet.super = bullet.Super
						existingBullet.posX = bullet.Position.PosX
						existingBullet.posY = bullet.Position.PosY
					}
				}
				for _, bulletParticle := range worldUpdate.BulletParticles {
					bulletParticleID := bulletParticle.Id
					inColor := color.RGBA{
						R: uint8(bulletParticle.Color.Red),
						G: uint8(bulletParticle.Color.Green),
						B: uint8(bulletParticle.Color.Blue),
						A: uint8(bulletParticle.Color.Alpha),
					}
					existingBulletParticle := bulletParticles[bulletParticleID]
					if existingBulletParticle == nil {
						bulletParticles[bulletParticleID] = &BulletParticle{
							posX:            bulletParticle.Position.PosX,
							posY:            bulletParticle.Position.PosY,
							expirationTimer: bulletParticle.ExpirationTimer,
							color:           inColor,
							id:              bulletParticleID,
						}
					} else {
						existingBulletParticle.color = inColor
						existingBulletParticle.posX = bulletParticle.Position.PosX
						existingBulletParticle.posY = bulletParticle.Position.PosY
						existingBulletParticle.expirationTimer = bulletParticle.ExpirationTimer
					}
				}
				for _, tileUpdate := range worldUpdate.TileUpdate {
					posX := uint32(tileUpdate.Position.PosX)
					posY := uint32(tileUpdate.Position.PosY)
					kind := uint8(tileUpdate.Kind)
					if posX > 0 && posX < gameMap.width && posY > 0 && posY < gameMap.height {
						gameMap.tiles[posX][posY] = kind
					}
				}
				worldLock.Unlock()
			}
		}
	}
}