Also: re-written to take advantage of a new plugin I installed that makes code-in-posts MUCH more readable!

return result;
}
}


public T getComponent( Entity e, Class exampleClass )

well you weren’t too far off. I got it to work (read not give compile errors) like this:

public class EntitySystemSimple extends BaseEntitySystem
{
//note that even the Class object is too. May as well enforce that
HashMap< Class, HashMap > componentStores;

//you only have to write “T extends Component” once at the beginning
//all the other T’s in the method refer to it, including in the parameter list
public T getComponent( Entity e, Class exampleClass )
{
//The rest of the code is the same as how you originally wrote it
HashMap store = componentStores.get( exampleClass );

T result = (T) store.get( e );
if( result == null ) {
throw new IllegalArgumentException( “GET FAIL: “+e+” does not possess Component of class\n missing: “+exampleClass );
}

return result;
}
…
}

a call to the getComponent method now enforces that the Class you give it is a subclass from Component like you wanted. I hope that helped.

With kind regards

On topic … Apple specifically promoted OS X machines as running Windows as a selling point. Then a combination of their cheap-ass purchasing of crappy hardware (implied by ATI: the problem is that Apple knowingly used out-of-date, end-of-life hardware), and (maybe) some problem of how they customized the hardware … mean that the compatibility that *should* have worked out of the box … stopped working entirely.

But come on Adam, complaining about how long it takes Apple to provide support for another company’s OS is a bit unfair. How long has it taken for Microsoft to build in support for installing OS X? Oh right, they haven’t.

Apple goes above and beyond already by making it easy to run Windows side by side on a Mac. Complaining about how long it takes it like being that guy who complains WiFi isn’t working on the plane :)

A focus on implicit composition / the implicit has-a relationship as the central organization method is the key to component oriented programming and an ES may be considered an implementation of such an approach.

*”Of course a Java implementation is object oriented, Java enforces an OOP framework. This is unfortunate (in the context of ES), because it seems to require a good deal of creativity to circumvent language restrictions.”

*”OOP, COP are nothing more than methods used to establish order in a system, and are concepts that transcend language.”

While Java is traditionally OOP aligned in what the language allows in regard to architecture it was Java 1.5 / 5 that opened the door with generics. In particular generic methods. Advanced use of generics isn’t something that hit mainstream Java development per se outside of maybe adding typed collections to ones everyday usage.

Dynamic and functional languages are more suited out of the box for component oriented programming and even allow more exotic typing aspects like duck typing. However, the nice thing about Java is that it is strongly typed and one can get the best of a functional _like_ situation via COP techniques. I also prefer the superior IDE support which comes with a strongly typed language.

A specific API that is implemented by generic methods is how one creates a component architecture / ES with Java. While everything still is an Object the COP API allows one to break away from structuring ones code via traditional OOP.

*” One could use COP to impose a “traditional OOP” inheritance hierarchy.”

Except without the inheritance and explicit composition; the corner stones of traditional OOP.

The most common way of structuring an inheritance _like_ operation with COP is “(implicit) extension by iteration”. This however is not a 1:1 direct replacement or the same thing as inheritance.

*” In my view, the client/server relationship isn’t any different than child/parent or sub/super class relationships.”

Not really unless one is taking an extremely loose view as in a whatever goes mentality. IE these two different architecture models have relationships between each other therefore they are equal… Nope…

*”The key concept is abstraction – “Avoiding the direct use of memory references.” is intentionally vague – how exactly this is accomplished doesn’t matter.”

Yes, the key is implicit composition which is a particular type of abstraction usually involves a query interface of some sort whether a GUID or in the case of the COP API I’ve made and other ES implementations in Java a query interface that is strongly typed via Class references.

*”So no, MINIX is not an ES, but I believe it’s architecture and systems are sufficently similar to make it a useful reference.”

In a loose manner to some respect yes, but only insofar that MINIX is a microkernal architecture, IE based on component architecture techniques.

An ES as implemented in Adam’s efforts and other reference implementations such as Artemis do tightly tie the component architecture aspects to a specific more game-centric context.

You might have seen me advocate strongly to make the component architecture implementation a superset of an ES because it is very useful for many other purposes beyond a game context.

In that regard MINIX has more similarities to my larger work with TyphonRT which provides a stable middleware runtime across diverse hardware and OS versions. My efforts also do contain a specific ES implementation, but it is based on a generalized component architecture vs a game-centric implementation.

—–

I do believe the client / server comparison is where things got derailed in the discussion. Component architectures have been around for a while. They can be implemented in traditional OOP, but implicit composition or the preferred way of pulling them off in Java especially for ES requires generic methods.

T. Oliver

1. Google has two-phase auth. Finding out that someone has successfully logged in isn’t much good if they’ve… already done it, changed your password & security question and locked you out.

2. Google’s spam detection runs rings around Yahoo. I have an old yahoo account I periodically log into. It’s absolutely choked with tens of thousands of spam emails! My google account receives a handful of successful spam mails every month.

The only downside to google is the aforementioned UI changes and the faceless nature of the company. I can’t really imagine having to reclaim my account if something goes wrong. It’ll be a ticket floating through a pipe in a maze somewhere.

What they call “kit based” is the 30-year-old technique of “build a game level by assembling lego-like smaller (re-usable) pieces”.

I’m not sure what you’re trying to achieve here. If a layer is not CAShapeLayer, then it has no “shape” and cannot be filled anyway – setting a fill colour would be impossible. Have you checked what class your CALayer actually is ? CALayer is merely the “root” class of all CA…something…Layer classes.

More generally … the answer to all these problems is “read the Apple docs”. Apple’s CoreAnimation library (c.f. the docs links I’ve already posted) has extensive docs and features on pretty much everything you could ever want to do.

SVGKImage *corn = [SVGKImage imageNamed:@"Corn.svg"];
CALayer *layer = [corn layerWithIdentifier:@"Layer_1"];

UIView *viewToMask = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 320, 460)];
viewToMask.layer.backgroundColor = [UIColor darkGrayColor].CGColor;
viewToMask.layer.mask = layer;
[self.view addSubview:viewToMask];

I tried changing the “fillColor” of the corn’s CALayer, but only CAShapeLayer has this attribute.

Is there a better way of changing the fill color for the image without using the mask?

Apple’s CGPath cant be edited directly – you have to write your own code to clone it / convert it to a sensible format. I’ve got code for that but its commercial/private , not part of SVGKit.

In many cases, it’s easier to leave the DOM alone, and just edit the CALayer objects directly. For each SVGElement there is a CALayer object in the “newCALayerTree” that should have the same ID. If you look at the demo project, and search the source code for “monkey”, the bit of code that animates the monkey shows how to find a specific CALayer, I think

NSString* tagToFind = @”LWPOLYLINE”;
Element * element = [buildingImage.DOMDocument getElementById:tagToFind];
NodeList *elementList = [element getElementsByTagName:@"rect"];
for( Element* domElement in elementList )
{
SVGElement* svgElement = (SVGElement*) domElement;
NSLog(@”before change:%@”,[svgElement getAttributeNode:@"fill"].nodeValue);
[[svgElement getAttributeNode:@"fill"] setNodeValue:@”#000000″];
NSLog(@”after change:%@”,[svgElement getAttributeNode:@"fill"].nodeValue);
}

CALayer * myNewRootLayer = [buildingImage newCALayerTree];

[[self.view layer] addSublayer:myNewRootLayer];

https://developer.apple.com/library/mac/#documentation/cocoa/conceptual/coreanimation_guide/introduction/introduction.html

If you only select one thing at once, then a SelectableComponent is probably enough, and you simply store the “current selected unit” inside the System that deals with mouseclicks and selection etc.

For simple examples, you might think of sounds as “one-off events”. But for most games, sounds are simply a form of Animation: they have a timeline, a current time-offset, a state (playing/paused/etc), and triggers for “do stuff as soon as it finishes”.

e.g. when you pause the game, you want your explosion sound effect to pause, right? Because when you un-pause it, you want the animation + sound to resume from where they were.

Given that animations *always* need complex state, unless you have a very very simple game … you can expect to have at least one component dedicated to them, maybe several.

(e.g. you could have a general “Animatable” component which stores stuff like “duration, starttime, currenttime, etc” … and a “VisualAnimation” which has info for animating the graphics (uses the Animatable to handle the core animation stuff), and an “AuralAnimation” that has info for playing the sound(s).

1)How often are the methods addCompontent/removeComponent used (not in the creation of an entity)? (all the time or just a few times)
I ask this since the following question are based on this.

2)An entity can play different sounds but I don’t know how i should manage them (same for different movements).
- One sound component which holds all sounds the enitity can play and an field which says which sound should be played.
- For each sound a seperate component which is added as soon as it should be played and is removed if it has been played (for example when the unit shoots)
- If you have an attack sound is it better to ‘save’ the sound in the attack component?

3) How should I implement the selection of a unit:
- SelectableComponent with an boolean field which says if its selected or add a isSelectedComponent as sson as the entity is selected and will be removed if its unselected?

4)Is it possible that all entity posses the same component like a PositionComponent?

I changed the entites now back into integers only. Before I had an field for the bitValues of all components an entity possess for efficient look up. This restricted my total number of different components to 64 (long value) what was quite annoying.
5) How would you search for entities which possess more than 1 components (let’s say components x,y and z) in an efficient way? (add a component bitValueComponent instead of the field i used? or take all entities of each component and search in the one with the least entries)
6)Is there a way to bypass this restriction of 64 components and still have good performance for look up?

big thanks in advance,
Jan

Google “svg trace” if you want to convert images into SVG.

SVGKit is for drawing SVG’s, not for image-conversion, sorry.

The point is to focus on similarities across ES definitions and implementations (not necessarily agree with my synopsis). What do you and Adam agree on? What – in most basic terms – qualifies as an entity system in your opinion?

I personally feel the language issues are distracting. Of course a Java implementation is object oriented, Java enforces an OOP framework. This is unfortunate (in the context of ES), because it seems to require a good deal of creativity to circumvent language restrictions.

It also seems that (many, not all) Java programmers view OOP as something more concrete than it actually is. OOP, COP are nothing more than methods used to establish order in a system, and are concepts that transcend language. One could use COP to impose a “traditional OOP” inheritance hierarchy. In my view, the client/server relationship isn’t any different than child/parent or sub/super class relationships. The difference is, client/server relationships aren’t enforced (so you have more freedom to create a tangled mess if you like).

The mention of GUID’s was given with respect to Adam’s article. The key concept is abstraction – “Avoiding the direct use of memory references.” is intentionally vague – how exactly this is accomplished doesn’t matter.

If anyone is expecting to “cut & paste” MINIX source code (or even repurpose most of it), they will be disappointed. What they will find are implementation ideas for a “similar” substantial system (that will at least set them on a path for further research).

The use of “similar” is imprecise. To clarify – the usage here is inline with that of George Polya in his book, How to solve It: A New Aspect of Mathematical Method.
According to Polya, one of the first things someone should do once the problem is understood, is look for existing solutions to similar or related problems. This may involve viewing the problem differently, breaking a problem into sub-problems, even modifying the problem to fit an existing solution.

So no, MINIX is not an ES, but I believe it’s architecture and systems are sufficently similar to make it a useful reference.

It is perfectly “possible” to do something *around* the git library that causes an outcome that is impossible for a user to pull off.

Most importantly, you are COMPLETELY WRONG in claiming that Smartgit is merely a “wrapper”. It is not. It contains many features that are not part of git, although tey are PARTLY IMPLEMENETED using git. I believe its bugs in these bits of code (smartgits behaviour reminds me of bugs i had in my earliest Java programs when i didnt know much about file handling, and wrote fragile crappy code)

Please can you issue a pull request against the “1.1.0″ branch from master.

Im not sure how you do this, but i think:
1. Get the latest master into hour fork, including the 1.1.0 branch
2. Switch to 1.1.0 branch
3. Apply fixes
4. Push to your fork
5. In github web oage, select the 1.1.0 branch and click issue oull request

All i can suggest is to read apples user guides on CG and COreAnimation – they are very detailed and clear on all this.

SVGkit is almost entirely standard in this respect – it does almost zero deviation from core CA and CG

You can use anything from CoreAnimation on them.

CoreGraphics is incompatible, but you can write a CALayer that uses CoreGraphics if you like

I have a SCGKImage displaying correctly, but I want to change the graphical effects on it, preferably with core graphics. Changing the fill color would be the first step, so I know what I’m doing from there on. How can I get core graphics to work with my vector shape?

Except what you brought up really has not much to do with Entity Systems (ES) in the context of these blog posts or at least in my efforts with my own ES / Java work. First off ES is an _in process_ mechanism and has nothing to do with client / server associations. Technically an ES as implemented in Java is still OOP, but not traditional OOP ala a focus on inheritance / explicit composition and strong encapsulation mixing data / logic with an unchecked amount of mutator methods. ES focus on the _implicit has-a_ relationship by providing an API vs built in language constructs at least for Java. A second pillar that may or may not be adopted is supporting indirect message passing vs more traditional OOP methods such as the Observer / Listener pattern. Indirect messaging is not mandatory for an ES, but solves a lot of general problems over direct indexing of components / systems / tight coupling.

In many ways indirect message passing and the implicit has-a relationship are much closer to what language pioneers like Alan Kay had in mind for OOP, before it got derailed toward what we call “traditional OOP”. The distinction against traditional OOP in regarding to ES is enough for us to generally call it “COP – component oriented programming”.

One can of course still apply client / server development with an ES like API on each side potentially, but that doesn’t mean an ES has anything to do with client / server programming in general. It also has little to do with COM / DCOM of years past except that there is a query mechanism, but it functions drastically differently at least the Java implementations of ES concepts do. Also not all ES rely on a GUID approach as a central implementation detail. Adam’s demo code does, but my efforts don’t.

The MINIX OS also has little relevance to ES proper.

I suppose of minor note that Adam and I don’t always agree on terminology or implementation and such, but as things go I can chime in and say you are barking up the wrong tree.

Object oriented programming has become increasingly dominant over the last few decades. You acknowledge the core entity system is not an object oriented solution, so it shouldn’t be suprising that one might need to go back a decade or two to find an analogue solution.

The following is my opinion on how an entity system should be considered, followed by a few reasons why, and a resource I believe is relevant.

Entity system:
The core system is comprised of a client server coupled with a memory abstraction layer. The major design goal is a high degree of modularity in the addition of services and composition of clients.

Client server:
The client server is conceptually a relationship that specifies a seperation of responsibilities, and is consistent with the client server model as outlined in the component object model. It is this framework that provides for the easy and unobtrusive addition of services.

Key ideas from the component object model:
1) A client is any entity that uses the services of a component object.
2) The location or layout of data within the system is irrelevant.

Memory abstraction layer:
The memory abstraction layer is responsible for virtualizing client objects. It accomplishes this by avoiding the direct use of memory references to clients and their constituent elements. A system may use multiple layers.

Data layout:
At one point in the article, you give five examples that demonstrate the differences in opinion on what exactly constitutes an entity system. The main argument is over data layout. When data layout is no longer used as a qualifier, suddenly they’re all entity systems.
(Yes, even the one whose client classes contain member functions – I would argue – since those methods are only invoked by the server, they are extensions of the server, and I can’t think of a good reason to disallow extendable servers.)
You may not agree that data layout is irrelevant, but I believe – the fact you were able to sidestep the question “where does the data live?” and still discuss entity systems in depth supports the claim.

Terms:
Why insist on the terms client server model and memory abstraction layer? The reason is, they lead to richer resources than the inconsistent and ad hoc names that are currently being used to describe these systems.
The core system is implemented using component oriented programming. A search for COP coupled with client server will quckly lead to COM. In this environment I can’t think of a better resource than COM (and by extension the .NET framework) to use as a model for providing dynamic services.
Memory abstraction leads to virtual memory managment, which covers exactly the kinds of techniques you’ll need to implement this system well. Think about what the use of identifiers (GUIDs) does at the lowest level. It virtualizes memory. It enables the system to hand a singular entity to the user, while behind the scenes its individual components (aspects) may be scattered all over the system. This isn’t any different than what your operating system’s virtual memory manager does when it hands memory to a process. To the process it looks like a contiguous block of memory, but the physical layout may be a patchwork of memory, even residing on the hard drive or somewhere offsite.

Supporting code:
This is where things get heavy. Questions being asked in this forum include – memory management, scheduling, inter-process (module) communication, event handling, streams, optimization issues.
If only there were an existing layered, client server architecture with similar design goals and systems…
Good news, there is.
In fact if we eliminate purpose (game development), what we are describing is very similar to micro-kernel operating system architecture.

MINIX:
The MINIX operating system is an open source project that has been used in academia forever. The source code is up to date and free to download. Documentation is plentiful. A full treatment of all systems, design decisions, advice, and ideas for future research may be found in books by the original author of MINIX, Andrew S. Tanenbaum.

I hope this resource keeps at least one person from shooting in the dark and reinventing wheels.

Come out into the real world Google. Don’t just take everyone’s picture and snoop on them. Listen to their complaints. I couldn’t find anywhere to give Google my feelings. Fortunately, the internet is still free enough to find someone who will listen….

Yes, it’s very good for that.

“it seems kinda difficult to keep entities only an integer”

No, it’s very easy. If you think it’s difficult, you should stop and re-think, and make sure you understand the entity system properly. You should find it EASIER to do this with components (leaving the “entity” as a pure integer).

Other questions:
1)Is it ok to use objects for special entities like the map (2D) and the gui? So for now I got a WORLD class which extends ENTITYMANAGER and i thought i handle the map seperate in the world class instead of with the entitymanager.
2)For the input I just implemented a INPUTSYSTEM which checks which button was pressed and then gets all entities which are involved. So in the end this will be a very big Switch or if/else part… Is there a better way to do this?
(I search pretty long to find answers to that but there were just to many ideas so i though maybe ill ask you since you seem to know what you are talking about^^)

Cheers and thank you in advance,
Jan
PS: also thanks for the fast answer last time :)

Initwithlayer is called implicitly by apple if you do implicit CALayer animations

(Which happens auotmatically a lot)

I was looking at the SVGKLayer dealloc and a saw your comment regarding the crash.
After some digging i observed that the dealloc-ated instance is not the one initialized by [init], but one initialized with -(id)initWithLayer:(id)layer. If i register the observer there everything works ok. i don’t know why the initWithLayer method get’s called, probable is something “internal” to CA.

John

Here’s my starting position:

1. I have several books that describe the Client/Server paradigm, and there’s nothing even vaguely similar to an ES in there
2. ES’s specifically solve problems to do with OOP; since Client/Server was invented 10-20 years before OOP was invented, it would be rather surprising if it included ES’s.

So far, all you’ve done is say “[absurd thing] is true because I say so”, and to cast insults. It’s very difficult to take you seriously if you won’t engage, and fail to provide anything remotely constructive or evidential.