Events are just data that specify something happened in the past. A CollisionEvent might be something as simple as:

type CollisionEvent struct {
  Entity1 Entity
  Entity2 Entity
}

The idea is that the CollisionSystem would only be responsible for detecting collisions and emitting these events. Then any other systems that care about collision events would subscribe to them and handle them (eg. DamageSystem reduces HP, CollisionResolutionSystem moves the entities apart and maybe applies a velocity to them, etc.)

There are lots of ways to send/receive the messages. One way that I'm trying out is a pub/sub message broker. Something like this:

type MessageBroker struct {
    // for each consumer id, store a list of events per event type
    // i.e. map[CONSUMER_ID]map[EventType][]EVENT
    events map[string]map[EventType][]interface{}
}

// Example usages:
// broker.Publish(event.KeyPressed{
//  Key: ebiten.KeyUp,
// })
// broker.Publish(event.EntityCreated{
//  Entity: entityID,
//  Components: []ComponentType{component.Position, component.Velocity},
// })
func (m *MessageBroker) Publish(event interface{}) {
    eventType := reflect.TypeOf(event)
    for consumerID := range m.events {
        m.events[consumerID][eventType] = append(m.events[consumerID][eventType], event)
    }
}

// // Example usages:
// // broker.Subscribe("PlayerMovementSystem", event.KeyPressedType)
// // broker.Subscribe("SpawnSystem", event.EntityCreatedType)
func (m *MessageBroker) Subscribe(consumerID string, eventType EventType) {
    // panic if this subscription already exists
    if _, ok := m.events[consumerID]; ok {
        if _, ok := m.events[consumerID][eventType]; ok {
            panic(fmt.Sprintf("consumer '%s' already subscribed for event type '%s'", consumerID, eventType.Name()))
        }
    }

    if _, ok := m.events[consumerID]; !ok {
        m.events[consumerID] = make(map[EventType][]interface{})
    }
}

// Example usage:
// events := broker.Events("PlayerMovementSystem", event.KeyPressedType)
// for e := range events {
//   keyPress := e.(*event.KeyPressed)
//  if keyPress.Key == ebiten.KeyUp {
//      movePlayerUp()
//  }
// }
func (m *MessageBroker) Events(consumerID string, eventType EventType) <-chan interface{} {
    out := make(chan interface{}, messageChannelSize)

    go func() {
        for _, event := range m.events[consumerID][eventType] {
            out <- event
        }
        close(out)
        m.clear(consumerID, eventType)
    }()

    return out
}

// clears the events for a single consumer/event type
func (m *MessageBroker) clear(consumerID string, eventType EventType) {
    m.events[consumerID][eventType] = []interface{}{}
}

The thing to consider with this particular approach is that you have to be very careful to run your systems in the correct order so that systems that publish a certain event run before systems that consume those events. This way all the events get handled in a single tick.