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(¶ms, &mut self.random_numbers_gen); |
84 let land = landgen.generate_land(¶ms, &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 |
|