487 lines
14 KiB
Dart
487 lines
14 KiB
Dart
import 'dart:math' as math;
|
|
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter/scheduler.dart';
|
|
import 'package:flutter/services.dart';
|
|
import 'package:wolf_dart/classes/linear_coordinates.dart';
|
|
import 'package:wolf_dart/classes/matrix.dart';
|
|
import 'package:wolf_dart/features/difficulty/difficulty.dart';
|
|
import 'package:wolf_dart/features/entities/collectible.dart';
|
|
import 'package:wolf_dart/features/entities/enemies/enemy.dart';
|
|
import 'package:wolf_dart/features/entities/entity.dart';
|
|
import 'package:wolf_dart/features/entities/entity_registry.dart';
|
|
import 'package:wolf_dart/features/map/wolf_map.dart';
|
|
import 'package:wolf_dart/features/player/player.dart';
|
|
import 'package:wolf_dart/features/renderer/raycast_painter.dart';
|
|
import 'package:wolf_dart/features/renderer/weapon_painter.dart';
|
|
import 'package:wolf_dart/features/ui/hud.dart';
|
|
import 'package:wolf_dart/sprite_gallery.dart';
|
|
|
|
class WolfRenderer extends StatefulWidget {
|
|
const WolfRenderer({
|
|
super.key,
|
|
required this.difficulty,
|
|
this.showSpriteGallery = false,
|
|
this.isDemo = true,
|
|
});
|
|
|
|
final Difficulty difficulty;
|
|
final bool showSpriteGallery;
|
|
final bool isDemo;
|
|
|
|
@override
|
|
State<WolfRenderer> createState() => _WolfRendererState();
|
|
}
|
|
|
|
class _WolfRendererState extends State<WolfRenderer>
|
|
with SingleTickerProviderStateMixin {
|
|
late Ticker _gameLoop;
|
|
final FocusNode _focusNode = FocusNode();
|
|
late WolfMap gameMap;
|
|
late Matrix<int> currentLevel;
|
|
|
|
final double fov = math.pi / 3;
|
|
|
|
late Player player;
|
|
|
|
bool _isLoading = true;
|
|
bool _spaceWasPressed = false;
|
|
|
|
double damageFlashOpacity = 0.0;
|
|
|
|
List<Entity> entities = [];
|
|
|
|
// Track door animations
|
|
// Key is "X,Y" coordinate. Value is how far open it is (0.0 to 1.0)
|
|
Map<String, double> doorOffsets = {};
|
|
Map<String, int> doorStates = {}; // 1 = opening, 2 = fully open
|
|
|
|
double moveStepX = 0;
|
|
double moveStepY = 0;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
_initGame(demo: widget.isDemo);
|
|
}
|
|
|
|
Future<void> _initGame({bool demo = true}) async {
|
|
// 1. Load the entire WL1 (demo)/WL6 (retail) data
|
|
gameMap = demo ? await WolfMap.loadDemo() : await WolfMap.load();
|
|
|
|
// 2. Extract Level 1 (E1M1)
|
|
currentLevel = gameMap.levels[0].wallGrid;
|
|
|
|
final Matrix<int> objectLevel = gameMap.levels[0].objectGrid;
|
|
|
|
// 1. SCAN FOR PLAYER SPAWN & ENTITIES
|
|
for (int y = 0; y < 64; y++) {
|
|
for (int x = 0; x < 64; x++) {
|
|
int objId = objectLevel[y][x];
|
|
|
|
// Player Spawn
|
|
if (objId >= 19 && objId <= 22) {
|
|
double spawnAngle = 0.0;
|
|
switch (objId) {
|
|
case 19:
|
|
spawnAngle = 3 * math.pi / 2;
|
|
break;
|
|
case 20:
|
|
spawnAngle = 0.0;
|
|
break;
|
|
case 21:
|
|
spawnAngle = math.pi / 2;
|
|
break;
|
|
case 22:
|
|
spawnAngle = math.pi;
|
|
break;
|
|
}
|
|
player = Player(
|
|
x: x + 0.5,
|
|
y: y + 0.5,
|
|
angle: spawnAngle,
|
|
);
|
|
} else {
|
|
Entity? newEntity = EntityRegistry.spawn(
|
|
objId,
|
|
x + 0.5,
|
|
y + 0.5,
|
|
widget.difficulty.level,
|
|
gameMap.sprites.length,
|
|
);
|
|
|
|
if (newEntity != null) {
|
|
entities.add(newEntity);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 2. CLEAN UP WALLS / PRESERVE DOORS
|
|
for (int y = 0; y < 64; y++) {
|
|
for (int x = 0; x < 64; x++) {
|
|
int id = currentLevel[y][x];
|
|
if ((id >= 1 && id <= 63) || (id >= 90 && id <= 101)) {
|
|
// Leave walls and doors solid
|
|
} else {
|
|
currentLevel[y][x] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 4. Start the game!
|
|
_bumpPlayerIfStuck();
|
|
_gameLoop = createTicker(_tick)..start();
|
|
_focusNode.requestFocus();
|
|
|
|
setState(() {
|
|
_isLoading = false;
|
|
});
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_gameLoop.dispose();
|
|
_focusNode.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
void _bumpPlayerIfStuck() {
|
|
int pX = player.x.toInt();
|
|
int pY = player.y.toInt();
|
|
|
|
if (pY < 0 ||
|
|
pY >= currentLevel.length ||
|
|
pX < 0 ||
|
|
pX >= currentLevel[0].length ||
|
|
currentLevel[pY][pX] > 0) {
|
|
double shortestDist = double.infinity;
|
|
LinearCoordinates nearestSafeSpot = (x: 1.5, y: 1.5);
|
|
|
|
for (int y = 0; y < currentLevel.length; y++) {
|
|
for (int x = 0; x < currentLevel[y].length; x++) {
|
|
if (currentLevel[y][x] == 0) {
|
|
double safeX = x + 0.5;
|
|
double safeY = y + 0.5;
|
|
double dist = math.sqrt(
|
|
math.pow(safeX - player.x, 2) + math.pow(safeY - player.y, 2),
|
|
);
|
|
|
|
if (dist < shortestDist) {
|
|
shortestDist = dist;
|
|
nearestSafeSpot = (x: safeX, y: safeY);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
player.x = nearestSafeSpot.x;
|
|
player.y = nearestSafeSpot.y;
|
|
}
|
|
}
|
|
|
|
bool _isWalkable(int x, int y) {
|
|
if (currentLevel[y][x] == 0) return true; // Empty space
|
|
if (currentLevel[y][x] >= 90) {
|
|
String key = '$x,$y';
|
|
// Allow the player to walk through if the door is > 70% open
|
|
if (doorOffsets[key] != null && doorOffsets[key]! > 0.7) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void _tick(Duration elapsed) {
|
|
const double moveSpeed = 0.12;
|
|
const double turnSpeed = 0.08;
|
|
|
|
// Reset steps each tick before calculation
|
|
moveStepX = 0;
|
|
moveStepY = 0;
|
|
|
|
// 1. ANIMATE DOORS
|
|
doorStates.forEach((key, state) {
|
|
if (state == 1) {
|
|
// If opening
|
|
doorOffsets[key] = (doorOffsets[key] ?? 0.0) + 0.02; // Slide speed
|
|
if (doorOffsets[key]! >= 1.0) {
|
|
doorOffsets[key] = 1.0;
|
|
doorStates[key] = 2; // Mark as fully open
|
|
}
|
|
}
|
|
});
|
|
|
|
final pressedKeys = HardwareKeyboard.instance.logicalKeysPressed;
|
|
|
|
if (pressedKeys.contains(LogicalKeyboardKey.keyW)) {
|
|
moveStepX += math.cos(player.angle) * moveSpeed;
|
|
moveStepY += math.sin(player.angle) * moveSpeed;
|
|
}
|
|
if (pressedKeys.contains(LogicalKeyboardKey.keyS)) {
|
|
moveStepX -= math.cos(player.angle) * moveSpeed;
|
|
moveStepY -= math.sin(player.angle) * moveSpeed;
|
|
}
|
|
if (pressedKeys.contains(LogicalKeyboardKey.keyA)) {
|
|
player.angle -= turnSpeed;
|
|
}
|
|
if (pressedKeys.contains(LogicalKeyboardKey.keyD)) {
|
|
player.angle += turnSpeed;
|
|
}
|
|
if (player.angle < 0) player.angle += 2 * math.pi;
|
|
if (player.angle > 2 * math.pi) player.angle -= 2 * math.pi;
|
|
|
|
// 2. UPDATED WALL COLLISION
|
|
const double margin = 0.3;
|
|
double newX = player.x + moveStepX;
|
|
int checkX = (moveStepX > 0)
|
|
? (newX + margin).toInt()
|
|
: (newX - margin).toInt();
|
|
|
|
if (_isWalkable(checkX, player.y.toInt())) {
|
|
player.x = newX;
|
|
}
|
|
|
|
double newY = player.y + moveStepY;
|
|
int checkY = (moveStepY > 0)
|
|
? (newY + margin).toInt()
|
|
: (newY - margin).toInt();
|
|
|
|
if (_isWalkable(player.x.toInt(), checkY)) {
|
|
player.y = newY;
|
|
}
|
|
|
|
// 3. UPDATED DOOR INTERACTION
|
|
bool isSpacePressed = pressedKeys.contains(LogicalKeyboardKey.space);
|
|
|
|
if (isSpacePressed && !_spaceWasPressed) {
|
|
int targetX = (player.x + math.cos(player.angle)).toInt();
|
|
int targetY = (player.y + math.sin(player.angle)).toInt();
|
|
|
|
if (targetY > 0 &&
|
|
targetY < currentLevel.length &&
|
|
targetX > 0 &&
|
|
targetX < currentLevel[0].length) {
|
|
if (currentLevel[targetY][targetX] >= 90) {
|
|
String key = '$targetX,$targetY';
|
|
// Start the animation if it isn't already opening!
|
|
if (!doorStates.containsKey(key) || doorStates[key] == 0) {
|
|
doorStates[key] = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
_spaceWasPressed = isSpacePressed;
|
|
|
|
// --- 4. UPDATE ENTITY LOGIC ---
|
|
List<Entity> itemsToRemove = []; // Collect items to delete after the loop
|
|
|
|
for (Entity entity in entities) {
|
|
if (entity is Enemy) {
|
|
entity.update(
|
|
elapsedMs: elapsed.inMilliseconds,
|
|
player: player.position,
|
|
isWalkable: _isWalkable,
|
|
onDamagePlayer: _takeDamage,
|
|
);
|
|
}
|
|
// NEW: Add Collectible Interaction Logic
|
|
else if (entity is Collectible) {
|
|
double dx = player.x - entity.x;
|
|
double dy = player.y - entity.y;
|
|
double dist = math.sqrt(dx * dx + dy * dy);
|
|
|
|
// If player is close enough to the item
|
|
if (dist < 0.5) {
|
|
if (player.tryPickup(entity)) {
|
|
itemsToRemove.add(entity);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Remove the items that were successfully picked up
|
|
if (itemsToRemove.isNotEmpty) {
|
|
setState(() {
|
|
entities.removeWhere((e) => itemsToRemove.contains(e));
|
|
});
|
|
}
|
|
|
|
// 5. Weapon
|
|
// Update weapon animation and check for flash frame
|
|
bool shouldCheckHit = player.updateWeapon(elapsed.inMilliseconds);
|
|
|
|
if (shouldCheckHit) {
|
|
_performRaycastAttack(elapsed);
|
|
}
|
|
|
|
// Input to trigger firing
|
|
if (pressedKeys.contains(LogicalKeyboardKey.controlLeft) &&
|
|
!_spaceWasPressed) {
|
|
player.fire(elapsed.inMilliseconds);
|
|
}
|
|
|
|
// Fade out the damage flash smoothly
|
|
if (damageFlashOpacity > 0) {
|
|
damageFlashOpacity = math.max(0.0, damageFlashOpacity - 0.05);
|
|
}
|
|
|
|
setState(() {});
|
|
}
|
|
|
|
// A helper method to handle getting shot
|
|
void _takeDamage(int damage) {
|
|
player.takeDamage(damage);
|
|
damageFlashOpacity = 0.5;
|
|
}
|
|
|
|
void _performRaycastAttack(Duration elapsed) {
|
|
Enemy? closestEnemy;
|
|
double minDistance = 15.0; // Maximum range of the gun
|
|
|
|
for (Entity entity in entities) {
|
|
if (entity is Enemy && entity.state != EntityState.dead) {
|
|
// 1. Calculate the angle from player to enemy
|
|
double dx = entity.x - player.x;
|
|
double dy = entity.y - player.y;
|
|
double angleToEnemy = math.atan2(dy, dx);
|
|
|
|
// 2. Check if that angle is close to our player's aiming angle
|
|
double angleDiff = player.angle - angleToEnemy;
|
|
while (angleDiff <= -math.pi) angleDiff += 2 * math.pi;
|
|
while (angleDiff > math.pi) angleDiff -= 2 * math.pi;
|
|
|
|
// 3. Simple bounding box check (approx 0.4 units wide)
|
|
double dist = math.sqrt(dx * dx + dy * dy);
|
|
double threshold =
|
|
0.2 / dist; // Smaller threshold as they get further away
|
|
|
|
if (angleDiff.abs() < threshold) {
|
|
// 4. Ensure there is no wall between you and the enemy
|
|
if (_hasLineOfSightToEnemy(entity, dist)) {
|
|
if (dist < minDistance) {
|
|
minDistance = dist;
|
|
closestEnemy = entity;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (closestEnemy != null) {
|
|
closestEnemy.takeDamage(
|
|
player.currentWeapon.damage,
|
|
elapsed.inMilliseconds,
|
|
);
|
|
|
|
// If the shot was fatal, reward the player
|
|
if (closestEnemy.state == EntityState.dead) {
|
|
player.score += 100;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool _hasLineOfSightToEnemy(Enemy enemy, double distance) {
|
|
double dirX = math.cos(player.angle);
|
|
double dirY = math.sin(player.angle);
|
|
|
|
for (double i = 0.5; i < distance; i += 0.2) {
|
|
int checkX = (player.x + dirX * i).toInt();
|
|
int checkY = (player.y + dirY * i).toInt();
|
|
if (!_isWalkable(checkX, checkY)) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
if (_isLoading) {
|
|
return const Center(child: CircularProgressIndicator(color: Colors.teal));
|
|
}
|
|
|
|
if (widget.showSpriteGallery) {
|
|
return SpriteGallery(sprites: gameMap.sprites);
|
|
}
|
|
|
|
return Scaffold(
|
|
backgroundColor: Colors.black,
|
|
body: KeyboardListener(
|
|
focusNode: _focusNode,
|
|
autofocus: true,
|
|
onKeyEvent: (_) {},
|
|
child: Column(
|
|
children: [
|
|
// Game view
|
|
Expanded(
|
|
child: LayoutBuilder(
|
|
builder: (context, constraints) {
|
|
return Stack(
|
|
children: [
|
|
CustomPaint(
|
|
size: Size(constraints.maxWidth, constraints.maxHeight),
|
|
painter: RaycasterPainter(
|
|
map: currentLevel,
|
|
textures: gameMap.textures,
|
|
player: player,
|
|
fov: fov,
|
|
doorOffsets: doorOffsets,
|
|
entities: entities,
|
|
sprites: gameMap.sprites,
|
|
),
|
|
),
|
|
// Weapon Viewmodel
|
|
Positioned(
|
|
bottom: -20,
|
|
left: 0,
|
|
right: 0,
|
|
child: Center(
|
|
child: Transform.translate(
|
|
offset: Offset(
|
|
0,
|
|
// Bobbing math: only moves if velocity is > 0
|
|
(moveStepX.abs() + moveStepY.abs()) > 0
|
|
? math.sin(
|
|
DateTime.now()
|
|
.millisecondsSinceEpoch /
|
|
100,
|
|
) *
|
|
12
|
|
: 0,
|
|
),
|
|
child: SizedBox(
|
|
width: 500,
|
|
height: 500,
|
|
child: CustomPaint(
|
|
painter: WeaponPainter(
|
|
sprite:
|
|
gameMap.sprites[player
|
|
.currentWeapon
|
|
.currentSprite],
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
if (damageFlashOpacity > 0)
|
|
Positioned.fill(
|
|
child: Container(
|
|
color: Colors.red.withValues(
|
|
alpha: damageFlashOpacity,
|
|
),
|
|
),
|
|
),
|
|
],
|
|
);
|
|
},
|
|
),
|
|
),
|
|
|
|
// HUD
|
|
Hud(player: player),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|