game: balance and debug improvements

- Increased starting money to 100 for better early game progression
- Rebalanced tile processing intervals for better gameplay flow
- Added debug logging for item animation system
- Reorganized router tile processing logic
- Updated tile pricing structure

Author: VexarCoding

src/main.rs

@@ -109,7 +109,7 @@ fn setup_resources(mut commands: Commands) {
                 tick_timer: Timer::from_seconds(TICK_LENGTH, TimerMode::Repeating),
                 tick_count: 0,
                 actions: Vec::new(),
-                money: 30,
+                money: 100,
             });
             commands.insert_resource(Hotkeys::default());
         }

src/resources.rs

@@ -148,13 +148,7 @@ impl WorldRes {
                                 direction: conveyor.direction,
                                 item: conveyor.item,
                             }
-                        } else if let Some(router) = tile.as_any().downcast_ref::<Router>() {
-                            SerializableTile::Router {
-                                position: router.position,
-                                direction: router.direction,
-                                item: router.item,
-                                last_output: router.last_output,
-                            }
+
                         } else if let Some(extractor) = tile.as_any().downcast_ref::<Extractor>() {
                             SerializableTile::Extractor {
                                 position: extractor.position,
@@ -190,6 +184,13 @@ impl WorldRes {
                                 ticks: core.ticks,
                                 tile_id: core.tile_id,
                             }
+                        } else if let Some(router) = tile.as_any().downcast_ref::<Router>() {
+                            SerializableTile::Router {
+                                position: router.position,
+                                direction: router.direction,
+                                item: router.item,
+                                last_output: router.last_output,
+                            }
                         } else {
                             SerializableTile::Conveyor {
                                 position: *pos,
@@ -249,17 +250,7 @@ impl WorldRes {
                     direction,
                     item,
                 }),
-                SerializableTile::Router {
-                    position,
-                    direction,
-                    item,
-                    last_output,
-                } => Box::new(Router {
-                    position,
-                    direction,
-                    item,
-                    last_output,
-                }),
+
                 SerializableTile::Extractor {
                     position,
                     direction,
@@ -300,6 +291,17 @@ impl WorldRes {
                     inventory,
                 }),
                 SerializableTile::Portal { position, item } => Box::new(Portal { position, item }),
+                SerializableTile::Router {
+                    position,
+                    direction,
+                    item,
+                    last_output,
+                } => Box::new(Router {
+                    position,
+                    direction,
+                    item,
+                    last_output,
+                }),
                 SerializableTile::Junction {
                     position,
                     horizontal_item,

src/systems/items.rs

@@ -44,6 +44,8 @@ pub fn spawn_animations(
                 }
             }
         }
+        println!("Initial empty_positions: {:?}", empty_positions);
+        println!("Initial filled_positions: {:?}", filled_positions);
 
         for action in &world.actions {
             match action {
@@ -67,6 +69,10 @@ pub fn spawn_animations(
                                     end.y as f32 * TILE_SIZE,
                                     1.0,
                                 );
+                                println!(
+                                    "Spawning animation for item {:?} from {:?} to {:?}",
+                                    item, start, end
+                                );
                                 commands.spawn((
                                     ItemAnimation {
                                         start_pos,
@@ -217,6 +223,11 @@ pub fn spawn_animations(
                                     },
                                 ));
                             }
+                        } else {
+                            println!(
+                                "Skipping animation for item {:?} from {:?} to {:?} due to conditions",
+                                item, start, end
+                            );
                         }
                     }
                 }

src/utils.rs

@@ -57,22 +57,23 @@ pub fn get_tile_name(tile_type: (u8, u8)) -> String {
 
 pub fn get_tile_core_interval(tile_type: (u8, u8)) -> u32 {
     match tile_type {
-        (1, 2) => 50,
-        (2, 1) => 10,
-        (2, 2) => 15,
-        (2, 3) => 15,
-        (3, 1) => 20,
-        (3, 2) => 20,
-        (3, 3) => 20,
-        (4, 1) => 30,
-        (4, 2) => 30,
-        (4, 3) => 35,
-        (4, 4) => 40,
-        (4, 5) => 40,
-        (5, 1) => 25,
-        (5, 2) => 25,
-        (5, 3) => 25,
-        _ => 60,
+        (1, 2) => 100,
+        (2, 1) => 20,
+        (2, 2) => 30,
+        (2, 3) => 30,
+
+        (3, 1) => 40,
+        (3, 2) => 40,
+        (3, 3) => 40,
+        (4, 1) => 60,
+        (4, 2) => 60,
+        (4, 3) => 70,
+        (4, 4) => 80,
+        (4, 5) => 80,
+        (5, 1) => 50,
+        (5, 2) => 50,
+        (5, 3) => 50,
+        _ => 6942,
     }
 }
 
@@ -82,6 +83,7 @@ pub fn get_tile_price(tile_type: (u8, u8)) -> u32 {
         (2, 1) => 10,
         (2, 2) => 15,
         (2, 3) => 15,
+
         (3, 1) => 20,
         (3, 2) => 20,
         (3, 3) => 20,
@@ -136,6 +138,7 @@ pub fn get_new_tile(
             }) as Box<dyn Tile>,
             tile_type,
         ),
+
         (2, 3) => (
             Box::new(Junction {
                 position,