Advertisement Jump to content
Sign in to follow this  

[Game] Problem with Object cumunication

This topic is 2718 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

In my current project I'm trying to create an text based rpg engine.
The main classes are: Engine.cs, World.cs, Entity.cs, Event.cs and Dialog.cs

The Engine contains Handlers for handling and processing Dialogs and Events that occures during the game as well as an World object that contains all game data as monsters, player status, rooms ect.
My problem is my Entity's aswell as the battle engine need to be able to push Events and Dialogs inside the queue so that they can be processed by the engine handlers.

So: Engine->World->Entitys->Events.
So I'v been thinking should i add an object refrence to EACH of the games entitys to the Engine object? So that they can access the methods to be able to push events and dialogs inside the queue? It seams quite inefficient :S

But i can't think of another way really...
The Handlers ( Input, Event, Dialog and well World object each gets a refrence to the owning Engine object. ) like InputHandler inputmanager = new InputHandler(this); inside the Engine objects constructor.
The world object also gets this refrence...

Any ideas or tips?

Share this post

Link to post
Share on other sites
I use a functor message system.

The uml shows it (my uml is a bit rusty so this might not be correct)
Basicly you have a message dispatcher class where you bind your subscribers.

Entity is a message dispatcher and your components that want to talk to each other are subscribers.
Now you define a message class for every message you want to send here the OnDamageMessage.
Now you bind a receiver function to the entity.
Then when sending a message to the entity its automaticly dispatched to the correct receiver. So that you only get messages with the type desired. This way you don't have to worry about the type of the message bc you already know it.


Share this post

Link to post
Share on other sites
Uh I'm heavily confused :S
I think i need have it explained in context.
I'm programming it in the Console :S

Sorry D: I'm really trying! But i find it hard to wrap my head around design patterns :S recently took inspiration from the Command Design Pattern :3
( Event is an abstract class aswell as Dialog ) :3

Share this post

Link to post
Share on other sites

That is essentially an implementation of the observer pattern. :)

I know but a absolute generic observer system. never said it isn't :)

Share this post

Link to post
Share on other sites
Sorry for my bad grammar! I haven't been on my home computer and my girlfriends desktop has a really small keyboard! :(
Anyways, as I said before this design patters is really hard to wrap my head around :S

So each of my Entities can dispatch ( send ) a message to a Subscriber ( Engine classes EventHandler and DialogHandler that holds the Queue and methods to process them. )
This way i still need to pass an object reference to the Subscribers ( EventHandler and DialogHandler which are components, I think).

This is quite possible in it's current state because InputHandler, EventHandler, DialogHandler and World Object gets an reference to the owner of them ( The Engine object that uses them ) by there constructors inside the Engine class constructor:

public Engine(GameState state)
inputmanager = new InputHandler(this);
dialogmanager = new DialogHandler(this);
eventmanager = new EventHandler(this);
world = new World(this);

The world contains an Engine owner reference and thus might be able to pass It's registered Event and Dialog Handler to each Entity inside the World object? Rather than passing the whole Engine as an reference it just passes the necessary component as reference?

The Entities can then just access the EventHandler and DialogManager AddToQueue method ( for example: EventReciever.AddToQueue(new MoveEvent(this, "Lost Woods"));
Am i getting this anywhere near right? :)

Share this post

Link to post
Share on other sites
It is pretty common to pass an engine with all the subsytems encapsulated as a method. Hell its common enough for them to be global.

What you have implemented isn't exactly what I described, but it sounds like it should work. Instead of passing a literal string as a param in your AddToQueue, why not pass an object reference instead?

Share this post

Link to post
Share on other sites
Well I'm a beginner ;D so i don't really know whats common and not ( Sorry for being a total noob... ).
I have always thought that the herachy of objects should be in a straight line :S Like

Engine object holds the "World"(Game Data) object, and the "World" object holds the Entity data ( Managed in arrays ).

By passing itself it kinda breaks the straight line of inheritance but i guess that this is not bad practice since it's so common? :o
Oh well by only passing the EventHandler and DialogHandler to the Entities ( By Method or Properties ( Get in C# )) I can at least withhold some kind of encapsulation :)
But Isn't that method kinda memory intensive since all Entities creates an reference object? :o

And how would your method be? Care to elaborate :3?

PS. The AddToQueue was a fictional example i actually pass an location object-reference :)

Share this post

Link to post
Share on other sites
Sign in to follow this  

  • Advertisement

Important Information

By using, you agree to our community Guidelines, Terms of Use, and Privacy Policy. is your game development community. Create an account for your GameDev Portfolio and participate in the largest developer community in the games industry.

Sign me up!