use super::scene_helper::*;
use babalcore::*;
use gdnative::api::GridMap;
use gdnative::api::Performance;
use gdnative::prelude::*;
#[derive(NativeClass)]
#[inherit(Spatial)]
pub struct Tunnel {
data: Option<Data>,
template: Option<Ref<PackedScene, ThreadLocal>>,
grid_scale: Vector3,
level_row: isize,
level_col: isize,
player_position: Vector3,
player_best_row: isize,
player_last_col: isize,
player_last_col_acc: f64,
fall_state: bool,
boost_state: bool,
now_sec: f64,
far_view: isize,
time_since_last_adjust_far_view: f64,
}
struct Data {
level: Level,
rail_resource_name: String,
}
const LENGTH_MARGIN: usize = 100;
const LEVEL_LENGTH: usize = 10000;
const SLAB_SIZE: f32 = 1.0;
const RAIL_OFFSET: isize = 2;
const RAIL_FAR_VIEW_INIT: isize = 25;
const RAIL_FAR_VIEW_MAX: isize = 45;
const RAIL_FAR_VIEW_MIN: isize = 15;
const ADJUST_FAR_VIEW_DELAY: f64 = 0.5;
const FPS_TARGET: f64 = 55.0;
const SLAB_RATIO: f64 = 3.0;
const MATERIAL_FLAVORS: usize = 10;
const PLAYER_LAST_COL_PERIOD: f64 = 0.5;
#[methods]
impl Tunnel {
fn new(_owner: &Spatial) -> Self {
Tunnel {
data: None,
template: None,
grid_scale: Vector3::new(1.0, 1.0, 1.0),
level_row: 0,
level_col: 0,
player_position: Vector3::default(),
player_best_row: 0,
player_last_col: -1,
player_last_col_acc: 1.0,
fall_state: false,
boost_state: false,
now_sec: 0.0,
far_view: RAIL_FAR_VIEW_INIT,
time_since_last_adjust_far_view: 0.0,
}
}
#[export]
fn _ready(&self, _owner: &Spatial) {
godot_print!("Tunnel is ready.");
}
#[export]
fn _process(&mut self, owner: &Spatial, delta: f64) {
self.now_sec += delta;
self.player_last_col_acc += delta / PLAYER_LAST_COL_PERIOD;
self.adjust_far_view(owner, delta);
self.sync(owner);
}
#[export]
fn setup(
&mut self,
owner: &Spatial,
rail_resource_name: GodotString,
skill: GodotString,
seed: u64,
) {
let skill = Skill::from_str(skill.to_string().as_str());
godot_print!("Tunnel setup {}x{}.", skill.width(), LEVEL_LENGTH);
let mut level = Level::new(seed, skill);
Self::generate_missing(&mut level, 0);
let data = Data {
level,
rail_resource_name: rail_resource_name.to_string(),
};
self.template = load_scene(data.rail_resource_name.as_str());
match &self.template {
Some(_) => godot_print!(
"Loaded template rail scene \"{}\".",
data.rail_resource_name
),
None => godot_print!(
"Unable to load rail scene \"{}\", please check name.",
data.rail_resource_name
),
};
self.data = Some(data);
self.remove_all_children(owner);
self.add_all_rails(owner);
match self.get_grid_scale(owner) {
Ok(mut scale) => {
scale.z = Self::calc_scale_z(skill.width());
match self.set_grid_scale(owner, scale) {
Ok(_) => {}
Err(e) => godot_print!("unable to set grid scale: {}", e),
}
self.grid_scale = scale;
}
Err(e) => godot_print!("unable to get grid scale: {}", e),
}
self.sync(owner);
}
fn calc_scale_z(width: usize) -> f32 {
(2.0 * std::f64::consts::PI * SLAB_RATIO as f64 / width as f64) as f32
}
fn generate_missing(level: &mut Level, row: isize) {
while level.last() < row + (LENGTH_MARGIN as isize) {
level.generate(LENGTH_MARGIN);
}
}
#[export]
fn remove_last_child(&mut self, owner: &Spatial) -> bool {
let num_children = owner.get_child_count();
if num_children <= 0 {
return false;
}
let last_child = owner.get_child(num_children - 1);
if let Some(node) = last_child {
owner.remove_child(node);
unsafe {
node.assume_safe().queue_free();
}
}
return num_children == owner.get_child_count() + 1;
}
#[export]
fn remove_all_children(&mut self, owner: &Spatial) -> usize {
let mut removed: usize = 0;
while self.remove_last_child(owner) {
removed += 1;
}
removed
}
fn prepare_rail_grid(&self, grid: &Spatial, n: usize) {
let w: f32 = SLAB_SIZE * std::f32::consts::PI * 2f32 / n as f32;
let mut translation = grid.translation();
translation.x = -w / 2f32;
grid.set_translation(translation);
let mut scale = grid.scale();
scale.x = w;
grid.set_scale(scale);
}
fn prepare_rail(&self, rail: &Spatial, i: usize, n: usize) {
let key_str = format!("rail_{}", i);
rail.set_name(&key_str);
let angle: f64 = i as f64 * 360f64 / n as f64;
rail.rotate_z(angle * std::f64::consts::PI / 180f64);
let num_children = rail.get_child_count();
if num_children != 1 {
godot_print!("Unexpected number of children for rail: {}.", num_children);
return;
}
let child = rail.get_child(0);
if let Some(grid) = child {
let grid = unsafe { grid.assume_safe() };
if let Some(grid) = grid.cast::<Spatial>() {
self.prepare_rail_grid(&grid, n);
}
}
}
#[export]
fn add_one_rail(&mut self, owner: &Spatial, i: usize, n: usize) -> bool {
match &self.template {
Some(template) => match instanciate_scene::<Spatial>(template) {
Ok(spatial) => {
self.prepare_rail(&spatial, i, n);
owner.add_child(spatial.into_shared(), false);
true
}
Err(err) => {
godot_print!("Could not instanciate rail scene: \"{:?}\".", err);
false
}
},
None => false,
}
}
#[export]
fn add_all_rails(&mut self, owner: &Spatial) -> usize {
match &self.data {
Some(data) => {
let mut added: usize = 0;
let width = data.level.width();
if width == 0 {
return 0;
}
for i in 0..width {
if !self.add_one_rail(owner, i, width) {
break;
}
added += 1;
}
added
}
None => 0,
}
}
fn get_grid_scale(&self, owner: &Spatial) -> Result<Vector3, String> {
let num_children = owner.get_child_count() as usize;
if num_children == 0 {
return Err(format!("Please setup tunnel"));
}
match owner.get_child(0) {
Some(rail) => {
let rail = unsafe { rail.assume_safe() };
match rail.cast::<Spatial>() {
Some(rail) => match rail.get_child(0) {
Some(grid) => {
let grid = unsafe { grid.assume_safe() };
match grid.cast::<GridMap>() {
Some(grid) => return Ok(grid.scale()),
None => Err(format!("Unable to cast child of rail to GridMap.")),
}
}
None => Err(format!("rail has no child")),
},
None => Err(format!("rail is not spatial")),
}
}
None => Err(format!("tunnel has no child")),
}
}
fn set_grid_scale(&self, owner: &Spatial, scale: Vector3) -> Result<(), String> {
let num_children = owner.get_child_count() as usize;
if num_children == 0 {
return Err(format!("Please setup tunnel"));
}
for i in 0..(num_children as isize) {
let child = owner.get_child(i as i64);
if let Some(rail) = child {
let rail = unsafe { rail.assume_safe() };
match rail.cast::<Spatial>() {
Some(rail) => match rail.get_child(0) {
Some(grid) => {
let grid = unsafe { grid.assume_safe() };
match grid.cast::<GridMap>() {
Some(grid) => {
let mut translation = grid.translation();
translation.z = -scale.z / 2.0;
grid.set_translation(translation);
grid.set_scale(scale);
}
None => {
return Err(format!("Unable to cast child of rail to GridMap."))
}
}
}
None => return Err(format!("rail has no child")),
},
None => return Err(format!("rail is not spatial")),
}
}
}
return Ok(());
}
#[export]
fn get_max_item(&self, _owner: &Spatial) -> i64 {
babalcore::MAX_ITEM as i64
}
#[export]
fn get_material_flavors(&self, _owner: &Spatial) -> i64 {
MATERIAL_FLAVORS as i64
}
fn sync_rail_grid(&mut self, rail: &GridMap, col: isize) -> bool {
rail.clear();
let n = match rail.mesh_library() {
Some(mesh_library) => {
let mesh_library = unsafe { mesh_library.assume_safe() };
mesh_library.get_last_unused_item_id()
}
None => 0,
};
if n != (babalcore::MAX_ITEM * MATERIAL_FLAVORS) as i64 {
godot_print!(
"wrong number of items in rail grid, should be {} and got {}",
babalcore::MAX_ITEM * MATERIAL_FLAVORS,
n
);
return false;
}
match &mut self.data {
Some(data) => {
data.level.set_now_sec(self.now_sec);
let start = -RAIL_OFFSET;
let end = std::cmp::min(
start + data.level.len() as isize,
RAIL_OFFSET + self.far_view,
);
for row in start..end {
let mut kind =
data.level
.slab_kind(col, row + self.level_row, self.boost_state);
if self.level_col == col
&& self.player_position.y == 0.0
&& row == 0
&& kind != SlabKind::Void
{
kind = SlabKind::HighLight;
}
if self.fall_state
&& row + self.level_row == self.player_best_row
&& self.player_best_row > 0
&& kind != SlabKind::Void
{
kind = SlabKind::HighLight;
}
let mut item = kind.as_item();
if item >= 0 {
if self.level_col == col && MATERIAL_FLAVORS > 1 {
let blend = babalcore::fade_out(self.player_last_col_acc);
let cat = std::cmp::min(
(blend * (MATERIAL_FLAVORS as f64)).floor() as usize,
MATERIAL_FLAVORS - 1,
);
let offset = (babalcore::MAX_ITEM * cat) as i64;
item += offset;
}
let orientation = 0;
rail.set_cell_item(0, 0, (RAIL_OFFSET - 2 - row) as i64, item, orientation);
}
}
true
}
None => false,
}
}
fn adjust_far_view(&mut self, _owner: &Spatial, delta: f64) {
self.time_since_last_adjust_far_view += delta;
if self.time_since_last_adjust_far_view < ADJUST_FAR_VIEW_DELAY {
return;
}
self.time_since_last_adjust_far_view = 0.0;
let perf = Performance::godot_singleton();
let fps = perf.get_monitor(Performance::TIME_FPS);
if fps < FPS_TARGET && self.far_view > RAIL_FAR_VIEW_MIN {
self.far_view -= 1;
godot_print!("Decreasing far view to {}", self.far_view);
}
if fps > FPS_TARGET && self.far_view < RAIL_FAR_VIEW_MAX {
self.far_view += 1;
godot_print!("Increasing far view to {}", self.far_view);
}
}
#[export]
fn sync(&mut self, owner: &Spatial) -> bool {
match &mut self.data {
Some(data) => {
Self::generate_missing(&mut data.level, self.level_row);
let num_children = owner.get_child_count() as usize;
let width = data.level.width();
if num_children == 0 {
godot_print!("Please setup tunnel");
return false;
}
if num_children != (data.level.width()) {
godot_print!("Wrong number of rails: {} != {}.", num_children, width);
return false;
}
for i in 0..(num_children as isize) {
let child = owner.get_child(i as i64);
if let Some(rail) = child {
let rail = unsafe { rail.assume_safe() };
match rail.cast::<Spatial>() {
Some(rail) => {
let child = rail.get_child(0);
if let Some(grid) = child {
let grid = unsafe { grid.assume_safe() };
match grid.cast::<GridMap>() {
Some(grid) => {
self.sync_rail_grid(&grid, i);
}
None => {
godot_print!(
"Unable to cast child of rail to GridMap.",
);
}
}
}
}
None => {
godot_print!("Unable to cast child of rail to Spatial.",);
}
}
}
}
true
}
None => false,
}
}
#[export]
fn update_player_position(&mut self, owner: &Spatial, pos: Vector3) {
let mut rotation = owner.rotation();
rotation.z = pos.x;
owner.set_rotation(rotation);
let mut translation = owner.translation();
translation.z = pos.z * self.grid_scale.z;
owner.set_translation(translation);
self.player_position = pos;
}
#[export]
fn set_fall_state(&mut self, _owner: &Spatial, fall_state: bool) {
self.fall_state = fall_state;
}
#[export]
fn fall_state(&mut self, _owner: &Spatial) -> bool {
self.fall_state
}
#[export]
fn set_boost_state(&mut self, _owner: &Spatial, boost_state: bool) {
self.boost_state = boost_state;
}
#[export]
fn boost_state(&mut self, _owner: &Spatial) -> bool {
self.boost_state
}
#[export]
fn set_level_row(&mut self, _owner: &Spatial, level_row: isize) {
self.level_row = level_row;
if self.player_best_row < level_row {
self.player_best_row = level_row;
}
}
#[export]
fn set_level_col(&mut self, _owner: &Spatial, level_col: isize) {
self.level_col = level_col;
if self.player_last_col != level_col {
self.player_last_col = level_col;
self.player_last_col_acc = 0.0;
}
}
#[export]
pub fn width(&self, _owner: &Spatial) -> usize {
match &self.data {
Some(data) => data.level.width(),
None => 0,
}
}
#[export]
pub fn len(&self, _owner: &Spatial) -> usize {
match &self.data {
Some(data) => data.level.len(),
None => 0,
}
}
#[export]
pub fn first(&self, _owner: &Spatial) -> isize {
match &self.data {
Some(data) => data.level.first(),
None => 0,
}
}
#[export]
pub fn last(&self, _owner: &Spatial) -> isize {
match &self.data {
Some(data) => data.level.last(),
None => 0,
}
}
#[export]
pub fn item(&self, _owner: &Spatial, col: isize, row: isize, boost: bool) -> i64 {
match &self.data {
Some(data) => data.level.item(col, row, boost),
None => 0,
}
}
#[export]
pub fn find_start_spot(
&self,
_owner: &Spatial,
col: isize,
row: isize,
) -> Option<(isize, isize)> {
match &self.data {
Some(data) => data.level.find_start_spot(col, row),
None => None,
}
}
#[export]
pub fn skill(&self, _owner: &Spatial) -> GodotString {
let skill = match &self.data {
Some(data) => data.level.skill(),
None => Skill::default(),
};
GodotString::from_str(skill.as_str())
}
}