Simulating pod racing over a 2D map : am I implementing OOP in a GO-like fashion?
As per request in the comment, here's an implementation of the rotate function in a more idiomatic golang way (ie using a pointer receiver):

// let's use constants so code becomes self-documenting
const (
    maxRotation float64 = 18 // max rotation as typed constant
    fullCircle  int     = 360 // just like all hard-coded values, let's use constants
    semiCircle  int     = fullCirle/2 // do this for all hard-coded values
)

// note the receiver is a pointer, and there's no return value
func (pod *Pod) rotate(p Dot) {
    a := pod.diffAngle(p)

    if a &gt; maxRotation {
        a = maxRotation
    } else if a &lt; -maxRotation {
        a = -maxRotation
    }

    pod.angle += int(math.Round(a))

    var add int // add this value, defaults to 0
    // you are comparing pod.angle (an int) to a float64 (360.0)
    // that shouldn't be happening. I'd say angle should be a float64
    // but keeping the fields in pod the types they are for now
    if pod.angle &gt;= fullCircle {
        add -= fullCircle
    } else if pod.angle &lt; 0 {
        add = fullCircle
    }
    pod.angle += add // adds 0, 360, or -360 depending on the new value for pod.angle
}


That's all there is to it, really. Instead of calling it like this:

pod.angle = pod.rotate(p)


You simply call it like this:

pod.rotate(p)


The value of pod.angle will be updated. If you start doing this stuff concurrently, you'll need to ensure that pod.rotate() is "thread-safe" (ignoring the fact that goroutines aren't really threads for a second). The easiest way to do this is using a sync.Mutex (or sync.RWMutex), to make sure that you're not accidentally updating pod.angle in 2 routines etc...

I might revisit this stuff to give a more detailed review, so stay tuned for updates.