69 lines
2.5 KiB
Go
69 lines
2.5 KiB
Go
package westworldwithmessaging
|
|
|
|
import "math"
|
|
|
|
// Telegram is the Go version of the C++ struct:
|
|
//
|
|
// struct Telegram
|
|
// {
|
|
// int Sender;
|
|
// int Receiver;
|
|
// int Msg;
|
|
// double DispatchTime;
|
|
// void* ExtraInfo;
|
|
// };
|
|
//
|
|
// It's one message passed between entities through the dispatcher /
|
|
// entity manager we'll build next: who sent it, who it's for, what
|
|
// it says, when it should actually go out, and any extra data riding
|
|
// along with it. The book's "/* CONSTRUCTORS OMITTED */" means we
|
|
// haven't been shown how one gets built yet, so this is just the
|
|
// plain data shape for now, no constructor.
|
|
type Telegram struct {
|
|
// Sender is the ID of the entity that sent this telegram.
|
|
Sender int
|
|
|
|
// Receiver is the ID of the entity meant to receive this telegram.
|
|
Receiver int
|
|
|
|
// Msg is the message itself. The book keeps this as a plain int
|
|
// rather than the MessageType enum, presumably so the dispatcher
|
|
// can stay generic and doesn't need to know about every possible
|
|
// message type - we're matching that choice exactly rather than
|
|
// tightening it to MessageType ourselves.
|
|
Msg int
|
|
|
|
// DispatchTime supports delayed messages: instead of going out
|
|
// immediately, a telegram can be stamped with the time it should
|
|
// actually be delivered. C++'s "double" becomes Go's float64 -
|
|
// Go has no bare "double" keyword, float64 is its 64-bit
|
|
// floating-point type.
|
|
DispatchTime float64
|
|
|
|
// ExtraInfo carries any additional data that should travel with
|
|
// the message. C++'s "void*" (a pointer with no fixed type -
|
|
// "could point to anything") becomes Go's "any" (an alias for
|
|
// interface{} - "could hold a value of any type"). Whoever reads
|
|
// ExtraInfo later type-asserts it back to something concrete.
|
|
ExtraInfo any
|
|
}
|
|
|
|
// smallestDelay is our stand-in for the book's "a quarter of a
|
|
// second" tolerance - it doesn't give us an exact named constant for
|
|
// this, just that written description.
|
|
const smallestDelay = 0.25
|
|
|
|
// telegramsMatch is our own Go version of the behavior the book
|
|
// describes for Telegram.h's overloaded == operator (we haven't been
|
|
// shown that file's actual code, only this description): two
|
|
// telegrams count as the same message if they're headed the same
|
|
// direction with the same content, and their dispatch times are less
|
|
// than smallestDelay apart. This is what keeps a burst of near-
|
|
// identical messages from flooding an entity's queue.
|
|
func telegramsMatch(a, b Telegram) bool {
|
|
return a.Sender == b.Sender &&
|
|
a.Receiver == b.Receiver &&
|
|
a.Msg == b.Msg &&
|
|
math.Abs(a.DispatchTime-b.DispatchTime) < smallestDelay
|
|
}
|