trying to improve play on my vps

box.go

@@ -31,11 +31,14 @@ func (g *Game) NewBox(id BoxID) *Box {
 	return g.Boxes[id]
 }
 
+var boxSequence uint64
+
 func (b *Box) Location() pkt.BoxLocation {
 	return pkt.BoxLocation{
-		ID:    b.ID,
-		X:     float32(b.Body.Position().X),
-		Y:     float32(b.Body.Position().Y),
-		Angle: float32(b.Body.Angle()),
+		ID:       b.ID,
+		Sequence: boxSequence,
+		X:        float32(b.Body.Position().X),
+		Y:        float32(b.Body.Position().Y),
+		Angle:    float32(b.Body.Angle()),
 	}
 }

client/handlersc.go

@@ -76,13 +76,21 @@ func join(packet tanklets.Packet, game *tanklets.Game, network *Client) {
 	game.Tanks[tank.ID] = tank
 }
 
+var lastLocationSeq uint64
+
 func location(packet tanklets.Packet, game *tanklets.Game, network *Client) {
 	l := pkt.Location{}
 	if _, err := l.Serialize(packet.Bytes); err != nil {
 		log.Println(err)
 		return
 	}
 
+	if l.Sequence < lastLocationSeq {
+		fmt.Println("out of order packet")
+		return
+	}
+	lastLocationSeq = l.Sequence
+
 	player := game.Tanks[tanklets.PlayerID(l.ID)]
 	if player == nil {
 		log.Println("Client", Me, "-- Tank with ID", l.ID, "not found")
@@ -112,13 +120,20 @@ func location(packet tanklets.Packet, game *tanklets.Game, network *Client) {
 	player.Turret.Body.SetAngle(float64(l.Turret))
 }
 
+var lastBoxSeq uint64
+
 func boxlocation(packet tanklets.Packet, game *tanklets.Game, network *Client) {
 	l := pkt.BoxLocation{}
 	if _, err := l.Serialize(packet.Bytes); err != nil {
 		log.Println(err)
 		return
 	}
 
+	if l.Sequence < lastBoxSeq {
+		return
+	}
+	lastBoxSeq = l.Sequence
+
 	box := game.Boxes[tanklets.BoxID(l.ID)]
 	if box == nil {
 		box = game.NewBox(tanklets.BoxID(l.ID))

pkt/boxlocation.go

@@ -6,9 +6,10 @@ import (
 
 // message sent to clients: update location information
 type BoxLocation struct {
-	ID                     BoxID
-	X, Y                   float32
-	Angle float32
+	ID       BoxID
+	Sequence uint64
+	X, Y     float32
+	Angle    float32
 }
 
 func (l BoxLocation) MarshalBinary() ([]byte, error) {
@@ -25,6 +26,7 @@ func (l *BoxLocation) Serialize(b []byte) ([]byte, error) {
 	var m uint8 = PacketBoxLocation
 	stream.Uint8(&m)
 	stream.Uint16((*uint16)(&l.ID))
+	stream.Uint64(&l.Sequence)
 	stream.Float32(&l.X)
 	stream.Float32(&l.Y)
 	stream.Float32(&l.Angle)

pkt/location.go

@@ -6,10 +6,12 @@ import (
 
 // message sent to clients: update location information
 type Location struct {
-	ID                     PlayerID
-	X, Y                   float32
-	Vx, Vy                 float32
-	Angle, AngularVelocity float32
+	ID              PlayerID
+	Sequence        uint64
+	X, Y            float32
+	Vx, Vy          float32
+	Angle           float32
+	AngularVelocity float32
 
 	Turret float32
 }
@@ -28,6 +30,7 @@ func (l *Location) Serialize(b []byte) ([]byte, error) {
 	var m uint8 = PacketLocation
 	stream.Uint8(&m)
 	stream.Uint16((*uint16)(&l.ID))
+	stream.Uint64(&l.Sequence)
 	stream.Float32(&l.X)
 	stream.Float32(&l.Y)
 	stream.Float32(&l.Vx)

server/loop.go

@@ -9,7 +9,7 @@ import (
 )
 
 func Loop(network *Server) {
-	pingTick := time.Tick(1*time.Second)
+	pingTick := time.Tick(1 * time.Second)
 	go func() {
 		for range pingTick {
 			ping := pkt.Ping{T: time.Now()}
@@ -47,7 +47,7 @@ func Loop(network *Server) {
 
 	fmt.Println("Let's do this")
 	// This seems hacky but it works
-	time.Sleep(3*time.Second)
+	time.Sleep(3 * time.Second)
 	game.State = tanklets.StatePlaying
 	Players.SendAll(game.Network, pkt.State{State: tanklets.StatePlaying})
 
@@ -57,16 +57,19 @@ func Loop(network *Server) {
 var BoxLocations = map[tanklets.BoxID]pkt.BoxLocation{}
 
 const (
-	serverUpdates   = time.Second / 21.0
+	playerUpdates   = time.Second / 21.0
+	boxUpdates      = time.Second / 5
 	physicsTicks    = 180.0
 	physicsTickrate = 1.0 / physicsTicks
 )
 
 func Play(game *Game) {
 	physicsTick := time.NewTicker(time.Second / physicsTicks)
-	updateTick := time.NewTicker(serverUpdates)
+	updateTick := time.NewTicker(playerUpdates)
+	boxTick := time.NewTicker(boxUpdates)
 	defer physicsTick.Stop()
 	defer updateTick.Stop()
+	defer boxTick.Stop()
 
 	var accumulator float64
 	var dt time.Duration
@@ -106,6 +109,7 @@ func Play(game *Game) {
 				for _, tank := range game.Tanks {
 					Players.SendAll(game.Network, tank.Location())
 				}
+			case <-boxTick.C:
 				for _, box := range game.Boxes {
 					loc := box.Location()
 					if loc != BoxLocations[box.ID] {

tank.go

@@ -36,8 +36,8 @@ type Tank struct {
 
 	width, height float64
 	Color         mgl32.Vec3
-	Name string
-	Score int
+	Name          string
+	Score         int
 
 	LastShot time.Time
 
@@ -58,7 +58,7 @@ type Turret struct {
 func (g *Game) NewTank(id PlayerID, color mgl32.Vec3) *Tank {
 	tank := &Tank{
 		ID:    id,
-		Name: fmt.Sprintf("Player %v", id),
+		Name:  fmt.Sprintf("Player %v", id),
 		Color: color,
 	}
 	tank.Body = g.Space.AddBody(cp.NewBody(1, cp.MomentForBox(1, TankWidth, TankHeight)))
@@ -95,7 +95,7 @@ func (tank *Tank) Update(dt float64) {
 func (tank *Tank) FixedUpdate(dt float64) {
 	if tank.Destroyed {
 		// slowly stop, looks cool
-		tank.ControlBody.SetAngularVelocity(tank.ControlBody.AngularVelocity()*.99)
+		tank.ControlBody.SetAngularVelocity(tank.ControlBody.AngularVelocity() * .99)
 		tank.ControlBody.SetVelocityVector(tank.ControlBody.Velocity().Mult(.99))
 		return
 	}
@@ -118,10 +118,14 @@ func (tank *Tank) FixedUpdate(dt float64) {
 	tank.LastMove = tank.NextMove
 }
 
+var locationSequence uint64
+
 // gather important data to transmit
 func (tank *Tank) Location() *pkt.Location {
+	locationSequence++
 	return &pkt.Location{
 		ID:              tank.ID,
+		Sequence:        locationSequence,
 		X:               float32(tank.Body.Position().X),
 		Y:               float32(tank.Body.Position().Y),
 		Angle:           float32(tank.Body.Angle()),