I've found this is more or less the entire point of design principles.

When you learn design principles in schools or otherwise serious courses, you get taught to always use them no matter what. This is a useful lesson for someone learning these principles exist in the first place, and I'm pretty sure the reason they are taught like this is to avoid having half the codebase using them and the other half not, which would definitely be a no-no (and is a thing that i've seen happen multiple times!).

A more pragmatic programmer that knows what they're doing should be able to say "this is unnecessary complexity" like you did and forgo applying a design principle where it makes sense. This is a valid opinion to have, but it's still possible it's not correct, because being a pragmatic programmer and being a skilled programmer are not the same thing. For example, it's entirely possible your next update to your project involves doing something that would be better served by event-driven development where you previously decided this was unnecessary, and you'll be paying for that in refactoring time. It's also possible this will never be the case.

There's also a point to be made about "Why introduce the complexity of an event system?". The fact of the matter is, you already have done that when you used this event system where you knew it would be useful, and so the complexity is already increased. By choosing not to unify the communication model across all objects in your project, you're actually introducing more complexity because there are now 2 ways objects can communicate and it's not necessarly instantly clear which one an object uses. In the scenario you're describing, I'd personally choose to use the event system even in the trivial cases you describe. I think you'll find that this is really not that more complex, and you'll build the habit that "this is how communication happens" across your project.

ultimately, this is a subjective decision and there is no right answer in general. Considering you're doing this in the context of a course with a professor, the professor will probably expect you to use the event system regardless of if it's a good idea or not.

P.S. the point about "high-frequency" communication doesn't really hold water, because the compiler will be able to optimize away a lot of the event infrastructure where it makes sense and raising an event will be just as fast as calling a method on a singleton. As you learn more about programming in general, you'll learn that basically nothing you write ends up being what actually happens physically on the CPU. Most of the performance optimization tips you will learn are actually just ways of structuring your code in a way the compiler understands better, and where better programmers than both of us have written really efficient code paths.

I've found this is more or less the entire point of design principles.

When you learn design principles in schools or otherwise serious courses, you get taught to always use them no matter what. This is a useful lesson for someone learning these principles exist in the first place, and I'm pretty sure the reason they are taught like this is to avoid having half the codebase using them and the other half not, which would definitely be a no-no (and is a thing that I've seen happen multiple times!).

A more pragmatic programmer that knows what they're doing should be able to say "this is unnecessary complexity" like you did and forgo applying a design principle where it makes sense. This is a valid opinion to have, but it's still possible it's not correct, because being a pragmatic programmer and being a skilled programmer are not the same thing. For example, it's entirely possible your next update to your project involves doing something that would be better served by event-driven development where you previously decided this was unnecessary, and you'll be paying for that in refactoring time. It's also possible this will never be the case.

There's also a point to be made about "Why introduce the complexity of an event system?". The fact of the matter is, you already have done that when you used this event system where you knew it would be useful, and so the complexity is already increased. By choosing not to unify the communication model across all objects in your project, you're actually introducing more complexity because there are now two ways objects can communicate and it's not necessarily instantly clear which one an object uses. In the scenario you're describing, I'd personally choose to use the event system even in the trivial cases you describe. I think you'll find that this is really not that more complex, and you'll build the habit that "this is how communication happens" across your project.

Ultimately, this is a subjective decision and there is no right answer in general. Considering you're doing this in the context of a course with a professor, the professor will probably expect you to use the event system regardless of if it's a good idea or not.

P.S. the point about "high-frequency" communication doesn't really hold water, because the compiler will be able to optimize away a lot of the event infrastructure where it makes sense and raising an event will be just as fast as calling a method on a singleton. As you learn more about programming in general, you'll learn that basically nothing you write ends up being what actually happens physically on the CPU. Most of the performance optimization tips you will learn are actually just ways of structuring your code in a way the compiler understands better, and where better programmers than both of us have written really efficient code paths.