1559 lines
72 KiB
Rust
1559 lines
72 KiB
Rust
use std::cmp::Ordering;
|
|
use std::collections::HashMap;
|
|
use std::io;
|
|
use std::io::Cursor;
|
|
use std::io::Seek;
|
|
use std::io::SeekFrom;
|
|
use std::ops::Not;
|
|
|
|
use num_traits::{clamp, FromPrimitive};
|
|
|
|
use crate::bitfield;
|
|
use crate::common::Direction::{Left, Right};
|
|
use crate::common::{Direction, FadeDirection, FadeState, Rect};
|
|
use crate::engine_constants::EngineConstants;
|
|
use crate::entity::GameEntity;
|
|
use crate::frame::UpdateTarget;
|
|
use crate::framework::context::Context;
|
|
use crate::framework::error::GameResult;
|
|
use crate::input::touch_controls::TouchControlType;
|
|
use crate::npc::NPC;
|
|
use crate::player::{ControlMode, TargetPlayer};
|
|
use crate::scene::game_scene::GameScene;
|
|
use crate::scene::title_scene::TitleScene;
|
|
use crate::scripting::tsc::bytecode_utils::read_cur_varint;
|
|
use crate::scripting::tsc::opcodes::OpCode;
|
|
use crate::shared_game_state::SharedGameState;
|
|
use crate::weapon::WeaponType;
|
|
|
|
bitfield! {
|
|
pub struct TextScriptFlags(u16);
|
|
impl Debug;
|
|
pub render, set_render: 0;
|
|
pub background_visible, set_background_visible: 1;
|
|
pub fast, set_fast: 4;
|
|
pub position_top, set_position_top: 5;
|
|
pub perma_fast, set_perma_fast: 6;
|
|
pub cutscene_skip, set_cutscene_skip: 7;
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
|
|
#[repr(u8)]
|
|
pub enum TextScriptEncoding {
|
|
UTF8 = 0,
|
|
ShiftJIS,
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
|
|
#[repr(u8)]
|
|
pub enum TextScriptLine {
|
|
Line1 = 0,
|
|
Line2,
|
|
Line3,
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
|
|
#[repr(u8)]
|
|
pub enum ConfirmSelection {
|
|
Yes,
|
|
No,
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
|
|
#[repr(u8)]
|
|
pub enum ScriptMode {
|
|
Map,
|
|
Inventory,
|
|
StageSelect,
|
|
}
|
|
|
|
impl Not for ConfirmSelection {
|
|
type Output = ConfirmSelection;
|
|
|
|
fn not(self) -> ConfirmSelection {
|
|
if self == ConfirmSelection::Yes {
|
|
ConfirmSelection::No
|
|
} else {
|
|
ConfirmSelection::Yes
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Copy, Clone)]
|
|
#[repr(u8)]
|
|
pub enum TextScriptExecutionState {
|
|
Ended,
|
|
Running(u16, u32),
|
|
Msg(u16, u32, u32, u8),
|
|
WaitTicks(u16, u32, u16),
|
|
WaitInput(u16, u32, u16),
|
|
WaitStanding(u16, u32),
|
|
WaitConfirmation(u16, u32, u16, u8, ConfirmSelection),
|
|
WaitFade(u16, u32),
|
|
SaveProfile(u16, u32),
|
|
LoadProfile,
|
|
Reset,
|
|
}
|
|
|
|
pub struct TextScriptVM {
|
|
pub scripts: Scripts,
|
|
pub state: TextScriptExecutionState,
|
|
pub stack: Vec<TextScriptExecutionState>,
|
|
pub flags: TextScriptFlags,
|
|
pub mode: ScriptMode,
|
|
/// The player who triggered the event.
|
|
pub executor_player: TargetPlayer,
|
|
/// Toggle for non-strict TSC parsing because English versions of CS+ (both AG and Nicalis release)
|
|
/// modified the events carelessly and since original Pixel's engine hasn't enforced constraints
|
|
/// while parsing no one noticed them.
|
|
pub strict_mode: bool,
|
|
pub suspend: bool,
|
|
pub numbers: [u16; 4],
|
|
pub face: u16,
|
|
pub item: u16,
|
|
pub current_line: TextScriptLine,
|
|
pub line_1: Vec<char>,
|
|
pub line_2: Vec<char>,
|
|
pub line_3: Vec<char>,
|
|
prev_char: char,
|
|
}
|
|
|
|
pub struct Scripts {
|
|
/// Head.tsc - shared part of map scripts
|
|
pub global_script: TextScript,
|
|
/// <Map>.tsc - map script
|
|
pub scene_script: TextScript,
|
|
/// ArmsItem.tsc - used by inventory
|
|
pub inventory_script: TextScript,
|
|
/// StageSelect.tsc - used by teleport target selector
|
|
pub stage_select_script: TextScript,
|
|
}
|
|
|
|
impl Scripts {
|
|
pub fn find_script(&self, mode: ScriptMode, event_num: u16) -> Option<&Vec<u8>> {
|
|
match mode {
|
|
ScriptMode::Map => {
|
|
if let Some(tsc) = self.scene_script.event_map.get(&event_num) {
|
|
return Some(tsc);
|
|
} else if let Some(tsc) = self.global_script.event_map.get(&event_num) {
|
|
return Some(tsc);
|
|
}
|
|
}
|
|
ScriptMode::Inventory => {
|
|
if let Some(tsc) = self.inventory_script.event_map.get(&event_num) {
|
|
return Some(tsc);
|
|
}
|
|
}
|
|
ScriptMode::StageSelect => {
|
|
if let Some(tsc) = self.stage_select_script.event_map.get(&event_num) {
|
|
return Some(tsc);
|
|
}
|
|
}
|
|
}
|
|
|
|
None
|
|
}
|
|
}
|
|
|
|
impl TextScriptVM {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
scripts: Scripts {
|
|
global_script: TextScript::new(),
|
|
scene_script: TextScript::new(),
|
|
inventory_script: TextScript::new(),
|
|
stage_select_script: TextScript::new(),
|
|
},
|
|
state: TextScriptExecutionState::Ended,
|
|
stack: Vec::with_capacity(6),
|
|
flags: TextScriptFlags(0),
|
|
mode: ScriptMode::Map,
|
|
executor_player: TargetPlayer::Player1,
|
|
strict_mode: false,
|
|
suspend: true,
|
|
numbers: [0; 4],
|
|
face: 0,
|
|
item: 0,
|
|
current_line: TextScriptLine::Line1,
|
|
line_1: Vec::with_capacity(24),
|
|
line_2: Vec::with_capacity(24),
|
|
line_3: Vec::with_capacity(24),
|
|
prev_char: '\x00',
|
|
}
|
|
}
|
|
|
|
pub fn set_global_script(&mut self, script: TextScript) {
|
|
self.scripts.global_script = script;
|
|
if !self.suspend {
|
|
self.reset();
|
|
}
|
|
}
|
|
|
|
pub fn set_scene_script(&mut self, script: TextScript) {
|
|
self.scripts.scene_script = script;
|
|
if !self.suspend {
|
|
self.reset();
|
|
}
|
|
}
|
|
|
|
pub fn set_inventory_script(&mut self, script: TextScript) {
|
|
self.scripts.inventory_script = script;
|
|
}
|
|
|
|
pub fn set_stage_select_script(&mut self, script: TextScript) {
|
|
self.scripts.stage_select_script = script;
|
|
}
|
|
|
|
pub fn reset(&mut self) {
|
|
self.state = TextScriptExecutionState::Ended;
|
|
self.flags.0 = 0;
|
|
self.clear_text_box();
|
|
}
|
|
|
|
pub fn clear_text_box(&mut self) {
|
|
self.face = 0;
|
|
self.item = 0;
|
|
self.current_line = TextScriptLine::Line1;
|
|
self.line_1.clear();
|
|
self.line_2.clear();
|
|
self.line_3.clear();
|
|
}
|
|
|
|
pub fn set_mode(&mut self, mode: ScriptMode) {
|
|
self.reset();
|
|
self.mode = mode;
|
|
}
|
|
|
|
pub fn start_script(&mut self, event_num: u16) {
|
|
self.reset();
|
|
self.state = TextScriptExecutionState::Running(event_num, 0);
|
|
|
|
log::info!("Started script: #{:04}", event_num);
|
|
}
|
|
|
|
pub fn run(state: &mut SharedGameState, game_scene: &mut GameScene, ctx: &mut Context) -> GameResult {
|
|
loop {
|
|
if state.textscript_vm.suspend {
|
|
break;
|
|
}
|
|
|
|
match state.textscript_vm.state {
|
|
TextScriptExecutionState::Ended => {
|
|
state.control_flags.set_interactions_disabled(false);
|
|
break;
|
|
}
|
|
TextScriptExecutionState::Running(event, ip) => {
|
|
state.control_flags.set_interactions_disabled(true);
|
|
state.textscript_vm.state = TextScriptVM::execute(event, ip, state, game_scene, ctx)?;
|
|
|
|
if state.textscript_vm.state == TextScriptExecutionState::Ended {
|
|
state.textscript_vm.reset();
|
|
}
|
|
}
|
|
TextScriptExecutionState::Msg(event, ip, remaining, counter) => {
|
|
if counter > 0 {
|
|
state.textscript_vm.state = TextScriptExecutionState::Msg(event, ip, remaining, counter - 1);
|
|
break;
|
|
}
|
|
|
|
if !state.control_flags.control_enabled() {
|
|
state.touch_controls.control_type = TouchControlType::Dialog;
|
|
}
|
|
|
|
if let Some(bytecode) = state.textscript_vm.scripts.find_script(state.textscript_vm.mode, event) {
|
|
let mut cursor = Cursor::new(bytecode);
|
|
cursor.seek(SeekFrom::Start(ip as u64))?;
|
|
|
|
let chr = std::char::from_u32(read_cur_varint(&mut cursor)? as u32).unwrap_or('\u{fffd}');
|
|
|
|
match chr {
|
|
'\n' if state.textscript_vm.current_line == TextScriptLine::Line1 => {
|
|
state.textscript_vm.current_line = TextScriptLine::Line2;
|
|
}
|
|
'\n' if state.textscript_vm.current_line == TextScriptLine::Line2 => {
|
|
state.textscript_vm.current_line = TextScriptLine::Line3;
|
|
}
|
|
'\n' => {
|
|
state.textscript_vm.line_1.clear();
|
|
state.textscript_vm.line_1.append(&mut state.textscript_vm.line_2);
|
|
state.textscript_vm.line_2.append(&mut state.textscript_vm.line_3);
|
|
}
|
|
'\r' => {}
|
|
_ if state.textscript_vm.current_line == TextScriptLine::Line1 => {
|
|
state.textscript_vm.prev_char = chr;
|
|
state.textscript_vm.line_1.push(chr);
|
|
|
|
let text_len =
|
|
state.font.text_width(state.textscript_vm.line_1.iter().copied(), &state.constants);
|
|
if text_len >= 284.0 {
|
|
state.textscript_vm.current_line = TextScriptLine::Line2;
|
|
}
|
|
}
|
|
_ if state.textscript_vm.current_line == TextScriptLine::Line2 => {
|
|
state.textscript_vm.prev_char = chr;
|
|
state.textscript_vm.line_2.push(chr);
|
|
|
|
let text_len =
|
|
state.font.text_width(state.textscript_vm.line_2.iter().copied(), &state.constants);
|
|
if text_len >= 284.0 {
|
|
state.textscript_vm.current_line = TextScriptLine::Line3;
|
|
}
|
|
}
|
|
_ if state.textscript_vm.current_line == TextScriptLine::Line3 => {
|
|
state.textscript_vm.prev_char = chr;
|
|
state.textscript_vm.line_3.push(chr);
|
|
|
|
let text_len =
|
|
state.font.text_width(state.textscript_vm.line_3.iter().copied(), &state.constants);
|
|
if text_len >= 284.0 {
|
|
state.textscript_vm.line_1.clear();
|
|
state.textscript_vm.line_1.append(&mut state.textscript_vm.line_2);
|
|
state.textscript_vm.line_2.append(&mut state.textscript_vm.line_3);
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
|
|
if remaining > 1 {
|
|
let ticks = if state.textscript_vm.flags.fast() || state.textscript_vm.flags.cutscene_skip()
|
|
{
|
|
0
|
|
} else if remaining != 2
|
|
&& (game_scene.player1.controller.jump()
|
|
|| game_scene.player1.controller.shoot()
|
|
|| game_scene.player2.controller.jump()
|
|
|| game_scene.player2.controller.shoot())
|
|
{
|
|
state.constants.textscript.text_speed_fast
|
|
} else {
|
|
state.constants.textscript.text_speed_normal
|
|
};
|
|
|
|
if ticks > 0 {
|
|
state.sound_manager.play_sfx(2);
|
|
}
|
|
|
|
state.textscript_vm.state =
|
|
TextScriptExecutionState::Msg(event, cursor.position() as u32, remaining - 1, ticks);
|
|
} else {
|
|
state.textscript_vm.state =
|
|
TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
} else {
|
|
state.textscript_vm.reset();
|
|
}
|
|
}
|
|
TextScriptExecutionState::WaitTicks(event, ip, ticks) => {
|
|
if ticks == 0 {
|
|
state.textscript_vm.state = TextScriptExecutionState::Running(event, ip);
|
|
} else if ticks != 9999 {
|
|
state.textscript_vm.state = TextScriptExecutionState::WaitTicks(event, ip, ticks - 1);
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
TextScriptExecutionState::WaitConfirmation(event, ip, no_event, wait, selection) => {
|
|
state.textscript_vm.flags.set_cutscene_skip(false);
|
|
|
|
if wait > 0 {
|
|
state.textscript_vm.state =
|
|
TextScriptExecutionState::WaitConfirmation(event, ip, no_event, wait - 1, selection);
|
|
break;
|
|
}
|
|
|
|
let mut confirm =
|
|
game_scene.player1.controller.trigger_jump() || game_scene.player2.controller.trigger_jump();
|
|
|
|
if state.settings.touch_controls && !state.control_flags.control_enabled() {
|
|
state.touch_controls.control_type = TouchControlType::None;
|
|
|
|
let (off_left, _, off_right, off_bottom) =
|
|
crate::framework::graphics::screen_insets_scaled(ctx, state.scale);
|
|
let box_x = ((state.canvas_size.0 - off_left - off_right) / 2.0) as isize + 51;
|
|
let box_y = (state.canvas_size.1 - off_bottom - 96.0 - 10.0) as isize;
|
|
|
|
if state.touch_controls.consume_click_in(Rect::new_size(box_x, box_y, 40, 40)) {
|
|
match selection {
|
|
ConfirmSelection::Yes => confirm = true,
|
|
ConfirmSelection::No => {
|
|
state.sound_manager.play_sfx(1);
|
|
state.textscript_vm.state = TextScriptExecutionState::WaitConfirmation(
|
|
event,
|
|
ip,
|
|
no_event,
|
|
0,
|
|
ConfirmSelection::Yes,
|
|
);
|
|
}
|
|
}
|
|
} else if state.touch_controls.consume_click_in(Rect::new_size(box_x + 41, box_y, 40, 40)) {
|
|
match selection {
|
|
ConfirmSelection::Yes => {
|
|
state.sound_manager.play_sfx(1);
|
|
state.textscript_vm.state = TextScriptExecutionState::WaitConfirmation(
|
|
event,
|
|
ip,
|
|
no_event,
|
|
0,
|
|
ConfirmSelection::No,
|
|
);
|
|
}
|
|
ConfirmSelection::No => confirm = true,
|
|
}
|
|
}
|
|
}
|
|
|
|
if game_scene.player1.controller.trigger_left()
|
|
|| game_scene.player1.controller.trigger_right()
|
|
|| game_scene.player2.controller.trigger_left()
|
|
|| game_scene.player2.controller.trigger_right()
|
|
{
|
|
state.sound_manager.play_sfx(1);
|
|
state.textscript_vm.state =
|
|
TextScriptExecutionState::WaitConfirmation(event, ip, no_event, 0, !selection);
|
|
break;
|
|
}
|
|
|
|
if confirm {
|
|
state.sound_manager.play_sfx(18);
|
|
match selection {
|
|
ConfirmSelection::Yes => {
|
|
state.textscript_vm.state = TextScriptExecutionState::Running(event, ip);
|
|
}
|
|
ConfirmSelection::No => {
|
|
state.textscript_vm.clear_text_box();
|
|
state.textscript_vm.state = TextScriptExecutionState::Running(no_event, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
TextScriptExecutionState::WaitStanding(event, ip) => {
|
|
if game_scene.player1.flags.hit_bottom_wall() {
|
|
state.textscript_vm.state = TextScriptExecutionState::Running(event, ip);
|
|
}
|
|
break;
|
|
}
|
|
TextScriptExecutionState::WaitInput(event, ip, blink) => {
|
|
state.textscript_vm.state = TextScriptExecutionState::WaitInput(event, ip, (blink + 1) % 20);
|
|
|
|
if !state.control_flags.control_enabled() {
|
|
state.touch_controls.control_type = TouchControlType::Dialog;
|
|
}
|
|
|
|
if state.textscript_vm.flags.cutscene_skip()
|
|
|| game_scene.player1.controller.trigger_jump()
|
|
|| game_scene.player1.controller.trigger_shoot()
|
|
|| game_scene.player2.controller.trigger_jump()
|
|
|| game_scene.player2.controller.trigger_shoot()
|
|
{
|
|
state.textscript_vm.state = TextScriptExecutionState::Running(event, ip);
|
|
}
|
|
break;
|
|
}
|
|
TextScriptExecutionState::WaitFade(event, ip) => {
|
|
if state.fade_state == FadeState::Hidden || state.fade_state == FadeState::Visible {
|
|
state.textscript_vm.state = TextScriptExecutionState::Running(event, ip);
|
|
}
|
|
break;
|
|
}
|
|
|
|
TextScriptExecutionState::SaveProfile(event, ip) => {
|
|
state.save_game(game_scene, ctx)?;
|
|
state.textscript_vm.state = TextScriptExecutionState::Running(event, ip);
|
|
break;
|
|
}
|
|
TextScriptExecutionState::LoadProfile => {
|
|
state.load_or_start_game(ctx)?;
|
|
break;
|
|
}
|
|
TextScriptExecutionState::Reset => {
|
|
state.reset();
|
|
state.start_new_game(ctx)?;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn execute(
|
|
event: u16,
|
|
ip: u32,
|
|
state: &mut SharedGameState,
|
|
game_scene: &mut GameScene,
|
|
ctx: &mut Context,
|
|
) -> GameResult<TextScriptExecutionState> {
|
|
let mut exec_state = state.textscript_vm.state;
|
|
|
|
let state_ref = state as *mut SharedGameState;
|
|
let scripts = unsafe { &(*state_ref).textscript_vm.scripts };
|
|
|
|
if let Some(bytecode) = scripts.find_script(state.textscript_vm.mode, event) {
|
|
let mut cursor = Cursor::new(bytecode);
|
|
cursor.seek(SeekFrom::Start(ip as u64))?;
|
|
|
|
let op_maybe: Option<OpCode> =
|
|
FromPrimitive::from_i32(read_cur_varint(&mut cursor).unwrap_or_else(|_| OpCode::END as i32));
|
|
|
|
if let Some(op) = op_maybe {
|
|
match op {
|
|
OpCode::_NOP => {
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::_UNI => {}
|
|
OpCode::_STR => {
|
|
let mut len = read_cur_varint(&mut cursor)? as u32;
|
|
if state.textscript_vm.flags.render() {
|
|
state.textscript_vm.prev_char = '\x00';
|
|
exec_state = TextScriptExecutionState::Msg(event, cursor.position() as u32, len, 4);
|
|
} else {
|
|
while len > 0 {
|
|
len -= 1;
|
|
let _ = read_cur_varint(&mut cursor)?;
|
|
}
|
|
// simply skip the text if we aren't in message mode.
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
}
|
|
OpCode::_END => {
|
|
state.textscript_vm.flags.set_cutscene_skip(false);
|
|
exec_state = TextScriptExecutionState::Ended;
|
|
}
|
|
OpCode::END => {
|
|
state.textscript_vm.flags.set_cutscene_skip(false);
|
|
state.control_flags.set_tick_world(true);
|
|
state.control_flags.set_control_enabled(true);
|
|
|
|
state.textscript_vm.flags.set_render(false);
|
|
state.textscript_vm.flags.set_background_visible(false);
|
|
state.textscript_vm.stack.clear();
|
|
|
|
game_scene.player1.cond.set_interacted(false);
|
|
game_scene.player2.cond.set_interacted(false);
|
|
|
|
exec_state = TextScriptExecutionState::Ended;
|
|
}
|
|
OpCode::SLP => {
|
|
state.textscript_vm.set_mode(ScriptMode::StageSelect);
|
|
|
|
let event_num = if let Some(slot) =
|
|
state.teleporter_slots.get(game_scene.stage_select.current_teleport_slot as usize)
|
|
{
|
|
1000 + slot.0
|
|
} else {
|
|
1000
|
|
};
|
|
|
|
exec_state = TextScriptExecutionState::Running(event_num, 0);
|
|
}
|
|
OpCode::PSp => {
|
|
let index = read_cur_varint(&mut cursor)? as u16;
|
|
let event_num = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
if let Some(slot) = state.teleporter_slots.iter_mut().find(|s| s.0 == index) {
|
|
slot.1 = event_num;
|
|
} else {
|
|
state.teleporter_slots.push((index, event_num));
|
|
}
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::PRI => {
|
|
state.control_flags.set_tick_world(false);
|
|
state.control_flags.set_control_enabled(false);
|
|
|
|
game_scene.player1.shock_counter = 0;
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::KEY => {
|
|
state.control_flags.set_tick_world(true);
|
|
state.control_flags.set_control_enabled(false);
|
|
|
|
game_scene.player1.up = false;
|
|
game_scene.player1.shock_counter = 0;
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::FRE => {
|
|
state.control_flags.set_tick_world(true);
|
|
state.control_flags.set_control_enabled(true);
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::MYD => {
|
|
let new_direction = read_cur_varint(&mut cursor)? as usize;
|
|
if let Some(direction) = Direction::from_int(new_direction) {
|
|
game_scene.player1.direction = direction;
|
|
game_scene.player2.direction = direction;
|
|
}
|
|
game_scene.player1.cond.set_interacted(new_direction == 3);
|
|
game_scene.player2.cond.set_interacted(new_direction == 3);
|
|
|
|
game_scene.player1.vel_x = 0;
|
|
game_scene.player2.vel_x = 0;
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::MYB => {
|
|
let new_direction = read_cur_varint(&mut cursor)? as usize;
|
|
|
|
game_scene.player1.vel_y = -0x200;
|
|
game_scene.player2.vel_y = -0x200;
|
|
|
|
// Reset interaction condition, needed for places like talking to Toroko in shack
|
|
game_scene.player1.cond.set_interacted(false);
|
|
game_scene.player2.cond.set_interacted(false);
|
|
|
|
if let Some(direction) = Direction::from_int_facing(new_direction) {
|
|
match direction {
|
|
Direction::Left => {
|
|
game_scene.player1.direction = Left;
|
|
game_scene.player2.direction = Left;
|
|
game_scene.player1.vel_x = 0x200;
|
|
game_scene.player2.vel_x = 0x200;
|
|
}
|
|
Direction::Up => {
|
|
game_scene.player1.vel_y = -0x200;
|
|
game_scene.player2.vel_y = -0x200;
|
|
}
|
|
Direction::Right => {
|
|
game_scene.player1.direction = Right;
|
|
game_scene.player2.direction = Right;
|
|
game_scene.player1.vel_x = -0x200;
|
|
game_scene.player2.vel_x = -0x200;
|
|
}
|
|
Direction::Bottom => {
|
|
game_scene.player1.vel_y = 0x200;
|
|
game_scene.player2.vel_y = 0x200;
|
|
}
|
|
Direction::FacingPlayer => {
|
|
for npc in game_scene.npc_list.iter_alive() {
|
|
if npc.event_num == new_direction as u16 {
|
|
if game_scene.player1.x >= npc.x {
|
|
game_scene.player1.direction = Left;
|
|
game_scene.player1.vel_x = 0x200;
|
|
} else {
|
|
game_scene.player1.direction = Right;
|
|
game_scene.player1.vel_x = -0x200;
|
|
}
|
|
|
|
if game_scene.player2.x >= npc.x {
|
|
game_scene.player2.direction = Left;
|
|
game_scene.player2.vel_x = 0x200;
|
|
} else {
|
|
game_scene.player2.direction = Right;
|
|
game_scene.player2.vel_x = -0x200;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::SMC => {
|
|
game_scene.player1.cond.set_hidden(false);
|
|
game_scene.player2.cond.set_hidden(false);
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::HMC => {
|
|
game_scene.player1.cond.set_hidden(true);
|
|
game_scene.player2.cond.set_hidden(true);
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::WAI => {
|
|
let ticks = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
exec_state = TextScriptExecutionState::WaitTicks(event, cursor.position() as u32, ticks);
|
|
}
|
|
OpCode::WAS => {
|
|
exec_state = TextScriptExecutionState::WaitStanding(event, cursor.position() as u32);
|
|
}
|
|
OpCode::NOD => {
|
|
exec_state = TextScriptExecutionState::WaitInput(event, cursor.position() as u32, 0);
|
|
}
|
|
OpCode::FLp | OpCode::FLm => {
|
|
let flag_num = read_cur_varint(&mut cursor)? as u16;
|
|
state.set_flag(flag_num as usize, op == OpCode::FLp);
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::SKp | OpCode::SKm => {
|
|
let flag_num = read_cur_varint(&mut cursor)? as u16;
|
|
state.set_skip_flag(flag_num as usize, op == OpCode::SKp);
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::FFm => {
|
|
let flag_from = read_cur_varint(&mut cursor)? as usize;
|
|
let flag_to = read_cur_varint(&mut cursor)? as usize;
|
|
|
|
if flag_to >= flag_from {
|
|
for flag in flag_from..=flag_to {
|
|
if state.get_flag(flag) {
|
|
state.game_flags.set(flag, false);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::FLJ => {
|
|
let flag_num = read_cur_varint(&mut cursor)? as usize;
|
|
let event_num = read_cur_varint(&mut cursor)? as u16;
|
|
if state.get_flag(flag_num) {
|
|
state.textscript_vm.clear_text_box();
|
|
exec_state = TextScriptExecutionState::Running(event_num, 0);
|
|
} else {
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
}
|
|
OpCode::MPJ => {
|
|
let event_num = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
if state.get_map_flag(game_scene.stage_id) {
|
|
state.textscript_vm.clear_text_box();
|
|
exec_state = TextScriptExecutionState::Running(event_num, 0);
|
|
} else {
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
}
|
|
OpCode::ITJ => {
|
|
let item_id = read_cur_varint(&mut cursor)? as u16;
|
|
let event_num = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
if game_scene.inventory_player1.has_item(item_id) {
|
|
state.textscript_vm.clear_text_box();
|
|
exec_state = TextScriptExecutionState::Running(event_num, 0);
|
|
} else {
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
}
|
|
OpCode::INJ => {
|
|
let item_id = read_cur_varint(&mut cursor)? as u16;
|
|
let amount = read_cur_varint(&mut cursor)? as u16;
|
|
let event_num = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
if game_scene.inventory_player1.has_item_amount(item_id, Ordering::Equal, amount) {
|
|
state.textscript_vm.clear_text_box();
|
|
exec_state = TextScriptExecutionState::Running(event_num, 0);
|
|
} else {
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
}
|
|
OpCode::AMJ => {
|
|
let weapon = read_cur_varint(&mut cursor)? as u8;
|
|
let event_num = read_cur_varint(&mut cursor)? as u16;
|
|
let weapon_type: Option<WeaponType> = FromPrimitive::from_u8(weapon);
|
|
|
|
if weapon_type.is_some() && game_scene.inventory_player1.has_weapon(weapon_type.unwrap()) {
|
|
state.textscript_vm.clear_text_box();
|
|
exec_state = TextScriptExecutionState::Running(event_num, 0);
|
|
} else {
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
}
|
|
OpCode::NCJ => {
|
|
let npc_type = read_cur_varint(&mut cursor)? as u16;
|
|
let event_num = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
if game_scene.npc_list.is_alive_by_type(npc_type) {
|
|
state.textscript_vm.clear_text_box();
|
|
exec_state = TextScriptExecutionState::Running(event_num, 0);
|
|
} else {
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
}
|
|
OpCode::ECJ => {
|
|
let npc_event_num = read_cur_varint(&mut cursor)? as u16;
|
|
let event_num = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
if game_scene.npc_list.is_alive_by_event(npc_event_num) {
|
|
state.textscript_vm.clear_text_box();
|
|
exec_state = TextScriptExecutionState::Running(event_num, 0);
|
|
} else {
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
}
|
|
OpCode::SKJ => {
|
|
let flag_id = read_cur_varint(&mut cursor)? as u16;
|
|
let event_num = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
if state.get_skip_flag(flag_id as usize) {
|
|
state.textscript_vm.clear_text_box();
|
|
exec_state = TextScriptExecutionState::Running(event_num, 0);
|
|
} else {
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
}
|
|
|
|
OpCode::S2PJ => {
|
|
let event_num = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
exec_state = if game_scene.player2.cond.alive() {
|
|
TextScriptExecutionState::Running(event_num, 0)
|
|
} else {
|
|
TextScriptExecutionState::Running(event, cursor.position() as u32)
|
|
}
|
|
}
|
|
OpCode::EVE => {
|
|
let event_num = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
state.textscript_vm.clear_text_box();
|
|
exec_state = TextScriptExecutionState::Running(event_num, 0);
|
|
}
|
|
OpCode::PSH => {
|
|
let event_num = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
let saved_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
state.textscript_vm.stack.push(saved_state);
|
|
|
|
state.textscript_vm.clear_text_box();
|
|
exec_state = TextScriptExecutionState::Running(event_num, 0);
|
|
}
|
|
OpCode::POP => {
|
|
if let Some(saved_state) = state.textscript_vm.stack.pop() {
|
|
exec_state = saved_state;
|
|
} else {
|
|
log::warn!("Tried to <POP from TSC stack without saved state!");
|
|
exec_state = TextScriptExecutionState::Ended;
|
|
}
|
|
}
|
|
OpCode::MM0 => {
|
|
game_scene.player1.vel_x = 0;
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::SMP => {
|
|
let pos_x = read_cur_varint(&mut cursor)? as usize;
|
|
let pos_y = read_cur_varint(&mut cursor)? as usize;
|
|
|
|
let tile_type = game_scene.stage.tile_at(pos_x, pos_y);
|
|
game_scene.stage.change_tile(pos_x, pos_y, tile_type.wrapping_sub(1));
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::CMP => {
|
|
let pos_x = read_cur_varint(&mut cursor)? as usize;
|
|
let pos_y = read_cur_varint(&mut cursor)? as usize;
|
|
let tile_type = read_cur_varint(&mut cursor)? as u8;
|
|
|
|
if game_scene.stage.change_tile(pos_x, pos_y, tile_type) {
|
|
let mut npc = NPC::create(4, &state.npc_table);
|
|
npc.cond.set_alive(true);
|
|
npc.x = pos_x as i32 * 0x2000;
|
|
npc.y = pos_y as i32 * 0x2000;
|
|
|
|
let _ = game_scene.npc_list.spawn(0x100, npc.clone());
|
|
let _ = game_scene.npc_list.spawn(0x100, npc);
|
|
}
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::MLp => {
|
|
let life = read_cur_varint(&mut cursor)? as u16;
|
|
game_scene.player1.life += life;
|
|
game_scene.player1.max_life += life;
|
|
game_scene.player2.life += life;
|
|
game_scene.player2.max_life += life;
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::FAC => {
|
|
let face = read_cur_varint(&mut cursor)? as u16;
|
|
state.textscript_vm.face = face;
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::CLR => {
|
|
state.textscript_vm.current_line = TextScriptLine::Line1;
|
|
state.textscript_vm.line_1.clear();
|
|
state.textscript_vm.line_2.clear();
|
|
state.textscript_vm.line_3.clear();
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::MSG | OpCode::MS2 | OpCode::MS3 => {
|
|
state.textscript_vm.current_line = TextScriptLine::Line1;
|
|
state.textscript_vm.line_1.clear();
|
|
state.textscript_vm.line_2.clear();
|
|
state.textscript_vm.line_3.clear();
|
|
state.textscript_vm.flags.set_render(true);
|
|
state.textscript_vm.flags.set_background_visible(op != OpCode::MS2);
|
|
state.textscript_vm.flags.set_fast(state.textscript_vm.flags.perma_fast());
|
|
state.textscript_vm.flags.set_position_top(op != OpCode::MSG);
|
|
if op == OpCode::MS2 {
|
|
state.textscript_vm.face = 0;
|
|
}
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::SAT | OpCode::CAT => {
|
|
state.textscript_vm.flags.set_perma_fast(true);
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
|
|
OpCode::TUR => {
|
|
state.textscript_vm.flags.set_fast(true);
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::CLO => {
|
|
state.textscript_vm.flags.set_render(false);
|
|
state.textscript_vm.flags.set_background_visible(false);
|
|
state.textscript_vm.flags.set_fast(false);
|
|
state.textscript_vm.flags.set_position_top(false);
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::YNJ => {
|
|
let event_no = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
state.sound_manager.play_sfx(5);
|
|
|
|
exec_state = TextScriptExecutionState::WaitConfirmation(
|
|
event,
|
|
cursor.position() as u32,
|
|
event_no,
|
|
16,
|
|
ConfirmSelection::Yes,
|
|
);
|
|
}
|
|
OpCode::NUM => {
|
|
let index = read_cur_varint(&mut cursor)? as usize;
|
|
|
|
if let Some(num) = state.textscript_vm.numbers.get(index) {
|
|
let mut str = num.to_string().chars().collect();
|
|
|
|
match state.textscript_vm.current_line {
|
|
TextScriptLine::Line1 => state.textscript_vm.line_1.append(&mut str),
|
|
TextScriptLine::Line2 => state.textscript_vm.line_2.append(&mut str),
|
|
TextScriptLine::Line3 => state.textscript_vm.line_3.append(&mut str),
|
|
}
|
|
}
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::GIT => {
|
|
let item = read_cur_varint(&mut cursor)? as u16;
|
|
state.textscript_vm.item = item;
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::TRA => {
|
|
let map_id = read_cur_varint(&mut cursor)? as usize;
|
|
let event_num = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
let mut new_scene = GameScene::new(state, ctx, map_id)?;
|
|
|
|
let block_size = new_scene.stage.map.tile_size.as_int() * 0x200;
|
|
let pos_x = read_cur_varint(&mut cursor)? as i32 * block_size;
|
|
let pos_y = read_cur_varint(&mut cursor)? as i32 * block_size;
|
|
|
|
new_scene.intro_mode = game_scene.intro_mode;
|
|
new_scene.inventory_player1 = game_scene.inventory_player1.clone();
|
|
new_scene.inventory_player2 = game_scene.inventory_player2.clone();
|
|
new_scene.player1 = game_scene.player1.clone();
|
|
new_scene.player1.vel_x = 0;
|
|
new_scene.player1.vel_y = 0;
|
|
new_scene.player1.x = pos_x;
|
|
new_scene.player1.y = pos_y;
|
|
new_scene.player2 = game_scene.player2.clone();
|
|
new_scene.player2.vel_x = 0;
|
|
new_scene.player2.vel_y = 0;
|
|
new_scene.player2.x = pos_x;
|
|
new_scene.player2.y = pos_y;
|
|
// Reset player interaction flag upon TRA
|
|
new_scene.player1.cond.set_interacted(false);
|
|
new_scene.player2.cond.set_interacted(false);
|
|
new_scene.frame.wait = game_scene.frame.wait;
|
|
|
|
let skip = state.textscript_vm.flags.cutscene_skip();
|
|
state.control_flags.set_tick_world(true);
|
|
state.control_flags.set_interactions_disabled(true);
|
|
state.textscript_vm.flags.0 = 0;
|
|
state.textscript_vm.flags.set_cutscene_skip(skip);
|
|
state.textscript_vm.face = 0;
|
|
state.textscript_vm.item = 0;
|
|
state.textscript_vm.current_line = TextScriptLine::Line1;
|
|
state.textscript_vm.line_1.clear();
|
|
state.textscript_vm.line_2.clear();
|
|
state.textscript_vm.line_3.clear();
|
|
state.textscript_vm.suspend = true;
|
|
state.next_scene = Some(Box::new(new_scene));
|
|
|
|
log::info!("Transitioning to stage {}, with script #{:04}", map_id, event_num);
|
|
exec_state = TextScriptExecutionState::Running(event_num, 0);
|
|
}
|
|
OpCode::MOV => {
|
|
let block_size = state.tile_size.as_int() * 0x200;
|
|
|
|
let pos_x = read_cur_varint(&mut cursor)? as i32 * block_size;
|
|
let pos_y = read_cur_varint(&mut cursor)? as i32 * block_size;
|
|
|
|
game_scene.player1.cond.set_interacted(false);
|
|
game_scene.player2.cond.set_interacted(false);
|
|
|
|
for player in [&mut game_scene.player1, &mut game_scene.player2].iter_mut() {
|
|
player.vel_x = 0;
|
|
player.vel_y = 0;
|
|
player.x = pos_x;
|
|
player.y = pos_y;
|
|
}
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::S2MV => {
|
|
let param = read_cur_varint(&mut cursor)? as usize;
|
|
|
|
let (executor, partner) = match state.textscript_vm.executor_player {
|
|
TargetPlayer::Player1 => (&game_scene.player1, &mut game_scene.player2),
|
|
TargetPlayer::Player2 => (&game_scene.player2, &mut game_scene.player1),
|
|
};
|
|
|
|
match param {
|
|
0 | 1 => {
|
|
partner.vel_x = 0;
|
|
partner.vel_y = 0;
|
|
partner.x = executor.x + if param == 0 { -0x2000 } else { 0x2000 };
|
|
partner.y = executor.y;
|
|
}
|
|
2..=10 => {
|
|
log::warn!("<2MV unknown param");
|
|
}
|
|
// what the fuck
|
|
i => {
|
|
let distance = i as i32 / 10;
|
|
|
|
partner.vel_x = 0;
|
|
partner.vel_y = 0;
|
|
partner.x =
|
|
executor.x + if (param % 10) == 1 { distance * 0x200 } else { -distance * 0x200 };
|
|
partner.y = executor.y;
|
|
}
|
|
}
|
|
|
|
if partner.cond.alive() && !partner.cond.hidden() {
|
|
let mut npc = NPC::create(4, &state.npc_table);
|
|
npc.cond.set_alive(true);
|
|
npc.x = partner.x;
|
|
npc.y = partner.y;
|
|
|
|
let _ = game_scene.npc_list.spawn(0x100, npc.clone());
|
|
let _ = game_scene.npc_list.spawn(0x100, npc.clone());
|
|
let _ = game_scene.npc_list.spawn(0x100, npc.clone());
|
|
let _ = game_scene.npc_list.spawn(0x100, npc);
|
|
}
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::UNI => {
|
|
let control_mode = read_cur_varint(&mut cursor)? as u8;
|
|
|
|
let mode: Option<ControlMode> = FromPrimitive::from_u8(control_mode);
|
|
if let Some(mode) = mode {
|
|
game_scene.player1.control_mode = mode;
|
|
}
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::FAI => {
|
|
let fade_type = read_cur_varint(&mut cursor)? as usize;
|
|
|
|
if let Some(direction) = FadeDirection::from_int(fade_type) {
|
|
state.fade_state = FadeState::FadeIn(15, direction);
|
|
}
|
|
|
|
exec_state = TextScriptExecutionState::WaitFade(event, cursor.position() as u32);
|
|
}
|
|
OpCode::FAO => {
|
|
let fade_type = read_cur_varint(&mut cursor)? as usize;
|
|
|
|
if let Some(direction) = FadeDirection::from_int(fade_type) {
|
|
state.fade_state = FadeState::FadeOut(-15, direction.opposite());
|
|
}
|
|
|
|
exec_state = TextScriptExecutionState::WaitFade(event, cursor.position() as u32);
|
|
}
|
|
OpCode::QUA => {
|
|
let count = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
state.quake_counter = count;
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::MNA => {
|
|
game_scene.display_map_name(160);
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::CMU => {
|
|
let song_id = read_cur_varint(&mut cursor)? as usize;
|
|
state.sound_manager.play_song(song_id, &state.constants, &state.settings, ctx)?;
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::FMU => {
|
|
state.sound_manager.play_song(0, &state.constants, &state.settings, ctx)?;
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::RMU => {
|
|
state.sound_manager.restore_state()?;
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::SOU => {
|
|
let sound = read_cur_varint(&mut cursor)? as u8;
|
|
|
|
state.sound_manager.play_sfx(sound);
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::DNP => {
|
|
let event_num = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
game_scene.npc_list.remove_by_event(event_num, state);
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::DNA => {
|
|
let npc_remove_type = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
game_scene.npc_list.remove_by_type(npc_remove_type, state);
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::FOB => {
|
|
let part_id = read_cur_varint(&mut cursor)? as u16;
|
|
let ticks = read_cur_varint(&mut cursor)? as i32;
|
|
|
|
game_scene.frame.wait = ticks;
|
|
game_scene.frame.update_target = UpdateTarget::Boss(part_id);
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::FOM => {
|
|
let ticks = read_cur_varint(&mut cursor)? as i32;
|
|
game_scene.frame.wait = ticks;
|
|
game_scene.frame.update_target = UpdateTarget::Player;
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::FON => {
|
|
let event_num = read_cur_varint(&mut cursor)? as u16;
|
|
let ticks = read_cur_varint(&mut cursor)? as i32;
|
|
game_scene.frame.wait = ticks;
|
|
|
|
for npc in game_scene.npc_list.iter() {
|
|
if event_num == npc.event_num {
|
|
game_scene.frame.update_target = UpdateTarget::NPC(npc.id);
|
|
break;
|
|
}
|
|
}
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::BSL => {
|
|
let event_num = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
if event_num == 0 {
|
|
game_scene.boss_life_bar.set_boss_target(&game_scene.boss);
|
|
} else {
|
|
for npc in game_scene.npc_list.iter_alive() {
|
|
if event_num == npc.event_num {
|
|
game_scene.boss_life_bar.set_npc_target(npc.id, &game_scene.npc_list);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::BOA => {
|
|
let action_num = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
game_scene.boss.parts[0].action_num = action_num;
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::ANP => {
|
|
let event_num = read_cur_varint(&mut cursor)? as u16;
|
|
let action_num = read_cur_varint(&mut cursor)? as u16;
|
|
let tsc_direction = read_cur_varint(&mut cursor)? as usize;
|
|
let direction = Direction::from_int_facing(tsc_direction).unwrap_or(Direction::Left);
|
|
|
|
for npc in game_scene.npc_list.iter_alive() {
|
|
if npc.event_num == event_num {
|
|
npc.action_num = action_num;
|
|
npc.tsc_direction = tsc_direction as u16;
|
|
|
|
if direction == Direction::FacingPlayer {
|
|
npc.direction =
|
|
if game_scene.player1.x < npc.x { Direction::Right } else { Direction::Left };
|
|
} else {
|
|
npc.direction = direction;
|
|
}
|
|
}
|
|
}
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::CNP | OpCode::INP => {
|
|
let event_num = read_cur_varint(&mut cursor)? as u16;
|
|
let new_type = read_cur_varint(&mut cursor)? as u16;
|
|
let tsc_direction = read_cur_varint(&mut cursor)? as usize;
|
|
let direction = Direction::from_int_facing(tsc_direction).unwrap_or(Direction::Left);
|
|
|
|
for npc in game_scene.npc_list.iter_alive() {
|
|
if npc.event_num == event_num {
|
|
npc.npc_flags.set_solid_soft(false);
|
|
npc.npc_flags.set_ignore_tile_44(false);
|
|
npc.npc_flags.set_invulnerable(false);
|
|
npc.npc_flags.set_ignore_solidity(false);
|
|
npc.npc_flags.set_bouncy(false);
|
|
npc.npc_flags.set_shootable(false);
|
|
npc.npc_flags.set_solid_hard(false);
|
|
npc.npc_flags.set_rear_and_top_not_hurt(false);
|
|
npc.npc_flags.set_show_damage(false);
|
|
|
|
if op == OpCode::INP {
|
|
npc.npc_flags.set_event_when_touched(true);
|
|
}
|
|
|
|
npc.npc_type = new_type;
|
|
npc.display_bounds = state.npc_table.get_display_bounds(new_type);
|
|
npc.hit_bounds = state.npc_table.get_hit_bounds(new_type);
|
|
let entry = state.npc_table.get_entry(new_type).unwrap().to_owned();
|
|
npc.npc_flags.0 |= entry.npc_flags.0;
|
|
npc.life = entry.life;
|
|
npc.size = entry.size;
|
|
npc.exp = entry.experience as u16;
|
|
npc.damage = entry.damage as u16;
|
|
npc.spritesheet_id = entry.spritesheet_id as u16;
|
|
|
|
npc.cond.set_alive(true);
|
|
npc.action_num = 0;
|
|
npc.action_counter = 0;
|
|
npc.anim_num = 0;
|
|
npc.anim_counter = 0;
|
|
npc.vel_x = 0;
|
|
npc.vel_y = 0;
|
|
npc.tsc_direction = tsc_direction as u16;
|
|
|
|
if direction == Direction::FacingPlayer {
|
|
npc.direction =
|
|
if game_scene.player1.x < npc.x { Direction::Right } else { Direction::Left };
|
|
} else {
|
|
npc.direction = direction;
|
|
}
|
|
|
|
npc.tick(
|
|
state,
|
|
(
|
|
[&mut game_scene.player1, &mut game_scene.player2],
|
|
&game_scene.npc_list,
|
|
&mut game_scene.stage,
|
|
&mut game_scene.bullet_manager,
|
|
&mut game_scene.flash,
|
|
),
|
|
)?;
|
|
}
|
|
}
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::MNP => {
|
|
let event_num = read_cur_varint(&mut cursor)? as u16;
|
|
let x = read_cur_varint(&mut cursor)? as i32;
|
|
let y = read_cur_varint(&mut cursor)? as i32;
|
|
let tsc_direction = read_cur_varint(&mut cursor)? as usize;
|
|
let direction = Direction::from_int_facing(tsc_direction).unwrap_or(Direction::Left);
|
|
let block_size = state.tile_size.as_int() * 0x200;
|
|
|
|
for npc in game_scene.npc_list.iter_alive() {
|
|
if npc.event_num == event_num {
|
|
npc.x = x * block_size;
|
|
npc.y = y * block_size;
|
|
npc.tsc_direction = tsc_direction as u16;
|
|
|
|
if direction == Direction::FacingPlayer {
|
|
npc.direction =
|
|
if game_scene.player1.x < npc.x { Direction::Right } else { Direction::Left };
|
|
} else {
|
|
npc.direction = direction;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::SNP => {
|
|
let npc_type = read_cur_varint(&mut cursor)? as u16;
|
|
let x = read_cur_varint(&mut cursor)? as i32;
|
|
let y = read_cur_varint(&mut cursor)? as i32;
|
|
let tsc_direction = read_cur_varint(&mut cursor)? as usize;
|
|
let direction = Direction::from_int_facing(tsc_direction).unwrap_or(Direction::Left);
|
|
let block_size = state.tile_size.as_int() * 0x200;
|
|
|
|
let mut npc = NPC::create(npc_type, &state.npc_table);
|
|
npc.cond.set_alive(true);
|
|
npc.x = x * block_size;
|
|
npc.y = y * block_size;
|
|
npc.tsc_direction = tsc_direction as u16;
|
|
|
|
if direction == Direction::FacingPlayer {
|
|
npc.direction =
|
|
if game_scene.player1.x < npc.x { Direction::Right } else { Direction::Left };
|
|
} else {
|
|
npc.direction = direction;
|
|
}
|
|
|
|
let _ = game_scene.npc_list.spawn(0x100, npc);
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::LIp => {
|
|
let life = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
game_scene.player1.life = clamp(game_scene.player1.life + life, 0, game_scene.player1.max_life);
|
|
game_scene.player2.life = clamp(game_scene.player2.life + life, 0, game_scene.player2.max_life);
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::ITp => {
|
|
let item_id = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
state.sound_manager.play_sfx(38);
|
|
|
|
if !game_scene.inventory_player1.has_item(item_id) {
|
|
game_scene.inventory_player1.add_item(item_id);
|
|
}
|
|
|
|
if !game_scene.inventory_player2.has_item(item_id) {
|
|
game_scene.inventory_player2.add_item(item_id);
|
|
}
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::IpN => {
|
|
let item_id = read_cur_varint(&mut cursor)? as u16;
|
|
let amount = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
if game_scene.inventory_player1.has_item_amount(item_id, Ordering::Less, amount) {
|
|
game_scene.inventory_player1.add_item(item_id);
|
|
}
|
|
|
|
if game_scene.inventory_player2.has_item_amount(item_id, Ordering::Less, amount) {
|
|
game_scene.inventory_player2.add_item(item_id);
|
|
}
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::ITm => {
|
|
let item_id = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
game_scene.inventory_player1.consume_item(item_id);
|
|
game_scene.inventory_player2.consume_item(item_id);
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::AMp => {
|
|
let weapon_id = read_cur_varint(&mut cursor)? as u8;
|
|
let max_ammo = read_cur_varint(&mut cursor)? as u16;
|
|
let weapon_type: Option<WeaponType> = FromPrimitive::from_u8(weapon_id);
|
|
|
|
state.textscript_vm.numbers[0] = max_ammo;
|
|
|
|
if let Some(wtype) = weapon_type {
|
|
game_scene.inventory_player1.add_weapon(wtype, max_ammo);
|
|
game_scene.inventory_player2.add_weapon(wtype, max_ammo);
|
|
}
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::AMm => {
|
|
let weapon_id = read_cur_varint(&mut cursor)? as u8;
|
|
let weapon_type: Option<WeaponType> = FromPrimitive::from_u8(weapon_id);
|
|
|
|
if let Some(wtype) = weapon_type {
|
|
game_scene.inventory_player1.remove_weapon(wtype);
|
|
game_scene.inventory_player2.remove_weapon(wtype);
|
|
}
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::AEp => {
|
|
game_scene.inventory_player1.refill_all_ammo();
|
|
game_scene.inventory_player2.refill_all_ammo();
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::TAM => {
|
|
let old_weapon_id = read_cur_varint(&mut cursor)? as u8;
|
|
let new_weapon_id = read_cur_varint(&mut cursor)? as u8;
|
|
let max_ammo = read_cur_varint(&mut cursor)? as u16;
|
|
let old_weapon_type: Option<WeaponType> = FromPrimitive::from_u8(old_weapon_id);
|
|
let new_weapon_type: Option<WeaponType> = FromPrimitive::from_u8(new_weapon_id);
|
|
|
|
if let Some(wtype) = new_weapon_type {
|
|
game_scene.inventory_player1.trade_weapon(old_weapon_type, wtype, max_ammo);
|
|
game_scene.inventory_player2.trade_weapon(old_weapon_type, wtype, max_ammo);
|
|
}
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::ZAM => {
|
|
game_scene.inventory_player1.reset_all_weapon_xp();
|
|
game_scene.inventory_player2.reset_all_weapon_xp();
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::EQp => {
|
|
let mask = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
game_scene.player1.equip.0 |= mask;
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::EQm => {
|
|
let mask = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
game_scene.player1.equip.0 &= !mask;
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::FLA => {
|
|
game_scene.flash.set_blink();
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::INI => {
|
|
exec_state = TextScriptExecutionState::Reset;
|
|
}
|
|
OpCode::ESC => {
|
|
state.next_scene = Some(Box::new(TitleScene::new()));
|
|
state.control_flags.set_tick_world(false);
|
|
state.control_flags.set_control_enabled(false);
|
|
state.control_flags.set_interactions_disabled(true);
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
OpCode::SVP => {
|
|
exec_state = TextScriptExecutionState::SaveProfile(event, cursor.position() as u32);
|
|
}
|
|
OpCode::LDP => {
|
|
state.control_flags.set_tick_world(false);
|
|
state.control_flags.set_control_enabled(false);
|
|
state.control_flags.set_interactions_disabled(true);
|
|
|
|
exec_state = TextScriptExecutionState::LoadProfile;
|
|
}
|
|
OpCode::MPp => {
|
|
let stage_id = read_cur_varint(&mut cursor)? as u16;
|
|
|
|
state.set_map_flag(stage_id as usize, true);
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
// unimplemented opcodes
|
|
// Zero operands
|
|
OpCode::CIL
|
|
| OpCode::CPS
|
|
| OpCode::KE2
|
|
| OpCode::CRE
|
|
| OpCode::CSS
|
|
| OpCode::MLP
|
|
| OpCode::SPS
|
|
| OpCode::FR2
|
|
| OpCode::STC
|
|
| OpCode::HM2 => {
|
|
log::warn!("unimplemented opcode: {:?}", op);
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
// One operand codes
|
|
OpCode::UNJ | OpCode::XX1 | OpCode::SIL | OpCode::SSS | OpCode::ACH => {
|
|
let par_a = read_cur_varint(&mut cursor)?;
|
|
|
|
log::warn!("unimplemented opcode: {:?} {}", op, par_a);
|
|
|
|
exec_state = TextScriptExecutionState::Running(event, cursor.position() as u32);
|
|
}
|
|
}
|
|
} else {
|
|
exec_state = TextScriptExecutionState::Ended;
|
|
}
|
|
} else {
|
|
return Ok(TextScriptExecutionState::Ended);
|
|
}
|
|
|
|
Ok(exec_state)
|
|
}
|
|
}
|
|
|
|
pub struct TextScript {
|
|
pub(in crate::scripting::tsc) event_map: HashMap<u16, Vec<u8>>,
|
|
}
|
|
|
|
impl Clone for TextScript {
|
|
fn clone(&self) -> Self {
|
|
Self { event_map: self.event_map.clone() }
|
|
}
|
|
}
|
|
|
|
impl Default for TextScript {
|
|
fn default() -> Self {
|
|
TextScript::new()
|
|
}
|
|
}
|
|
|
|
impl TextScript {
|
|
pub fn new() -> TextScript {
|
|
Self { event_map: HashMap::new() }
|
|
}
|
|
|
|
/// Loads, decrypts and compiles a text script from specified stream.
|
|
pub fn load_from<R: io::Read>(mut data: R, constants: &EngineConstants) -> GameResult<TextScript> {
|
|
let mut buf = Vec::new();
|
|
data.read_to_end(&mut buf)?;
|
|
|
|
if constants.textscript.encrypted {
|
|
let half = buf.len() / 2;
|
|
let key = if let Some(0) = buf.get(half) { 0xf9 } else { (-(*buf.get(half).unwrap() as isize)) as u8 };
|
|
log::info!("Decrypting TSC using key {:#x}", key);
|
|
|
|
for (idx, byte) in buf.iter_mut().enumerate() {
|
|
if idx == half {
|
|
continue;
|
|
}
|
|
|
|
*byte = byte.wrapping_add(key);
|
|
}
|
|
}
|
|
|
|
TextScript::compile(&buf, false, constants.textscript.encoding)
|
|
}
|
|
|
|
pub fn get_event_ids(&self) -> Vec<u16> {
|
|
let mut vec: Vec<u16> = self.event_map.keys().copied().collect();
|
|
vec.sort();
|
|
vec
|
|
}
|
|
|
|
pub fn has_event(&self, id: u16) -> bool {
|
|
self.event_map.contains_key(&id)
|
|
}
|
|
}
|