component.rs

use std::to_str::*;

pub trait Component :  Clone {
}

#[deriving(Clone)]
pub struct TextRenderable {
    sigil: char,
    fg: uint,
    bg: uint,
}

impl TextRenderable {
    pub fn new(sign: char, fgd: uint, bgd: uint) -> TextRenderable {
        TextRenderable{sigil: sign, fg: fgd, bg: bgd}
    }
}

impl Component for TextRenderable {
}

entity.rs

use component::*;
use std::hashmap::HashMap;

pub struct Entity {
    components: HashMap<~str, ~Component>,
}

impl Entity  {
    pub fn new() -> Entity {
        Entity{
            components: HashMap::new()
        }
    }

    pub fn add_component(&mut self, name: &str, comp: ~Component) {
        self.components.insert(name.to_owned(), comp);
    }

    pub fn remove_component(&mut self, id: &str) {
        self.components.remove(&id.to_owned());
    }
}

event.rs

pub struct Event;

main.rs

#[feature(globs)];

use entity::Entity;
use system::System;
use component::*;
use std::to_str::ToStr;

pub mod entity;
pub mod component;
pub mod system;
pub mod event;


fn main() {
    let dt: f64 = 0.01;

    let mut renderer = system::TextRenderer::new();
    let mut Oliver = Entity::new();
    let mut Jeff = Entity::new();

    Oliver.add_component(renderer.getKey(),
                         ~TextRenderable::new('@',12,13) as ~Component);
    Jeff.add_component(renderer.getKey(),
                         ~TextRenderable::new('!',1,2) as ~Component);

    let entities = [Oliver, Jeff];

    renderer.update(entities, [], dt);
}

system.rs

use entity::*;
use component::*;
use event::*;

pub trait System {
    fn configure(&mut self, &[Event]);
    fn update(&mut self, &[Entity], &[Event], f64);
    fn getKey(&self) -> ~str;
}

pub struct TextRenderer {
    key: ~str,
}

impl TextRenderer {
    pub fn new() -> TextRenderer {
        TextRenderer{ key: ~"textRenderable" }
    }
}

impl System for TextRenderer {
    fn configure(&mut self, events: &[Event]) {
        //Setup the screen and such
        //NCurses init goes here?
    }

    fn update(&mut self, entities: &[Entity], events: &[Event], dt: f64) {
        println!("Recieved {} as dt", dt);
        for entity in entities.iter() {
            let result = entity.components.find(&self.key);
            match result {
                Some(component) => {
                    let comp = component as &~TextRenderable;
                    println(comp.sigil);
                }
                None => {}
            }
        }
    }

    fn getKey(&self) -> ~str {
        self.key.clone()
    }
}