lifetimes!

Author: jaredonline

src/actor.rs

@@ -7,18 +7,25 @@ use rendering::renderers::{Color};
 use rendering::windows::Windows;
 use movement::{AggroMovementComponent, RandomMovementComponent, UserMovementComponent, MovementComponent};
 
-pub struct Actor<'a> {
+pub struct Actor {
     pub position:     Point,
     pub display_char: char,
-    pub movement_component: Box<MovementComponent + 'a>,
+    pub movement_component: Box<MovementComponent + 'static>,
     pub is_pc: bool,
     pub foreground: Color,
     pub background: Color,
     pub health: u8
 }
 
-impl<'a> Actor<'a> {
-    pub fn new(x: i32, y: i32, dc: char, mc: Box<MovementComponent + 'a>, is_pc: bool, foreground: Color, background: Color, health: u8) -> Actor<'a> {
+impl Clone for Actor {
+    pub fn clone(&self) -> Actor {
+        let mc = self.movement_component.box_clone();
+        Actor::new(self.position.x, self.position.y, self.display_char, mc, self.is_pc, self.foreground, self.background, self.health)
+    }
+}
+
+impl Actor {
+    pub fn new(x: i32, y: i32, dc: char, mc: Box<MovementComponent + 'static>, is_pc: bool, foreground: Color, background: Color, health: u8) -> Actor {
         Actor {
             position: Point { x: x, y: y },
             display_char: dc,
@@ -30,30 +37,25 @@ impl<'a> Actor<'a> {
         }
     }
 
-    pub fn clone(&'a self) -> Actor<'a> {
-        let mc = self.movement_component.box_clone();
-        Actor::new(self.position.x, self.position.y, self.display_char, mc, self.is_pc, self.foreground, self.background, self.health)
-    }
-
-    pub fn dog(x: i32, y: i32, move_info: Rc<RefCell<MoveInfo>>) -> Actor<'a> {
+    pub fn dog(x: i32, y: i32, move_info: Rc<RefCell<MoveInfo>>) -> Actor {
         let mc : Box<RandomMovementComponent> = box MovementComponent::new(move_info);
         Actor::new(x, y, 'd', mc, false, Color::White, Color::Black, 20u8)
     }
 
-    pub fn cat(x: i32, y: i32, move_info: Rc<RefCell<MoveInfo>>) -> Actor<'a> {
+    pub fn cat(x: i32, y: i32, move_info: Rc<RefCell<MoveInfo>>) -> Actor {
         let mc : Box<RandomMovementComponent> = box MovementComponent::new(move_info);
         Actor::new(x, y, 'c', mc, false, Color::White, Color::Black, 20u8)
     }
 
-    pub fn heroine(move_info: Rc<RefCell<MoveInfo>>) -> Actor<'a> {
+    pub fn heroine(move_info: Rc<RefCell<MoveInfo>>) -> Actor {
         let point = {
             move_info.borrow().deref().char_location
         };
         let mc : Box<UserMovementComponent> = box MovementComponent::new(move_info);
         Actor::new(point.x, point.y, '@', mc, true, Color::Blue, Color::Black, 20u8)
     }
 
-    pub fn kobold(x: i32, y: i32, move_info: Rc<RefCell<MoveInfo>>) -> Actor<'a> {
+    pub fn kobold(x: i32, y: i32, move_info: Rc<RefCell<MoveInfo>>) -> Actor {
         let mc : Box<AggroMovementComponent> = box MovementComponent::new(move_info);
         Actor::new(x, y, 'k', mc, false, Color::Red, Color::Black, 20u8)
     }

src/game.rs

@@ -51,7 +51,7 @@ pub struct Game<'a, 'b> {
     pub rendering_component: Box<RenderingComponent + 'a>,
     pub game_state:          Box<GameState<'a>      + 'a>,
     pub windows:             Windows<'a>,
-    pub maps:                Maps<'b>
+    pub maps:                Maps
 }
 
 impl<'a, 'b> Game<'a, 'b> {

src/game_states.rs

@@ -15,7 +15,7 @@ pub trait GameState<'a> {
     fn enter(&self, &mut Windows) {}
     fn exit(&self)  {}
 
-    fn update<'b>(&mut self, maps: &'b mut Maps<'b>, windows: &mut Windows, Rc<RefCell<MoveInfo>>);
+    fn update(&mut self, maps: &mut Maps, windows: &mut Windows, Rc<RefCell<MoveInfo>>);
     fn render<'r>(&mut self, renderer: &mut Box<RenderingComponent>, maps: &mut Maps, windows: &'r mut Windows<'r>) {
         renderer.before_render_new_frame();
         let mut all_windows = windows.all_windows();
@@ -48,7 +48,7 @@ impl<'a> GameState<'a> for MovementGameState {
         windows.input.flush_buffer();
     }
 
-    fn update<'b>(&mut self, maps: &'b mut Maps<'b>, windows: &mut Windows, move_info: Rc<RefCell<MoveInfo>>) {
+    fn update(&mut self, maps: &mut Maps, windows: &mut Windows, move_info: Rc<RefCell<MoveInfo>>) {
         let last_keypress = {
             move_info.borrow().deref().last_keypress
         };
@@ -102,7 +102,7 @@ impl<'a> GameState<'a> for AttackInputGameState<'a> {
         windows.input.buffer_message(msg.as_slice())
     }
 
-    fn update<'b>(&mut self, maps: &'b mut Maps<'b>, windows: &mut Windows, move_info: Rc<RefCell<MoveInfo>>) {
+    fn update(&mut self, maps: &mut Maps, windows: &mut Windows, move_info: Rc<RefCell<MoveInfo>>) {
         let last_keypress = {
             move_info.borrow().deref().last_keypress
         };

src/map.rs

@@ -7,15 +7,15 @@ use rendering::windows::Windows;
 use rendering::renderers::RenderingComponent;
 use game::MoveInfo;
 
-pub struct Maps<'a> {
-    pub terrain: Box<Map<'a>>,
-    pub enemies: Box<Map<'a>>,
-    pub friends: Box<Map<'a>>,
-    pub pcs:     Box<Map<'a>>
+pub struct Maps {
+    pub terrain: Box<Map>,
+    pub enemies: Box<Map>,
+    pub friends: Box<Map>,
+    pub pcs:     Box<Map>
 }
 
-impl<'a> Maps<'a> {
-    pub fn new(move_info: Rc<RefCell<MoveInfo>>) -> Maps<'a> {
+impl Maps {
+    pub fn new(move_info: Rc<RefCell<MoveInfo>>) -> Maps {
         let terrain = box Map::new(move_info.clone());
         let enemies = box Map::new(move_info.clone());
         let friends = box Map::new(move_info.clone());
@@ -29,7 +29,7 @@ impl<'a> Maps<'a> {
         }
     }
 
-    pub fn update(&'a mut self, windows: &mut Windows) {
+    pub fn update(&mut self, windows: &mut Windows) {
         self.pcs.update(windows);
         self.terrain.update(windows);
         self.friends.update(windows);
@@ -53,15 +53,15 @@ impl<'a> Maps<'a> {
     }
 }
 
-pub struct Map<'a> {
-    pub content:   Vec<Vec<Vec<Box<Actor<'a>>>>>,
+pub struct Map {
+    pub content:   Vec<Vec<Vec<Box<Actor>>>>,
     pub size:      Bound,
     pub move_info: Rc<RefCell<MoveInfo>>
 }
 
 
-impl<'a> Map<'a> {
-    pub fn new(move_info: Rc<RefCell<MoveInfo>>) -> Map<'a> {
+impl Map {
+    pub fn new(move_info: Rc<RefCell<MoveInfo>>) -> Map {
         let size    = {
             move_info.borrow().deref().bounds
         };
@@ -73,7 +73,7 @@ impl<'a> Map<'a> {
         }
     }
 
-    pub fn init_contents(size: Bound) -> Vec<Vec<Vec<Box<Actor<'a>>>>> {
+    pub fn init_contents(size: Bound) -> Vec<Vec<Vec<Box<Actor>>>> {
         let mut contents : Vec<Vec<Vec<Box<Actor>>>> = vec![];
         for _ in range(0, size.max.x) {
             let mut x_vec : Vec<Vec<Box<Actor>>> = vec![];
@@ -86,7 +86,7 @@ impl<'a> Map<'a> {
         return contents;
     }
 
-    pub fn push_actor(&mut self, point: Point, actor: Box<Actor<'a>>) {
+    pub fn push_actor(&mut self, point: Point, actor: Box<Actor>) {
         self.content[point.x as uint][point.y as uint].push(actor);
     }
 
@@ -100,7 +100,7 @@ impl<'a> Map<'a> {
                         { self.move_info.borrow_mut().deref_mut().char_location = actor.position };
                     }
                     let point = actor.position;
-                    let new_actor = box actor.clone();
+                    let new_actor = actor.clone();
                     new_content[point.x as uint][point.y as uint].push(new_actor);
                 }
             }