README updates.

5 files changed, 42 insertions, 42 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 253cc70..afb3146 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -59,7 +59,7 @@ set(CMAKE_CXX_FLAGS_MINSIZEREL "-Os -DNDEBUG")
 set(CMAKE_CXX_FLAGS_RELEASE "-O2 -DNDEBUG")
 set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g")
 
-set(sources entityx/Components.cc entityx/System.cc entityx/Event.cc entityx/Entity.cc entityx/World.cc)
+set(sources entityx/Components.cc entityx/System.cc entityx/Event.cc entityx/Entity.cc entityx/Manager.cc)
 add_library(entityx STATIC ${sources})
 add_library(entityx_shared SHARED ${sources})
 
diff --git a/README.md b/README.md
index cd5fff6..4b71e94 100644
--- a/README.md
+++ b/README.md
@@ -1,18 +1,18 @@
 # EntityX - A fast, type-safe C++ Entity-Component system
 
-Entity-Component (EC) systems are a form of decomposition that completely decouple entity logic and data from the entity "objects" themselves. The [Evolve your Hierarchy](http://cowboyprogramming.com/2007/01/05/evolve-your-heirachy/) article provides a solid overview of EC systems.
+Entity-Component (EC) systems are a form of decomposition that completely decouples entity logic and data from the entity "objects" themselves. The [Evolve your Hierarchy](http://cowboyprogramming.com/2007/01/05/evolve-your-heirachy/) article provides a solid overview of EC systems and why you should use them.
 
-EntityX is an EC system that uses C++11 features to provide type-safe component management, event delivery, etc.
+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.
 
 ## Overview
 
-In EntityX data associated with an entity is called a `Component`. `Systems` use components to implement behavior and can utilize as many components as necessary. An `EventManager` allows systems to interact without being tightly coupled. Finally, a `World` object ties all of the systems together for convenience.
+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.
 
 As an example, a physics system might need *position* and *mass* data, while a collision system might only need *position* - the data would be logically separated into two components, but usable by any system. The physics system might emit *collision* events whenever two entities collide.
 
 ## Tutorial
 
-
+Following is some skeleton code that implements `Position` and `Direction` components, a `MovementSystem` using these data components, and a `CollisionSystem` that emits `Collision` events when two entities collide.
 
 ### Entities
 
@@ -66,15 +66,6 @@ entities.assign(entity, position);
 
 #### Querying entities and their components
 
-To retrieve a component associated with an entity use ``EntityManager::component()``:
-
-```
-boost::shared_ptr<Position> position = entities.component<Position>();
-if (position) {
-  // Do stuff with position
-}
-```
-
 To query all components with a set of components assigned use ``EntityManager::entities_with_components()``. This method will return only those entities that have *all* of the specified components associated with them, assigning each component pointer to the corresponding component instance:
 
 ```
@@ -85,6 +76,15 @@ for (auto entity : entities.entities_with_components(position, direction)) {
 }
 ```
 
+To retrieve a component associated with an entity use ``EntityManager::component()``:
+
+```
+boost::shared_ptr<Position> position = entities.component<Position>();
+if (position) {
+  // Do stuff with position
+}
+```
+
 ### Systems (implementing behavior)
 
 Systems implement behavior using one or more components. Implementations are subclasses of `System<T>` and *must* implement the `update()` method, as shown below.
@@ -94,8 +94,8 @@ A basic movement system might be implemented with something like the following:
 ```
 struct MovementSystem : public System<MovementSystem> {
   void update(EntityManager &es, EventManager &events, double dt) override {
-    Position *position;
-    Direction *direction;
+    boost::shared_ptr<Position> position;
+    boost::shared_ptr<Direction> direction;
     for (auto entity : es.entities_with_components(position, direction)) {
       position->x += direction->x;
       position->y += direction->y;
@@ -154,7 +154,7 @@ struct DebugCollisions : public Receiver<DebugCollisions> {
 };
 ```
 
-Note that a single class can receive any number of types of events by implementing a ``receive(const EventType &)`` method for each event type.
+***Note:** a single class can receive any number of types of events by implementing a ``receive(const EventType &)`` method for each event type.*
 
 Finally, we subscribe our receiver to collision events:
 
@@ -168,14 +168,14 @@ DebugCollisions debug_collisions;
 events.subscribe<Collision>(debug_collisions);
 ```
 
-### World (tying it all together)
+### Manager (tying it all together)
 
-Managing systems, components and entities can be streamlined by subclassing `World`. It is not necessary, but it provides callbacks for configuring systems, initializing entities and the world, and so on.
+Managing systems, components and entities can be streamlined by subclassing `Manager`. It is not necessary, but it provides callbacks for configuring systems, initializing entities, and so on.
 
-To use it, subclass `World` and implement `configure()`, `initialize()` and `update()`:
+To use it, subclass `Manager` and implement `configure()`, `initialize()` and `update()`:
 
 ```
-class GameWorld : public World {
+class GameManager : public Manager {
  protected:
   void configure() {
     system_manager.add<MovementSystem>();
@@ -202,7 +202,7 @@ class GameWorld : public World {
 
 EntityX has the following build and runtime requirements:
 
-- A C++ compiler that supports a basic set of C++11 features (eg. recent clang, recent gcc).
+- A C++ compiler that supports a basic set of C++11 features (ie. recent clang, recent gcc, but **NOT** Visual C++).
 - [CMake](http://cmake.org/)
 - [Boost](http://boost.org) `1.48.0` or higher (links against `boost::signals`).
 - [Glog](http://code.google.com/p/google-glog/) (tested with `0.3.2`).
diff --git a/entityx/World.cc b/entityx/Manager.cc
index 05a10d7..012e06f 100644
--- a/entityx/World.cc
+++ b/entityx/Manager.cc
@@ -8,17 +8,17 @@
  * Author: Alec Thomas <alec@swapoff.org>
  */
 
-#include "World.h"
+#include "Manager.h"
 
 namespace entity {
 
-void World::start() {
+void Manager::start() {
   configure();
   system_manager.configure();
   initialize();
 }
 
-void World::run() {
+void Manager::run() {
   running_ = true;
   double dt;
   timer_.restart();
@@ -29,7 +29,7 @@ void World::run() {
   }
 }
 
-void World::stop() {
+void Manager::stop() {
   running_ = false;
 }
 
diff --git a/entityx/World.h b/entityx/Manager.h
index 0cca1e2..66ace3f 100644
--- a/entityx/World.h
+++ b/entityx/Manager.h
@@ -17,10 +17,10 @@
 
 namespace entity {
 
-class World {
+class Manager {
  public:
-  World() : entity_manager(event_manager), system_manager(entity_manager, event_manager) {}
-  virtual ~World() {}
+  Manager() : entity_manager(event_manager), system_manager(entity_manager, event_manager) {}
+  virtual ~Manager() {}
 
   void start();
   void run();
@@ -30,7 +30,7 @@ class World {
   /**
    * Configure the world.
    *
-   * This is called once on World initialization. It is typically used to add Systems to the world, load permanent
+   * This is called once on Manager initialization. It is typically used to add Systems to the world, load permanent
    * resources, global configuration, etc.
    */
   virtual void configure() = 0;
diff --git a/entityx/System_test.cc b/entityx/System_test.cc
index 0c54dab..2dad4d9 100644
--- a/entityx/System_test.cc
+++ b/entityx/System_test.cc
@@ -12,7 +12,7 @@
 #include <vector>
 #include <glog/logging.h>
 #include <gtest/gtest.h>
-#include "entityx/World.h"
+#include "entityx/Manager.h"
 #include "entityx/System.h"
 
 
@@ -52,7 +52,7 @@ class MovementSystem : public System<MovementSystem> {
 };
 
 
-class TestWorld : public entity::World {
+class TestManager : public entity::Manager {
  public:
   std::vector<Entity> entities;
 
@@ -81,31 +81,31 @@ class TestWorld : public entity::World {
 
 class SystemManagerTest : public ::testing::Test {
  protected:
-  TestWorld world;
+  TestManager manager;
 
   virtual void SetUp() override {
-    world.start();
+    manager.start();
   }
 };
 
 
 TEST_F(SystemManagerTest, TestConstructSystemWithArgs) {
-  world.sm().add<MovementSystem>("movement");
-  world.sm().configure();
+  manager.sm().add<MovementSystem>("movement");
+  manager.sm().configure();
 
-  ASSERT_EQ("movement", world.sm().system<MovementSystem>()->label);
+  ASSERT_EQ("movement", manager.sm().system<MovementSystem>()->label);
 }
 
 
 TEST_F(SystemManagerTest, TestApplySystem) {
-  world.sm().add<MovementSystem>();
-  world.sm().configure();
+  manager.sm().add<MovementSystem>();
+  manager.sm().configure();
 
-  world.sm().update<MovementSystem>(0.0);
+  manager.sm().update<MovementSystem>(0.0);
   shared_ptr<Position> position;
   shared_ptr<Direction> direction;
-  for (auto entity : world.entities) {
-    world.em().unpack<Position, Direction>(entity, position, direction);
+  for (auto entity : manager.entities) {
+    manager.em().unpack<Position, Direction>(entity, position, direction);
     if (position && direction) {
       ASSERT_FLOAT_EQ(2.0, position->x);
       ASSERT_FLOAT_EQ(3.0, position->y);