284 lines
9.7 KiB
Rust
284 lines
9.7 KiB
Rust
use std::cell::RefCell;
|
|
|
|
use crate::common::{Color, Rect};
|
|
use crate::framework::backend::{BackendTexture, SpriteBatchCommand};
|
|
use crate::framework::context::Context;
|
|
use crate::framework::error::GameResult;
|
|
use crate::graphics;
|
|
use crate::input::touch_controls::TouchControlType;
|
|
use crate::player::Player;
|
|
use crate::scripting::tsc::text_script::TextScriptExecutionState;
|
|
use crate::shared_game_state::{Language, SharedGameState};
|
|
use crate::stage::Stage;
|
|
|
|
#[derive(Copy, Clone, Eq, PartialEq)]
|
|
pub enum MapSystemState {
|
|
Hidden,
|
|
FadeInBox(u16),
|
|
FadeInLine(u16),
|
|
Visible,
|
|
FadeOutBox(u16),
|
|
}
|
|
|
|
pub struct MapSystem {
|
|
texture: RefCell<Option<Box<dyn BackendTexture>>>,
|
|
has_map_data: RefCell<bool>,
|
|
last_size: (u16, u16),
|
|
tick: u16,
|
|
state: MapSystemState,
|
|
}
|
|
|
|
impl MapSystem {
|
|
pub fn new() -> MapSystem {
|
|
MapSystem {
|
|
texture: RefCell::new(None),
|
|
has_map_data: RefCell::new(false),
|
|
last_size: (0, 0),
|
|
tick: 0,
|
|
state: MapSystemState::Hidden,
|
|
}
|
|
}
|
|
|
|
fn render_map(&self, state: &mut SharedGameState, ctx: &mut Context, stage: &Stage) -> GameResult {
|
|
if self.texture.borrow().is_none() {
|
|
*self.has_map_data.borrow_mut() = false;
|
|
return Ok(());
|
|
}
|
|
|
|
*self.has_map_data.borrow_mut() = true;
|
|
|
|
graphics::set_render_target(ctx, self.texture.borrow().as_ref())?;
|
|
graphics::clear(ctx, Color::new(0.0, 0.0, 0.0, 1.0));
|
|
|
|
let batch = state.texture_set.get_or_load_batch(ctx, &state.constants, "TextBox")?;
|
|
|
|
for y in 0..stage.map.height {
|
|
for x in 0..stage.map.width {
|
|
const RECTS: [Rect<u16>; 4] = [
|
|
Rect { left: 240, top: 24, right: 241, bottom: 25 },
|
|
Rect { left: 241, top: 24, right: 242, bottom: 25 },
|
|
Rect { left: 242, top: 24, right: 243, bottom: 25 },
|
|
Rect { left: 243, top: 24, right: 244, bottom: 25 },
|
|
];
|
|
|
|
let attr = stage.map.get_attribute(x as _, y as _);
|
|
|
|
let layer = match attr {
|
|
0 => 0,
|
|
0x01 | 0x02 | 0x40 | 0x44 | 0x51 | 0x52 | 0x55 | 0x56 | 0x60 | 0x71 | 0x72 | 0x75 | 0x76 | 0x80
|
|
| 0x81 | 0x82 | 0x83 | 0xA0 | 0xA1 | 0xA2 | 0xA3 => 1,
|
|
0x43 | 0x50 | 0x53 | 0x54 | 0x57 | 0x63 | 0x70 | 0x73 | 0x74 | 0x77 => 2,
|
|
_ => 3,
|
|
};
|
|
|
|
batch.add_rect(x as _, y as _, &RECTS[layer]);
|
|
}
|
|
}
|
|
|
|
batch.draw(ctx)?;
|
|
graphics::set_render_target(ctx, None)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn tick(
|
|
&mut self,
|
|
state: &mut SharedGameState,
|
|
ctx: &mut Context,
|
|
stage: &Stage,
|
|
players: [&Player; 2],
|
|
) -> GameResult {
|
|
let touch_rect = Rect::new_size(0, 0, state.canvas_size.0 as isize, state.canvas_size.1 as isize);
|
|
|
|
if state.textscript_vm.state == TextScriptExecutionState::MapSystem {
|
|
if self.state == MapSystemState::Hidden {
|
|
state.touch_controls.control_type = TouchControlType::None;
|
|
state.control_flags.set_control_enabled(false);
|
|
self.state = MapSystemState::FadeInBox(0);
|
|
}
|
|
} else {
|
|
self.state = MapSystemState::Hidden;
|
|
}
|
|
|
|
if self.state == MapSystemState::Hidden {
|
|
self.tick = 0;
|
|
*self.has_map_data.borrow_mut() = false;
|
|
return Ok(());
|
|
}
|
|
|
|
self.tick = self.tick.wrapping_add(1);
|
|
|
|
let width = (stage.map.width as f32 * state.scale) as u16;
|
|
let height = (stage.map.height as f32 * state.scale) as u16;
|
|
|
|
if self.last_size != (width, height) {
|
|
self.last_size = (width, height);
|
|
*self.texture.borrow_mut() = graphics::create_texture_mutable(ctx, width, height).ok();
|
|
*self.has_map_data.borrow_mut() = false;
|
|
}
|
|
|
|
match self.state {
|
|
MapSystemState::FadeInBox(tick) => {
|
|
if tick >= 8 {
|
|
self.state = MapSystemState::FadeInLine(0);
|
|
} else {
|
|
self.state = MapSystemState::FadeInBox(tick + 1);
|
|
}
|
|
}
|
|
MapSystemState::FadeOutBox(tick) => {
|
|
if tick == 0 {
|
|
state.control_flags.set_tick_world(true);
|
|
state.control_flags.set_control_enabled(true);
|
|
state.textscript_vm.state = TextScriptExecutionState::Ended;
|
|
self.state = MapSystemState::Hidden;
|
|
} else {
|
|
self.state = MapSystemState::FadeOutBox(tick - 1);
|
|
}
|
|
}
|
|
MapSystemState::FadeInLine(tick) => {
|
|
if (tick + 2) < stage.map.height {
|
|
self.state = MapSystemState::FadeInLine(tick + 2);
|
|
} else {
|
|
self.state = MapSystemState::Visible;
|
|
}
|
|
|
|
for player in &players {
|
|
if player.controller.trigger_jump()
|
|
|| player.controller.trigger_shoot()
|
|
|| state.touch_controls.consume_click_in(touch_rect)
|
|
{
|
|
self.state = MapSystemState::FadeOutBox(8);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
MapSystemState::Visible => {
|
|
for player in &players {
|
|
if player.controller.trigger_jump()
|
|
|| player.controller.trigger_shoot()
|
|
|| state.touch_controls.consume_click_in(touch_rect)
|
|
{
|
|
self.state = MapSystemState::FadeOutBox(8);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
_ => (),
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn draw(
|
|
&self,
|
|
state: &mut SharedGameState,
|
|
ctx: &mut Context,
|
|
stage: &Stage,
|
|
players: [&Player; 2],
|
|
) -> GameResult {
|
|
if self.state == MapSystemState::Hidden {
|
|
return Ok(());
|
|
}
|
|
|
|
if !*self.has_map_data.borrow() {
|
|
self.render_map(state, ctx, stage)?;
|
|
}
|
|
|
|
let (scr_w, scr_h) = (state.canvas_size.0 * state.scale, state.canvas_size.1 * state.scale);
|
|
let text_height = state.font.line_height(&state.constants);
|
|
let rect_black_bar = Rect::new_size(
|
|
0,
|
|
(7.0 * state.scale) as _,
|
|
state.screen_size.0 as _,
|
|
((text_height + 4.0) * state.scale) as _,
|
|
);
|
|
|
|
if !state.constants.is_switch {
|
|
graphics::draw_rect(ctx, rect_black_bar, Color::new(0.0, 0.0, 0.0, 1.0))?;
|
|
}
|
|
|
|
let map_name = if state.settings.locale == Language::Japanese {
|
|
stage.data.name_jp.chars()
|
|
} else {
|
|
stage.data.name.chars()
|
|
};
|
|
|
|
let map_name_width = state.font.text_width(map_name.clone(), &state.constants);
|
|
let map_name_off_x = (state.canvas_size.0 - map_name_width) / 2.0;
|
|
|
|
state.font.draw_text(map_name, map_name_off_x, 9.0, &state.constants, &mut state.texture_set, ctx)?;
|
|
|
|
let mut map_rect = Rect::new(0.0, 0.0, self.last_size.0 as f32, self.last_size.1 as f32);
|
|
|
|
match self.state {
|
|
MapSystemState::FadeInBox(tick) | MapSystemState::FadeOutBox(tick) => {
|
|
let width = (state.scale * tick as f32 * stage.map.width as f32 / 16.0) as isize;
|
|
let height = (state.scale * tick as f32 * stage.map.height as f32 / 16.0) as isize;
|
|
|
|
let rect = Rect::new_size(
|
|
(scr_w / 2.0) as isize - width,
|
|
(scr_h / 2.0) as isize - height,
|
|
width * 2,
|
|
height * 2,
|
|
);
|
|
|
|
graphics::draw_rect(ctx, rect, Color::new(0.0, 0.0, 0.0, 1.0))?;
|
|
|
|
return Ok(());
|
|
}
|
|
MapSystemState::FadeInLine(line) => {
|
|
map_rect.bottom = state.scale * (line as f32 + 1.0);
|
|
}
|
|
_ => (),
|
|
}
|
|
|
|
let width_border = state.scale * (stage.map.width as f32 + 2.0);
|
|
let height_border = state.scale * (stage.map.height as f32 + 2.0);
|
|
|
|
let rect = Rect::new_size(
|
|
((scr_w - width_border) / 2.0) as isize,
|
|
((scr_h - height_border) / 2.0) as isize,
|
|
width_border as isize,
|
|
height_border as isize,
|
|
);
|
|
|
|
graphics::draw_rect(ctx, rect, Color::new(0.0, 0.0, 0.0, 1.0))?;
|
|
|
|
if let Some(tex) = self.texture.borrow_mut().as_mut() {
|
|
let width = state.scale * stage.map.width as f32;
|
|
let height = state.scale * stage.map.height as f32;
|
|
|
|
tex.clear();
|
|
tex.add(SpriteBatchCommand::DrawRect(
|
|
map_rect,
|
|
Rect::new_size((scr_w - width) / 2.0, (scr_h - height) / 2.0, map_rect.width(), map_rect.height()),
|
|
));
|
|
tex.draw()?;
|
|
}
|
|
|
|
if (self.tick & 8) != 0 {
|
|
const PLAYER_RECT: Rect<u16> = Rect { left: 0, top: 57, right: 1, bottom: 58 };
|
|
|
|
let batch = state.texture_set.get_or_load_batch(ctx, &state.constants, "TextBox")?;
|
|
let x_offset = (state.canvas_size.0 - stage.map.width as f32) / 2.0;
|
|
let y_offset = (state.canvas_size.1 - stage.map.height as f32) / 2.0;
|
|
let tile_div = stage.map.tile_size.as_int() * 0x200;
|
|
|
|
for player in &players {
|
|
if !player.cond.alive() {
|
|
continue;
|
|
}
|
|
|
|
let plr_x = x_offset + (player.x / tile_div) as f32;
|
|
let plr_y = y_offset + (player.y / tile_div) as f32;
|
|
|
|
batch.add_rect(plr_x, plr_y, &PLAYER_RECT);
|
|
}
|
|
|
|
batch.draw(ctx)?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|