├── .gitignore
└── EntitySystemJava
    ├── src
        └── com
        │   └── wikidot
        │       └── entitysystems
        │           └── rdbmswithcodeinsystems
        │               ├── Component.java
        │               ├── EntityManager.java
        │               ├── SubSystem.java
        │               └── examplecomponents
        │                   └── Position.java
    └── tests
        └── com
            └── wikidot
                └── entitysystems
                    └── rdbmswithcodeinsystems
                        └── tests
                            ├── AllTests.java
                            ├── TestComponentAccess.java
                            ├── TestKillEntity.java
                            ├── TestPosition.java
                            └── quicktest.java


/.gitignore:
--------------------------------------------------------------------------------
1 | /.metadata/
2 | /bin/
3 | /*/bin/
4 | EntitySystemJava/.classpath
5 | 
6 | EntitySystemJava/.project
7 | 


--------------------------------------------------------------------------------
/EntitySystemJava/src/com/wikidot/entitysystems/rdbmswithcodeinsystems/Component.java:
--------------------------------------------------------------------------------
 1 | package com.wikidot.entitysystems.rdbmswithcodeinsystems;
 2 | 
 3 | /**
 4 |  * Standard design: c.f. http://entity-systems.wikidot.com/rdbms-with-code-in-systems
 5 |  * 
 6 |  * Modified in java to use Generics: instead of having a "ComponentType" field, we use the class type
 7 |  * of each subclass instead. This is safer.
 8 |  */
 9 | 
10 | public interface Component
11 | {
12 | 	
13 | }


--------------------------------------------------------------------------------
/EntitySystemJava/src/com/wikidot/entitysystems/rdbmswithcodeinsystems/EntityManager.java:
--------------------------------------------------------------------------------
  1 | package com.wikidot.entitysystems.rdbmswithcodeinsystems;
  2 | import java.util.ArrayList;
  3 | import java.util.HashMap;
  4 | import java.util.HashSet;
  5 | import java.util.LinkedList;
  6 | import java.util.List;
  7 | import java.util.Set;
  8 | 
  9 | /**
 10 |  * Standard design: c.f. http://entity-systems.wikidot.com/rdbms-with-code-in-systems
 11 |  * 
 12 |  * Modified in java to use Generics: instead of having a "ComponentType" enum, we use the class type
 13 |  * of each subclass instead. This is safer.
 14 |  */
 15 | 
 16 | public class EntityManager
 17 | {
 18 | 	int lowestUnassignedEntityID=1;
 19 | 	List<Integer> allEntities;
 20 | 	HashMap<Class<?>, HashMap<Integer, ? extends Component>> componentStores;
 21 | 	
 22 | 	public EntityManager()
 23 | 	{
 24 | 		allEntities = new LinkedList<Integer>();
 25 | 		componentStores = new HashMap<Class<?>, HashMap<Integer,? extends Component>>();
 26 | 	}
 27 | 	
 28 | 	public <T extends Component> T getComponent( int entity, Class<T> componentType)
 29 | 	{
 30 | 	   HashMap<Integer, ? extends Component> store = componentStores.get( componentType );
 31 | 	   
 32 | 	   if( store == null)
 33 | 	   	throw new IllegalArgumentException( "GET FAIL: there are no entities with a Component of class: "+componentType );
 34 | 	   
 35 | 	   T result = componentType.cast(store.get(entity));
 36 | 	   if( result == null )
 37 | 	      throw new IllegalArgumentException( "GET FAIL: "+entity+" does not possess Component of class\n   missing: "+componentType );
 38 | 
 39 | 	   return result;
 40 | 	}
 41 | 
 42 | 	public <T extends Component> List<T> getAllComponentsOfType( Class<T> componentType )
 43 | 	{
 44 | 		HashMap<Integer, ? extends Component> store = componentStores.get( componentType );
 45 | 		
 46 | 		if( store == null )
 47 | 		{
 48 | 			return new LinkedList<T>();
 49 | 		}
 50 | 		else
 51 | 		{
 52 | 			List<T> result = new ArrayList<T>((java.util.Collection<T>)store.values());
 53 | 			return result;
 54 | 		}
 55 | 	}
 56 | 	
 57 | 	public <T extends Component> Set<Integer> getAllEntitiesPossessingComponent( Class<T> componentType )
 58 | 	{
 59 | 		HashMap<Integer, ? extends Component> store = componentStores.get( componentType );
 60 | 		
 61 | 		if( store == null)
 62 | 	   	return new HashSet<Integer>();
 63 | 		
 64 | 		return store.keySet();
 65 | 	}
 66 | 	
 67 | 	public <T extends Component> void addComponent( int entity, T component )
 68 | 	{
 69 | 		HashMap<Integer, ? extends Component> store = componentStores.get( component.getClass() );
 70 | 		
 71 | 		if( store == null )
 72 | 		{
 73 | 			store = new HashMap<Integer, T>();
 74 | 			componentStores.put(component.getClass(), store );
 75 | 		}
 76 | 		
 77 | 		((HashMap<Integer, T>)store).put(entity, component);
 78 | 	}
 79 | 	
 80 | 	public int createEntity()
 81 | 	{
 82 | 
 83 | 		int newID = generateNewEntityID();
 84 | 		
 85 | 		if( newID < 1 )
 86 | 		{
 87 | 			/**
 88 | 			 Fatal error...
 89 | 			 */
 90 | 			return 0;
 91 | 		}
 92 | 		else
 93 | 		{
 94 | 			allEntities.add(newID);
 95 | 		
 96 | 			return newID;
 97 | 		}
 98 | 	}
 99 | 	
100 | 	public void killEntity( Integer entity ) // Pass as an object to remove key instead of index
101 | 	{
102 | 		synchronized( this ) // prevent it generating two entities with same ID at once
103 | 		{
104 | 			allEntities.remove(entity);
105 | 			for( HashMap<Integer, ? extends Component> store : componentStores.values() )
106 | 			{
107 | 				store.remove(entity);
108 | 			}
109 | 		}
110 | 	}
111 | 	
112 | 	public int generateNewEntityID()
113 | 	{
114 | 		synchronized( this ) // prevent it generating two entities with same ID at once
115 | 		{
116 | 			if( lowestUnassignedEntityID < Integer.MAX_VALUE )
117 | 			{
118 | 				return lowestUnassignedEntityID++;
119 | 			}
120 | 			else
121 | 			{
122 | 				for( int i=1; i<Integer.MAX_VALUE; i++ )
123 | 				{
124 | 					if( ! allEntities.contains(i) )
125 | 						return i;
126 | 				}
127 | 			
128 | 				throw new Error("ERROR: no available Entity IDs; too many entities!" );
129 | 			}
130 | 		}
131 | 	}
132 | }
133 | 


--------------------------------------------------------------------------------
/EntitySystemJava/src/com/wikidot/entitysystems/rdbmswithcodeinsystems/SubSystem.java:
--------------------------------------------------------------------------------
 1 | package com.wikidot.entitysystems.rdbmswithcodeinsystems;
 2 | 
 3 | /**
 4 |  * Standard design: c.f. http://entity-systems.wikidot.com/rdbms-with-code-in-systems
 5 |  */
 6 | 
 7 | public interface SubSystem
 8 | {
 9 | 	public void processOneGameTick( long lastFrameTime );
10 | }


--------------------------------------------------------------------------------
/EntitySystemJava/src/com/wikidot/entitysystems/rdbmswithcodeinsystems/examplecomponents/Position.java:
--------------------------------------------------------------------------------
 1 | package com.wikidot.entitysystems.rdbmswithcodeinsystems.examplecomponents;
 2 | 
 3 | import com.wikidot.entitysystems.rdbmswithcodeinsystems.Component;
 4 | 
 5 | /**
 6 |  * Example of a single component - a 2D position component with an x and a y
 7 |  * 
 8 |  * Note: all fields should be public, so you can direct-access them!
 9 |  * 
10 |  * c.f. http://entity-systems.wikidot.com/rdbms-with-code-in-systems
11 |  */
12 | public class Position implements Component
13 | {
14 | 	public float x, y;
15 | 	
16 | 	@Override
17 | 	public String toString()
18 | 	{
19 | 		return "("+x+","+y+")";
20 | 	}
21 | }


--------------------------------------------------------------------------------
/EntitySystemJava/tests/com/wikidot/entitysystems/rdbmswithcodeinsystems/tests/AllTests.java:
--------------------------------------------------------------------------------
 1 | package com.wikidot.entitysystems.rdbmswithcodeinsystems.tests;
 2 | 
 3 | import org.junit.runner.RunWith;
 4 | import org.junit.runners.Suite;
 5 | import org.junit.runners.Suite.SuiteClasses;
 6 | 
 7 | @RunWith(Suite.class)
 8 | @SuiteClasses({ TestComponentAccess.class, TestKillEntity.class, TestPosition.class })
 9 | public class AllTests {
10 | 
11 | }
12 | 


--------------------------------------------------------------------------------
/EntitySystemJava/tests/com/wikidot/entitysystems/rdbmswithcodeinsystems/tests/TestComponentAccess.java:
--------------------------------------------------------------------------------
 1 | package com.wikidot.entitysystems.rdbmswithcodeinsystems.tests;
 2 | 
 3 | import static org.junit.Assert.*;
 4 | 
 5 | import org.junit.Before;
 6 | import org.junit.Test;
 7 | 
 8 | import com.wikidot.entitysystems.rdbmswithcodeinsystems.EntityManager;
 9 | import com.wikidot.entitysystems.rdbmswithcodeinsystems.examplecomponents.Position;
10 | 
11 | public class TestComponentAccess {
12 | 
13 | 	private EntityManager em;
14 | 
15 | 	@Before
16 | 	public void setUp() throws Exception {
17 | 		em = new EntityManager();
18 | 	}
19 | 
20 | 	@Test
21 | 	public void testAccessingComponent() {
22 | 		int entity = em.createEntity();
23 | 		Position pos = new Position();
24 | 		pos.x = 5;
25 | 		pos.y = 10;
26 | 		em.addComponent(entity, pos);
27 | 
28 | 		assertEquals(pos, em.getAllComponentsOfType(Position.class).get(0));
29 | 	}
30 | }
31 | 


--------------------------------------------------------------------------------
/EntitySystemJava/tests/com/wikidot/entitysystems/rdbmswithcodeinsystems/tests/TestKillEntity.java:
--------------------------------------------------------------------------------
 1 | package com.wikidot.entitysystems.rdbmswithcodeinsystems.tests;
 2 | 
 3 | import static org.junit.Assert.*;
 4 | 
 5 | import java.util.Collection;
 6 | import java.util.List;
 7 | 
 8 | import org.junit.Before;
 9 | import org.junit.Test;
10 | 
11 | import com.wikidot.entitysystems.rdbmswithcodeinsystems.EntityManager;
12 | import com.wikidot.entitysystems.rdbmswithcodeinsystems.examplecomponents.Position;
13 | 
14 | public class TestKillEntity {
15 | 
16 | 	private EntityManager em;
17 | 
18 | 	@Before
19 | 	public void setUp() throws Exception {
20 | 		em = new EntityManager();
21 | 	}
22 | 
23 | 	@Test
24 | 	public void testKillingTwoForwards() {
25 | 		int first = em.createEntity();
26 | 		int second = em.createEntity();
27 | 
28 | 		em.killEntity(first);
29 | 		em.killEntity(second);
30 | 	}
31 | 
32 | 	@Test
33 | 	public void testKillingTwoBackwards() {
34 | 		int first = em.createEntity();
35 | 		int second = em.createEntity();
36 | 
37 | 		em.killEntity(second);
38 | 		em.killEntity(first);
39 | 	}
40 | 
41 | 	@Test(expected = IllegalArgumentException.class)
42 | 	public void testAccessingRemovedComponentIndividually() {
43 | 		int entity = em.createEntity();
44 | 		Position pos = new Position();
45 | 		pos.x = 5;
46 | 		pos.y = 10;
47 | 		em.addComponent(entity, pos);
48 | 
49 | 		em.killEntity(entity);
50 | 		Position result = em.getComponent(entity, Position.class);
51 | 	}
52 | 	
53 | 	@Test
54 | 	public void testAccessingRemovedComponentList() {
55 | 		int entity = em.createEntity();
56 | 		Position pos = new Position();
57 | 		pos.x = 5;
58 | 		pos.y = 10;
59 | 		em.addComponent(entity, pos);
60 | 
61 | 		em.killEntity(entity);
62 | 		List<Position> result = em.getAllComponentsOfType(Position.class);
63 | 		assertTrue(result.isEmpty());
64 | 	}
65 | }
66 | 


--------------------------------------------------------------------------------
/EntitySystemJava/tests/com/wikidot/entitysystems/rdbmswithcodeinsystems/tests/TestPosition.java:
--------------------------------------------------------------------------------
 1 | package com.wikidot.entitysystems.rdbmswithcodeinsystems.tests;
 2 | 
 3 | import static org.junit.Assert.*;
 4 | 
 5 | import org.junit.Before;
 6 | import org.junit.Test;
 7 | 
 8 | import com.wikidot.entitysystems.rdbmswithcodeinsystems.EntityManager;
 9 | import com.wikidot.entitysystems.rdbmswithcodeinsystems.examplecomponents.Position;
10 | 
11 | public class TestPosition {
12 | 	private EntityManager em;
13 | 
14 | 	@Before
15 | 	public void setUp() throws Exception {
16 | 		em = new EntityManager();
17 | 	}
18 | 
19 | 	/*
20 | 	 * This is just quicktest.
21 | 	 */
22 | 	@Test
23 | 	public void test() {
24 | 		int entity1 = em.createEntity();
25 | 
26 | 		em.addComponent(entity1, new Position());
27 | 		em.getComponent(entity1, Position.class).x = 5;
28 | 		em.getComponent(entity1, Position.class).y = 10;
29 | 
30 | 		assertEquals("(5.0,10.0)", ""+em.getComponent(entity1, Position.class));
31 | 	}
32 | }
33 | 


--------------------------------------------------------------------------------
/EntitySystemJava/tests/com/wikidot/entitysystems/rdbmswithcodeinsystems/tests/quicktest.java:
--------------------------------------------------------------------------------
 1 | package com.wikidot.entitysystems.rdbmswithcodeinsystems.tests;
 2 | 
 3 | import com.wikidot.entitysystems.rdbmswithcodeinsystems.EntityManager;
 4 | import com.wikidot.entitysystems.rdbmswithcodeinsystems.examplecomponents.Position;
 5 | 
 6 | /**
 7 |  * Very brief test to check that the ES implementation is compiling and running OK
 8 |  * 
 9 |  * Run from the command line - no arguments - and see if you get Exceptions / Errors.
10 |  */
11 | public class quicktest
12 | {
13 | 	
14 | 	public static void main(String[] args)
15 | 	{
16 | 		EntityManager em = new EntityManager();
17 | 		
18 | 		int entity1 = em.createEntity();
19 | 		
20 | 		em.addComponent(entity1, new Position());
21 | 		em.getComponent(entity1, Position.class).x = 5;
22 | 		em.getComponent(entity1, Position.class).y = 10;
23 | 		
24 | 		System.out.println( "Value of Position component is: "+em.getComponent(entity1, Position.class));
25 | 	}
26 | }
27 | 


--------------------------------------------------------------------------------