hodasemi/mill_game
1
0
Fork 0
Code Issues 1 Pull requests Projects Releases Wiki Activity Actions

Update to latest dependency versions

Browse source
This commit is contained in:
Michael Huebner 2025-03-25 12:07:45 +01:00
parent 5f509ba05b
commit b55e4fbbba
5 changed files with 347 additions and 402 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
Cargo.toml
View file

@ -6,8 +6,8 @@ edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies] [dependencies]
engine = { path = "../Gavania/engine", features = ["graphical"] } engine = { git = "https://gavania.de/hodasemi/engine.git" }
assetpath = { git = "https://gavania.de/hodasemi/vulkan_lib.git" } assetpath = { git = "https://gavania.de/hodasemi/vulkan_lib.git" }
ecs = { git = "https://gavania.de/hodasemi/ecs.git" }
anyhow = { version = "1.0.75", features = ["backtrace"] } anyhow = { version = "1.0.97", features = ["backtrace"] }

195
src/board.rs
View file

@ -27,11 +27,15 @@ impl BoardSlot {
y: usize, y: usize,
z: usize, z: usize,
position: Vector2<f32>, position: Vector2<f32>,
scene: &mut Scene, world: &mut World,
) -> Result<Self> { ) -> Result<Self> {
let mut marker = scene.engine().assets().empty_entity(); let mut marker = AssetHandler::create(world).empty_entity();
let meshes = vec![Self::create_mesh(&scene.engine(), Color::Black)?]; let meshes = vec![Self::create_mesh(
world.resources.get::<Context>().device(),
world.resources.get::<EngineSettings>(),
Color::Black,
)?];
let draw = Draw::new(meshes); let draw = Draw::new(meshes);
marker.insert_component(draw); marker.insert_component(draw);
@ -47,7 +51,7 @@ impl BoardSlot {
state: Mutex::new(BoardSlotState::default()), state: Mutex::new(BoardSlotState::default()),
position, position,
slot_marker: Some(scene.add_entity(marker)?), slot_marker: Some(world.add_entity(marker)?),
}) })
} }
@ -63,11 +67,12 @@ impl BoardSlot {
} }
} }
fn create_mesh(engine: &Arc<Engine>, color: Color) -> Result<AssetMesh> { fn create_mesh(
let mut mesh = AssetMesh::new( device: &Arc<Device>,
engine.device(), engine_settings: &EngineSettings,
engine.settings().graphics_info()?.render_type, color: Color,
)?; ) -> Result<AssetMesh> {
let mut mesh = AssetMesh::new(device, engine_settings.graphics_info()?.render_type)?;
let vertex_buffer = Buffer::builder() let vertex_buffer = Buffer::builder()
.set_data(&Objects::create_flat_quad([ .set_data(&Objects::create_flat_quad([
@ -78,7 +83,7 @@ impl BoardSlot {
])) ]))
.set_usage(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT) .set_usage(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT)
.set_memory_usage(MemoryUsage::CpuOnly) .set_memory_usage(MemoryUsage::CpuOnly)
.build(engine.device().clone())?; .build(device.clone())?;
let a: [f32; 3] = color.into(); let a: [f32; 3] = color.into();
@ -157,10 +162,10 @@ pub struct Board {
} }
impl Board { impl Board {
pub fn new(engine: &Arc<Engine>, scene: &mut SceneHandle) -> Result<Self> { pub fn new(world: &mut World) -> Result<Self> {
let mut board_entity = engine.assets().empty_entity(); let mut board_entity = AssetHandler::create(world).empty_entity();
let meshes = vec![Self::create_board_base(&engine)?]; let meshes = vec![Self::create_board_base(&world)?];
let draw = Draw::new(meshes); let draw = Draw::new(meshes);
board_entity.insert_component(draw); board_entity.insert_component(draw);
@ -168,35 +173,31 @@ impl Board {
let location = Location::from_entity(&mut board_entity); let location = Location::from_entity(&mut board_entity);
board_entity.insert_component(location); board_entity.insert_component(location);
let mut board = None; let board = world.add_entity(board_entity)?;
let mut slots = None;
scene.on_scene(|scene| { let slots = [
board = Some(scene.add_entity(board_entity)?);
slots = Some([
[ [
[ [
BoardSlot::new(0, 0, 0, vec2(-15.0, -15.0), scene)?, // 0 0 0 BoardSlot::new(0, 0, 0, vec2(-15.0, -15.0), world)?, // 0 0 0
BoardSlot::new(0, 0, 1, vec2(-10.0, -10.0), scene)?, // 0 0 1 BoardSlot::new(0, 0, 1, vec2(-10.0, -10.0), world)?, // 0 0 1
BoardSlot::new(0, 0, 2, vec2(-5.0, -5.0), scene)?, // 0 0 2 BoardSlot::new(0, 0, 2, vec2(-5.0, -5.0), world)?, // 0 0 2
], ],
[ [
BoardSlot::new(0, 1, 0, vec2(-15.0, 0.0), scene)?, // 0 1 0 BoardSlot::new(0, 1, 0, vec2(-15.0, 0.0), world)?, // 0 1 0
BoardSlot::new(0, 1, 1, vec2(-10.0, 0.0), scene)?, // 0 1 1 BoardSlot::new(0, 1, 1, vec2(-10.0, 0.0), world)?, // 0 1 1
BoardSlot::new(0, 1, 2, vec2(-5.0, 0.0), scene)?, // 0 1 2 BoardSlot::new(0, 1, 2, vec2(-5.0, 0.0), world)?, // 0 1 2
], ],
[ [
BoardSlot::new(0, 2, 0, vec2(-15.0, 15.0), scene)?, // 0 2 0 BoardSlot::new(0, 2, 0, vec2(-15.0, 15.0), world)?, // 0 2 0
BoardSlot::new(0, 2, 1, vec2(-10.0, 10.0), scene)?, // 0 2 1 BoardSlot::new(0, 2, 1, vec2(-10.0, 10.0), world)?, // 0 2 1
BoardSlot::new(0, 2, 2, vec2(-5.0, 5.0), scene)?, // 0 2 2 BoardSlot::new(0, 2, 2, vec2(-5.0, 5.0), world)?, // 0 2 2
], ],
], ],
[ [
[ [
BoardSlot::new(1, 0, 0, vec2(0.0, -15.0), scene)?, // 1 0 0 BoardSlot::new(1, 0, 0, vec2(0.0, -15.0), world)?, // 1 0 0
BoardSlot::new(1, 0, 1, vec2(0.0, -10.0), scene)?, // 1 0 1 BoardSlot::new(1, 0, 1, vec2(0.0, -10.0), world)?, // 1 0 1
BoardSlot::new(1, 0, 2, vec2(0.0, -5.0), scene)?, // 1 0 2 BoardSlot::new(1, 0, 2, vec2(0.0, -5.0), world)?, // 1 0 2
], ],
[ [
BoardSlot::invalid(1, 1, 0), // 1 1 0 BoardSlot::invalid(1, 1, 0), // 1 1 0
@ -204,66 +205,53 @@ impl Board {
BoardSlot::invalid(1, 1, 2), // 1 1 2 BoardSlot::invalid(1, 1, 2), // 1 1 2
], ],
[ [
BoardSlot::new(1, 2, 0, vec2(0.0, 15.0), scene)?, // 1 2 0 BoardSlot::new(1, 2, 0, vec2(0.0, 15.0), world)?, // 1 2 0
BoardSlot::new(1, 2, 1, vec2(0.0, 10.0), scene)?, // 1 2 1 BoardSlot::new(1, 2, 1, vec2(0.0, 10.0), world)?, // 1 2 1
BoardSlot::new(1, 2, 2, vec2(0.0, 5.0), scene)?, // 1 2 2 BoardSlot::new(1, 2, 2, vec2(0.0, 5.0), world)?, // 1 2 2
], ],
], ],
[ [
[ [
BoardSlot::new(2, 0, 0, vec2(15.0, -15.0), scene)?, // 2 0 0 BoardSlot::new(2, 0, 0, vec2(15.0, -15.0), world)?, // 2 0 0
BoardSlot::new(2, 0, 1, vec2(10.0, -10.0), scene)?, // 2 0 1 BoardSlot::new(2, 0, 1, vec2(10.0, -10.0), world)?, // 2 0 1
BoardSlot::new(2, 0, 2, vec2(5.0, -5.0), scene)?, // 2 0 2 BoardSlot::new(2, 0, 2, vec2(5.0, -5.0), world)?, // 2 0 2
], ],
[ [
BoardSlot::new(2, 1, 0, vec2(15.0, 0.0), scene)?, // 2 1 0 BoardSlot::new(2, 1, 0, vec2(15.0, 0.0), world)?, // 2 1 0
BoardSlot::new(2, 1, 1, vec2(10.0, 0.0), scene)?, // 2 1 1 BoardSlot::new(2, 1, 1, vec2(10.0, 0.0), world)?, // 2 1 1
BoardSlot::new(2, 1, 2, vec2(5.0, 0.0), scene)?, // 2 1 2 BoardSlot::new(2, 1, 2, vec2(5.0, 0.0), world)?, // 2 1 2
], ],
[ [
BoardSlot::new(2, 2, 0, vec2(15.0, 15.0), scene)?, // 2 2 0 BoardSlot::new(2, 2, 0, vec2(15.0, 15.0), world)?, // 2 2 0
BoardSlot::new(2, 2, 1, vec2(10.0, 10.0), scene)?, // 2 2 1 BoardSlot::new(2, 2, 1, vec2(10.0, 10.0), world)?, // 2 2 1
BoardSlot::new(2, 2, 2, vec2(5.0, 5.0), scene)?, // 2 2 2 BoardSlot::new(2, 2, 2, vec2(5.0, 5.0), world)?, // 2 2 2
], ],
], ],
]); ];
Ok(())
})?;
let distance = 20.0; let distance = 20.0;
let white_start_slots = [ let white_start_slots = (16..=16)
vec2(-16.0, distance), .step_by(4)
vec2(-12.0, distance), .map(|x| vec2(x as f32, distance))
vec2(-8.0, distance), .collect()
vec2(-4.0, distance), .try_into()
vec2(0.0, distance), .unwrap();
vec2(4.0, distance),
vec2(8.0, distance),
vec2(12.0, distance),
vec2(16.0, distance),
];
let black_start_slots = [ let black_start_slots = (16..=16)
vec2(-16.0, -distance), .step_by(4)
vec2(-12.0, -distance), .map(|x| vec2(x as f32, -distance))
vec2(-8.0, -distance), .collect()
vec2(-4.0, -distance), .try_into()
vec2(0.0, -distance), .unwrap();
vec2(4.0, -distance),
vec2(8.0, -distance),
vec2(12.0, -distance),
vec2(16.0, -distance),
];
Ok(Self { Ok(Self {
_board: board.unwrap(), _board: board,
center: vec3(0.0, 0.0, 0.0), center: vec3(0.0, 0.0, 0.0),
_connection_lines: Self::create_connection_lines(scene, Color::Black)?, _connection_lines: Self::create_connection_lines(world, Color::Black)?,
slots: slots.unwrap(), slots,
white_start_slots, white_start_slots,
black_start_slots, black_start_slots,
}) })
@ -374,10 +362,14 @@ impl Board {
} }
impl Board { impl Board {
fn create_board_base(engine: &Arc<Engine>) -> Result<AssetMesh> { fn create_board_base(world: &World) -> Result<AssetMesh> {
let mut board_base = AssetMesh::new( let mut board_base = AssetMesh::new(
engine.device(), world.resources.get::<Context>().device(),
engine.settings().graphics_info()?.render_type, world
.resources
.get::<EngineSettings>()
.graphics_info()?
.render_type,
)?; )?;
let vertex_buffer = Buffer::builder() let vertex_buffer = Buffer::builder()
@ -387,7 +379,7 @@ impl Board {
)) ))
.set_usage(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT) .set_usage(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT)
.set_memory_usage(MemoryUsage::CpuOnly) .set_memory_usage(MemoryUsage::CpuOnly)
.build(engine.device().clone())?; .build(world.resources.get::<Context>().device().clone())?;
let color = Color::try_from("#b77b2b")?; let color = Color::try_from("#b77b2b")?;
let a: [f32; 3] = color.into(); let a: [f32; 3] = color.into();
@ -410,16 +402,19 @@ impl Board {
Ok(board_base) Ok(board_base)
} }
fn create_connection_lines(scene: &mut SceneHandle, color: Color) -> Result<Vec<Entity>> { fn create_connection_lines(world: &mut World, color: Color) -> Result<Vec<Entity>> {
let mut entities = Vec::new(); let mut entities = Vec::new();
scene.on_scene(|scene| { let mut lines = AssetHandler::create(world).empty_entity();
let mut lines = scene.engine().assets().empty_entity();
let draw = Draw::new(vec![{ let draw = Draw::new(vec![{
let mut mesh = AssetMesh::new( let mut mesh = AssetMesh::new(
scene.engine().device(), world.resources.get::<Context>().device(),
scene.engine().settings().graphics_info()?.render_type, world
.resources
.get::<EngineSettings>()
.graphics_info()?
.render_type,
)?; )?;
let vertex_buffer = Buffer::builder() let vertex_buffer = Buffer::builder()
@ -526,7 +521,7 @@ impl Board {
) )
.set_usage(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT) .set_usage(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT)
.set_memory_usage(MemoryUsage::CpuOnly) .set_memory_usage(MemoryUsage::CpuOnly)
.build(scene.engine().device().clone())?; .build(world.resources.get::<Context>().device().clone())?;
let a: [f32; 3] = color.into(); let a: [f32; 3] = color.into();
@ -553,42 +548,8 @@ impl Board {
location.set_offset(vec3(0.0, 0.0, MillGame::OFFSET_TO_BOARD)); location.set_offset(vec3(0.0, 0.0, MillGame::OFFSET_TO_BOARD));
lines.insert_component(location); lines.insert_component(location);
entities.push(scene.add_entity(lines)?); entities.push(world.add_entity(lines)?);
Ok(())
})?;
Ok(entities) Ok(entities)
} }
} }
impl Map for Board {
fn name(&self) -> &str {
"MillBoard"
}
fn check_walkability(
&self,
_position: cgmath::Vector2<f32>,
_direction: cgmath::Vector2<f32>,
_radius: f32,
) -> Result<bool> {
Ok(true)
}
fn get_height(&self, _x: f32, _y: f32) -> Result<f32> {
Ok(0.0)
}
fn spawn_positions(&self) -> Result<Vec<cgmath::Vector3<f32>>> {
Ok(vec![])
}
fn leave_markers(&self) -> Result<Vec<Entity>> {
Ok(vec![])
}
fn disable(&self, _scene: &mut Scene) -> Result<()> {
unreachable!()
}
}

178
src/game.rs
View file

@ -218,28 +218,22 @@ impl TurnState {
} }
pub struct MillGame { pub struct MillGame {
engine: Arc<Engine>, last_turn_timing: Duration,
last_turn_timing: Mutex<Duration>,
board: Arc<Mutex<Board>>, board: Board,
white_stones: Mutex<[Stone; 9]>, white_stones: [Stone; 9],
black_stones: Mutex<[Stone; 9]>, black_stones: [Stone; 9],
state: Mutex<GameState>, state: GameState,
current_player: Mutex<PlayerColor>, current_player: PlayerColor,
scene: Mutex<SceneHandle>, mouse_x: u32,
camera_controls: Mutex<CameraControl>, mouse_y: u32,
mouse_x: AtomicU32, turn_finished: bool,
mouse_y: AtomicU32, turn_states: Vec<TurnState>,
turn_finished: AtomicBool, selected_field: Option<(usize, usize, usize)>,
turn_states: Mutex<Vec<TurnState>>,
selected_field: Mutex<Option<(usize, usize, usize)>>,
simple_ai: SimpleAI,
white_player_label: Arc<Label>, white_player_label: Arc<Label>,
black_player_label: Arc<Label>, black_player_label: Arc<Label>,
@ -253,30 +247,24 @@ impl MillGame {
pub const OFFSET_TO_BOARD: f32 = 0.02; pub const OFFSET_TO_BOARD: f32 = 0.02;
pub const TURN_WAIT_TIME: Duration = Duration::from_millis(500); pub const TURN_WAIT_TIME: Duration = Duration::from_millis(500);
pub fn new(engine: Arc<Engine>) -> Result<Arc<Self>> { pub fn new(world: &mut World) -> Result<()> {
let mut scene = SceneHandle::new(&engine)?; let board = Board::new(world)?;
let board = Board::new(&engine, &mut scene)?;
let mut white_stones = None;
let mut black_stones = None;
scene.on_scene(|scene| {
let view = scene.view_mut();
view.camera_mut().set_center(board.center());
view.update_buffer()?;
// add light // add light
let mut sun_light = engine.new_directional_light()?; let mut sun_light = Light::directional_light(world.resources.get::<Context>().device());
sun_light.set_direction(vec3(10.0, -4.0, -20.0))?; sun_light.set_direction(vec3(10.0, -4.0, -20.0))?;
sun_light.set_color(vec3(1.0, 1.0, 1.0))?; sun_light.set_color(vec3(1.0, 1.0, 1.0))?;
sun_light.set_position(vec3(0.0, 0.0, 100.0))?; sun_light.set_position(vec3(0.0, 0.0, 100.0))?;
sun_light.set_power(10000000000.0)?; sun_light.set_power(10000000000.0)?;
let scene = world.resources.get_mut::<Scene>();
scene.add_light(sun_light)?; scene.add_light(sun_light)?;
white_stones = Some( let view = scene.view_mut();
Self::init_nine_stones(&engine, Color::White)? view.camera_mut().set_center(board.center());
view.update_buffer()?;
let white_stones = Self::init_nine_stones(world, Color::White)?
.into_iter() .into_iter()
.enumerate() .enumerate()
.map(|(index, mut e)| { .map(|(index, mut e)| {
@ -284,19 +272,15 @@ impl MillGame {
location.set_position(board.white_start_slots()[index].extend(0.0)); location.set_position(board.white_start_slots()[index].extend(0.0));
Ok(Stone { Ok(Stone {
stone: scene.add_entity(e)?, stone: world.add_entity(e)?,
state: StoneState::ReadyToBePlaced, state: StoneState::ReadyToBePlaced,
}) })
}) })
.collect::<Result<Vec<Stone>>>()? .collect::<Result<Vec<Stone>>>()?
.try_into() .try_into()
.unwrap_or_else(|_: Vec<Stone>| { .unwrap_or_else(|_: Vec<Stone>| unreachable!("create array from vec from an array"));
unreachable!("create array from vec from an array")
}),
);
black_stones = Some( let black_stones = Self::init_nine_stones(world, Color::try_from("#2c2c2c")?)?
Self::init_nine_stones(&engine, Color::try_from("#2c2c2c")?)?
.into_iter() .into_iter()
.enumerate() .enumerate()
.map(|(index, mut e)| { .map(|(index, mut e)| {
@ -304,28 +288,22 @@ impl MillGame {
location.set_position(board.black_start_slots()[index].extend(0.0)); location.set_position(board.black_start_slots()[index].extend(0.0));
Ok(Stone { Ok(Stone {
stone: scene.add_entity(e)?, stone: world.add_entity(e)?,
state: StoneState::ReadyToBePlaced, state: StoneState::ReadyToBePlaced,
}) })
}) })
.collect::<Result<Vec<Stone>>>()? .collect::<Result<Vec<Stone>>>()?
.try_into() .try_into()
.unwrap_or_else(|_: Vec<Stone>| { .unwrap_or_else(|_: Vec<Stone>| unreachable!("create array from vec from an array"));
unreachable!("create array from vec from an array")
}),
);
Ok(()) let mut camera_control = TopDownCameraControl::new(&mut scene)?;
})?;
let mut camera_control = CameraControl::new(&mut scene)?;
camera_control.set_zoom_levels( camera_control.set_zoom_levels(
(3..60).into_iter().rev().map(|z| z as f32).collect(), (3..60).into_iter().rev().map(|z| z as f32).collect(),
5, 5,
&mut scene, &mut scene,
)?; )?;
scene.activate()?; world.resources.insert(camera_control);
let gui = GuiBuilder::new( let gui = GuiBuilder::new(
engine.gui_handler(), engine.gui_handler(),
@ -340,31 +318,50 @@ impl MillGame {
let black_player_label: Arc<Label> = gui.element("black_player_label")?; let black_player_label: Arc<Label> = gui.element("black_player_label")?;
let start_button: Arc<Button> = gui.element("start")?; let start_button: Arc<Button> = gui.element("start")?;
gui.enable()?; gui.enable(world.resources.get_mut::<GuiHandler>())?;
let me = Arc::new(Self { start_button.set_callback({
engine: engine.clone(), let weak_grid = Arc::downgrade(&grid);
last_turn_timing: Mutex::default(),
board: Arc::new(Mutex::new(board)), move |world| {
white_stones: Mutex::new(white_stones.unwrap()), if let Some(grid) = weak_grid.upgrade() {
black_stones: Mutex::new(black_stones.unwrap()), grid.detach(world, 1, 0)?;
}
state: Mutex::new(GameState::Waiting), let now = world.now();
current_player: Mutex::new(PlayerColor::White), let me = world.resources.get_mut::<Self>();
scene: Mutex::new(scene), Self::log(" ===== START GAME =====", LogSeverity::Basic);
camera_controls: Mutex::new(camera_control),
mouse_x: AtomicU32::new(0), me.state = GameState::Placing;
mouse_y: AtomicU32::new(0), me.current_player = PlayerColor::Black;
turn_finished: AtomicBool::new(false), me.finish_turn();
turn_states: Mutex::default(), me.last_turn_timing = now;
selected_field: Mutex::default(), Ok(())
}
});
simple_ai: SimpleAI::new(PlayerColor::White), world.resources.insert(SimpleAI::new(PlayerColor::White));
let me = Self {
last_turn_timing: Duration::default(),
board,
white_stones,
black_stones,
state: GameState::Waiting,
current_player: PlayerColor::White,
mouse_x: 0,
mouse_y: 0,
turn_finished: false,
turn_states: TurnState::default(),
selected_field: None,
_grid: grid.clone(), _grid: grid.clone(),
white_player_label, white_player_label,
@ -372,33 +369,12 @@ impl MillGame {
_start_button: start_button.clone(), _start_button: start_button.clone(),
_gui: gui, _gui: gui,
}); };
start_button.set_callback({ world.resources.insert(me);
let weak_grid = Arc::downgrade(&grid);
let weak_self = Arc::downgrade(&me);
move || {
if let Some(grid) = weak_grid.upgrade() {
grid.detach(1, 0)?;
}
if let Some(me) = weak_self.upgrade() {
Self::log(" ===== START GAME =====", LogSeverity::Basic);
*me.state.lock().unwrap() = GameState::Placing;
*me.current_player.lock().unwrap() = PlayerColor::Black;
me.finish_turn();
*me.last_turn_timing.lock().unwrap() = me.engine.time();
}
Ok(()) Ok(())
} }
});
Ok(me)
}
pub fn finish_turn(&self) { pub fn finish_turn(&self) {
Self::log( Self::log(
@ -570,16 +546,16 @@ impl MillGame {
Ok(()) Ok(())
} }
fn stones(&self, player_color: PlayerColor) -> MutexGuard<'_, [Stone; 9]> { fn stones(&self, player_color: PlayerColor) -> &[Stone; 9] {
match player_color { match player_color {
PlayerColor::White => self.white_stones.lock().unwrap(), PlayerColor::White => &self.white_stones,
PlayerColor::Black => self.black_stones.lock().unwrap(), PlayerColor::Black => &self.black_stones,
} }
} }
fn init_nine_stones(engine: &Arc<Engine>, color: Color) -> Result<[EntityObject; 9]> { fn init_nine_stones(world: &mut World, color: Color) -> Result<[EntityObject; 9]> {
Ok((0..9) Ok((0..9)
.map(|_| Self::init_stone(engine, color)) .map(|_| Self::init_stone(world, color))
.collect::<Result<Vec<EntityObject>>>()? .collect::<Result<Vec<EntityObject>>>()?
.try_into() .try_into()
.unwrap_or_else(|_: Vec<EntityObject>| { .unwrap_or_else(|_: Vec<EntityObject>| {
@ -587,20 +563,24 @@ impl MillGame {
})) }))
} }
fn init_stone(engine: &Arc<Engine>, color: Color) -> Result<EntityObject> { fn init_stone(world: &mut World, color: Color) -> Result<EntityObject> {
let mut marker = engine.assets().empty_entity(); let mut marker = AssetHandler::create(world).empty_entity();
let draw = Draw::new(vec![{ let draw = Draw::new(vec![{
let mut mesh = AssetMesh::new( let mut mesh = AssetMesh::new(
engine.device(), world.resources.get::<Context>().device(),
engine.settings().graphics_info()?.render_type, world
.resources
.get::<EngineSettings>()
.graphics_info()?
.render_type,
)?; )?;
let vertex_buffer = Buffer::builder() let vertex_buffer = Buffer::builder()
.set_data(&Objects::create_cylinder(1.1, 0.25, 30)) .set_data(&Objects::create_cylinder(1.1, 0.25, 30))
.set_usage(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT) .set_usage(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT)
.set_memory_usage(MemoryUsage::CpuOnly) .set_memory_usage(MemoryUsage::CpuOnly)
.build(engine.device().clone())?; .build(world.resources.get::<Context>().device().clone())?;
let a: [f32; 3] = color.into(); let a: [f32; 3] = color.into();

14
src/main.rs
View file

@ -9,6 +9,12 @@ use engine::prelude::*;
use game::MillGame; use game::MillGame;
fn main() -> Result<()> { fn main() -> Result<()> {
let mut world_builder = World::builder();
world_builder.build().run()
}
fn create_engine(world_builder: &mut WorldBuilder) -> Result<()> {
let mut create_info = EngineCreateInfo::default(); let mut create_info = EngineCreateInfo::default();
create_info.resource_base_path = "resources".to_string(); create_info.resource_base_path = "resources".to_string();
@ -17,7 +23,7 @@ fn main() -> Result<()> {
create_info.gui_info.menu_button = AssetPath::from("button_dark.png"); create_info.gui_info.menu_button = AssetPath::from("button_dark.png");
create_info.gui_info.menu_button_selected = AssetPath::from("button_light.png"); create_info.gui_info.menu_button_selected = AssetPath::from("button_light.png");
create_info.gui_info.resource_directory = create_info.gui_info.resource_directory =
AssetPath::from((create_info.resource_base_path.as_str(), "")); AssetPath::from((create_info.resource_base_path.as_str(), "")).into();
create_info.graphics_info.render_scale = 1.0; create_info.graphics_info.render_scale = 1.0;
create_info.graphics_info.vsync = true; create_info.graphics_info.vsync = true;
@ -32,9 +38,7 @@ fn main() -> Result<()> {
create_info.enable_keyboard = true; create_info.enable_keyboard = true;
create_info.enable_mouse = true; create_info.enable_mouse = true;
let engine = Engine::new(create_info)?; let engine = Engine::new(create_info, world_builder)?;
engine.set_game_object(Some(MillGame::new(engine.clone())?))?; Ok(())
engine.run()
} }

2
src/simple_ai.rs
View file

@ -19,7 +19,7 @@ impl SimpleAI {
&self, &self,
stones: &mut [Stone; 9], stones: &mut [Stone; 9],
board: &mut [[[BoardSlot; 3]; 3]; 3], board: &mut [[[BoardSlot; 3]; 3]; 3],
scene: &mut SceneHandle, world: &mut World,
state: &mut GameState, state: &mut GameState,
) -> Result<()> { ) -> Result<()> {
MillGame::log(&format!("AI at state {:?}", *state), LogSeverity::Debug); MillGame::log(&format!("AI at state {:?}", *state), LogSeverity::Debug);