Add changelog, clean up docs a bit.

diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644 (file)
index 0000000..ae58255
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,17 @@
+# Change Log
+
+## 2013-08-17 - Python scripting, and a more robust build system
+
+Two big changes in this release:
+
+1. Python scripting support (alpha).
+
+    - Bridges the EntityX entity-component system into Python.
+    - Components and entities can both be defined in Python.
+    - Systems must still be defined in C++, for performance reasons.
+
+    Note that there is one major design difference between the Python ECS model and the C++ model: entities in Python can receive and handle events.
+ 
+    See the [README](https://github.com/alecthomas/entityx/blob/master/entityx/python/README.md) for help, and the [C++](https://github.com/alecthomas/entityx/blob/master/entityx/python/PythonSystem_test.cc) and [Python](https://github.com/alecthomas/entityx/tree/master/entityx/python/entityx/tests) test source for more examples.
+
+2. Updated the build system to 

diff --git a/README.md b/README.md
index 2a0f22adb28073230b59003d736b147999376b82..c8d29beedbf2551948e6c61f2b56d03403d771b3 100644 (file)
--- a/README.md
+++ b/README.md
@@ -6,6 +6,13 @@ Entity-Component (EC) systems are a form of decomposition that completely decoup
 
 EntityX is an EC system that uses C++11 features to provide type-safe component management, event delivery, etc. It was built during the creation of a 2D space shooter.
 
+## Recent Notable Changes
+
+- Python scripting system (alpha).
+- Revamped build system, including selectable smart pointer implementation (Boost or stdlib).
+
+See the [ChangeLog](https://github.com/alecthomas/entityx/blob/master/CHANGELOG.md) for a full list.
+
 ## Overview
 
 In EntityX data associated with an entity is called a `Component`. `Systems` encapsulate logic and can use as many component types as necessary. An `EventManager` allows systems to interact without being tightly coupled. Finally, a `Manager` object ties all of the systems together for convenience.
@@ -44,9 +51,9 @@ entity.destroy();
 
 ### Components (entity data)
 
-The idea with ECS is to not have any functionality in the component. All logic should be contained in Systems.
+The general idea with the EntityX interpretation of ECS is to have as little functionality in components as possible. All logic should be contained in Systems.
 
-To that end Components are typically [POD types](http://en.wikipedia.org/wiki/Plain_Old_Data_Structures) containing self-contained sets of related data. Implementations are [curiously recurring template pattern](http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern) (CRTP) subclasses of `Component<T>`.
+To that end Components are typically [POD types](http://en.wikipedia.org/wiki/Plain_Old_Data_Structures) consisting of self-contained sets of related data. Implementations are [curiously recurring template pattern](http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern) (CRTP) subclasses of `Component<T>`.
 
 #### Creating components
 

diff --git a/entityx/python/README.md b/entityx/python/README.md
index 17743b9e01359ab6a6dfce61b08c85e620a1f805..be543fb415b5411a64d3b80901f73eb46c94387c 100644 (file)
--- a/entityx/python/README.md
+++ b/entityx/python/README.md
@@ -1,7 +1,13 @@
-# Python Scripting System for EntityX
+# Python Scripting System for EntityX (α Alpha)
 
 This system adds the ability to extend entity logic with Python scripts. The goal is to allow ad-hoc behaviour to be assigned to entities, in contract to the more pure entity-component system approach.
 
+## Limitations
+
+Planned features that are currently unimplemented:
+
+- Emitting events from Python.
+
 ## Concepts
 
 - Python scripts are attached to entities with `PythonComponent`.
@@ -30,7 +36,7 @@ In most cases, this should be pretty simple. Given a component, provide a `boost
 
 Here's an example:
 
-```
+```c++
 namespace py = boost::python;
 
 struct Position : public Component<Position> {
@@ -76,7 +82,7 @@ To implement more refined logic, subclass `PythonEventProxy` and operate on
 the protected member `entities`. Here's a collision example, where the proxy
 only delivers collision events to the colliding entities themselves:
 
-```
+```c++
 struct CollisionEvent : public Event<CollisionEvent> {
   CollisionEvent(Entity a, Entity b) : a(a), b(b) {}
 
@@ -115,7 +121,7 @@ BOOST_PYTHON_MODULE(mygame) {
 
 Finally, initialize the `mygame` module once, before using `PythonSystem`, with something like this:
 
-```
+```c++
 // This should only be performed once, at application initialization time.
 CHECK(PyImport_AppendInittab("mygame", initmygame) != -1)
   << "Failed to initialize mygame Python module";
@@ -123,7 +129,7 @@ CHECK(PyImport_AppendInittab("mygame", initmygame) != -1)
 
 Then create and destroy `PythonSystem` as necessary:
 
-```
+```c++
 // Initialize the PythonSystem.
 vector<string> paths;
 paths.push_back(MYGAME_PYTHON_PATH);

diff --git a/entityx/python/entityx/tests/deep_subclass_test.py b/entityx/python/entityx/tests/deep_subclass_test.py
index 7dc7ca57c58c2216fcd1702eaedb0b43c72ca473..9c576b29004a307341b03c8c31c83f13b97a5f11 100644 (file)
--- a/entityx/python/entityx/tests/deep_subclass_test.py
+++ b/entityx/python/entityx/tests/deep_subclass_test.py
@@ -21,4 +21,4 @@ class DeepSubclassTest2(DeepSubclassTest):
         assert self.direction
         assert self.position
         assert self.position2
-        assert self.position is self.position
+        assert self.position is self.position2