276 lines
10 KiB
Rust
276 lines
10 KiB
Rust
// DungeonCraft – Dungeon-Aufbau & Verteidigung im Browser (Rust + macroquad, WASM).
|
||
|
||
mod game;
|
||
mod gfx;
|
||
mod map;
|
||
mod render;
|
||
mod sound;
|
||
mod ui;
|
||
|
||
use game::Game;
|
||
use gfx::Gfx;
|
||
use macroquad::prelude::*;
|
||
use map::{idx, inb, MH, MW};
|
||
use render::{draw_world, Overlay, View, ZOOMS};
|
||
use sound::SoundBank;
|
||
use ui::{hover_info, Tool, Ui, UiAction, TOOLS};
|
||
|
||
fn conf() -> Conf {
|
||
Conf { window_title: "DungeonCraft".into(), window_width: 1280, window_height: 800, high_dpi: false, ..Default::default() }
|
||
}
|
||
|
||
struct Input {
|
||
ldown: Option<(i32, i32)>, // Start des Auswahlrechtecks
|
||
rdown: Option<(f32, f32)>, // Startpunkt rechte Maustaste
|
||
rlast: (f32, f32),
|
||
rdrag: bool,
|
||
minimap_drag: bool,
|
||
}
|
||
|
||
fn new_game(seed: u32) -> (Game, View) {
|
||
let g = Game::new(seed);
|
||
let (cx, cy) = g.map.core;
|
||
let zoom = 32.0;
|
||
let view = View { cam_x: cx as f32 + 1.5 - screen_width() / zoom * 0.5, cam_y: cy as f32 + 1.5 - screen_height() / zoom * 0.5, zoom };
|
||
(g, view)
|
||
}
|
||
|
||
fn clamp_cam(v: &mut View) {
|
||
let vw = screen_width() / v.zoom;
|
||
let vh = screen_height() / v.zoom;
|
||
v.cam_x = v.cam_x.clamp(-vw * 0.5, MW as f32 - vw * 0.5);
|
||
v.cam_y = v.cam_y.clamp(-vh * 0.5, MH as f32 - vh * 0.5);
|
||
}
|
||
|
||
fn center_on(v: &mut View, wx: f32, wy: f32) {
|
||
v.cam_x = wx - screen_width() / v.zoom * 0.5;
|
||
v.cam_y = wy - screen_height() / v.zoom * 0.5;
|
||
}
|
||
|
||
#[macroquad::main(conf)]
|
||
async fn main() {
|
||
let gfx = Gfx::new();
|
||
let mut sounds = SoundBank::new();
|
||
sounds.generate_all().await;
|
||
let mut seed = (miniquad::date::now() * 1000.0) as u32 | 1;
|
||
let (mut game, mut view) = new_game(seed);
|
||
let mut ui = Ui::new();
|
||
let mut inp = Input { ldown: None, rdown: None, rlast: (0.0, 0.0), rdrag: false, minimap_drag: false };
|
||
|
||
loop {
|
||
let dt = get_frame_time();
|
||
let now = get_time();
|
||
let (mx, my) = mouse_position();
|
||
let over_ui = ui.over_ui(mx, my);
|
||
let (wx, wy) = view.world(mx, my);
|
||
let hover_tile = (wx.floor() as i32, wy.floor() as i32);
|
||
|
||
// ---------------- Tastatur
|
||
for (i, k) in [
|
||
KeyCode::Key1,
|
||
KeyCode::Key2,
|
||
KeyCode::Key3,
|
||
KeyCode::Key4,
|
||
KeyCode::Key5,
|
||
KeyCode::Key6,
|
||
KeyCode::Key7,
|
||
KeyCode::Key8,
|
||
KeyCode::Key9,
|
||
KeyCode::Key0,
|
||
KeyCode::Q,
|
||
KeyCode::E,
|
||
]
|
||
.iter()
|
||
.enumerate()
|
||
{
|
||
if is_key_pressed(*k) {
|
||
ui.tool = TOOLS[i];
|
||
inp.ldown = None;
|
||
}
|
||
}
|
||
if is_key_pressed(KeyCode::H) || (is_key_pressed(KeyCode::Escape) && ui.show_help) {
|
||
ui.show_help = !ui.show_help;
|
||
}
|
||
if is_key_pressed(KeyCode::Escape) {
|
||
inp.ldown = None;
|
||
}
|
||
if (is_key_pressed(KeyCode::P) || is_key_pressed(KeyCode::Space)) && game.state == 0 {
|
||
game.paused = !game.paused;
|
||
}
|
||
if is_key_pressed(KeyCode::M) {
|
||
sounds.muted = !sounds.muted;
|
||
}
|
||
if is_key_pressed(KeyCode::Equal) || is_key_pressed(KeyCode::KpAdd) {
|
||
sounds.change_volume(0.1);
|
||
}
|
||
if is_key_pressed(KeyCode::Minus) || is_key_pressed(KeyCode::KpSubtract) {
|
||
sounds.change_volume(-0.1);
|
||
}
|
||
if is_key_pressed(KeyCode::N) && game.state != 0 {
|
||
seed = seed.wrapping_mul(1103515245).wrapping_add(12345) | 1;
|
||
(game, view) = new_game(seed);
|
||
ui.show_help = false;
|
||
}
|
||
|
||
// ---------------- Kamera
|
||
let pan = 900.0 * dt / view.zoom;
|
||
if is_key_down(KeyCode::W) || is_key_down(KeyCode::Up) {
|
||
view.cam_y -= pan;
|
||
}
|
||
if is_key_down(KeyCode::S) || is_key_down(KeyCode::Down) {
|
||
view.cam_y += pan;
|
||
}
|
||
if is_key_down(KeyCode::A) || is_key_down(KeyCode::Left) {
|
||
view.cam_x -= pan;
|
||
}
|
||
if is_key_down(KeyCode::D) || is_key_down(KeyCode::Right) {
|
||
view.cam_x += pan;
|
||
}
|
||
// Bildschirmrand
|
||
let edge = 6.0;
|
||
if !ui.show_help && mx >= 0.0 && my >= 0.0 && mx < screen_width() && my < screen_height() {
|
||
if mx < edge {
|
||
view.cam_x -= pan;
|
||
} else if mx > screen_width() - edge {
|
||
view.cam_x += pan;
|
||
}
|
||
if my < edge {
|
||
view.cam_y -= pan;
|
||
} else if my > screen_height() - edge {
|
||
view.cam_y += pan;
|
||
}
|
||
}
|
||
// Zoom
|
||
let (_, wheel) = mouse_wheel();
|
||
if wheel != 0.0 && !over_ui {
|
||
let zi = ZOOMS.iter().position(|&z| z >= view.zoom).unwrap_or(2) as i32;
|
||
let ni = (zi + if wheel > 0.0 { 1 } else { -1 }).clamp(0, ZOOMS.len() as i32 - 1) as usize;
|
||
if ZOOMS[ni] != view.zoom {
|
||
view.zoom = ZOOMS[ni];
|
||
view.cam_x = wx - mx / view.zoom;
|
||
view.cam_y = wy - my / view.zoom;
|
||
}
|
||
}
|
||
// Rechte Maustaste: ziehen = verschieben, klicken = absetzen
|
||
if is_mouse_button_pressed(MouseButton::Right) {
|
||
inp.rdown = Some((mx, my));
|
||
inp.rlast = (mx, my);
|
||
inp.rdrag = false;
|
||
}
|
||
if let Some((sx, sy)) = inp.rdown {
|
||
if is_mouse_button_down(MouseButton::Right) {
|
||
if (mx - sx).abs() + (my - sy).abs() > 5.0 {
|
||
inp.rdrag = true;
|
||
}
|
||
if inp.rdrag {
|
||
view.cam_x -= (mx - inp.rlast.0) / view.zoom;
|
||
view.cam_y -= (my - inp.rlast.1) / view.zoom;
|
||
}
|
||
inp.rlast = (mx, my);
|
||
}
|
||
}
|
||
if is_mouse_button_released(MouseButton::Right) {
|
||
if !inp.rdrag && !over_ui && game.state == 0 {
|
||
if inp.ldown.is_some() {
|
||
inp.ldown = None;
|
||
} else {
|
||
game.drop(wx, wy);
|
||
}
|
||
}
|
||
inp.rdown = None;
|
||
}
|
||
|
||
// ---------------- Linke Maustaste
|
||
if is_mouse_button_pressed(MouseButton::Left) {
|
||
match ui.click(mx, my, &game) {
|
||
UiAction::SelectTool(t) => {
|
||
ui.tool = t;
|
||
game.sfx_ui(game::Sfx::Click);
|
||
}
|
||
UiAction::MinimapJump(x, y) => {
|
||
center_on(&mut view, x, y);
|
||
inp.minimap_drag = true;
|
||
}
|
||
UiAction::CloseHelp => ui.show_help = false,
|
||
UiAction::NewGame => {
|
||
seed = seed.wrapping_mul(1103515245).wrapping_add(12345) | 1;
|
||
(game, view) = new_game(seed);
|
||
ui.show_help = false;
|
||
}
|
||
UiAction::Consumed => {}
|
||
UiAction::None => {
|
||
if game.state == 0 && inb(hover_tile.0, hover_tile.1) {
|
||
match ui.tool {
|
||
Tool::Dig | Tool::Room(_) | Tool::Sell => inp.ldown = Some(hover_tile),
|
||
Tool::Hand => {
|
||
game.pickup(wx, wy);
|
||
}
|
||
Tool::Flag => game.set_flag(hover_tile.0, hover_tile.1),
|
||
Tool::Lightning => game.lightning(wx, wy),
|
||
Tool::Heal => game.heal(wx, wy),
|
||
Tool::Summon => game.summon(wx, wy),
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if inp.minimap_drag {
|
||
if is_mouse_button_down(MouseButton::Left) && ui.minimap_contains(mx, my) {
|
||
let (x, y) = ui.minimap_world(mx, my);
|
||
center_on(&mut view, x, y);
|
||
} else if !is_mouse_button_down(MouseButton::Left) {
|
||
inp.minimap_drag = false;
|
||
}
|
||
}
|
||
if is_mouse_button_released(MouseButton::Left) {
|
||
if let Some((sx, sy)) = inp.ldown.take() {
|
||
let (ex, ey) = (hover_tile.0.clamp(0, MW as i32 - 1), hover_tile.1.clamp(0, MH as i32 - 1));
|
||
match ui.tool {
|
||
Tool::Dig => {
|
||
let on = !game.map.t[idx(sx, sy)].marked;
|
||
game.mark_rect(sx, sy, ex, ey, on);
|
||
}
|
||
Tool::Room(r) => game.build_rect(r, sx, sy, ex, ey),
|
||
Tool::Sell => game.sell_rect(sx, sy, ex, ey),
|
||
_ => {}
|
||
}
|
||
}
|
||
}
|
||
clamp_cam(&mut view);
|
||
|
||
// ---------------- Update
|
||
game.update(dt);
|
||
for ev in game.events.drain(..) {
|
||
sounds.play(ev, &view, now);
|
||
}
|
||
for m in game.msgs.drain(..) {
|
||
ui.log.push((m, now));
|
||
}
|
||
|
||
// ---------------- Zeichnen
|
||
clear_background(Color::from_rgba(8, 6, 8, 255));
|
||
let (hover_color, radius) = match ui.tool {
|
||
Tool::Dig => (Color::new(1.0, 0.85, 0.3, 1.0), None),
|
||
Tool::Hand => (Color::new(0.9, 0.75, 0.6, 1.0), None),
|
||
Tool::Room(_) => (Color::new(0.4, 0.85, 1.0, 1.0), None),
|
||
Tool::Sell => (Color::new(1.0, 0.5, 0.3, 1.0), None),
|
||
Tool::Flag => (Color::new(1.0, 0.3, 0.3, 1.0), None),
|
||
Tool::Lightning => (Color::new(1.0, 1.0, 0.6, 1.0), Some((wx, wy, 1.6))),
|
||
Tool::Heal => (Color::new(0.4, 1.0, 0.5, 1.0), Some((wx, wy, 2.55))),
|
||
Tool::Summon => (Color::new(0.8, 0.5, 1.0, 1.0), None),
|
||
};
|
||
let ov = Overlay {
|
||
hover: if over_ui || !inb(hover_tile.0, hover_tile.1) { None } else { Some(hover_tile) },
|
||
hover_color,
|
||
rect: inp.ldown.map(|(sx, sy)| (sx, sy, hover_tile.0.clamp(0, MW as i32 - 1), hover_tile.1.clamp(0, MH as i32 - 1))),
|
||
rect_color: hover_color,
|
||
radius: if over_ui { None } else { radius },
|
||
};
|
||
draw_world(&game, &gfx, &view, now, &ov);
|
||
let info = if over_ui { Vec::new() } else { hover_info(&game, wx, wy) };
|
||
ui.draw(&game, &gfx, &view, &sounds, &info, now);
|
||
|
||
next_frame().await
|
||
}
|
||
}
|