rust/lib-hedgewars-engine/src/world.rs
changeset 14710 19122a329774
parent 14709 12db7e435ea6
child 14713 19358c313ebb
equal deleted inserted replaced
14709:12db7e435ea6 14710:19122a329774
     1 use fpnum::{FPNum, fp};
     1 use fpnum::{fp, FPNum};
       
     2 use hwphysics as hwp;
     2 use integral_geometry::{Point, Rect, Size};
     3 use integral_geometry::{Point, Rect, Size};
     3 use land2d::Land2D;
     4 use land2d::Land2D;
     4 use landgen::{
     5 use landgen::{
     5     outline_template::OutlineTemplate,
     6     outline_template::OutlineTemplate, template_based::TemplatedLandGenerator,
     6     template_based::TemplatedLandGenerator,
     7     LandGenerationParameters, LandGenerator,
     7     LandGenerationParameters,
       
     8     LandGenerator,
       
     9 };
     8 };
    10 use lfprng::LaggedFibonacciPRNG;
     9 use lfprng::LaggedFibonacciPRNG;
    11 use hwphysics as hwp;
       
    12 
    10 
    13 use crate::render::{
    11 use crate::render::{camera::Camera, MapRenderer};
    14     MapRenderer,
       
    15     camera::Camera
       
    16 };
       
    17 
    12 
    18 struct GameState {
    13 struct GameState {
    19     land: Land2D<u32>,
    14     land: Land2D<u32>,
    20     physics: hwp::World,
    15     physics: hwp::World,
    21 }
    16 }
    22 
    17 
    23 impl GameState {
    18 impl GameState {
    24     fn new(land: Land2D<u32>, physics: hwp::World) -> Self {
    19     fn new(land: Land2D<u32>, physics: hwp::World) -> Self {
    25         Self {
    20         Self { land, physics }
    26             land,
       
    27             physics,
       
    28         }
       
    29     }
    21     }
    30 }
    22 }
    31 
    23 
    32 pub struct World {
    24 pub struct World {
    33     random_numbers_gen: LaggedFibonacciPRNG,
    25     random_numbers_gen: LaggedFibonacciPRNG,
    34     preview: Option<Land2D<u8>>,
    26     preview: Option<Land2D<u8>>,
    35     game_state: Option<GameState>,
    27     game_state: Option<GameState>,
    36     renderer: MapRenderer,
    28     renderer: Option<MapRenderer>,
    37     camera: Camera
    29     camera: Camera,
    38 }
    30 }
    39 
    31 
    40 impl World {
    32 impl World {
    41     pub fn new() -> Self {
    33     pub fn new() -> Self {
    42         Self {
    34         Self {
    43             random_numbers_gen: LaggedFibonacciPRNG::new(&[]),
    35             random_numbers_gen: LaggedFibonacciPRNG::new(&[]),
    44             preview: None,
    36             preview: None,
    45             game_state: None,
    37             game_state: None,
    46             renderer: MapRenderer::new(512, 512),
    38             renderer: None,
    47             camera: Camera::new()
    39             camera: Camera::new(),
    48         }
    40         }
       
    41     }
       
    42 
       
    43     pub fn create_renderer(&mut self, width: u16, height: u16) {
       
    44         self.renderer = Some(MapRenderer::new(512, 512));
       
    45         self.camera = Camera::with_size(Size::new(width as usize, height as usize));
    49     }
    46     }
    50 
    47 
    51     pub fn set_seed(&mut self, seed: &[u8]) {
    48     pub fn set_seed(&mut self, seed: &[u8]) {
    52         self.random_numbers_gen = LaggedFibonacciPRNG::new(seed);
    49         self.random_numbers_gen = LaggedFibonacciPRNG::new(seed);
    53     }
    50     }
    85         let params = LandGenerationParameters::new(0u32, u32::max_value(), 5, false, false);
    82         let params = LandGenerationParameters::new(0u32, u32::max_value(), 5, false, false);
    86         let landgen = TemplatedLandGenerator::new(template);
    83         let landgen = TemplatedLandGenerator::new(template);
    87         let land = landgen.generate_land(&params, &mut self.random_numbers_gen);
    84         let land = landgen.generate_land(&params, &mut self.random_numbers_gen);
    88 
    85 
    89         use mapgen::{
    86         use mapgen::{
       
    87             theme::{slice_u32_to_u8, Theme},
    90             MapGenerator,
    88             MapGenerator,
    91             theme::{Theme, slice_u32_to_u8}
       
    92         };
    89         };
    93 
    90 
    94         use std::path::Path;
    91         use std::path::Path;
    95         
    92 
    96         let theme = Theme::load(Path::new("../../share/hedgewars/Data/Themes/Cheese/")).unwrap();
    93         let theme = Theme::load(Path::new("../../share/hedgewars/Data/Themes/Cheese/")).unwrap();
    97         let texture = MapGenerator::new().make_texture32(&land, &theme);
    94         let texture = MapGenerator::new().make_texture32(&land, &theme);
    98         self.renderer.init(&texture);
    95         if let Some(ref mut renderer) = self.renderer {
    99         
    96             renderer.init(&texture);
       
    97         }
   100         self.game_state = Some(GameState::new(land, physics));
    98         self.game_state = Some(GameState::new(land, physics));
   101     }
    99     }
   102 
   100 
   103     pub fn move_camera(&mut self, position_shift: Point, zoom_shift: f32) {
   101     pub fn move_camera(&mut self, position_shift: Point, zoom_shift: f32) {
   104         self.camera.position += position_shift;
   102         self.camera.position += position_shift;
   105         self.camera.zoom += zoom_shift;
   103         self.camera.zoom += zoom_shift;
   106     }
   104     }
   107 
   105 
   108     pub fn render(&mut self) {
   106     pub fn render(&mut self) {
       
   107         if let Some(ref mut renderer) = self.renderer {
       
   108             unsafe {
       
   109                 gl::ClearColor(0.4f32, 0f32, 0.2f32, 1f32);
       
   110                 gl::Clear(gl::COLOR_BUFFER_BIT);
       
   111             }
   109 
   112 
   110         unsafe {
   113             renderer.render(self.camera.viewport());
   111             gl::ClearColor(0.4f32, 0f32, 0.2f32, 1f32);
       
   112             gl::Clear(gl::COLOR_BUFFER_BIT);
       
   113         }
   114         }
   114 
       
   115         self.renderer.render(self.camera.viewport());
       
   116     }
   115     }
   117 
   116 
   118     pub fn step(&mut self) {
   117     pub fn step(&mut self) {
   119         if let Some(ref mut state) = self.game_state {
   118         if let Some(ref mut state) = self.game_state {
   120             state.physics.step(fp!(1), &state.land);
   119             state.physics.step(fp!(1), &state.land);
   121         }
   120         }
   122     }
   121     }
   123 }
   122 }
   124 
       
   125 
       
   126