349 lines
10 KiB
Rust
349 lines
10 KiB
Rust
#[macro_use]
|
|
extern crate log;
|
|
#[cfg_attr(feature = "scripting", macro_use)]
|
|
#[cfg(feature = "scripting")]
|
|
extern crate lua_ffi;
|
|
extern crate strum;
|
|
#[macro_use]
|
|
extern crate strum_macros;
|
|
|
|
use std::cell::UnsafeCell;
|
|
use std::env;
|
|
use std::path::PathBuf;
|
|
use std::time::Instant;
|
|
|
|
use directories::ProjectDirs;
|
|
use log::*;
|
|
use pretty_env_logger::env_logger::Env;
|
|
|
|
use crate::builtin_fs::BuiltinFS;
|
|
use crate::framework::context::Context;
|
|
use crate::framework::error::{GameError, GameResult};
|
|
use crate::framework::filesystem::{mount_user_vfs, mount_vfs};
|
|
use crate::framework::graphics;
|
|
use crate::framework::ui::UI;
|
|
use crate::framework::vfs::PhysicalFS;
|
|
use crate::scene::loading_scene::LoadingScene;
|
|
use crate::scene::Scene;
|
|
use crate::shared_game_state::{SharedGameState, TimingMode};
|
|
use crate::texture_set::{G_MAG, I_MAG};
|
|
|
|
mod bmfont;
|
|
mod bmfont_renderer;
|
|
mod builtin_fs;
|
|
mod bullet;
|
|
mod caret;
|
|
mod common;
|
|
mod components;
|
|
mod difficulty_modifier;
|
|
mod encoding;
|
|
mod engine_constants;
|
|
mod entity;
|
|
mod frame;
|
|
mod framework;
|
|
mod input;
|
|
mod inventory;
|
|
mod live_debugger;
|
|
mod macros;
|
|
mod map;
|
|
mod menu;
|
|
mod npc;
|
|
mod physics;
|
|
mod player;
|
|
mod profile;
|
|
mod rng;
|
|
mod scene;
|
|
#[cfg(feature = "scripting")]
|
|
mod scripting;
|
|
mod settings;
|
|
#[cfg(feature = "backend-gfx")]
|
|
mod shaders;
|
|
mod shared_game_state;
|
|
mod sound;
|
|
mod stage;
|
|
mod text_script;
|
|
mod texture_set;
|
|
mod weapon;
|
|
|
|
pub struct Game {
|
|
scene: Option<Box<dyn Scene>>,
|
|
state: UnsafeCell<SharedGameState>,
|
|
ui: UI,
|
|
start_time: Instant,
|
|
last_tick: u128,
|
|
next_tick: u128,
|
|
loops: u64,
|
|
}
|
|
|
|
impl Game {
|
|
fn new(ctx: &mut Context) -> GameResult<Game> {
|
|
let s = Game {
|
|
scene: None,
|
|
ui: UI::new(ctx)?,
|
|
state: UnsafeCell::new(SharedGameState::new(ctx)?),
|
|
start_time: Instant::now(),
|
|
last_tick: 0,
|
|
next_tick: 0,
|
|
loops: 0,
|
|
};
|
|
|
|
Ok(s)
|
|
}
|
|
|
|
fn update(&mut self, ctx: &mut Context) -> GameResult {
|
|
if let Some(scene) = self.scene.as_mut() {
|
|
let state_ref = unsafe { &mut *self.state.get() };
|
|
|
|
match state_ref.timing_mode {
|
|
TimingMode::_50Hz | TimingMode::_60Hz => {
|
|
let last_tick = self.next_tick;
|
|
|
|
while self.start_time.elapsed().as_nanos() >= self.next_tick && self.loops < 10
|
|
{
|
|
if (state_ref.settings.speed - 1.0).abs() < 0.01 {
|
|
self.next_tick += state_ref.timing_mode.get_delta() as u128;
|
|
} else {
|
|
self.next_tick += (state_ref.timing_mode.get_delta() as f64
|
|
/ state_ref.settings.speed)
|
|
as u128;
|
|
}
|
|
self.loops += 1;
|
|
}
|
|
|
|
if self.loops == 10 {
|
|
log::warn!("Frame skip is way too high, a long system lag occurred?");
|
|
self.last_tick = self.start_time.elapsed().as_nanos();
|
|
self.next_tick = self.last_tick
|
|
+ (state_ref.timing_mode.get_delta() as f64 / state_ref.settings.speed)
|
|
as u128;
|
|
self.loops = 0;
|
|
}
|
|
|
|
if self.loops != 0 {
|
|
scene.draw_tick(state_ref)?;
|
|
self.last_tick = last_tick;
|
|
}
|
|
|
|
for _ in 0..self.loops {
|
|
scene.tick(state_ref, ctx)?;
|
|
}
|
|
}
|
|
TimingMode::FrameSynchronized => {
|
|
scene.tick(state_ref, ctx)?;
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn draw(&mut self, ctx: &mut Context) -> GameResult {
|
|
let state_ref = unsafe { &mut *self.state.get() };
|
|
|
|
if state_ref.timing_mode != TimingMode::FrameSynchronized {
|
|
let mut elapsed = self.start_time.elapsed().as_nanos();
|
|
#[cfg(target_os = "windows")]
|
|
{
|
|
// Even with the non-monotonic Instant mitigation at the start of the event loop, there's still a chance of it not working.
|
|
// This check here should trigger if that happens and makes sure there's no panic from an underflow.
|
|
if elapsed < self.last_tick {
|
|
elapsed = self.last_tick;
|
|
}
|
|
}
|
|
let n1 = (elapsed - self.last_tick) as f64;
|
|
let n2 = (self.next_tick - self.last_tick) as f64;
|
|
state_ref.frame_time = if state_ref.settings.motion_interpolation {
|
|
n1 / n2
|
|
} else {
|
|
1.0
|
|
};
|
|
}
|
|
unsafe {
|
|
G_MAG = if state_ref.settings.subpixel_coords {
|
|
state_ref.scale
|
|
} else {
|
|
1.0
|
|
};
|
|
I_MAG = state_ref.scale;
|
|
}
|
|
self.loops = 0;
|
|
|
|
graphics::clear(ctx, [0.0, 0.0, 0.0, 1.0].into());
|
|
/*graphics::set_projection(ctx, DrawParam::new()
|
|
.scale(Vec2::new(state_ref.scale, state_ref.scale))
|
|
.to_matrix());*/
|
|
|
|
if let Some(scene) = self.scene.as_mut() {
|
|
scene.draw(state_ref, ctx)?;
|
|
if state_ref.settings.touch_controls {
|
|
state_ref.touch_controls.draw(
|
|
state_ref.canvas_size,
|
|
&state_ref.constants,
|
|
&mut state_ref.texture_set,
|
|
ctx,
|
|
)?;
|
|
}
|
|
|
|
//graphics::set_projection(ctx, self.def_matrix);
|
|
self.ui.draw(state_ref, ctx, scene)?;
|
|
}
|
|
|
|
graphics::present(ctx)?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[cfg(target_os = "android")]
|
|
fn request_perms() -> GameResult {
|
|
use jni::objects::JObject;
|
|
use jni::objects::JValue;
|
|
|
|
let native_activity = ndk_glue::native_activity();
|
|
let vm_ptr = native_activity.vm();
|
|
let vm = unsafe { jni::JavaVM::from_raw(vm_ptr) }?;
|
|
let vm_env = vm.attach_current_thread()?;
|
|
|
|
fn perm_name<'a, 'b, 'c>(
|
|
vm_env: &'b jni::AttachGuard<'a>,
|
|
name: &'c str,
|
|
) -> GameResult<jni::objects::JValue<'a>> {
|
|
let class = vm_env.find_class("android/Manifest$permission")?;
|
|
Ok(vm_env.get_static_field(class, name.to_owned(), "Ljava/lang/String;")?)
|
|
}
|
|
|
|
fn has_permission(
|
|
vm_env: &jni::AttachGuard,
|
|
activity: &jni::sys::jobject,
|
|
name: &str,
|
|
) -> GameResult<bool> {
|
|
let perm_granted = {
|
|
let class = vm_env.find_class("android/content/pm/PackageManager")?;
|
|
vm_env
|
|
.get_static_field(class, "PERMISSION_GRANTED", "I")?
|
|
.i()?
|
|
};
|
|
|
|
let perm = perm_name(vm_env, name)?;
|
|
let activity_obj = JObject::from(*activity);
|
|
let result = vm_env
|
|
.call_method(
|
|
activity_obj,
|
|
"checkSelfPermission",
|
|
"(Ljava/lang/String;)I",
|
|
&[perm],
|
|
)?
|
|
.i()?;
|
|
Ok(result == perm_granted)
|
|
}
|
|
|
|
let str_class = vm_env.find_class("java/lang/String")?;
|
|
let array = vm_env.new_object_array(2, str_class, JObject::null())?;
|
|
vm_env.set_object_array_element(array, 0, perm_name(&vm_env, "READ_EXTERNAL_STORAGE")?.l()?)?;
|
|
vm_env.set_object_array_element(
|
|
array,
|
|
1,
|
|
perm_name(&vm_env, "WRITE_EXTERNAL_STORAGE")?.l()?,
|
|
)?;
|
|
let activity_obj = JObject::from(native_activity.activity());
|
|
|
|
loop {
|
|
if has_permission(
|
|
&vm_env,
|
|
&native_activity.activity(),
|
|
"READ_EXTERNAL_STORAGE",
|
|
)? && has_permission(
|
|
&vm_env,
|
|
&native_activity.activity(),
|
|
"WRITE_EXTERNAL_STORAGE",
|
|
)? {
|
|
break;
|
|
}
|
|
|
|
vm_env.call_method(
|
|
activity_obj,
|
|
"requestPermissions",
|
|
"([Ljava/lang/String;I)V",
|
|
&[JValue::from(array), JValue::from(0)],
|
|
)?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(target_os = "android")]
|
|
#[cfg_attr(target_os = "android", ndk_glue::main(backtrace = "on"))]
|
|
pub fn android_main() {
|
|
println!("main invoked.");
|
|
|
|
request_perms().expect("Failed to attach to the JVM and request storage permissions.");
|
|
|
|
env::set_var("CAVESTORY_DATA_DIR", "/sdcard/doukutsu");
|
|
|
|
let _ = std::fs::create_dir("/sdcard/doukutsu/");
|
|
let _ = std::fs::write("/sdcard/doukutsu/.nomedia", b"");
|
|
|
|
init().unwrap();
|
|
}
|
|
|
|
pub fn init() -> GameResult {
|
|
pretty_env_logger::env_logger::from_env(Env::default().default_filter_or("info")).init();
|
|
|
|
let resource_dir = if let Ok(data_dir) = env::var("CAVESTORY_DATA_DIR") {
|
|
PathBuf::from(data_dir)
|
|
} else {
|
|
let mut resource_dir = env::current_exe()?;
|
|
if resource_dir.file_name().is_some() {
|
|
let _ = resource_dir.pop();
|
|
}
|
|
resource_dir.push("data");
|
|
resource_dir
|
|
};
|
|
|
|
info!("Resource directory: {:?}", resource_dir);
|
|
info!("Initializing engine...");
|
|
|
|
let mut context = Context::new();
|
|
mount_vfs(&mut context, Box::new(BuiltinFS::new()));
|
|
mount_vfs(&mut context, Box::new(PhysicalFS::new(&resource_dir, true)));
|
|
|
|
#[cfg(not(target_os = "android"))]
|
|
let project_dirs = match ProjectDirs::from("", "", "doukutsu-rs") {
|
|
Some(dirs) => dirs,
|
|
None => {
|
|
return Err(GameError::FilesystemError(String::from(
|
|
"No valid home directory path could be retrieved.",
|
|
)));
|
|
}
|
|
};
|
|
mount_user_vfs(
|
|
&mut context,
|
|
Box::new(PhysicalFS::new(project_dirs.data_local_dir(), false)),
|
|
);
|
|
|
|
#[cfg(target_os = "android")]
|
|
{
|
|
loop {
|
|
match ndk_glue::native_window().as_ref() {
|
|
Some(_) => {
|
|
println!("NativeScreen Found:{:?}", ndk_glue::native_window());
|
|
break;
|
|
}
|
|
None => (),
|
|
}
|
|
}
|
|
}
|
|
|
|
let mut game = Game::new(&mut context)?;
|
|
let state_ref = unsafe { &mut *game.state.get() };
|
|
#[cfg(feature = "scripting")]
|
|
{
|
|
state_ref
|
|
.lua
|
|
.update_refs(game.state.get(), &mut context as *mut Context);
|
|
}
|
|
|
|
state_ref.next_scene = Some(Box::new(LoadingScene::new()));
|
|
context.run(&mut game)?;
|
|
|
|
Ok(())
|
|
}
|