112 lines
2.9 KiB
Dart
112 lines
2.9 KiB
Dart
import 'dart:math' as math;
|
|
|
|
import 'package:wolf_dart/classes/linear_coordinates.dart';
|
|
import 'package:wolf_dart/features/entities/enemies/enemy.dart';
|
|
import 'package:wolf_dart/features/entities/entity.dart';
|
|
|
|
enum WeaponState { idle, firing }
|
|
|
|
enum WeaponType { knife, pistol, machineGun, chainGun }
|
|
|
|
abstract class Weapon {
|
|
final WeaponType type;
|
|
final int idleSprite;
|
|
final List<int> fireFrames;
|
|
final int damage;
|
|
final int msPerFrame;
|
|
|
|
WeaponState state = WeaponState.idle;
|
|
int frameIndex = 0;
|
|
int lastFrameTime = 0;
|
|
|
|
Weapon({
|
|
required this.type,
|
|
required this.idleSprite,
|
|
required this.fireFrames,
|
|
required this.damage,
|
|
this.msPerFrame = 100,
|
|
});
|
|
|
|
int get currentSprite =>
|
|
state == WeaponState.idle ? idleSprite : fireFrames[frameIndex];
|
|
|
|
bool fire(int currentTime, {required int currentAmmo}) {
|
|
if (state == WeaponState.idle && currentAmmo > 0) {
|
|
state = WeaponState.firing;
|
|
frameIndex = 0;
|
|
lastFrameTime = currentTime;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void update(int currentTime) {
|
|
if (state == WeaponState.firing) {
|
|
if (currentTime - lastFrameTime > msPerFrame) {
|
|
frameIndex++;
|
|
lastFrameTime = currentTime;
|
|
if (frameIndex >= fireFrames.length) {
|
|
state = WeaponState.idle;
|
|
frameIndex = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// NEW: The weapon calculates its own hits and applies damage!
|
|
void performHitscan({
|
|
required double playerX,
|
|
required double playerY,
|
|
required double playerAngle,
|
|
required List<Entity> entities,
|
|
required bool Function(int x, int y) isWalkable,
|
|
required int currentTime,
|
|
required void Function(int scoreToAdd) onEnemyKilled,
|
|
}) {
|
|
Enemy? closestEnemy;
|
|
double minDistance = 15.0;
|
|
|
|
for (Entity entity in entities) {
|
|
if (entity is Enemy && entity.state != EntityState.dead) {
|
|
double dx = entity.x - playerX;
|
|
double dy = entity.y - playerY;
|
|
double angleToEnemy = math.atan2(dy, dx);
|
|
|
|
double angleDiff = playerAngle - angleToEnemy;
|
|
while (angleDiff <= -math.pi) {
|
|
angleDiff += 2 * math.pi;
|
|
}
|
|
while (angleDiff > math.pi) {
|
|
angleDiff -= 2 * math.pi;
|
|
}
|
|
double dist = math.sqrt(dx * dx + dy * dy);
|
|
double threshold = 0.2 / dist;
|
|
|
|
if (angleDiff.abs() < threshold) {
|
|
LinearCoordinates source = (x: playerX, y: playerY);
|
|
|
|
// Delegate to the enemy to check if it's visible
|
|
if (entity.hasLineOfSightFrom(
|
|
source,
|
|
playerAngle,
|
|
dist,
|
|
isWalkable,
|
|
)) {
|
|
if (dist < minDistance) {
|
|
minDistance = dist;
|
|
closestEnemy = entity;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (closestEnemy != null) {
|
|
closestEnemy.takeDamage(damage, currentTime);
|
|
if (closestEnemy.state == EntityState.dead) {
|
|
onEnemyKilled(100);
|
|
}
|
|
}
|
|
}
|
|
}
|