866 lines
28 KiB
Dart
866 lines
28 KiB
Dart
import 'package:flutter/material.dart';
|
|
import 'package:provider/provider.dart';
|
|
import '../providers/battle_provider.dart';
|
|
import '../game/model/entity.dart';
|
|
import '../game/enums.dart';
|
|
import '../game/model/item.dart';
|
|
import '../game/model/damage_event.dart';
|
|
import '../game/model/effect_event.dart';
|
|
import 'dart:async';
|
|
import '../widgets/responsive_container.dart';
|
|
import '../utils/item_utils.dart';
|
|
|
|
class BattleScreen extends StatefulWidget {
|
|
const BattleScreen({super.key});
|
|
|
|
@override
|
|
State<BattleScreen> createState() => _BattleScreenState();
|
|
}
|
|
|
|
class _BattleScreenState extends State<BattleScreen> {
|
|
final ScrollController _scrollController = ScrollController();
|
|
final List<_DamageTextData> _floatingDamageTexts = [];
|
|
final List<_FloatingEffectData> _floatingEffects = [];
|
|
StreamSubscription<DamageEvent>? _damageSubscription;
|
|
StreamSubscription<EffectEvent>? _effectSubscription;
|
|
final GlobalKey _playerKey = GlobalKey();
|
|
final GlobalKey _enemyKey = GlobalKey();
|
|
final GlobalKey _stackKey = GlobalKey();
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
WidgetsBinding.instance.addPostFrameCallback((_) {
|
|
if (_scrollController.hasClients) {
|
|
_scrollController.jumpTo(_scrollController.position.maxScrollExtent);
|
|
}
|
|
});
|
|
|
|
final battleProvider = context.read<BattleProvider>();
|
|
_damageSubscription = battleProvider.damageStream.listen(
|
|
_addFloatingDamageText,
|
|
);
|
|
_effectSubscription = battleProvider.effectStream.listen(
|
|
_addFloatingEffect,
|
|
);
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_scrollController.dispose();
|
|
_damageSubscription?.cancel();
|
|
_effectSubscription?.cancel();
|
|
super.dispose();
|
|
}
|
|
|
|
void _addFloatingDamageText(DamageEvent event) {
|
|
WidgetsBinding.instance.addPostFrameCallback((_) {
|
|
if (!mounted) return;
|
|
|
|
GlobalKey targetKey = event.target == DamageTarget.player
|
|
? _playerKey
|
|
: _enemyKey;
|
|
|
|
if (targetKey.currentContext == null) return;
|
|
RenderBox? renderBox =
|
|
targetKey.currentContext!.findRenderObject() as RenderBox?;
|
|
if (renderBox == null) return;
|
|
|
|
Offset position = renderBox.localToGlobal(Offset.zero);
|
|
|
|
RenderBox? stackRenderBox =
|
|
_stackKey.currentContext?.findRenderObject() as RenderBox?;
|
|
if (stackRenderBox != null) {
|
|
Offset stackOffset = stackRenderBox.localToGlobal(Offset.zero);
|
|
position = position - stackOffset;
|
|
}
|
|
|
|
position = position + Offset(renderBox.size.width / 2 - 20, -20);
|
|
|
|
final String id = UniqueKey().toString();
|
|
|
|
setState(() {
|
|
_floatingDamageTexts.add(
|
|
_DamageTextData(
|
|
id: id,
|
|
widget: Positioned(
|
|
left: position.dx,
|
|
top: position.dy,
|
|
child: _FloatingDamageText(
|
|
key: ValueKey(id),
|
|
damage: event.damage.toString(),
|
|
color: event.color,
|
|
onRemove: () {
|
|
if (mounted) {
|
|
setState(() {
|
|
_floatingDamageTexts.removeWhere((e) => e.id == id);
|
|
});
|
|
}
|
|
},
|
|
),
|
|
),
|
|
),
|
|
);
|
|
});
|
|
});
|
|
}
|
|
|
|
void _addFloatingEffect(EffectEvent event) {
|
|
WidgetsBinding.instance.addPostFrameCallback((_) {
|
|
if (!mounted) return;
|
|
|
|
GlobalKey targetKey = event.target == EffectTarget.player
|
|
? _playerKey
|
|
: _enemyKey;
|
|
if (targetKey.currentContext == null) return;
|
|
|
|
RenderBox? renderBox =
|
|
targetKey.currentContext!.findRenderObject() as RenderBox?;
|
|
if (renderBox == null) return;
|
|
|
|
Offset position = renderBox.localToGlobal(Offset.zero);
|
|
|
|
RenderBox? stackRenderBox =
|
|
_stackKey.currentContext?.findRenderObject() as RenderBox?;
|
|
if (stackRenderBox != null) {
|
|
Offset stackOffset = stackRenderBox.localToGlobal(Offset.zero);
|
|
position = position - stackOffset;
|
|
}
|
|
|
|
position =
|
|
position +
|
|
Offset(renderBox.size.width / 2 - 30, renderBox.size.height / 2 - 30);
|
|
|
|
IconData icon;
|
|
Color color;
|
|
double size;
|
|
|
|
if (event.type == ActionType.attack) {
|
|
if (event.risk == RiskLevel.risky) {
|
|
icon = Icons.whatshot;
|
|
color = Colors.redAccent;
|
|
size = 60.0;
|
|
} else if (event.risk == RiskLevel.normal) {
|
|
icon = Icons.flash_on;
|
|
color = Colors.orangeAccent;
|
|
size = 40.0;
|
|
} else {
|
|
icon = Icons.close;
|
|
color = Colors.grey;
|
|
size = 30.0;
|
|
}
|
|
} else {
|
|
icon = Icons.shield;
|
|
if (event.risk == RiskLevel.risky) {
|
|
color = Colors.deepPurpleAccent;
|
|
size = 60.0;
|
|
} else if (event.risk == RiskLevel.normal) {
|
|
color = Colors.blueAccent;
|
|
size = 40.0;
|
|
} else {
|
|
color = Colors.greenAccent;
|
|
size = 30.0;
|
|
}
|
|
}
|
|
|
|
final String id = UniqueKey().toString();
|
|
|
|
setState(() {
|
|
_floatingEffects.add(
|
|
_FloatingEffectData(
|
|
id: id,
|
|
widget: Positioned(
|
|
left: position.dx,
|
|
top: position.dy,
|
|
child: _FloatingEffect(
|
|
key: ValueKey(id),
|
|
icon: icon,
|
|
color: color,
|
|
size: size,
|
|
onRemove: () {
|
|
if (mounted) {
|
|
setState(() {
|
|
_floatingEffects.removeWhere((e) => e.id == id);
|
|
});
|
|
}
|
|
},
|
|
),
|
|
),
|
|
),
|
|
);
|
|
});
|
|
});
|
|
}
|
|
|
|
void _showRiskLevelSelection(BuildContext context, ActionType actionType) {
|
|
final player = context.read<BattleProvider>().player;
|
|
final baseValue = actionType == ActionType.attack
|
|
? player.totalAtk
|
|
: player.totalDefense;
|
|
|
|
showDialog(
|
|
context: context,
|
|
builder: (BuildContext context) {
|
|
return SimpleDialog(
|
|
title: Text("Select Risk Level for ${actionType.name}"),
|
|
children: RiskLevel.values.map((risk) {
|
|
String infoText = "";
|
|
Color infoColor = Colors.black;
|
|
double efficiency = 0.0;
|
|
int expectedValue = 0;
|
|
|
|
switch (risk) {
|
|
case RiskLevel.safe:
|
|
efficiency = 0.5;
|
|
infoColor = Colors.green;
|
|
break;
|
|
case RiskLevel.normal:
|
|
efficiency = 1.0;
|
|
infoColor = Colors.blue;
|
|
break;
|
|
case RiskLevel.risky:
|
|
efficiency = 2.0;
|
|
infoColor = Colors.red;
|
|
break;
|
|
}
|
|
|
|
expectedValue = (baseValue * efficiency).toInt();
|
|
String valueUnit = actionType == ActionType.attack
|
|
? "Dmg"
|
|
: "Armor";
|
|
String successRate = "";
|
|
|
|
switch (risk) {
|
|
case RiskLevel.safe:
|
|
successRate = "100%";
|
|
break;
|
|
case RiskLevel.normal:
|
|
successRate = "80%";
|
|
break;
|
|
case RiskLevel.risky:
|
|
successRate = "40%";
|
|
break;
|
|
}
|
|
|
|
infoText =
|
|
"Success: $successRate, Eff: ${(efficiency * 100).toInt()}% ($expectedValue $valueUnit)";
|
|
|
|
return SimpleDialogOption(
|
|
onPressed: () {
|
|
context.read<BattleProvider>().playerAction(actionType, risk);
|
|
Navigator.pop(context);
|
|
WidgetsBinding.instance.addPostFrameCallback((_) {
|
|
_scrollController.animateTo(
|
|
_scrollController.position.maxScrollExtent,
|
|
duration: const Duration(milliseconds: 300),
|
|
curve: Curves.easeOut,
|
|
);
|
|
});
|
|
},
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Text(
|
|
risk.name,
|
|
style: const TextStyle(fontWeight: FontWeight.bold),
|
|
),
|
|
Text(
|
|
infoText,
|
|
style: TextStyle(fontSize: 12, color: infoColor),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}).toList(),
|
|
);
|
|
},
|
|
);
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return ResponsiveContainer(
|
|
child: Consumer<BattleProvider>(
|
|
builder: (context, battleProvider, child) {
|
|
if (battleProvider.currentStage.type == StageType.shop) {
|
|
return _buildShopUI(context, battleProvider);
|
|
} else if (battleProvider.currentStage.type == StageType.rest) {
|
|
return _buildRestUI(context, battleProvider);
|
|
}
|
|
|
|
return Stack(
|
|
key: _stackKey,
|
|
children: [
|
|
Container(color: Colors.black87),
|
|
Column(
|
|
children: [
|
|
// Top Bar
|
|
Padding(
|
|
padding: const EdgeInsets.all(8.0),
|
|
child: Row(
|
|
mainAxisAlignment: MainAxisAlignment.spaceBetween,
|
|
children: [
|
|
Text(
|
|
"Stage ${battleProvider.stage}",
|
|
style: const TextStyle(
|
|
color: Colors.white,
|
|
fontSize: 18,
|
|
fontWeight: FontWeight.bold,
|
|
),
|
|
),
|
|
Text(
|
|
"Turn ${battleProvider.turnCount}",
|
|
style: const TextStyle(
|
|
color: Colors.white,
|
|
fontSize: 18,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
|
|
// Battle Area
|
|
Expanded(
|
|
child: Center(
|
|
child: Row(
|
|
mainAxisAlignment: MainAxisAlignment.spaceEvenly,
|
|
children: [
|
|
_buildCharacterStatus(
|
|
battleProvider.player,
|
|
isPlayer: true,
|
|
isTurn: battleProvider.isPlayerTurn,
|
|
key: _playerKey,
|
|
),
|
|
// const Text(
|
|
// "VS",
|
|
// style: TextStyle(
|
|
// color: Colors.red,
|
|
// fontSize: 24,
|
|
// fontWeight: FontWeight.bold,
|
|
// ),
|
|
// ),
|
|
_buildCharacterStatus(
|
|
battleProvider.enemy,
|
|
isPlayer: false,
|
|
isTurn: !battleProvider.isPlayerTurn,
|
|
key: _enemyKey,
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
|
|
// Action Buttons
|
|
Padding(
|
|
padding: const EdgeInsets.all(16.0),
|
|
child: Column(
|
|
children: [
|
|
if (battleProvider.logs.isNotEmpty)
|
|
Container(
|
|
height: 60,
|
|
padding: const EdgeInsets.all(8.0),
|
|
decoration: BoxDecoration(
|
|
color: Colors.black54,
|
|
borderRadius: BorderRadius.circular(8),
|
|
),
|
|
child: ListView.builder(
|
|
reverse: true,
|
|
itemCount: battleProvider.logs.length,
|
|
itemBuilder: (context, index) {
|
|
final logIndex =
|
|
battleProvider.logs.length - 1 - index;
|
|
return Text(
|
|
battleProvider.logs[logIndex],
|
|
style: const TextStyle(
|
|
color: Colors.white70,
|
|
fontSize: 12,
|
|
),
|
|
);
|
|
},
|
|
),
|
|
),
|
|
const SizedBox(height: 16),
|
|
Card(
|
|
color: Colors.grey[900],
|
|
child: Padding(
|
|
padding: const EdgeInsets.all(8.0),
|
|
child: Row(
|
|
mainAxisAlignment: MainAxisAlignment.spaceAround,
|
|
children: [
|
|
_buildActionButton(
|
|
context,
|
|
"ATTACK",
|
|
ActionType.attack,
|
|
battleProvider.isPlayerTurn &&
|
|
!battleProvider.player.isDead &&
|
|
!battleProvider.enemy.isDead &&
|
|
!battleProvider.showRewardPopup,
|
|
),
|
|
_buildActionButton(
|
|
context,
|
|
"DEFEND",
|
|
ActionType.defend,
|
|
battleProvider.isPlayerTurn &&
|
|
!battleProvider.player.isDead &&
|
|
!battleProvider.enemy.isDead &&
|
|
!battleProvider.showRewardPopup,
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
if (battleProvider.showRewardPopup)
|
|
Container(
|
|
color: Colors.black54,
|
|
child: Center(
|
|
child: SimpleDialog(
|
|
title: const Text("Victory! Choose a Reward"),
|
|
children: battleProvider.rewardOptions.map((item) {
|
|
return SimpleDialogOption(
|
|
onPressed: () {
|
|
battleProvider.selectReward(item);
|
|
},
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Row(
|
|
children: [
|
|
Container(
|
|
padding: const EdgeInsets.all(4),
|
|
decoration: BoxDecoration(
|
|
color: Colors.blueGrey[700],
|
|
borderRadius: BorderRadius.circular(4),
|
|
border: Border.all(color: Colors.grey),
|
|
),
|
|
child: Icon(
|
|
ItemUtils.getIcon(item.slot),
|
|
color: ItemUtils.getColor(item.slot),
|
|
size: 24,
|
|
),
|
|
),
|
|
const SizedBox(width: 12),
|
|
Text(
|
|
item.name,
|
|
style: const TextStyle(
|
|
fontWeight: FontWeight.bold,
|
|
fontSize: 16,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
_buildItemStatText(item),
|
|
Text(
|
|
item.description,
|
|
style: const TextStyle(
|
|
fontSize: 12,
|
|
color: Colors.grey,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}).toList(),
|
|
),
|
|
),
|
|
),
|
|
..._floatingDamageTexts.map((e) => e.widget),
|
|
..._floatingEffects.map((e) => e.widget),
|
|
],
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _buildShopUI(BuildContext context, BattleProvider battleProvider) {
|
|
return Center(
|
|
child: Column(
|
|
mainAxisAlignment: MainAxisAlignment.center,
|
|
children: [
|
|
const Icon(Icons.store, size: 64, color: Colors.amber),
|
|
const SizedBox(height: 16),
|
|
const Text("Merchant Shop", style: TextStyle(fontSize: 24)),
|
|
const SizedBox(height: 8),
|
|
const Text("Buying/Selling feature coming soon!"),
|
|
const SizedBox(height: 32),
|
|
ElevatedButton(
|
|
onPressed: () => battleProvider.proceedToNextStage(),
|
|
child: const Text("Leave Shop"),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _buildRestUI(BuildContext context, BattleProvider battleProvider) {
|
|
return Center(
|
|
child: Column(
|
|
mainAxisAlignment: MainAxisAlignment.center,
|
|
children: [
|
|
const Icon(Icons.local_hotel, size: 64, color: Colors.blue),
|
|
const SizedBox(height: 16),
|
|
const Text("Rest Area", style: TextStyle(fontSize: 24)),
|
|
const SizedBox(height: 8),
|
|
const Text("Take a breath and heal."),
|
|
const SizedBox(height: 32),
|
|
ElevatedButton(
|
|
onPressed: () {
|
|
battleProvider.player.heal(20);
|
|
battleProvider.proceedToNextStage();
|
|
},
|
|
child: const Text("Rest & Leave (+20 HP)"),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _buildItemStatText(Item item) {
|
|
List<String> stats = [];
|
|
if (item.atkBonus > 0) stats.add("+${item.atkBonus} ATK");
|
|
if (item.hpBonus > 0) stats.add("+${item.hpBonus} HP");
|
|
if (item.armorBonus > 0) stats.add("+${item.armorBonus} DEF");
|
|
|
|
List<String> effectTexts = item.effects.map((e) => e.description).toList();
|
|
|
|
if (stats.isEmpty && effectTexts.isEmpty) return const SizedBox.shrink();
|
|
|
|
return Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
if (stats.isNotEmpty)
|
|
Padding(
|
|
padding: const EdgeInsets.only(top: 4.0, bottom: 4.0),
|
|
child: Text(
|
|
stats.join(", "),
|
|
style: const TextStyle(fontSize: 12, color: Colors.blueAccent),
|
|
),
|
|
),
|
|
if (effectTexts.isNotEmpty)
|
|
Padding(
|
|
padding: const EdgeInsets.only(bottom: 4.0),
|
|
child: Text(
|
|
effectTexts.join(", "),
|
|
style: const TextStyle(fontSize: 11, color: Colors.orangeAccent),
|
|
),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
|
|
Widget _buildCharacterStatus(
|
|
Character character, {
|
|
bool isPlayer = false,
|
|
bool isTurn = false,
|
|
Key? key,
|
|
}) {
|
|
return Column(
|
|
key: key,
|
|
children: [
|
|
Text("Armor: ${character.armor}"),
|
|
Text(
|
|
"${character.name}: HP ${character.hp}/${character.totalMaxHp}",
|
|
style: TextStyle(
|
|
color: character.isDead ? Colors.red : Colors.white,
|
|
fontWeight: FontWeight.bold,
|
|
),
|
|
),
|
|
SizedBox(
|
|
width: 100,
|
|
child: LinearProgressIndicator(
|
|
value: character.totalMaxHp > 0
|
|
? character.hp / character.totalMaxHp
|
|
: 0,
|
|
color: !isPlayer ? Colors.red : Colors.green,
|
|
backgroundColor: Colors.grey,
|
|
),
|
|
),
|
|
if (character.statusEffects.isNotEmpty)
|
|
Padding(
|
|
padding: const EdgeInsets.only(top: 4.0),
|
|
child: Wrap(
|
|
spacing: 4.0,
|
|
children: character.statusEffects.map((effect) {
|
|
return Container(
|
|
padding: const EdgeInsets.symmetric(
|
|
horizontal: 6,
|
|
vertical: 2,
|
|
),
|
|
decoration: BoxDecoration(
|
|
color: Colors.deepOrange,
|
|
borderRadius: BorderRadius.circular(4),
|
|
),
|
|
child: Text(
|
|
"${effect.type.name.toUpperCase()} (${effect.duration})",
|
|
style: const TextStyle(
|
|
color: Colors.white,
|
|
fontSize: 10,
|
|
fontWeight: FontWeight.bold,
|
|
),
|
|
),
|
|
);
|
|
}).toList(),
|
|
),
|
|
),
|
|
Text("ATK: ${character.totalAtk}"),
|
|
Text("DEF: ${character.totalDefense}"),
|
|
|
|
if (!isPlayer)
|
|
Consumer<BattleProvider>(
|
|
builder: (context, provider, child) {
|
|
if (provider.currentEnemyIntent != null && !character.isDead) {
|
|
final intent = provider.currentEnemyIntent!;
|
|
return Padding(
|
|
padding: const EdgeInsets.only(top: 8.0),
|
|
child: Container(
|
|
padding: const EdgeInsets.all(8.0),
|
|
decoration: BoxDecoration(
|
|
color: Colors.black54,
|
|
borderRadius: BorderRadius.circular(8),
|
|
border: Border.all(color: Colors.redAccent),
|
|
),
|
|
child: Column(
|
|
children: [
|
|
Text(
|
|
"INTENT",
|
|
style: TextStyle(
|
|
color: Colors.redAccent,
|
|
fontSize: 10,
|
|
fontWeight: FontWeight.bold,
|
|
),
|
|
),
|
|
Row(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
Icon(
|
|
intent.type == EnemyActionType.attack
|
|
? Icons.flash_on
|
|
: Icons.shield,
|
|
color: Colors.yellow,
|
|
size: 16,
|
|
),
|
|
const SizedBox(width: 4),
|
|
Text(
|
|
intent.description,
|
|
style: const TextStyle(
|
|
color: Colors.white,
|
|
fontSize: 12,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
return const SizedBox.shrink();
|
|
},
|
|
),
|
|
],
|
|
);
|
|
}
|
|
|
|
Widget _buildActionButton(
|
|
BuildContext context,
|
|
String text,
|
|
ActionType actionType,
|
|
bool isEnabled,
|
|
) {
|
|
return ElevatedButton(
|
|
onPressed: isEnabled
|
|
? () => _showRiskLevelSelection(context, actionType)
|
|
: null,
|
|
style: ElevatedButton.styleFrom(
|
|
padding: const EdgeInsets.symmetric(horizontal: 30, vertical: 15),
|
|
backgroundColor: Colors.blueGrey,
|
|
foregroundColor: Colors.white,
|
|
textStyle: const TextStyle(fontSize: 18, fontWeight: FontWeight.bold),
|
|
),
|
|
child: Text(text),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _FloatingDamageText extends StatefulWidget {
|
|
final String damage;
|
|
final Color color;
|
|
final VoidCallback onRemove;
|
|
|
|
const _FloatingDamageText({
|
|
Key? key,
|
|
required this.damage,
|
|
required this.color,
|
|
required this.onRemove,
|
|
}) : super(key: key);
|
|
|
|
@override
|
|
__FloatingDamageTextState createState() => __FloatingDamageTextState();
|
|
}
|
|
|
|
class __FloatingDamageTextState extends State<_FloatingDamageText>
|
|
with SingleTickerProviderStateMixin {
|
|
late AnimationController _controller;
|
|
late Animation<Offset> _offsetAnimation;
|
|
late Animation<double> _opacityAnimation;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
_controller = AnimationController(
|
|
duration: const Duration(milliseconds: 1000),
|
|
vsync: this,
|
|
);
|
|
|
|
_offsetAnimation = Tween<Offset>(
|
|
begin: const Offset(0.0, 0.0),
|
|
end: const Offset(0.0, -1.5),
|
|
).animate(CurvedAnimation(parent: _controller, curve: Curves.easeOut));
|
|
|
|
_opacityAnimation = Tween<double>(begin: 1.0, end: 0.0).animate(
|
|
CurvedAnimation(
|
|
parent: _controller,
|
|
curve: const Interval(0.5, 1.0, curve: Curves.easeOut),
|
|
),
|
|
);
|
|
|
|
_controller.forward().then((_) {
|
|
if (mounted) {
|
|
widget.onRemove();
|
|
}
|
|
});
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_controller.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return AnimatedBuilder(
|
|
animation: _controller,
|
|
builder: (context, child) {
|
|
return FractionalTranslation(
|
|
translation: _offsetAnimation.value,
|
|
child: Opacity(
|
|
opacity: _opacityAnimation.value,
|
|
child: Material(
|
|
color: Colors.transparent,
|
|
child: Text(
|
|
widget.damage,
|
|
style: TextStyle(
|
|
color: widget.color,
|
|
fontSize: 20,
|
|
fontWeight: FontWeight.bold,
|
|
shadows: const [
|
|
Shadow(
|
|
blurRadius: 2.0,
|
|
color: Colors.black,
|
|
offset: Offset(1.0, 1.0),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
},
|
|
);
|
|
}
|
|
}
|
|
|
|
class _DamageTextData {
|
|
final String id;
|
|
final Widget widget;
|
|
|
|
_DamageTextData({required this.id, required this.widget});
|
|
}
|
|
|
|
class _FloatingEffect extends StatefulWidget {
|
|
final IconData icon;
|
|
final Color color;
|
|
final double size;
|
|
final VoidCallback onRemove;
|
|
|
|
const _FloatingEffect({
|
|
Key? key,
|
|
required this.icon,
|
|
required this.color,
|
|
required this.size,
|
|
required this.onRemove,
|
|
}) : super(key: key);
|
|
|
|
@override
|
|
__FloatingEffectState createState() => __FloatingEffectState();
|
|
}
|
|
|
|
class __FloatingEffectState extends State<_FloatingEffect>
|
|
with SingleTickerProviderStateMixin {
|
|
late AnimationController _controller;
|
|
late Animation<double> _scaleAnimation;
|
|
late Animation<double> _opacityAnimation;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
_controller = AnimationController(
|
|
duration: const Duration(milliseconds: 800),
|
|
vsync: this,
|
|
);
|
|
|
|
_scaleAnimation = Tween<double>(
|
|
begin: 0.5,
|
|
end: 1.5,
|
|
).animate(CurvedAnimation(parent: _controller, curve: Curves.elasticOut));
|
|
|
|
_opacityAnimation = Tween<double>(begin: 1.0, end: 0.0).animate(
|
|
CurvedAnimation(
|
|
parent: _controller,
|
|
curve: const Interval(0.5, 1.0, curve: Curves.easeOut),
|
|
),
|
|
);
|
|
|
|
_controller.forward().then((_) {
|
|
if (mounted) {
|
|
widget.onRemove();
|
|
}
|
|
});
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_controller.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return AnimatedBuilder(
|
|
animation: _controller,
|
|
builder: (context, child) {
|
|
return Transform.scale(
|
|
scale: _scaleAnimation.value,
|
|
child: Opacity(
|
|
opacity: _opacityAnimation.value,
|
|
child: Icon(widget.icon, color: widget.color, size: widget.size),
|
|
),
|
|
);
|
|
},
|
|
);
|
|
}
|
|
}
|
|
|
|
class _FloatingEffectData {
|
|
final String id;
|
|
final Widget widget;
|
|
|
|
_FloatingEffectData({required this.id, required this.widget});
|
|
}
|