3097 lines
84 KiB
C#
3097 lines
84 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using Godot;
|
|
using Godot.Bridge;
|
|
using Godot.Collections;
|
|
using Godot.NativeInterop;
|
|
|
|
[ScriptPath("res://Scripts/Battle/BattleDR.cs")]
|
|
public partial class BattleDR : Node2D
|
|
{
|
|
public enum State
|
|
{
|
|
Override,
|
|
Next,
|
|
PlayerTurn,
|
|
SelectSkill,
|
|
SelectItem,
|
|
SelectTarget,
|
|
DoSpells,
|
|
DoAttack,
|
|
DoEnemy,
|
|
EndTurn,
|
|
SelectAct
|
|
}
|
|
|
|
public enum Selected
|
|
{
|
|
Attack,
|
|
Magic,
|
|
Act,
|
|
Item,
|
|
Defend,
|
|
Spare
|
|
}
|
|
|
|
public enum EndState
|
|
{
|
|
None,
|
|
Special,
|
|
Spared,
|
|
Executed,
|
|
Apprehended,
|
|
Defeated
|
|
}
|
|
|
|
public enum EventBattle
|
|
{
|
|
None,
|
|
WardenTutorial
|
|
}
|
|
|
|
[Signal]
|
|
public delegate void PlayerTurnEndEventHandler();
|
|
|
|
[Signal]
|
|
public delegate void EnemyTurnEndEventHandler();
|
|
|
|
public struct StartStats
|
|
{
|
|
public int[] hp;
|
|
|
|
public int money;
|
|
|
|
public Items.IDs[] items;
|
|
|
|
public Audio.AudioBlock audioBlock;
|
|
|
|
public Entity.IDs[] enemies;
|
|
|
|
public bool bg;
|
|
|
|
public bool special;
|
|
|
|
public string mes;
|
|
|
|
public Color roomMod;
|
|
}
|
|
|
|
public static BattleDR current;
|
|
|
|
public State state;
|
|
|
|
private Sprite2D background;
|
|
|
|
public BulletBoards.SoulType defaultSoul;
|
|
|
|
public BulletBoards.SoulType currentMode;
|
|
|
|
public List<Battlers> allBattlers = new List<Battlers>();
|
|
|
|
public List<Battlers> enemies = new List<Battlers>();
|
|
|
|
public List<Battlers> party = new List<Battlers>();
|
|
|
|
private Enemy caller;
|
|
|
|
public Coroutine busy;
|
|
|
|
public Coroutine events;
|
|
|
|
public EventBattle eventBattle;
|
|
|
|
public List<Coroutine> fleeing = new List<Coroutine>();
|
|
|
|
private Vector3[] partyStartPos;
|
|
|
|
public Node2D shield;
|
|
|
|
public int turn;
|
|
|
|
public int currentActor;
|
|
|
|
public int lastMes;
|
|
|
|
public int mesCount;
|
|
|
|
public int prizeM;
|
|
|
|
public int prizeE;
|
|
|
|
public List<int> lastActor = new List<int>();
|
|
|
|
private bool doBG;
|
|
|
|
private bool grazed;
|
|
|
|
private bool firstMes;
|
|
|
|
private bool playerSelect;
|
|
|
|
public bool started;
|
|
|
|
public bool spareAble;
|
|
|
|
public bool specialWarning;
|
|
|
|
public bool forceEnd;
|
|
|
|
public CharacterBody2D soul;
|
|
|
|
private string battleMes;
|
|
|
|
public static float inputCD;
|
|
|
|
public int TP;
|
|
|
|
public int option;
|
|
|
|
public int maxOption;
|
|
|
|
public int tpPreview;
|
|
|
|
public int selectedLast;
|
|
|
|
public int forceMes = -1;
|
|
|
|
public int focusAtk = -1;
|
|
|
|
private List<int> lastTP = new List<int>();
|
|
|
|
private List<Items.IDs> consumeItems = new List<Items.IDs>();
|
|
|
|
public List<SoulBullet> shots = new List<SoulBullet>();
|
|
|
|
public Color bgColor = Main.colorWhite;
|
|
|
|
public int[] blockedCommands;
|
|
|
|
public HashSet<StringName> tempFlags = new HashSet<StringName>();
|
|
|
|
public List<Entity> toDelete = new List<Entity>();
|
|
|
|
private System.Collections.Generic.Dictionary<int, Party.IDs[]> actExtra = new System.Collections.Generic.Dictionary<int, Party.IDs[]>();
|
|
|
|
public List<string> diag;
|
|
|
|
public List<string> portraits;
|
|
|
|
private int[] possible;
|
|
|
|
public int[][] resultAmts = new int[6][]
|
|
{
|
|
new int[2],
|
|
new int[2] { 1, 0 },
|
|
new int[2] { 2, 0 },
|
|
new int[2] { 3, 0 },
|
|
new int[2] { 4, 0 },
|
|
new int[2] { 5, 0 }
|
|
};
|
|
|
|
private RichTextLabel currentDiagText;
|
|
|
|
public Battlers currentlyActing;
|
|
|
|
public float iFrames;
|
|
|
|
public float grazeCD;
|
|
|
|
public BulletBoards activeBoard;
|
|
|
|
public static EndState lastResult;
|
|
|
|
private AudioStream owMusic;
|
|
|
|
public static StartStats? reloadStats;
|
|
|
|
private static readonly AudioStream defaultBTheme = GD.Load<AudioStream>("res://Audio/Music/rudebusteryellow.wav");
|
|
|
|
private const int sort = 2000;
|
|
|
|
private const int introTime = 20;
|
|
|
|
private const int defendTP = 16;
|
|
|
|
private const int grazeTP = 3;
|
|
|
|
private const int maxShoot = 5;
|
|
|
|
private const int defaultIframe = 40;
|
|
|
|
private static System.Collections.Generic.Dictionary<Entity.IDs, string[]> blurbText;
|
|
|
|
public static System.Collections.Generic.Dictionary<Entity.IDs, Battlers> enemyData;
|
|
|
|
public static readonly Vector2[][] partyPos = new Vector2[5][]
|
|
{
|
|
new Vector2[1]
|
|
{
|
|
new Vector2(-100f, 0f)
|
|
},
|
|
new Vector2[2]
|
|
{
|
|
new Vector2(-86f, -34f),
|
|
new Vector2(-103f, 18f)
|
|
},
|
|
new Vector2[3]
|
|
{
|
|
new Vector2(-97f, -68f),
|
|
new Vector2(-86f, -24f),
|
|
new Vector2(-103f, 18f)
|
|
},
|
|
new Vector2[4]
|
|
{
|
|
new Vector2(-97f, -68f),
|
|
new Vector2(-74f, -37f),
|
|
new Vector2(-101f, -13f),
|
|
new Vector2(-83f, 15f)
|
|
},
|
|
new Vector2[5]
|
|
{
|
|
new Vector2(-99f, -76f),
|
|
new Vector2(-71f, -47f),
|
|
new Vector2(-108f, -27f),
|
|
new Vector2(-73f, -5f),
|
|
new Vector2(-103f, 18f)
|
|
}
|
|
};
|
|
|
|
private const float textBarLength = 15f;
|
|
|
|
private const float fleeTime = 7f;
|
|
|
|
private const float boardSpeed = 20f;
|
|
|
|
public int lastBoard;
|
|
|
|
private StringName lastAttack;
|
|
|
|
private static readonly List<StringName> enAnim = new List<StringName> { "Idle", "Happy", "Sad", "Weak" };
|
|
|
|
private Color soulColor;
|
|
|
|
private float shootCD;
|
|
|
|
private const float soulSpeed = 55f;
|
|
|
|
private const float defaultShootCD = 10f;
|
|
|
|
private static readonly PackedScene soulBullet = GD.Load<PackedScene>("res://Objects/Bullets/SoulBullet.tscn");
|
|
|
|
public const float damageRand = 0.1f;
|
|
|
|
private List<State> extended = new List<State>
|
|
{
|
|
State.SelectSkill,
|
|
State.SelectAct,
|
|
State.SelectItem
|
|
};
|
|
|
|
|
|
|
|
public static void LoadData(bool reload = false)
|
|
{
|
|
if (enemyData == null || reload)
|
|
{
|
|
enemyData = new System.Collections.Generic.Dictionary<Entity.IDs, Battlers>();
|
|
blurbText = new System.Collections.Generic.Dictionary<Entity.IDs, string[]>();
|
|
string[] array = FileAccess.Open(Texts.textFolder + "Blurbs.txt", FileAccess.ModeFlags.Read).GetAsText(skipCr: true).Split('\n');
|
|
BattleData battleData = GD.Load<BattleData>("res://Data/Battlers.tres");
|
|
for (int i = 0; i < battleData.enemies.Length; i++)
|
|
{
|
|
Entity.IDs key = (Entity.IDs)Enum.Parse(typeof(Entity.IDs), battleData.enemies[i].ResourceName);
|
|
enemyData.Add(key, battleData.enemies[i]);
|
|
for (int j = 0; j < array.Length; j++)
|
|
{
|
|
if (array[j] == "@" + battleData.enemies[i].ResourceName)
|
|
{
|
|
List<string> list = new List<string>();
|
|
for (int k = j + 1; k < array.Length && array[k].Length >= 3; k++)
|
|
{
|
|
list.Add(array[k]);
|
|
}
|
|
blurbText.Add(key, list.ToArray());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (Texts.battleMes == null || Texts.battleMes.Count < 1 || reload)
|
|
{
|
|
Texts.SetBattleMes();
|
|
}
|
|
}
|
|
|
|
public static IEnumerator IntroNoise()
|
|
{
|
|
Audio.PlaySound("snd_tensionhorn_ch1.wav");
|
|
for (float a = 0f; a < 17f; a += Main.deltaTime)
|
|
{
|
|
yield return null;
|
|
}
|
|
Audio.PlaySound("snd_tensionhorn_ch1.wav", 1f, 1.1f);
|
|
for (float a = 0f; a < 23f; a += Main.deltaTime)
|
|
{
|
|
yield return null;
|
|
}
|
|
}
|
|
|
|
public static IEnumerator StartBattle(Enemy caller, bool useOWBG = false, Entity.IDs[] enemies = null, List<Entity> enemyEntities = null, string battleMes = null, Audio.AudioBlock music = null, bool quickIntro = false)
|
|
{
|
|
GameOver.repeatable = Main.inEvent != null;
|
|
if (Acts.instance == null)
|
|
{
|
|
Acts.instance = new Acts();
|
|
}
|
|
DWMenu.instance.battleText.Text = "";
|
|
DWMenu.instance.mainBox.Visible = false;
|
|
SaveFile.current.values[6]++;
|
|
lastResult = EndState.None;
|
|
LoadData();
|
|
DWMenu.instance.soulHitbox.AddException(DWMenu.instance.soulGrazebox);
|
|
Player.instance.canInput = false;
|
|
Player.instance.StopMoving();
|
|
CameraController.instance.AddChild(current = new BattleDR
|
|
{
|
|
Name = "Battle",
|
|
ZIndex = 1200
|
|
}, forceReadableName: false, InternalMode.Disabled);
|
|
if (caller != null)
|
|
{
|
|
caller.currentAnim = Entity.Animations.Hurt;
|
|
if (GodotObject.IsInstanceValid(caller.emoticonObj))
|
|
{
|
|
caller.emoticonObj.Free();
|
|
}
|
|
}
|
|
yield return null;
|
|
Room.current.ProcessMode = ProcessModeEnum.Disabled;
|
|
current.battleMes = battleMes;
|
|
if (DWMenu.instance.soulGrazebox != null)
|
|
{
|
|
DWMenu.instance.soulGrazebox.AreaEntered += current.Graze;
|
|
}
|
|
if (caller != null && !quickIntro)
|
|
{
|
|
current.caller = caller;
|
|
Coroutine i = Coroutine.Start(IntroNoise());
|
|
while (!i.done)
|
|
{
|
|
yield return null;
|
|
}
|
|
}
|
|
if (Main.inEvent == null)
|
|
{
|
|
current.owMusic = Audio.music.Stream;
|
|
}
|
|
Audio.ChangeMusic((Audio.AudioBlock)null, 0.5f);
|
|
current.doBG = !useOWBG;
|
|
Room.UpdateEntityList();
|
|
foreach (Entity entity3 in Room.current.entities)
|
|
{
|
|
Main.SetActive(entity3, state: false);
|
|
}
|
|
Player.SetActive(state: false);
|
|
current.partyStartPos = new Vector3[SaveFile.current.activeParty.Count];
|
|
if (!useOWBG)
|
|
{
|
|
current.background = new Sprite2D();
|
|
}
|
|
List<Vector2> pos = new List<Vector2>();
|
|
for (int j = 0; j < SaveFile.current.activeParty.Count; j++)
|
|
{
|
|
current.allBattlers.Add(Party.party[SaveFile.current.activeParty[j]]);
|
|
Entity entity = GD.Load<PackedScene>("res://Objects/Characters/" + Party.party[SaveFile.current.activeParty[j]].id.ToString() + ".tscn").Instantiate<Entity>(PackedScene.GenEditState.Disabled);
|
|
if (reloadStats.HasValue)
|
|
{
|
|
List<Battlers> list = current.allBattlers;
|
|
list[list.Count - 1].HP = reloadStats.Value.hp[j];
|
|
}
|
|
List<Battlers> list2 = current.allBattlers;
|
|
list2[list2.Count - 1].entity = entity;
|
|
List<Battlers> list3 = current.allBattlers;
|
|
list3[list3.Count - 1].id = entity.id;
|
|
List<Battlers> list4 = current.allBattlers;
|
|
list4[list4.Count - 1].posID = j;
|
|
List<Battlers> list5 = current.allBattlers;
|
|
list5[list5.Count - 1].selectedAction = null;
|
|
List<Battlers> list6 = current.allBattlers;
|
|
list6[list6.Count - 1].atkMod = null;
|
|
List<Battlers> list7 = current.allBattlers;
|
|
list7[list7.Count - 1].defMod = null;
|
|
current.AddChild(entity, forceReadableName: false, InternalMode.Disabled);
|
|
entity.trigger.ProcessMode = ProcessModeEnum.Disabled;
|
|
entity.direction = Entity.Direction.West;
|
|
entity.animMod = Entity.AnimMods.DW;
|
|
List<Battlers> list8 = current.allBattlers;
|
|
entity.battleData = list8[list8.Count - 1];
|
|
entity.CollisionLayer = 0u;
|
|
entity.CollisionMask = 0u;
|
|
entity.UpdateAnim(force: true);
|
|
List<Battlers> list9 = current.party;
|
|
List<Battlers> list10 = current.allBattlers;
|
|
list9.Add(list10[list10.Count - 1]);
|
|
entity.GlobalPosition = ((j == 0) ? Player.instance.GlobalPosition : Player.instance.followers[j - 1].GlobalPosition);
|
|
if (j == 0)
|
|
{
|
|
List<Battlers> list11 = current.allBattlers;
|
|
list11[list11.Count - 1].oEntity = Player.instance;
|
|
}
|
|
else
|
|
{
|
|
List<Battlers> list12 = current.allBattlers;
|
|
list12[list12.Count - 1].oEntity = Player.instance.followers[j - 1];
|
|
}
|
|
pos.Add(entity.Position);
|
|
entity.ZIndex = 2000 + j;
|
|
entity.doTrail = true;
|
|
DWMenu.instance.partyHUDs[j].battleStuff.Visible = true;
|
|
}
|
|
bool hasCriminal = false;
|
|
for (int k = 0; k < enemies.Length; k++)
|
|
{
|
|
Battlers battlers = (Battlers)enemyData[enemies[k]].Duplicate();
|
|
Vector2 globalPosition = current.GlobalPosition + new Vector2(200f, 0f);
|
|
if (enemyEntities != null)
|
|
{
|
|
for (int l = 0; l < enemyEntities.Count && l < enemies.Length; l++)
|
|
{
|
|
globalPosition = enemyEntities[l].GlobalPosition;
|
|
}
|
|
}
|
|
Entity entity2;
|
|
current.AddChild(entity2 = GD.Load<PackedScene>("res://Objects/Characters/" + enemies[k].ToString() + ".tscn").Instantiate<Entity>(PackedScene.GenEditState.Disabled), forceReadableName: false, InternalMode.Disabled);
|
|
battlers.entity = entity2;
|
|
battlers.id = enemies[k];
|
|
if (entity2.trigger != null)
|
|
{
|
|
entity2.trigger.ProcessMode = ProcessModeEnum.Disabled;
|
|
}
|
|
entity2.direction = Entity.Direction.East;
|
|
current.enemies.Add(battlers);
|
|
current.allBattlers.Add(battlers);
|
|
List<Battlers> list13 = current.allBattlers;
|
|
entity2.battleData = list13[list13.Count - 1];
|
|
entity2.CollisionLayer = 0u;
|
|
entity2.CollisionMask = 0u;
|
|
battlers.posID = k;
|
|
if (entity2.anim != null)
|
|
{
|
|
Array<Array<Variant>> animOverrides = entity2.battleData.animOverrides;
|
|
if (animOverrides != null && animOverrides.Count > 0)
|
|
{
|
|
entity2.replaceAnim.AddRange(entity2.battleData.animOverrides);
|
|
}
|
|
entity2.anim.Play("Idle");
|
|
}
|
|
entity2.GlobalPosition = globalPosition;
|
|
pos.Add(entity2.Position);
|
|
battlers.enemy = true;
|
|
entity2.ZIndex = 2000 + k;
|
|
List<Battlers> list14 = current.enemies;
|
|
if (list14[list14.Count - 1].isOutlaw)
|
|
{
|
|
List<Battlers> list15 = current.enemies;
|
|
if (list15[list15.Count - 1].id != Entity.IDs.Warden)
|
|
{
|
|
hasCriminal = true;
|
|
}
|
|
}
|
|
}
|
|
DWMenu.instance.tpVar = 0;
|
|
Party.UpdateHUD();
|
|
DWMenu.instance.Visible = true;
|
|
DWMenu.instance.showHP = -200f;
|
|
DWMenu.instance.battleCover.Visible = true;
|
|
current.soul = DWMenu.instance.soulBody;
|
|
current.soul.Visible = false;
|
|
for (float a = 0f; a <= 21f; a += Main.deltaTime)
|
|
{
|
|
int m = 0;
|
|
int num = 0;
|
|
int num2 = 0;
|
|
for (; m < current.allBattlers.Count; m++)
|
|
{
|
|
Vector2 vector;
|
|
if (current.allBattlers[m].enemy)
|
|
{
|
|
vector = new Vector2(0f - partyPos[current.enemies.Count - 1][num2].X, partyPos[current.enemies.Count - 1][num2].Y) + Vector2.Down * ((current.enemies.Count == 1) ? (-20) : 16) + current.allBattlers[m].positionOffset;
|
|
if (enemies.Length == 2)
|
|
{
|
|
vector += Vector2.Up * 16f;
|
|
}
|
|
current.allBattlers[m].startPos = vector;
|
|
num2++;
|
|
}
|
|
else
|
|
{
|
|
if (a == 0f)
|
|
{
|
|
current.allBattlers[m].entity.currentAnim = Entity.Animations.BattleStart;
|
|
}
|
|
vector = partyPos[SaveFile.current.activeParty.Count - 1][num];
|
|
num++;
|
|
}
|
|
current.allBattlers[m].entity.Position = pos[m].Lerp(vector, Mathf.Min(a / 20f, 1f));
|
|
}
|
|
yield return null;
|
|
}
|
|
if (music == null)
|
|
{
|
|
Audio.ChangeMusic(defaultBTheme);
|
|
}
|
|
else
|
|
{
|
|
Audio.ChangeMusic(music, 0.5f);
|
|
}
|
|
Audio.PlaySound("snd_weaponpull.wav");
|
|
for (int n = 0; n < current.allBattlers.Count; n++)
|
|
{
|
|
current.allBattlers[n].entity.doTrail = false;
|
|
}
|
|
CameraController.Transition(Main.colorClearB, 15f);
|
|
if (hasCriminal)
|
|
{
|
|
current.defaultSoul = BulletBoards.SoulType.Shoot;
|
|
Coroutine i = Coroutine.Start(ShootSoulChangeAnim());
|
|
while (!i.done)
|
|
{
|
|
yield return null;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
current.soul.RotationDegrees = 0f;
|
|
}
|
|
current.started = true;
|
|
current.state = State.Next;
|
|
GameOver.instance = null;
|
|
current.soul.TopLevel = false;
|
|
yield return null;
|
|
if (!reloadStats.HasValue)
|
|
{
|
|
reloadStats = new StartStats
|
|
{
|
|
items = SaveFile.current.dwItems.ToArray(),
|
|
hp = new int[SaveFile.current.activeParty.Count],
|
|
money = SaveFile.current.dollars,
|
|
enemies = enemies,
|
|
audioBlock = music,
|
|
bg = useOWBG,
|
|
special = (lastResult == EndState.Special),
|
|
mes = battleMes,
|
|
roomMod = Room.current.Modulate
|
|
};
|
|
for (int num3 = 0; num3 < SaveFile.current.activeParty.Count; num3++)
|
|
{
|
|
reloadStats.Value.hp[num3] = Party.party[SaveFile.current.activeParty[num3]].HP;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SaveFile.current.dwItems = new List<Items.IDs>(reloadStats.Value.items);
|
|
SaveFile.current.dollars = reloadStats.Value.money;
|
|
Room.current.Modulate = reloadStats.Value.roomMod;
|
|
for (int num4 = 0; num4 < SaveFile.current.activeParty.Count; num4++)
|
|
{
|
|
Party.party[SaveFile.current.activeParty[num4]].HP = reloadStats.Value.hp[num4];
|
|
}
|
|
if (reloadStats.Value.special)
|
|
{
|
|
lastResult = EndState.Special;
|
|
}
|
|
Party.UpdateHUD();
|
|
}
|
|
}
|
|
|
|
private static IEnumerator ShootSoulChangeAnim()
|
|
{
|
|
current.soul.RotationDegrees = 0f;
|
|
current.soul.GlobalPosition = current.party[0].entity.GlobalPosition + Vector2.Up * 16f;
|
|
float a;
|
|
for (a = 0f; a < 20f; a += Main.deltaTime)
|
|
{
|
|
yield return null;
|
|
}
|
|
current.soul.Visible = true;
|
|
Main.Particle("SoulSplit", Vector2.Up * 16f, 1, current.party[0].entity);
|
|
Audio.PlaySound("snd_great_shine.ogg");
|
|
for (a = 0f; a < 40f; a += Main.deltaTime)
|
|
{
|
|
current.bgColor = Main.colorWhite.Lerp(Main.colorDark, a / 30f);
|
|
yield return null;
|
|
}
|
|
Audio.PlaySound("snd_spearappear_ch1.wav");
|
|
a = 0f;
|
|
for (float b = 40f; a <= b + 1f; a += Main.deltaTime)
|
|
{
|
|
current.soul.Rotation = Mathf.LerpAngle(0f, Mathf.DegToRad(-90f), Mathf.Min(a / b, 1f));
|
|
yield return null;
|
|
}
|
|
for (float b = 0f; b < 20f; b += Main.deltaTime)
|
|
{
|
|
yield return null;
|
|
}
|
|
Main.Particle("SoulSplit", Vector2.Up * 16f, 1, current.party[0].entity);
|
|
Audio.PlaySound("snd_great_shine.ogg");
|
|
for (float b = 0f; b < 40f; b += Main.deltaTime)
|
|
{
|
|
current.bgColor = Main.colorDark.Lerp(Main.colorWhite, b / 30f);
|
|
yield return null;
|
|
}
|
|
}
|
|
|
|
private void ReturnToPrevious()
|
|
{
|
|
if (lastActor.Count <= 0)
|
|
{
|
|
return;
|
|
}
|
|
List<int> list = lastActor;
|
|
currentActor = list[list.Count - 1];
|
|
List<int> list2 = lastTP;
|
|
TP = list2[list2.Count - 1];
|
|
lastTP.RemoveAt(lastTP.Count - 1);
|
|
List<Items.IDs> list3 = consumeItems;
|
|
if (list3[list3.Count - 1] != Items.IDs.None)
|
|
{
|
|
List<Items.IDs> dwItems = SaveFile.current.dwItems;
|
|
List<Items.IDs> list4 = consumeItems;
|
|
dwItems.Add(list4[list4.Count - 1]);
|
|
}
|
|
consumeItems.RemoveAt(consumeItems.Count - 1);
|
|
if (actExtra.Count > 0)
|
|
{
|
|
if (actExtra.ContainsKey(currentActor))
|
|
{
|
|
for (int i = 0; i < actExtra[currentActor].Length; i++)
|
|
{
|
|
Party.party[(int)actExtra[currentActor][i]].acted = false;
|
|
Party.party[(int)actExtra[currentActor][i]].entity.currentAnim = Entity.Animations.BattleIdle;
|
|
}
|
|
}
|
|
actExtra.Remove(currentActor);
|
|
}
|
|
allBattlers[currentActor].selectedAction = null;
|
|
allBattlers[currentActor].entity.currentAnim = Entity.Animations.BattleIdle;
|
|
lastActor.RemoveAt(lastActor.Count - 1);
|
|
option = 0;
|
|
UpdateMenu();
|
|
}
|
|
|
|
private void UpdateDiag()
|
|
{
|
|
List<string> list = diag;
|
|
if (list == null || list.Count <= 0)
|
|
{
|
|
return;
|
|
}
|
|
List<string> list2 = portraits;
|
|
if (list2 != null && list2.Count > 0)
|
|
{
|
|
currentDiagText = DWMenu.instance.battleText2;
|
|
DWMenu.instance.battlePortrait.Visible = portraits[0] != null;
|
|
DWMenu.instance.battlePortrait.Play(portraits[0]);
|
|
if (!TextSystem.bleepPlayer.Playing)
|
|
{
|
|
float volume = 1f;
|
|
TextSystem.AssignBleep(portraits[0], ref volume);
|
|
TextSystem.bleepPlayer.Play();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
currentDiagText = DWMenu.instance.battleText;
|
|
}
|
|
currentDiagText.Visible = true;
|
|
Party.ShowBattleCommands(-1);
|
|
currentDiagText.Text = diag[0];
|
|
if (currentDiagText.VisibleRatio < 1f)
|
|
{
|
|
currentDiagText.VisibleCharacters++;
|
|
}
|
|
else
|
|
{
|
|
DWMenu.instance.battlePortrait.Stop();
|
|
if (TextSystem.bleepPlayer.Playing)
|
|
{
|
|
TextSystem.bleepPlayer.Stop();
|
|
}
|
|
}
|
|
if (inputCD <= 0f && Input.IsActionJustPressed(Main.keys[4]))
|
|
{
|
|
AdvanceDiag();
|
|
}
|
|
}
|
|
|
|
public void AdvanceDiag(bool skipskip = false)
|
|
{
|
|
List<string> list = diag;
|
|
if (list == null || list.Count <= 0)
|
|
{
|
|
return;
|
|
}
|
|
if (TextSystem.bleepPlayer.Playing)
|
|
{
|
|
TextSystem.bleepPlayer.Stop();
|
|
}
|
|
if (currentDiagText.VisibleRatio < 1f && !skipskip)
|
|
{
|
|
currentDiagText.VisibleRatio = 1f;
|
|
return;
|
|
}
|
|
inputCD = 5f;
|
|
diag.RemoveAt(0);
|
|
TextSystem.bleepPlayer.PitchScale = 1f;
|
|
TextSystem.bleepPlayer.VolumeDb = Mathf.LinearToDb(1f);
|
|
List<string> list2 = portraits;
|
|
if (list2 != null && list2.Count > 0)
|
|
{
|
|
DWMenu.instance.battlePortrait.Visible = false;
|
|
currentDiagText.VisibleRatio = 0f;
|
|
currentDiagText.Visible = false;
|
|
portraits.RemoveAt(0);
|
|
}
|
|
else
|
|
{
|
|
currentDiagText.VisibleRatio = 0f;
|
|
}
|
|
}
|
|
|
|
public static void Abort(bool nullify = true)
|
|
{
|
|
if (GodotObject.IsInstanceValid(current.activeBoard))
|
|
{
|
|
current.activeBoard.QueueFree();
|
|
}
|
|
DWMenu.instance.bulletBoard.Visible = false;
|
|
current.QueueFree();
|
|
if (nullify)
|
|
{
|
|
current = null;
|
|
}
|
|
}
|
|
|
|
public override void _Process(double delta)
|
|
{
|
|
if (grazeCD > 0f)
|
|
{
|
|
grazeCD -= Main.deltaTime;
|
|
}
|
|
if (CameraController.instance.shakeTime > 0f)
|
|
{
|
|
base.Position = Vector2.One * Main.RandomRange(0f - CameraController.instance.shakeIntensity, CameraController.instance.shakeIntensity);
|
|
}
|
|
else
|
|
{
|
|
base.Position = Vector2.Zero;
|
|
}
|
|
UpdateTP(ref DWMenu.instance.tpVar, in TP, in tpPreview, 1);
|
|
if (inputCD > 0f)
|
|
{
|
|
inputCD -= Main.deltaTime;
|
|
}
|
|
UpdateDiag();
|
|
DWMenu.instance.grazeIndicator.SelfModulate = DWMenu.instance.grazeIndicator.SelfModulate.Lerp(Main.colorClear, 0.1f);
|
|
if (doBG)
|
|
{
|
|
DWMenu.instance.battleBG.Modulate = DWMenu.instance.battleBG.Modulate.Lerp(bgColor, 0.1f);
|
|
}
|
|
Coroutine coroutine = busy;
|
|
if (coroutine == null || coroutine.done)
|
|
{
|
|
Coroutine coroutine2 = events;
|
|
if (coroutine2 == null || coroutine2.done)
|
|
{
|
|
switch (state)
|
|
{
|
|
case State.Next:
|
|
{
|
|
if (eventBattle == EventBattle.WardenTutorial && TP >= 40 && !tempFlags.Contains("TPMes"))
|
|
{
|
|
tempFlags.Add("TPMes");
|
|
busy = Coroutine.Start(Acts.instance.WardenTutorial(1));
|
|
break;
|
|
}
|
|
spareAble = false;
|
|
for (int j = 0; j < enemies.Count; j++)
|
|
{
|
|
if (enemies[j].CanSpare())
|
|
{
|
|
spareAble = true;
|
|
break;
|
|
}
|
|
}
|
|
for (int k = 0; k < party.Count; k++)
|
|
{
|
|
if (party[k].CanAct() && party[k].selectedAction == null)
|
|
{
|
|
currentActor = k;
|
|
state = State.PlayerTurn;
|
|
option = 0;
|
|
maxOption = 5;
|
|
DWMenu.instance.partyHUDs[k].UpdateOpt(0);
|
|
UpdateMenu();
|
|
break;
|
|
}
|
|
soul.Visible = false;
|
|
ResetEnemyHighlight();
|
|
state = State.DoSpells;
|
|
}
|
|
break;
|
|
}
|
|
case State.PlayerTurn:
|
|
if (DWMenu.instance.battleText.VisibleRatio < 1f)
|
|
{
|
|
DWMenu.instance.battleText.VisibleCharacters++;
|
|
}
|
|
Party.ShowBattleCommands(currentActor);
|
|
if (Input.IsActionJustPressed(Main.keys[2]))
|
|
{
|
|
ChangeOption(-1);
|
|
if (option < 0)
|
|
{
|
|
option = maxOption - 1;
|
|
}
|
|
DWMenu.instance.partyHUDs[currentActor].UpdateOpt(option);
|
|
}
|
|
else if (Input.IsActionJustPressed(Main.keys[3]))
|
|
{
|
|
ChangeOption(1);
|
|
DWMenu.instance.partyHUDs[currentActor].UpdateOpt(option);
|
|
}
|
|
else if (Input.IsActionJustPressed(Main.keys[4]))
|
|
{
|
|
selectedLast = option;
|
|
int[] array = blockedCommands;
|
|
if (array != null && array.Contains(option))
|
|
{
|
|
Audio.PlaySound(Audio.commonSounds[1]);
|
|
break;
|
|
}
|
|
switch (option)
|
|
{
|
|
case 0:
|
|
allBattlers[currentActor].selectedAction = new int[2];
|
|
state = State.SelectTarget;
|
|
option = 0;
|
|
maxOption = enemies.Count;
|
|
playerSelect = false;
|
|
UpdateMenu();
|
|
Audio.PlaySound(Audio.commonSounds[2]);
|
|
break;
|
|
case 1:
|
|
if (allBattlers[currentActor].doMagicMenu)
|
|
{
|
|
allBattlers[currentActor].selectedAction = new int[3] { 1, 0, 0 };
|
|
state = State.SelectSkill;
|
|
}
|
|
else
|
|
{
|
|
allBattlers[currentActor].selectedAction = new int[3] { 2, 0, 0 };
|
|
state = State.SelectTarget;
|
|
}
|
|
option = 0;
|
|
UpdateMenu();
|
|
Audio.PlaySound(Audio.commonSounds[2]);
|
|
break;
|
|
case 2:
|
|
if (SaveFile.current.dwItems.Count > 0)
|
|
{
|
|
Audio.PlaySound(Audio.commonSounds[2]);
|
|
allBattlers[currentActor].selectedAction = new int[3] { 3, 0, 0 };
|
|
state = State.SelectItem;
|
|
option = 0;
|
|
UpdateMenu();
|
|
}
|
|
else
|
|
{
|
|
Audio.PlaySound(Audio.commonSounds[1]);
|
|
}
|
|
break;
|
|
case 3:
|
|
allBattlers[currentActor].selectedAction = new int[3] { 2, 0, 12 };
|
|
state = State.SelectTarget;
|
|
option = 0;
|
|
playerSelect = false;
|
|
UpdateMenu();
|
|
Audio.PlaySound(Audio.commonSounds[2]);
|
|
break;
|
|
case 4:
|
|
allBattlers[currentActor].entity.currentAnim = Entity.Animations.Defend;
|
|
allBattlers[currentActor].selectedAction = new int[1] { 4 };
|
|
option = 0;
|
|
lastActor.Add(currentActor);
|
|
consumeItems.Add(Items.IDs.None);
|
|
currentActor = -1;
|
|
lastTP.Add(TP);
|
|
TP = Mathf.Clamp(TP + 16, 0, 100);
|
|
state = State.Next;
|
|
UpdateMenu();
|
|
Audio.PlaySound(Audio.commonSounds[2]);
|
|
break;
|
|
}
|
|
}
|
|
else if (Input.IsActionJustPressed(Main.keys[5]))
|
|
{
|
|
ReturnToPrevious();
|
|
}
|
|
break;
|
|
case State.SelectSkill:
|
|
case State.SelectItem:
|
|
case State.SelectAct:
|
|
Party.ShowBattleCommands(currentActor);
|
|
if (Input.IsActionJustPressed(Main.keys[0]))
|
|
{
|
|
ChangeOption(-2);
|
|
UpdateMenu(1);
|
|
}
|
|
else if (Input.IsActionJustPressed(Main.keys[1]))
|
|
{
|
|
ChangeOption(2);
|
|
UpdateMenu(1);
|
|
}
|
|
else if (Input.IsActionJustPressed(Main.keys[2]))
|
|
{
|
|
ChangeOption(-1);
|
|
UpdateMenu(1);
|
|
}
|
|
else if (Input.IsActionJustPressed(Main.keys[3]))
|
|
{
|
|
ChangeOption(1);
|
|
UpdateMenu(1);
|
|
}
|
|
else if (Input.IsActionJustPressed(Main.keys[4]))
|
|
{
|
|
if (state == State.SelectItem)
|
|
{
|
|
allBattlers[currentActor].selectedAction[2] = (int)SaveFile.current.dwItems[option];
|
|
playerSelect = UseOnParty(currentActor);
|
|
Items.IDs ds2 = SaveFile.current.dwItems[option];
|
|
if (Texts.items[ds2].instantUse)
|
|
{
|
|
allBattlers[currentActor].selectedAction[1] = currentActor;
|
|
allBattlers[currentActor].entity.currentAnim = Entity.Animations.ItemReady;
|
|
lastActor.Add(currentActor);
|
|
SaveFile.current.dwItems.Remove(ds2);
|
|
consumeItems.Add(ds2);
|
|
currentActor = -1;
|
|
lastTP.Add(TP);
|
|
state = State.Next;
|
|
UpdateMenu();
|
|
}
|
|
else
|
|
{
|
|
option = 0;
|
|
state = State.SelectTarget;
|
|
UpdateMenu((!Texts.items[ds2].useOnEnemy) ? 2 : 0);
|
|
}
|
|
Audio.PlaySound(Audio.commonSounds[2]);
|
|
break;
|
|
}
|
|
Acts.IDs ds3 = (Acts.IDs)possible[option];
|
|
if (TP >= Texts.skills[ds3].TP)
|
|
{
|
|
if (state == State.SelectAct || Texts.skills[ds3].skipSelection)
|
|
{
|
|
if (ds3 == Acts.IDs.Check)
|
|
{
|
|
busy = Acts.DoActRoutine("Check", enemies[allBattlers[currentActor].selectedAction[1]]);
|
|
Coroutine coroutine3 = busy;
|
|
coroutine3.onEnd = (Action)Delegate.Combine(coroutine3.onEnd, new Action(CancelEnemySelect));
|
|
break;
|
|
}
|
|
lastActor.Add(currentActor);
|
|
consumeItems.Add(Items.IDs.None);
|
|
allBattlers[currentActor].selectedAction[2] = possible[option];
|
|
if (allBattlers[currentActor].selectedAction[2] == 3)
|
|
{
|
|
allBattlers[currentActor].entity.anim.Play("Execution_Ready");
|
|
}
|
|
else
|
|
{
|
|
allBattlers[currentActor].entity.currentAnim = ((state == State.SelectItem) ? Entity.Animations.ItemReady : ((state == State.SelectAct) ? Entity.Animations.ActReady : Entity.Animations.SkillReady));
|
|
}
|
|
if (state == State.SelectAct)
|
|
{
|
|
List<Party.IDs> useTurns = Texts.skills[(Acts.IDs)allBattlers[currentActor].selectedAction[2]].useTurns;
|
|
if (useTurns != null && useTurns.Count > 0)
|
|
{
|
|
actExtra.Add(currentActor, Texts.skills[(Acts.IDs)allBattlers[currentActor].selectedAction[2]].useTurns.ToArray());
|
|
for (int l = 0; l < Texts.skills[(Acts.IDs)allBattlers[currentActor].selectedAction[2]].useTurns.Count; l++)
|
|
{
|
|
Party.party[(int)Texts.skills[(Acts.IDs)allBattlers[currentActor].selectedAction[2]].useTurns[l]].acted = true;
|
|
Party.party[(int)Texts.skills[(Acts.IDs)allBattlers[currentActor].selectedAction[2]].useTurns[l]].entity.currentAnim = Entity.Animations.ActReady;
|
|
}
|
|
}
|
|
}
|
|
currentActor = -1;
|
|
lastTP.Add(TP);
|
|
TP = Mathf.Clamp(TP - Texts.skills[ds3].TP, 0, 100);
|
|
state = State.Next;
|
|
UpdateMenu();
|
|
}
|
|
else
|
|
{
|
|
allBattlers[currentActor].selectedAction[2] = possible[option];
|
|
option = 0;
|
|
playerSelect = UseOnParty(currentActor);
|
|
state = State.SelectTarget;
|
|
UpdateMenu(Texts.skills[ds3].useOnParty ? 2 : 0);
|
|
}
|
|
Audio.PlaySound(Audio.commonSounds[2]);
|
|
}
|
|
else
|
|
{
|
|
Audio.PlaySound(Audio.commonSounds[1]);
|
|
}
|
|
}
|
|
else if (Input.IsActionJustPressed(Main.keys[5]))
|
|
{
|
|
CancelEnemySelect();
|
|
Audio.PlaySound(Audio.commonSounds[2]);
|
|
}
|
|
break;
|
|
case State.SelectTarget:
|
|
Party.ShowBattleCommands(currentActor);
|
|
if (!playerSelect)
|
|
{
|
|
for (int i = 0; i < enemies.Count; i++)
|
|
{
|
|
if (i == option)
|
|
{
|
|
enemies[i].entity.Modulate = Main.colorWhite.Lerp(Main.colorDark, Mathf.Abs(Mathf.Sin(Mathf.DegToRad(0.15f * (float)Time.GetTicksMsec()))));
|
|
}
|
|
else
|
|
{
|
|
enemies[i].entity.Modulate = Main.colorWhite;
|
|
}
|
|
}
|
|
}
|
|
if (Input.IsActionJustPressed(Main.keys[0]) || Input.IsActionJustPressed(Main.keys[2]))
|
|
{
|
|
ChangeOption(-1);
|
|
UpdateMenu(1);
|
|
}
|
|
else if (Input.IsActionJustPressed(Main.keys[1]) || Input.IsActionJustPressed(Main.keys[3]))
|
|
{
|
|
ChangeOption(1);
|
|
UpdateMenu(1);
|
|
}
|
|
else if (Input.IsActionJustPressed(Main.keys[4]))
|
|
{
|
|
if (allBattlers[currentActor].selectedAction[0] == 2 && allBattlers[currentActor].selectedAction[2] != 12)
|
|
{
|
|
allBattlers[currentActor].selectedAction[1] = option;
|
|
state = State.SelectAct;
|
|
option = 0;
|
|
UpdateMenu();
|
|
}
|
|
else
|
|
{
|
|
lastTP.Add(TP);
|
|
if (allBattlers[currentActor].selectedAction[0] == 0)
|
|
{
|
|
allBattlers[currentActor].selectedAction[1] = option;
|
|
allBattlers[currentActor].entity.currentAnim = Entity.Animations.AttackReady;
|
|
allBattlers[currentActor].entity.UpdateAnim(force: true);
|
|
allBattlers[currentActor].entity.anim.Stop();
|
|
}
|
|
else
|
|
{
|
|
Acts.IDs ds = (Acts.IDs)allBattlers[currentActor].selectedAction[2];
|
|
allBattlers[currentActor].selectedAction[1] = option;
|
|
if (allBattlers[currentActor].selectedAction[0] != 3)
|
|
{
|
|
TP = Mathf.Clamp(TP - Texts.skills[ds].TP, 0, 100);
|
|
}
|
|
if (allBattlers[currentActor].selectedAction[2] == 3)
|
|
{
|
|
allBattlers[currentActor].entity.anim.Play("Execution_Ready");
|
|
}
|
|
else if (allBattlers[currentActor].selectedAction[0] == 3)
|
|
{
|
|
allBattlers[currentActor].entity.currentAnim = Entity.Animations.ItemReady;
|
|
}
|
|
else if (Texts.skills[ds].spAction || ds == Acts.IDs.Spare)
|
|
{
|
|
allBattlers[currentActor].entity.currentAnim = Entity.Animations.ActReady;
|
|
}
|
|
else
|
|
{
|
|
allBattlers[currentActor].entity.currentAnim = Entity.Animations.SkillReady;
|
|
}
|
|
}
|
|
if (allBattlers[currentActor].selectedAction[0] == 3)
|
|
{
|
|
Items.IDs item = (Items.IDs)allBattlers[currentActor].selectedAction[2];
|
|
consumeItems.Add(item);
|
|
SaveFile.current.dwItems.Remove(item);
|
|
}
|
|
else
|
|
{
|
|
consumeItems.Add(Items.IDs.None);
|
|
}
|
|
lastActor.Add(currentActor);
|
|
currentActor = -1;
|
|
state = State.Next;
|
|
UpdateMenu();
|
|
}
|
|
Audio.PlaySound(Audio.commonSounds[2]);
|
|
}
|
|
else if (Input.IsActionJustPressed(Main.keys[5]))
|
|
{
|
|
CancelEnemySelect();
|
|
Audio.PlaySound(Audio.commonSounds[2]);
|
|
}
|
|
break;
|
|
case State.DoSpells:
|
|
busy = Coroutine.Start(DoSpells());
|
|
break;
|
|
case State.DoAttack:
|
|
busy = Coroutine.Start(DoAttack());
|
|
break;
|
|
case State.DoEnemy:
|
|
busy = Coroutine.Start(DoEnemy());
|
|
break;
|
|
case State.EndTurn:
|
|
busy = Coroutine.Start(AdvanceTurn());
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
Party.ShowBattleCommands(-1);
|
|
}
|
|
|
|
public static bool DoingAction()
|
|
{
|
|
if (current != null)
|
|
{
|
|
if (current.state != State.DoSpells && current.state != State.DoAttack && current.state != State.DoEnemy)
|
|
{
|
|
return current.state == State.EndTurn;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void CancelEnemySelect()
|
|
{
|
|
state = State.PlayerTurn;
|
|
option = selectedLast;
|
|
maxOption = 5;
|
|
allBattlers[currentActor].selectedAction = null;
|
|
ResetEnemyHighlight();
|
|
UpdateMenu();
|
|
}
|
|
|
|
private string GetTextBar(float amt, Color? color = null)
|
|
{
|
|
Color valueOrDefault = color.GetValueOrDefault();
|
|
if (!color.HasValue)
|
|
{
|
|
valueOrDefault = new Color(0f, 1f, 0f);
|
|
color = valueOrDefault;
|
|
}
|
|
string text = color.Value.ToHtml(includeAlpha: false);
|
|
string text2 = "#870900";
|
|
amt *= 15f;
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
for (int i = 0; (float)i < 15f; i++)
|
|
{
|
|
stringBuilder.Append("[img color=" + (((float)i < amt) ? text : text2) + "]res://Sprites/Menus/Menu Sprites/HPBar3.tres[/img]");
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
private int[] GetPossibleActs(int id = -1)
|
|
{
|
|
if (id == -1)
|
|
{
|
|
id = currentActor;
|
|
}
|
|
List<int> list = new List<int>();
|
|
for (int i = 0; i < party[id].acts.Count; i++)
|
|
{
|
|
if (CanUseAct(party[id].acts[i]))
|
|
{
|
|
list.Add((int)party[id].acts[i]);
|
|
}
|
|
}
|
|
return list.ToArray();
|
|
}
|
|
|
|
private bool CanUseAct(Acts.IDs id)
|
|
{
|
|
List<Items.IDs> needEquip = Texts.skills[id].needEquip;
|
|
if (needEquip != null && needEquip.Count > 0 && !party[currentActor].HasEquip(Texts.skills[id].needEquip.ToArray()))
|
|
{
|
|
return false;
|
|
}
|
|
if ((Texts.skills[id].needFlags == null || SaveFile.HasFlags(Texts.skills[id].needFlags)) && (Texts.skills[id].neededMembers == null || Party.HasMembers(Texts.skills[id].neededMembers, checkAlive: true)) && (!Texts.skills[id].onlyOnExecutable || enemies.FirstOrDefault((Battlers x) => x.isOutlaw) != null))
|
|
{
|
|
if (Texts.skills[id].spAction)
|
|
{
|
|
return enemies.FirstOrDefault((Battlers x) => x.partyAction.Count > 1 || x.acts.Count > 0) != null;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public EndState GetLastResult()
|
|
{
|
|
return (EndState)resultAmts.OrderByDescending((int[] x) => x[1]).ToArray()[0][0];
|
|
}
|
|
|
|
public IEnumerator EndBattle(EndState endState = EndState.None)
|
|
{
|
|
shield?.Free();
|
|
shield = null;
|
|
soul.RotationDegrees = 0f;
|
|
reloadStats = null;
|
|
state = State.Override;
|
|
Vector2[] p = new Vector2[party.Count];
|
|
for (int i = 0; i < party.Count; i++)
|
|
{
|
|
p[i] = party[i].entity.GlobalPosition;
|
|
if (party[i].HP < 0)
|
|
{
|
|
party[i].HP = 1;
|
|
}
|
|
party[i].entity.currentAnim = Entity.Animations.BattleEnd;
|
|
party[i].entity.direction = Entity.Direction.West;
|
|
}
|
|
if (lastResult != EndState.Special)
|
|
{
|
|
lastResult = GetLastResult();
|
|
}
|
|
if (lastResult != EndState.Special)
|
|
{
|
|
prizeM = Mathf.FloorToInt((float)prizeM * Mathf.Lerp(1f, 1.5f, (float)TP / 100f));
|
|
Enemy enemy = caller;
|
|
if (enemy != null && enemy.respawnType == Enemy.Respawn.NoMoney && SaveFile.HasFlag(caller.flag))
|
|
{
|
|
prizeM = 0;
|
|
}
|
|
if (lastResult == EndState.Executed)
|
|
{
|
|
Audio.PlaySound("snd_dtrans_lw.ogg", 1f, 1.1f);
|
|
DoDiag(new string[1] { Texts.common[129].Replace("@", "\n") });
|
|
SaveFile.current.values[7]++;
|
|
for (int j = 0; j < SaveFile.current.activeParty.Count; j++)
|
|
{
|
|
Party.party[SaveFile.current.activeParty[j]].AddBonus();
|
|
}
|
|
Party.UpdateStats();
|
|
Party.UpdateHUD();
|
|
}
|
|
else
|
|
{
|
|
DoDiag(new string[1] { Texts.common[128].Replace("@", "\n").Replace("[EXP]", prizeE.ToString()).Replace("[MONEY]", prizeM.ToString()) });
|
|
}
|
|
SaveFile.AddMoney(prizeM);
|
|
while (diag.Count > 0)
|
|
{
|
|
yield return null;
|
|
}
|
|
Audio.ChangeMusic(owMusic);
|
|
started = false;
|
|
doBG = false;
|
|
Coroutine c = Coroutine.Start(FinalizeBattle(p));
|
|
while (!c.done)
|
|
{
|
|
yield return null;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (endState != EndState.None)
|
|
{
|
|
lastResult = endState;
|
|
}
|
|
started = false;
|
|
doBG = false;
|
|
DWMenu.instance.showHP = 0f;
|
|
Audio.ChangeMusic((Audio.AudioBlock)null, 5f);
|
|
}
|
|
}
|
|
|
|
public IEnumerator FinalizeBattle(Vector2[] p = null)
|
|
{
|
|
for (int i = 0; i < toDelete.Count; i++)
|
|
{
|
|
if (GodotObject.IsInstanceValid(toDelete[i]))
|
|
{
|
|
toDelete[i].QueueFree();
|
|
}
|
|
}
|
|
if (p == null)
|
|
{
|
|
p = new Vector2[party.Count];
|
|
for (int j = 0; j < party.Count; j++)
|
|
{
|
|
p[j] = party[j].entity.GlobalPosition;
|
|
}
|
|
}
|
|
for (float a = 0f; a < 20f; a += Main.deltaTime)
|
|
{
|
|
for (int k = 0; k < party.Count; k++)
|
|
{
|
|
party[k].entity.doTrail = true;
|
|
party[k].entity.GlobalPosition = p[k].Lerp(party[k].oEntity.GlobalPosition, a / 20f);
|
|
}
|
|
DWMenu.instance.battleBG.Modulate = DWMenu.instance.battleBG.Modulate.Lerp(Main.colorClear, a / 20f);
|
|
yield return null;
|
|
}
|
|
Room.UpdateEntityList();
|
|
foreach (Entity entity in Room.current.entities)
|
|
{
|
|
Main.SetActive(entity, state: true);
|
|
}
|
|
for (int l = 0; l < party.Count; l++)
|
|
{
|
|
Main.SetActive(party[l].oEntity, state: true);
|
|
DWMenu.instance.partyHUDs[l].battleStuff.Visible = false;
|
|
}
|
|
Room.current.ProcessMode = ProcessModeEnum.Inherit;
|
|
DWMenu.instance.showHP = 0f;
|
|
Player.instance.canInput = Main.inEvent == null || Main.inEvent.done;
|
|
DWMenu.instance.battleCover.Visible = false;
|
|
if (caller != null)
|
|
{
|
|
SaveFile.AddFlag(caller.flag);
|
|
if (GodotObject.IsInstanceValid(caller))
|
|
{
|
|
caller.QueueFree();
|
|
}
|
|
}
|
|
Party.StopMoving();
|
|
current = null;
|
|
QueueFree();
|
|
GC.Collect();
|
|
}
|
|
|
|
public static IEnumerator KillAnim(Entity entity, float startDelay = 0f)
|
|
{
|
|
float a;
|
|
if (startDelay > 0f)
|
|
{
|
|
for (a = 0f; a < startDelay; a += Main.deltaTime)
|
|
{
|
|
yield return null;
|
|
}
|
|
}
|
|
entity.Shake(99999f, 1f);
|
|
Audio.PlaySound("snd_vaporized.wav", 1f, 0.8f);
|
|
entity.Modulate = Main.colorRed;
|
|
entity.sprite.Material = (Material)GD.Load<Material>("res://Materials/Dissolve.tres").Duplicate();
|
|
StringName d = "shader_parameter/progress";
|
|
a = 0f;
|
|
for (float b = 120f; a < b; a += Main.deltaTime)
|
|
{
|
|
entity.sprite.Material.Set(d, Mathf.Lerp(0f, 1f, a / b));
|
|
yield return null;
|
|
}
|
|
entity.Visible = false;
|
|
}
|
|
|
|
public static IEnumerator KillAnim(Battlers target, float startDelay = 0f)
|
|
{
|
|
target.fleeing = true;
|
|
Coroutine anim = Coroutine.Start(KillAnim(target.entity, startDelay));
|
|
while (!anim.done)
|
|
{
|
|
yield return null;
|
|
}
|
|
RemoveEnemy(target, EndState.Executed);
|
|
target.Delete();
|
|
yield return null;
|
|
}
|
|
|
|
public static IEnumerator Flee(Battlers target, float startDelay = 30f)
|
|
{
|
|
target.fleeing = true;
|
|
target.entity.AddChild(new Sprite2D
|
|
{
|
|
Texture = GD.Load<Texture2D>("res://Sprites/Menus/Menu Sprites/Sweat.tres"),
|
|
Position = target.center + new Vector2(-16f, -16f)
|
|
}, forceReadableName: false, InternalMode.Disabled);
|
|
if (!target.dontFlee)
|
|
{
|
|
Audio.PlaySound("snd_defeatrun.wav");
|
|
if (startDelay > 0f)
|
|
{
|
|
for (float a = 0f; a < startDelay; a += Main.deltaTime)
|
|
{
|
|
yield return null;
|
|
}
|
|
}
|
|
Vector2 p = target.entity.Position;
|
|
target.entity.doTrail = true;
|
|
for (float a = 0f; a < 7f; a += Main.deltaTime)
|
|
{
|
|
target.entity.Position = new Vector2(Mathf.Lerp(p.X, 200f, a / 7f), p.Y);
|
|
yield return null;
|
|
}
|
|
}
|
|
RemoveEnemy(target, EndState.Defeated);
|
|
if (!target.dontFlee)
|
|
{
|
|
target.Delete();
|
|
}
|
|
yield return null;
|
|
}
|
|
|
|
public static void RemoveEnemy(Battlers target, EndState defeatType)
|
|
{
|
|
for (int i = 0; i < current.party.Count; i++)
|
|
{
|
|
int[] selectedAction = current.party[i].selectedAction;
|
|
if (selectedAction != null && selectedAction.Length > 1)
|
|
{
|
|
int[] selectedAction2 = current.party[i].selectedAction;
|
|
if (((selectedAction2 != null) ? new int?(selectedAction2[1]) : ((int?)null)) > target.posID)
|
|
{
|
|
current.party[i].selectedAction[1]--;
|
|
}
|
|
}
|
|
}
|
|
current.toDelete.Add(target.entity);
|
|
current.enemies.Remove(target);
|
|
current.allBattlers.Remove(target);
|
|
for (int j = 0; j < current.enemies.Count; j++)
|
|
{
|
|
current.enemies[j].posID = j;
|
|
}
|
|
if (current.caller != null && current.caller.respawnType != Enemy.Respawn.No && (current.caller.respawnType != Enemy.Respawn.NoMoney || SaveFile.HasFlag(current.caller.flag)))
|
|
{
|
|
return;
|
|
}
|
|
current.resultAmts[(int)defeatType][1]++;
|
|
switch (defeatType)
|
|
{
|
|
case EndState.Executed:
|
|
SaveFile.current.values[3]++;
|
|
break;
|
|
case EndState.Spared:
|
|
SaveFile.current.values[1]++;
|
|
current.prizeM += target.MONEY + SaveFile.current.values[1];
|
|
break;
|
|
case EndState.Defeated:
|
|
SaveFile.current.values[2]++;
|
|
current.prizeM += target.MONEY * 2;
|
|
break;
|
|
case EndState.Apprehended:
|
|
if (!target.isOutlaw && !SaveFile.current.apprehended.Contains(target.entity.id))
|
|
{
|
|
SaveFile.current.apprehended.Add(target.entity.id);
|
|
}
|
|
SaveFile.current.values[4]++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
public static IEnumerator ActEffect(Battlers b, float startDelay = 15f, bool flipDir = false)
|
|
{
|
|
if (startDelay > 0f)
|
|
{
|
|
for (float a = 0f; a < startDelay; a += Main.deltaTime)
|
|
{
|
|
yield return null;
|
|
}
|
|
}
|
|
Sprite2D[] sp = new Sprite2D[3];
|
|
for (int i = 0; i < sp.Length; i++)
|
|
{
|
|
if (b.enemy)
|
|
{
|
|
Entity entity = b.entity;
|
|
int num = i;
|
|
Sprite2D obj = new Sprite2D
|
|
{
|
|
Texture = b.entity.sprite.Texture,
|
|
Hframes = b.entity.sprite.Hframes,
|
|
Vframes = b.entity.sprite.Vframes,
|
|
RegionEnabled = b.entity.sprite.RegionEnabled,
|
|
RegionRect = b.entity.sprite.RegionRect,
|
|
Frame = Mathf.Clamp(b.actFrame, 0, b.entity.sprite.Hframes * b.entity.sprite.Vframes),
|
|
ZIndex = -1 * (i + 1),
|
|
Offset = b.entity.sprite.Offset
|
|
};
|
|
Sprite2D node = obj;
|
|
sp[num] = obj;
|
|
entity.AddChild(node, forceReadableName: false, InternalMode.Disabled);
|
|
}
|
|
else
|
|
{
|
|
Entity entity2 = b.entity;
|
|
int num2 = i;
|
|
Sprite2D obj2 = new Sprite2D
|
|
{
|
|
Texture = GD.Load<Texture2D>("res://Sprites/Particles/Act/" + b.id.ToString() + ".tres"),
|
|
ZIndex = -1 * (i + 1),
|
|
Offset = b.entity.sprite.Offset
|
|
};
|
|
Sprite2D node = obj2;
|
|
sp[num2] = obj2;
|
|
entity2.AddChild(node, forceReadableName: false, InternalMode.Disabled);
|
|
}
|
|
}
|
|
for (float a = 0f; a < 120f; a += Main.deltaTime)
|
|
{
|
|
for (int j = 0; j < sp.Length; j++)
|
|
{
|
|
if (GodotObject.IsInstanceValid(sp[j]))
|
|
{
|
|
sp[j].GlobalPosition += Vector2.Right * 0.35f * j * Main.deltaTime * (1f - a / 120f) * ((!flipDir) ? 1 : (-1));
|
|
sp[j].Modulate = Main.colorTransparent.Lerp(Main.colorClear, a / 120f);
|
|
}
|
|
}
|
|
yield return null;
|
|
}
|
|
for (int k = 0; k < sp.Length; k++)
|
|
{
|
|
if (GodotObject.IsInstanceValid(sp[k]))
|
|
{
|
|
sp[k].Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void UpdateSoul(BulletBoards.SoulType mode = BulletBoards.SoulType.Current)
|
|
{
|
|
if (mode == BulletBoards.SoulType.Current)
|
|
{
|
|
mode = defaultSoul;
|
|
}
|
|
switch (mode)
|
|
{
|
|
case BulletBoards.SoulType.Blue:
|
|
soul.RotationDegrees = 0f;
|
|
DWMenu.instance.soul.SelfModulate = Main.colorBlue;
|
|
break;
|
|
case BulletBoards.SoulType.Yellow:
|
|
soul.RotationDegrees = 0f;
|
|
DWMenu.instance.soul.SelfModulate = Main.colorYellow;
|
|
break;
|
|
case BulletBoards.SoulType.Shoot:
|
|
soul.RotationDegrees = -90f;
|
|
DWMenu.instance.soul.SelfModulate = Main.colorYellow;
|
|
break;
|
|
}
|
|
currentMode = mode;
|
|
}
|
|
|
|
public static void UpdateTP(ref int internalValue, in int amt, in int preview, int mod = 0)
|
|
{
|
|
if (internalValue != amt)
|
|
{
|
|
if (internalValue > amt)
|
|
{
|
|
internalValue--;
|
|
}
|
|
else
|
|
{
|
|
internalValue++;
|
|
}
|
|
}
|
|
float num = (float)internalValue / 100f;
|
|
DWMenu.instance.tpBar[1].Scale = new Vector2(1f, num);
|
|
DWMenu.instance.tpBar[2].Visible = (float)internalValue > 2f;
|
|
DWMenu.instance.tpBar[2].Position = new Vector2(0f, Mathf.Lerp(98f, -98f, num));
|
|
DWMenu.instance.tpBar[2].Scale = new Vector2(1f, Mathf.Clamp((float)Mathf.Clamp(preview, 0, amt) / 100f, 0.01f, 1f));
|
|
if (amt >= 100)
|
|
{
|
|
DWMenu.instance.tpBar[1].Modulate = DWMenu.instance.TPColors[2];
|
|
}
|
|
else
|
|
{
|
|
DWMenu.instance.tpBar[1].Modulate = DWMenu.instance.TPColors[1];
|
|
}
|
|
if (preview > 0)
|
|
{
|
|
DWMenu.instance.tpBar[2].Modulate = DWMenu.instance.TPColors[0].Lerp(Main.colorWhite, Mathf.Abs(Common.SinOverTime(0.35f)));
|
|
}
|
|
else
|
|
{
|
|
DWMenu.instance.tpBar[2].Modulate = DWMenu.instance.TPColors[0];
|
|
}
|
|
if (mod == 1)
|
|
{
|
|
if (amt >= 100)
|
|
{
|
|
DWMenu.instance.tpText.Text = "[color=yellow] M\n A\n X";
|
|
}
|
|
else
|
|
{
|
|
DWMenu.instance.tpText.Text = " " + internalValue + "\n %";
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool UseOnParty(int i)
|
|
{
|
|
if (party[i].selectedAction[0] != 3)
|
|
{
|
|
return Texts.skills[(Acts.IDs)party[i].selectedAction[2]].useOnParty;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private IEnumerator DoSpells()
|
|
{
|
|
for (int i = 0; i < party.Count; i++)
|
|
{
|
|
if (forceEnd)
|
|
{
|
|
yield break;
|
|
}
|
|
if (enemies.Count <= 0 || !party[i].CanAct())
|
|
{
|
|
continue;
|
|
}
|
|
int[] selectedAction = party[i].selectedAction;
|
|
if (selectedAction == null || selectedAction.Length == 0 || (party[i].selectedAction[0] != 2 && party[i].selectedAction[0] != 1 && party[i].selectedAction[0] != 3))
|
|
{
|
|
continue;
|
|
}
|
|
currentlyActing = party[i];
|
|
Acts.IDs key = (Acts.IDs)party[i].selectedAction[2];
|
|
if (party[i].selectedAction[0] == 3)
|
|
{
|
|
key = Acts.IDs.UseItem;
|
|
}
|
|
Battlers battlers;
|
|
if (party[i].selectedAction[0] == 3 || Texts.skills[key].useOnParty)
|
|
{
|
|
if (party[i].selectedAction[0] == 3)
|
|
{
|
|
if (!Texts.items[(Items.IDs)party[i].selectedAction[2]].useOnEnemy)
|
|
{
|
|
battlers = party[party[i].selectedAction[1]];
|
|
}
|
|
else
|
|
{
|
|
party[i].selectedAction[1] = (int)Main.Repeat(party[i].selectedAction[1], enemies.Count);
|
|
battlers = enemies[party[i].selectedAction[1]];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
battlers = party[party[i].selectedAction[1]];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
party[i].selectedAction[1] = (int)Main.Repeat(party[i].selectedAction[1], enemies.Count);
|
|
battlers = enemies[party[i].selectedAction[1]];
|
|
}
|
|
if (party[i].selectedAction[0] == 1 && Texts.skills[key].spAction)
|
|
{
|
|
party[i].selectedAction[0] = 2;
|
|
party[i].selectedAction[2] = (int)enemyData[battlers.id].acts[enemyData[battlers.id].partyAction[Main.RandomRange(0, enemyData[battlers.id].partyAction.Count - 1)]];
|
|
key = (Acts.IDs)party[i].selectedAction[2];
|
|
}
|
|
List<Battlers> list = new List<Battlers> { party[i] };
|
|
if (party[i].selectedAction[0] == 2)
|
|
{
|
|
party[i].entity.currentAnim = Entity.Animations.ActDo;
|
|
battlers.lastestAct.Add(party[i].selectedAction[2]);
|
|
Coroutine.Start(ActEffect(party[i]));
|
|
if (actExtra.ContainsKey(i))
|
|
{
|
|
for (int j = 0; j < actExtra[i].Length; j++)
|
|
{
|
|
Party.party[(int)actExtra[i][j]].entity.currentAnim = Entity.Animations.ActDo;
|
|
Coroutine.Start(ActEffect(Party.party[(int)actExtra[i][j]]));
|
|
list.Add(Party.party[(int)actExtra[i][j]]);
|
|
}
|
|
}
|
|
}
|
|
else if (party[i].selectedAction[0] == 3)
|
|
{
|
|
party[i].entity.currentAnim = Entity.Animations.ItemDo;
|
|
}
|
|
else
|
|
{
|
|
party[i].entity.currentAnim = Entity.Animations.SkillDo;
|
|
}
|
|
DWMenu.instance.battleText.Text = "";
|
|
Coroutine acting = Acts.DoActRoutine(key.ToString(), battlers, list.ToArray());
|
|
while (!acting.done)
|
|
{
|
|
yield return null;
|
|
}
|
|
party[i].entity.currentAnim = Entity.Animations.BattleIdle;
|
|
if (actExtra.ContainsKey(i))
|
|
{
|
|
for (int k = 0; k < actExtra[i].Length; k++)
|
|
{
|
|
Party.party[(int)actExtra[i][k]].entity.currentAnim = Entity.Animations.BattleIdle;
|
|
}
|
|
}
|
|
}
|
|
if (enemies.Count == 0 || forceEnd)
|
|
{
|
|
busy = Coroutine.Start(EndBattle());
|
|
}
|
|
else
|
|
{
|
|
state = State.DoAttack;
|
|
}
|
|
}
|
|
|
|
private IEnumerator DoAttack()
|
|
{
|
|
if (forceEnd)
|
|
{
|
|
yield break;
|
|
}
|
|
DWMenu.instance.battleText.Text = "";
|
|
List<int> list = new List<int>();
|
|
List<int> order = new List<int>();
|
|
for (int i = 0; i < party.Count; i++)
|
|
{
|
|
int[] selectedAction = party[i].selectedAction;
|
|
if (selectedAction != null && selectedAction[0] == 0)
|
|
{
|
|
list.Add(i);
|
|
order.Add(i);
|
|
}
|
|
}
|
|
if (list.Count > 0)
|
|
{
|
|
AttackActionCommand.actionCD = 0f;
|
|
AttackActionCommand[] bars = new AttackActionCommand[list.Count];
|
|
order = order.OrderBy((int x) => Guid.NewGuid()).ToList();
|
|
for (int num = 0; num < list.Count; num++)
|
|
{
|
|
bars[num] = GD.Load<PackedScene>("res://Objects/UI/ActionCommand.tscn").Instantiate<AttackActionCommand>(PackedScene.GenEditState.Disabled);
|
|
bars[num].ProcessPriority = order.Count - num;
|
|
bars[num].linked = party[order[num]];
|
|
AddChild(bars[num], forceReadableName: false, InternalMode.Disabled);
|
|
if (SaveFile.current.activeParty.Count > 3)
|
|
{
|
|
bars[num].Scale = new Vector2(1f, 0.5f);
|
|
bars[num].Position = new Vector2(-94f, 76 + 9 * list[num]);
|
|
}
|
|
else
|
|
{
|
|
bars[num].Position = new Vector2(-94f, 76 + 17 * list[num]);
|
|
}
|
|
}
|
|
List<int> list2 = new List<int>();
|
|
for (int num2 = 0; num2 < bars.Length; num2++)
|
|
{
|
|
for (int num3 = 0; num3 < bars.Length; num3++)
|
|
{
|
|
if (num2 != num3 && !list2.Contains(num3) && Mathf.Abs(bars[num3].bar.Position.X - bars[num2].bar.Position.X) < 15f)
|
|
{
|
|
list2.Add(num3);
|
|
bars[num3].bar.Position = new Vector2(bars[num2].bar.Position.X, bars[num3].bar.Position.Y);
|
|
}
|
|
}
|
|
}
|
|
yield return null;
|
|
Common.FillArray(ref order, order.Count, 0);
|
|
order = order.OrderBy((int x) => bars[x].bar.Position.X).ToList();
|
|
bool flag;
|
|
do
|
|
{
|
|
if (AttackActionCommand.actionCD > 0f)
|
|
{
|
|
AttackActionCommand.actionCD -= Main.deltaTime;
|
|
}
|
|
if (Input.IsActionJustPressed(Main.keys[4]))
|
|
{
|
|
for (int num4 = 0; num4 < bars.Length; num4++)
|
|
{
|
|
if (bars[order[num4]].active)
|
|
{
|
|
continue;
|
|
}
|
|
bars[order[num4]].Activate();
|
|
for (int num5 = 0; num5 < bars.Length; num5++)
|
|
{
|
|
if (order[num5] != order[num4] && !bars[order[num5]].active && Mathf.Abs(bars[order[num5]].bar.Position.X - bars[order[num4]].bar.Position.X) < 15f)
|
|
{
|
|
bars[order[num5]].Activate();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
yield return null;
|
|
flag = false;
|
|
for (int num6 = 0; num6 < bars.Length; num6++)
|
|
{
|
|
if (GodotObject.IsInstanceValid(bars[num6]))
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
}
|
|
while (flag);
|
|
}
|
|
bool flag2;
|
|
do
|
|
{
|
|
yield return null;
|
|
flag2 = false;
|
|
for (int num7 = 0; num7 < fleeing.Count; num7++)
|
|
{
|
|
Coroutine coroutine = fleeing[num7];
|
|
if (coroutine != null && !coroutine.done)
|
|
{
|
|
flag2 = true;
|
|
}
|
|
}
|
|
}
|
|
while (flag2);
|
|
fleeing.Clear();
|
|
yield return null;
|
|
if (enemies.Count == 0)
|
|
{
|
|
busy = Coroutine.Start(EndBattle());
|
|
yield break;
|
|
}
|
|
yield return null;
|
|
state = State.DoEnemy;
|
|
}
|
|
|
|
private void Graze(Node other)
|
|
{
|
|
IBullet parentOrNull = other.GetParentOrNull<IBullet>();
|
|
if (parentOrNull != null && !parentOrNull.grazed && iFrames <= 0f && grazeCD <= 0f)
|
|
{
|
|
parentOrNull.grazed = true;
|
|
Audio.PlaySound("snd_graze.wav");
|
|
TP = Mathf.Clamp(TP + (grazed ? 2 : 3), 0, 100);
|
|
grazed = true;
|
|
grazeCD = 5f;
|
|
activeBoard.timer -= 2f;
|
|
DWMenu.instance.grazeIndicator.SelfModulate = Main.colorWhite;
|
|
}
|
|
}
|
|
|
|
public Control DoBlurb(Battlers enemy, int id, ref RichTextLabel label)
|
|
{
|
|
if (enemy.blurbOverride > -1)
|
|
{
|
|
id = enemy.blurbOverride;
|
|
}
|
|
Control control;
|
|
AddChild(control = GD.Load<PackedScene>("res://Objects/UI/Bubble.tscn").Instantiate<Control>(PackedScene.GenEditState.Disabled), forceReadableName: false, InternalMode.Disabled);
|
|
BattleBlurbs[] blurbs = enemy.blurbs;
|
|
BattleBlurbs battleBlurbs = ((blurbs != null && blurbs.Length > 1 && enemy.blurbs[id] != null) ? enemy.blurbs[id] : null);
|
|
if (battleBlurbs == null)
|
|
{
|
|
battleBlurbs = new BattleBlurbs();
|
|
}
|
|
Vector2 vector = battleBlurbs.size;
|
|
if (vector.LengthSquared() < enemy.defaultBubbleSize.LengthSquared())
|
|
{
|
|
vector = enemy.defaultBubbleSize;
|
|
}
|
|
control.GlobalPosition = enemy.entity.GlobalPosition + enemy.center + new Vector2(-20f + Mathf.Min(battleBlurbs.offset.X, vector.X / -2f), battleBlurbs.offset.Y);
|
|
label = control.GetChild(0).GetChild<RichTextLabel>(0);
|
|
label.Text = blurbText[enemy.id][id].Replace("@", "\n");
|
|
control.GetChild<NinePatchRect>(0).Size = new Vector2(vector.X, Mathf.Max((float)label.GetLineCount() * 4.5f, vector.Y));
|
|
float volume = 1f;
|
|
string diagSound = enemy.diagSound;
|
|
if (diagSound != null && diagSound.Length > 0)
|
|
{
|
|
TextSystem.AssignBleep(enemy.diagSound, ref volume);
|
|
}
|
|
else
|
|
{
|
|
TextSystem.bleepPlayer.Stream = TextSystem.defaultBleep;
|
|
}
|
|
return control;
|
|
}
|
|
|
|
private string AnySpecial()
|
|
{
|
|
for (int i = 0; i < enemies.Count; i++)
|
|
{
|
|
if (enemies[i].hasSpecial > -1 && enemies[i].CanSpecial())
|
|
{
|
|
return enemies[i].bulletBoards[enemies[i].hasSpecial].ResourceName;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private IEnumerator DoEnemy()
|
|
{
|
|
string special = AnySpecial();
|
|
if (special != null && specialWarning)
|
|
{
|
|
activeBoard = GD.Load<PackedScene>("res://Objects/BulletBoards/" + special + ".tscn").Instantiate<BulletBoards>(PackedScene.GenEditState.Disabled);
|
|
lastBoard = activeBoard.id;
|
|
lastAttack = activeBoard.Name;
|
|
}
|
|
else
|
|
{
|
|
special = null;
|
|
List<object[]> list = new List<object[]>();
|
|
List<object[]> list2 = new List<object[]>();
|
|
for (int i = 0; i < enemies.Count; i++)
|
|
{
|
|
if (enemies[i].skipAttack)
|
|
{
|
|
continue;
|
|
}
|
|
for (int j = 0; j < enemies[i].bulletBoards.Length; j++)
|
|
{
|
|
if (!enemies[i].bulletBoards[j].CanDo(enemies[i]))
|
|
{
|
|
continue;
|
|
}
|
|
if (enemies[i].bulletBoards[j].weight == -1)
|
|
{
|
|
list2.Add(new object[2]
|
|
{
|
|
enemies[i].bulletBoards[j].ResourceName,
|
|
enemies[i]
|
|
});
|
|
continue;
|
|
}
|
|
if (enemies[i].bulletBoards[j].weight >= 50)
|
|
{
|
|
list.Clear();
|
|
list.Add(new object[2]
|
|
{
|
|
enemies[i].bulletBoards[j].ResourceName,
|
|
enemies[i]
|
|
});
|
|
break;
|
|
}
|
|
for (int k = 0; k < enemies[i].bulletBoards[j].weight; k++)
|
|
{
|
|
list.Add(new object[2]
|
|
{
|
|
enemies[i].bulletBoards[j].ResourceName,
|
|
enemies[i]
|
|
});
|
|
}
|
|
}
|
|
}
|
|
int num = 2;
|
|
string text;
|
|
int index;
|
|
while (true)
|
|
{
|
|
text = null;
|
|
index = 0;
|
|
if (list.Count == 0)
|
|
{
|
|
if (list2.Count > 0)
|
|
{
|
|
index = Main.RandomRange(0, list2.Count - 1);
|
|
text = (string)list2[index][0];
|
|
}
|
|
else
|
|
{
|
|
state = State.EndTurn;
|
|
}
|
|
break;
|
|
}
|
|
index = Main.RandomRange(0, list.Count - 1);
|
|
text = (string)list[index][0];
|
|
if (!((StringName)text == lastAttack) || num <= 0)
|
|
{
|
|
break;
|
|
}
|
|
num--;
|
|
}
|
|
if (text != null)
|
|
{
|
|
activeBoard = GD.Load<PackedScene>("res://Objects/BulletBoards/" + text + ".tscn").Instantiate<BulletBoards>(PackedScene.GenEditState.Disabled);
|
|
if (list.Count > 0)
|
|
{
|
|
activeBoard.caller = (Battlers)list[index][1];
|
|
}
|
|
lastBoard = activeBoard.id;
|
|
lastAttack = activeBoard.Name;
|
|
}
|
|
}
|
|
AnimatedSprite2D[] reticle = null;
|
|
List<int> target = new List<int>();
|
|
if (GodotObject.IsInstanceValid(activeBoard))
|
|
{
|
|
DWMenu.instance.bulletBoard.Size = activeBoard.boardSize;
|
|
DWMenu.instance.bulletBoard.AnchorsPreset = 8;
|
|
DWMenu.instance.bulletBoardPivot.Position = DWMenu.boardCenter + activeBoard.boardStartOffset;
|
|
if (focusAtk > -1)
|
|
{
|
|
activeBoard.target = BulletBoards.Target.OnlyOne;
|
|
}
|
|
if (activeBoard.target == BulletBoards.Target.OnlyOne)
|
|
{
|
|
int num2 = ((SaveFile.current.activeParty.Count < 3) ? 1 : GD.RandRange(2, 3));
|
|
for (int l = 0; l < num2 && l < party.Count && l < Party.AlivePartyAmount(); l++)
|
|
{
|
|
target.Add(-1);
|
|
if (focusAtk > -1)
|
|
{
|
|
target[0] = focusAtk;
|
|
break;
|
|
}
|
|
do
|
|
{
|
|
target[l] = Main.RandomRange(0, party.Count - 1);
|
|
}
|
|
while (party[target[l]].HP <= 0);
|
|
}
|
|
reticle = new AnimatedSprite2D[target.Count];
|
|
for (int m = 0; m < reticle.Length; m++)
|
|
{
|
|
AddChild(reticle[m] = GD.Load<PackedScene>("res://Objects/Particles/Reticle.tscn").Instantiate<AnimatedSprite2D>(PackedScene.GenEditState.Disabled), forceReadableName: false, InternalMode.Disabled);
|
|
reticle[m].GlobalPosition = party[target[m]].entity.GlobalPosition + party[target[m]].center + Vector2.Up * 8f;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
reticle = new AnimatedSprite2D[party.Count];
|
|
for (int n = 0; n < reticle.Length; n++)
|
|
{
|
|
AddChild(reticle[n] = GD.Load<PackedScene>("res://Objects/Particles/Reticle.tscn").Instantiate<AnimatedSprite2D>(PackedScene.GenEditState.Disabled), forceReadableName: false, InternalMode.Disabled);
|
|
reticle[n].GlobalPosition = party[n].entity.GlobalPosition + party[n].center;
|
|
}
|
|
}
|
|
}
|
|
yield return null;
|
|
Control[] blurbs = new Control[enemies.Count];
|
|
RichTextLabel[] text2 = new RichTextLabel[enemies.Count];
|
|
for (int num3 = 0; num3 < enemies.Count; num3++)
|
|
{
|
|
if (!enAnim.Contains(enemies[num3].entity.anim.CurrentAnimation) && !enemies[num3].lockAnim)
|
|
{
|
|
enemies[num3].entity.anim.Play("Idle");
|
|
}
|
|
int[] blurbOrder = enemies[num3].blurbOrder;
|
|
if (blurbOrder != null && blurbOrder.Length != 0 && turn < enemies[num3].blurbOrder.Length)
|
|
{
|
|
blurbs[num3] = DoBlurb(enemies[num3], enemies[num3].blurbCount, ref text2[num3]);
|
|
if (enemies[num3].blurbOverride == -1)
|
|
{
|
|
enemies[num3].blurbCount++;
|
|
}
|
|
continue;
|
|
}
|
|
int[] randomBlurbs = enemies[num3].randomBlurbs;
|
|
if (randomBlurbs != null && randomBlurbs.Length != 0)
|
|
{
|
|
blurbs[num3] = DoBlurb(enemies[num3], enemies[num3].randomBlurbs[Main.RandomRange(0, enemies[num3].randomBlurbs.Length - 1)], ref text2[num3]);
|
|
continue;
|
|
}
|
|
List<int> list3 = new List<int>();
|
|
int num4 = -1;
|
|
for (int num5 = 0; num5 < enemies[num3].blurbs.Length; num5++)
|
|
{
|
|
if (enemies[num3].blurbOverride > -1)
|
|
{
|
|
num4 = enemies[num3].blurbOverride;
|
|
break;
|
|
}
|
|
if (enemies[num3].blurbs[num5].Can(enemies[num3]))
|
|
{
|
|
if (enemies[num3].blurbs[num5].weight >= 50)
|
|
{
|
|
list3 = null;
|
|
num4 = num5;
|
|
break;
|
|
}
|
|
for (int num6 = 0; num6 < enemies[num3].blurbs[num5].weight; num6++)
|
|
{
|
|
list3.Add(num5);
|
|
}
|
|
}
|
|
}
|
|
if (list3 != null)
|
|
{
|
|
if (num4 == -1 && list3.Count > 0)
|
|
{
|
|
num4 = list3[Main.RandomRange(0, list3.Count - 1)];
|
|
}
|
|
else if (enemies[num3].blurbOverride == -1)
|
|
{
|
|
num4 = -1;
|
|
}
|
|
}
|
|
if (num4 == -1)
|
|
{
|
|
GD.Print("No blurbs found for " + enemies[num3].name);
|
|
num4 = 0;
|
|
}
|
|
blurbs[num3] = DoBlurb(enemies[num3], (enemies[num3].blurbs[num4].overrideIndex > -1) ? enemies[num3].blurbs[num4].overrideIndex : num4, ref text2[num3]);
|
|
}
|
|
TextSystem.bleepPlayer.Play();
|
|
while (true)
|
|
{
|
|
bool flag = true;
|
|
for (int num7 = 0; num7 < text2.Length; num7++)
|
|
{
|
|
text2[num7].VisibleCharacters++;
|
|
if (text2[num7].VisibleRatio < 1f)
|
|
{
|
|
flag = false;
|
|
}
|
|
}
|
|
if (flag && TextSystem.bleepPlayer.Playing)
|
|
{
|
|
TextSystem.bleepPlayer.Stop();
|
|
}
|
|
yield return null;
|
|
if (!Input.IsActionJustPressed(Main.keys[4]))
|
|
{
|
|
continue;
|
|
}
|
|
bool flag2 = false;
|
|
for (int num8 = 0; num8 < text2.Length; num8++)
|
|
{
|
|
RichTextLabel obj = text2[num8];
|
|
if (obj != null && obj.VisibleRatio < 1f)
|
|
{
|
|
text2[num8].VisibleCharacters = 999;
|
|
flag2 = true;
|
|
}
|
|
}
|
|
if (!flag2)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
TextSystem.bleepPlayer.Stop();
|
|
for (int num9 = 0; num9 < blurbs.Length; num9++)
|
|
{
|
|
blurbs[num9]?.Free();
|
|
}
|
|
Sprite2D soulShadow = null;
|
|
if (GodotObject.IsInstanceValid(activeBoard))
|
|
{
|
|
for (int num10 = 0; num10 < reticle.Length; num10++)
|
|
{
|
|
reticle[num10].Free();
|
|
}
|
|
soul.Visible = true;
|
|
soul.TopLevel = true;
|
|
soul.ZIndex = 4096;
|
|
soulShadow = new Sprite2D
|
|
{
|
|
Texture = DWMenu.instance.soul.Texture,
|
|
RegionEnabled = true,
|
|
RegionRect = DWMenu.instance.soul.RegionRect,
|
|
Modulate = new Color(soul.Modulate.R, soul.Modulate.G, soul.Modulate.B, 0.5f),
|
|
ZIndex = soul.ZIndex - 1,
|
|
TopLevel = true,
|
|
Position = Vector2.One * 999f
|
|
};
|
|
Vector2 boxCenter = DWMenu.instance.bulletBoardPivot.GlobalPosition + activeBoard.soulStartOffset;
|
|
Vector2 pcCenter = party[0].entity.GlobalPosition + party[0].center;
|
|
soul.GetParent().AddChild(soulShadow, forceReadableName: false, InternalMode.Disabled);
|
|
soul.GlobalPosition = Vector2.One * 9999f;
|
|
Main.SetActive(DWMenu.instance.bulletBoardPivot, state: true);
|
|
UpdateSoul(activeBoard.soulType);
|
|
Main.Particle("SoulSplit", Vector2.Up * 16f, 1, party[0].entity);
|
|
DWMenu.instance.bulletBoard.Visible = true;
|
|
float a;
|
|
for (a = 0f; a <= activeBoard.growTime; a += Main.deltaTime)
|
|
{
|
|
Room.current.Modulate = Main.colorWhite.Lerp(Main.colorDark, a / activeBoard.growTime);
|
|
DWMenu.instance.bulletBoardPivot.Scale = Vector2.Zero.Lerp(Vector2.One, a / activeBoard.growTime);
|
|
if ((int)a % 3 == 0 && a > 0f)
|
|
{
|
|
soulShadow.GlobalPosition = soul.GlobalPosition;
|
|
}
|
|
soul.GlobalPosition = pcCenter.Lerp(boxCenter, a / activeBoard.growTime);
|
|
if (activeBoard.special)
|
|
{
|
|
DWMenu.instance.bulletBoardPivot.Rotation = Mathf.Lerp(180f, 0f, a / activeBoard.growTime);
|
|
}
|
|
else
|
|
{
|
|
DWMenu.instance.bulletBoardPivot.Rotation = Mathf.LerpAngle(Mathf.DegToRad(90f), 0f, a / activeBoard.growTime);
|
|
}
|
|
for (int num11 = 0; num11 < allBattlers.Count; num11++)
|
|
{
|
|
allBattlers[num11].entity.Modulate = Main.colorWhite.Lerp(Main.colorDark, a / activeBoard.growTime);
|
|
}
|
|
yield return null;
|
|
}
|
|
DWMenu.instance.bulletBoardPivot.Scale = Vector2.One;
|
|
DWMenu.instance.bulletBoardPivot.Rotation = 0f;
|
|
for (int num12 = 0; num12 < 3; num12++)
|
|
{
|
|
if (num12 == 0)
|
|
{
|
|
DWMenu.instance.bulletBoard.GetChild<Control>(0).Visible = false;
|
|
}
|
|
else
|
|
{
|
|
DWMenu.instance.bulletBoard.GetChild(0).GetChild<Control>(num12 - 1).Visible = false;
|
|
}
|
|
yield return null;
|
|
}
|
|
soulShadow.Visible = false;
|
|
DWMenu.instance.soulHitbox.Enabled = true;
|
|
DWMenu.instance.soulHitbox.ForceShapecastUpdate();
|
|
iFrames = 0f;
|
|
soulColor = DWMenu.instance.soul.SelfModulate;
|
|
DWMenu.instance.bulletBoardPivot.AddChild(activeBoard, forceReadableName: false, InternalMode.Disabled);
|
|
soul.Reparent(DWMenu.instance.bulletBoardPivot);
|
|
activeBoard.targeted = target.ToArray();
|
|
yield return null;
|
|
do
|
|
{
|
|
if (BulletBoardInput())
|
|
{
|
|
yield break;
|
|
}
|
|
activeBoard.timer -= Main.deltaTime;
|
|
yield return null;
|
|
}
|
|
while (activeBoard.timer > 0f);
|
|
DWMenu.instance.bulletBoard.SelfModulate = Main.colorGreen;
|
|
soul.Reparent(DWMenu.instance);
|
|
DWMenu.instance.soul.SelfModulate = soulColor;
|
|
boxCenter = soul.GlobalPosition;
|
|
DWMenu.instance.soulHitbox.Enabled = false;
|
|
DWMenu.instance.soulBody.Velocity = Vector2.Zero;
|
|
activeBoard?.QueueFree();
|
|
yield return null;
|
|
for (int num13 = 0; num13 < enemies.Count; num13++)
|
|
{
|
|
if (special != null)
|
|
{
|
|
enemies[num13].internalFlags.Add("Special");
|
|
}
|
|
enemies[num13].entity.Position = enemies[num13].startPos;
|
|
enemies[num13].entity.UpdateAnim(force: true);
|
|
enemies[num13].entity.doTrail = false;
|
|
}
|
|
soulShadow.Visible = true;
|
|
soulShadow.GlobalPosition = soul.GlobalPosition;
|
|
a = 0f;
|
|
float i2 = 0f;
|
|
while (a <= 20f)
|
|
{
|
|
Room.current.Modulate = Main.colorDark.Lerp(Main.colorWhite, a / 20f);
|
|
if (i2 < 3f)
|
|
{
|
|
if (i2 == 0f)
|
|
{
|
|
DWMenu.instance.bulletBoard.GetChild<Control>(0).Visible = true;
|
|
}
|
|
else
|
|
{
|
|
DWMenu.instance.bulletBoard.GetChild(0).GetChild<Control>((int)i2 - 1).Visible = true;
|
|
}
|
|
yield return null;
|
|
}
|
|
for (int num14 = 0; num14 < allBattlers.Count; num14++)
|
|
{
|
|
allBattlers[num14].entity.Modulate = Main.colorWhite.Lerp(Main.colorDark, 1f - a / 20f);
|
|
}
|
|
DWMenu.instance.bulletBoardPivot.Rotation = Mathf.LerpAngle(0f, Mathf.DegToRad(90f), a / 20f);
|
|
DWMenu.instance.bulletBoardPivot.Scale = Vector2.Zero.Lerp(Vector2.One, 1f - a / 20f);
|
|
if ((int)a % 3 == 0 && a > 0f)
|
|
{
|
|
soulShadow.GlobalPosition = soul.GlobalPosition;
|
|
}
|
|
soul.GlobalPosition = pcCenter.Lerp(boxCenter, 1f - a / 20f);
|
|
yield return null;
|
|
a += Main.deltaTime;
|
|
i2 += 1f;
|
|
}
|
|
Main.Particle("SoulSplit", Vector2.Up * 16f, 1, party[0].entity);
|
|
}
|
|
UpdateSoul();
|
|
Room.current.Modulate = Main.colorWhite;
|
|
Main.SetActive(DWMenu.instance.bulletBoardPivot, state: false);
|
|
soulShadow?.Free();
|
|
soul.TopLevel = false;
|
|
soul.Visible = false;
|
|
state = State.EndTurn;
|
|
}
|
|
|
|
private bool BulletBoardInput()
|
|
{
|
|
if (shootCD > 0f)
|
|
{
|
|
shootCD -= Main.deltaTime;
|
|
}
|
|
switch (currentMode)
|
|
{
|
|
case BulletBoards.SoulType.Shoot:
|
|
if (shootCD <= 0f && shots.Count < 5 && ((!Settings.file.autoFire && Input.IsActionJustPressed(Main.keys[4])) || (Settings.file.autoFire && Input.IsActionPressed(Main.keys[4]))))
|
|
{
|
|
shootCD = 10f;
|
|
SoulBullet soulBullet;
|
|
activeBoard.AddChild(soulBullet = BattleDR.soulBullet.Instantiate<SoulBullet>(PackedScene.GenEditState.Disabled), forceReadableName: false, InternalMode.Disabled);
|
|
soulBullet.dir = Vector2.Up.Rotated(0f - soul.Rotation);
|
|
soulBullet.GlobalPosition = soul.GlobalPosition + soulBullet.dir * 3f;
|
|
shots.Add(soulBullet);
|
|
}
|
|
soul.Velocity = (Main.GetDirection() * Main.deltaTime).Normalized() * 55f;
|
|
soul.MotionMode = CharacterBody2D.MotionModeEnum.Floating;
|
|
break;
|
|
case BulletBoards.SoulType.Blue:
|
|
soul.MotionMode = CharacterBody2D.MotionModeEnum.Grounded;
|
|
break;
|
|
default:
|
|
soul.Velocity = (Main.GetDirection() * Main.deltaTime).Normalized() * 55f;
|
|
soul.MotionMode = CharacterBody2D.MotionModeEnum.Floating;
|
|
break;
|
|
}
|
|
soul.MoveAndSlide();
|
|
if (iFrames > 0f)
|
|
{
|
|
iFrames -= Main.deltaTime;
|
|
DWMenu.instance.soul.SelfModulate = soulColor.Lerp(Main.colorBlack, Mathf.Abs(Mathf.Sin(Mathf.DegToRad(Time.GetTicksMsec()))));
|
|
}
|
|
else
|
|
{
|
|
DWMenu.instance.soul.SelfModulate = soulColor;
|
|
if (DWMenu.instance.soulHitbox.GetCollisionCount() > 0 && PlayerHurt())
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool PlayerHurt()
|
|
{
|
|
IBullet bullet = null;
|
|
for (int i = 0; i < DWMenu.instance.soulHitbox.GetCollisionCount(); i++)
|
|
{
|
|
if (GodotObject.IsInstanceValid(DWMenu.instance.soulHitbox.GetCollider(i)))
|
|
{
|
|
Node parent = ((Node)DWMenu.instance.soulHitbox.GetCollider(i)).GetParent();
|
|
if (parent is IBullet bullet2)
|
|
{
|
|
bullet = bullet2;
|
|
break;
|
|
}
|
|
if (parent is SoulBullet)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
if (bullet != null)
|
|
{
|
|
switch (bullet.type)
|
|
{
|
|
case IBullet.Type.Blue:
|
|
if (soul.Velocity == Vector2.Zero)
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
case IBullet.Type.Orange:
|
|
if (soul.Velocity != Vector2.Zero)
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
if (shield != null)
|
|
{
|
|
CameraController.instance.shakeTime = 7f;
|
|
shield?.Free();
|
|
shield = null;
|
|
iFrames = 40 + Party.GetIframes();
|
|
Audio.PlaySound("snd_ceroba_shield_impact.wav");
|
|
return false;
|
|
}
|
|
float num = 0f;
|
|
if (activeBoard.caller == null)
|
|
{
|
|
for (int j = 0; j < enemies.Count; j++)
|
|
{
|
|
num += (float)enemies[j].ATK;
|
|
if (enemies[j].atkMod != null)
|
|
{
|
|
num += (float)enemies[j].atkMod[1];
|
|
}
|
|
num = Mathf.Clamp(num, (float)enemies[j].ATK / 2f, (float)enemies[j].ATK * 2f);
|
|
}
|
|
num /= (float)enemies.Count;
|
|
}
|
|
else
|
|
{
|
|
num += (float)activeBoard.caller.ATK;
|
|
if (activeBoard.caller.atkMod != null)
|
|
{
|
|
num += (float)activeBoard.caller.atkMod[1];
|
|
}
|
|
num = Mathf.Clamp(num, (float)activeBoard.caller.ATK / 2f, (float)activeBoard.caller.ATK * 2f);
|
|
}
|
|
num *= activeBoard.damageMult;
|
|
List<int> list = new List<int>();
|
|
if (activeBoard.target == BulletBoards.Target.OnlyOne)
|
|
{
|
|
list.Add(activeBoard.targeted[GD.RandRange(0, activeBoard.targeted.Length - 1)]);
|
|
}
|
|
else if (activeBoard.target == BulletBoards.Target.All)
|
|
{
|
|
for (int k = 0; k < party.Count; k++)
|
|
{
|
|
list.Add(k);
|
|
}
|
|
}
|
|
else if (activeBoard.target == BulletBoards.Target.RandomAll)
|
|
{
|
|
int num2;
|
|
do
|
|
{
|
|
num2 = Main.RandomRange(0, party.Count - 1);
|
|
}
|
|
while (party[num2].HP <= 0);
|
|
list.Add(num2);
|
|
}
|
|
CameraController.instance.shakeTime = 7f;
|
|
for (int l = 0; l < list.Count; l++)
|
|
{
|
|
if (party[list[l]].HP <= 0)
|
|
{
|
|
continue;
|
|
}
|
|
int num3 = Mathf.RoundToInt(Mathf.Clamp(num * (1f + Main.RandomRange(-0.1f, 0.1f)) - (float)party[list[l]].DEF, 1f, 999f));
|
|
if (party[list[l]].defMod != null)
|
|
{
|
|
num3 = Mathf.Clamp(num3 - party[list[l]].defMod[1], 0, 999);
|
|
}
|
|
int[] selectedAction = party[list[l]].selectedAction;
|
|
if (selectedAction != null && selectedAction[0] == 4)
|
|
{
|
|
num3 = (int)Mathf.Max((float)num3 / 2f, (float)num3 * 0.2f);
|
|
}
|
|
party[list[l]].HP -= num3;
|
|
if (activeBoard.cantKill)
|
|
{
|
|
party[list[l]].HP = Mathf.Clamp(party[list[l]].HP, 1, party[list[l]].MAXHP);
|
|
}
|
|
if (party[list[l]].HP <= 0)
|
|
{
|
|
if (Party.AlivePartyAmount() == 0)
|
|
{
|
|
soul.Reparent(DWMenu.instance);
|
|
activeBoard.QueueFree();
|
|
Coroutine.Start(GameOver.DoGameOver());
|
|
base.ProcessMode = ProcessModeEnum.Disabled;
|
|
return true;
|
|
}
|
|
party[list[l]].HP = -party[list[l]].MAXHP;
|
|
ShowFloatingText(Texts.common[127], party[list[l]].entity.GlobalPosition + new Vector2(-16f, 0f), Main.colorRed);
|
|
party[list[l]].entity.currentAnim = Entity.Animations.KO;
|
|
party[list[l]].selectedAction = null;
|
|
if (activeBoard.target == BulletBoards.Target.OnlyOne)
|
|
{
|
|
activeBoard.target = BulletBoards.Target.RandomAll;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ShowFloatingText(num3.ToString(), party[list[l]].entity.GlobalPosition + new Vector2(-16f, 0f), Main.colorWhite);
|
|
party[list[l]].entity.currentAnim = Entity.Animations.Hurt;
|
|
Entity entity = party[list[l]].entity;
|
|
int[] selectedAction2 = party[list[l]].selectedAction;
|
|
Coroutine.Start(entity.DelayedAnim(30f, (selectedAction2 != null && selectedAction2[0] == 4) ? Entity.Animations.Defend : Entity.Animations.BattleIdle));
|
|
}
|
|
}
|
|
Audio.PlaySound("snd_hurt1.wav");
|
|
Party.UpdateHUD();
|
|
iFrames = 40 + Party.GetIframes();
|
|
return false;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static Node2D NewBullet(in PackedScene type, Vector2 pos, Node2D parent = null, bool local = false)
|
|
{
|
|
Node2D node2D;
|
|
if (parent == null)
|
|
{
|
|
current.activeBoard.AddChild(node2D = type.Instantiate<Node2D>(PackedScene.GenEditState.Disabled), forceReadableName: false, InternalMode.Disabled);
|
|
}
|
|
else
|
|
{
|
|
parent.AddChild(node2D = type.Instantiate<Node2D>(PackedScene.GenEditState.Disabled), forceReadableName: false, InternalMode.Disabled);
|
|
}
|
|
if (local)
|
|
{
|
|
node2D.Position = pos;
|
|
}
|
|
else
|
|
{
|
|
node2D.GlobalPosition = pos;
|
|
}
|
|
node2D.ProcessMode = ProcessModeEnum.Inherit;
|
|
return node2D;
|
|
}
|
|
|
|
public static Node2D NewBullet(in Node2D type, Vector2 pos, Node2D parent = null, bool local = false)
|
|
{
|
|
Node2D node2D;
|
|
if (parent == null)
|
|
{
|
|
current.activeBoard.AddChild(node2D = (Node2D)type.Duplicate(), forceReadableName: false, InternalMode.Disabled);
|
|
}
|
|
else
|
|
{
|
|
parent.AddChild(node2D = (Node2D)type.Duplicate(), forceReadableName: false, InternalMode.Disabled);
|
|
}
|
|
if (local)
|
|
{
|
|
node2D.Position = pos;
|
|
}
|
|
else
|
|
{
|
|
node2D.GlobalPosition = pos;
|
|
}
|
|
node2D.ProcessMode = ProcessModeEnum.Inherit;
|
|
return node2D;
|
|
}
|
|
|
|
private IEnumerator AdvanceTurn()
|
|
{
|
|
turn++;
|
|
bool flag = false;
|
|
for (int i = 0; i < party.Count; i++)
|
|
{
|
|
party[i].selectedAction = null;
|
|
party[i].acted = false;
|
|
if (party[i].HP > 0)
|
|
{
|
|
party[i].entity.currentAnim = Entity.Animations.BattleIdle;
|
|
}
|
|
else
|
|
{
|
|
party[i].entity.currentAnim = Entity.Animations.KO;
|
|
}
|
|
int num = 0;
|
|
if (party[i].HP <= 0)
|
|
{
|
|
num += party[i].MAXHP / 3;
|
|
}
|
|
for (int j = 0; j < 3; j++)
|
|
{
|
|
if (party[i].EQUIP[j] > -1 && Texts.items[(Items.IDs)party[i].EQUIP[j]].healOverTime > 0)
|
|
{
|
|
num += Texts.items[(Items.IDs)party[i].EQUIP[j]].healOverTime;
|
|
}
|
|
}
|
|
if (num > 0)
|
|
{
|
|
Coroutine.Start(Heal(party[i], num, playParticles: false, doColor: false, showText: true, !flag));
|
|
flag = true;
|
|
}
|
|
}
|
|
for (int k = 0; k < enemies.Count; k++)
|
|
{
|
|
enemies[k].lastestAct.Clear();
|
|
enemies[k].blurbOverride = -1;
|
|
}
|
|
for (int l = 0; l < allBattlers.Count; l++)
|
|
{
|
|
int[] atkMod = allBattlers[l].atkMod;
|
|
if (atkMod != null && atkMod[0] > 0)
|
|
{
|
|
allBattlers[l].atkMod[0]--;
|
|
if (allBattlers[l].atkMod[0] == 0)
|
|
{
|
|
allBattlers[l].atkMod = null;
|
|
}
|
|
}
|
|
int[] defMod = allBattlers[l].defMod;
|
|
if (defMod != null && defMod[0] > 0)
|
|
{
|
|
allBattlers[l].defMod[0]--;
|
|
if (allBattlers[l].defMod[0] == 0)
|
|
{
|
|
allBattlers[l].defMod = null;
|
|
}
|
|
}
|
|
allBattlers[l].bulletSpeedMod = 0f;
|
|
}
|
|
Party.UpdateHUD();
|
|
firstMes = false;
|
|
grazed = false;
|
|
actExtra.Clear();
|
|
GetNextBattleText();
|
|
lastTP.Clear();
|
|
consumeItems.Clear();
|
|
lastActor.Clear();
|
|
option = 0;
|
|
focusAtk = -1;
|
|
maxOption = 5;
|
|
currentlyActing = null;
|
|
currentActor = -1;
|
|
for (float a = 0f; a < 3f; a += Main.deltaTime)
|
|
{
|
|
yield return null;
|
|
}
|
|
state = State.Next;
|
|
UpdateMenu();
|
|
}
|
|
|
|
private float GetMercy(int id = -1)
|
|
{
|
|
if (id > 3)
|
|
{
|
|
return 0f;
|
|
}
|
|
if (id == -1)
|
|
{
|
|
int num = 0;
|
|
for (int i = 0; i < enemies.Count; i++)
|
|
{
|
|
num += enemies[i].spare;
|
|
}
|
|
return num / enemies.Count;
|
|
}
|
|
return enemies[id].spare;
|
|
}
|
|
|
|
private void GetNextBattleText()
|
|
{
|
|
if (AnySpecial() != null)
|
|
{
|
|
for (int i = 0; i < Texts.battleMes[this.battleMes].Length; i++)
|
|
{
|
|
if (Texts.battleMes[this.battleMes][i].special)
|
|
{
|
|
lastMes = i;
|
|
specialWarning = true;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (turn == 0)
|
|
{
|
|
lastMes = 0;
|
|
return;
|
|
}
|
|
if (forceMes > -1)
|
|
{
|
|
lastMes = forceMes;
|
|
forceMes = -1;
|
|
return;
|
|
}
|
|
List<int> list = new List<int>();
|
|
for (int j = 1; j < Texts.battleMes[this.battleMes].Length; j++)
|
|
{
|
|
Texts.BattleMes battleMes = Texts.battleMes[this.battleMes][j];
|
|
Entity.IDs? check = battleMes.idToCheck;
|
|
Battlers battlers = (check.HasValue ? enemies.FirstOrDefault((Battlers x) => x.id == check.Value) : null);
|
|
if (!battleMes.cant && !battleMes.special && (battleMes.reqTurn <= 0 || turn >= battleMes.reqTurn) && (!check.HasValue || battlers != null) && (battleMes.everyXTurns <= 0 || turn % battleMes.everyXTurns == 0) && (battleMes.hpCheck <= 0f || (battlers != null && battlers.HPPercent() <= battleMes.hpCheck)) && (battleMes.mercyCheck <= 0f || (battlers != null && (float)battlers.spare <= battleMes.mercyCheck)) && (battleMes.atMesCount <= 0 || battleMes.atMesCount == mesCount) && (battleMes.onlyTurn <= 0 || turn == battleMes.onlyTurn) && enemies.Count >= battleMes.reqEnemyAmt && (battleMes.mercyCheck == -1f || GetMercy() >= battleMes.mercyCheck) && (battleMes.battleFlagReq == null || battleMes.battleFlagReq.Count == 0 || battleMes.battleFlagReq.All((StringName x) => tempFlags.Contains(x))) && (battleMes.battleFlagLimit == null || battleMes.battleFlagLimit.Count == 0 || !battleMes.battleFlagLimit.All((StringName x) => tempFlags.Contains(x))))
|
|
{
|
|
if (battleMes.weight >= 50)
|
|
{
|
|
list.Clear();
|
|
list.Add(j);
|
|
break;
|
|
}
|
|
for (int num = 0; num < battleMes.weight; num++)
|
|
{
|
|
list.Add(j);
|
|
}
|
|
}
|
|
}
|
|
int num2 = 0;
|
|
for (int num3 = 0; num3 < 10; num3++)
|
|
{
|
|
num2 = ((list.Count != 0) ? list[Main.RandomRange(0, list.Count - 1)] : 0);
|
|
if (num2 != lastMes)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if (Texts.battleMes[this.battleMes][num2].addCount)
|
|
{
|
|
mesCount++;
|
|
}
|
|
else if (Texts.battleMes[this.battleMes][num2].resetCount)
|
|
{
|
|
mesCount = 0;
|
|
}
|
|
lastMes = num2;
|
|
}
|
|
|
|
public static void DoDiag(string[] text, string[] portraits = null)
|
|
{
|
|
current.diag = new List<string>(text);
|
|
if (portraits != null)
|
|
{
|
|
current.portraits = new List<string>(portraits);
|
|
}
|
|
else
|
|
{
|
|
current.portraits?.Clear();
|
|
}
|
|
DWMenu.instance.battleText.VisibleRatio = 0f;
|
|
if (portraits != null)
|
|
{
|
|
DWMenu.instance.battleText2.VisibleRatio = 0f;
|
|
}
|
|
}
|
|
|
|
public void ResetEnemyHighlight()
|
|
{
|
|
for (int i = 0; i < enemies.Count; i++)
|
|
{
|
|
enemies[i].entity.Modulate = Main.colorWhite;
|
|
}
|
|
}
|
|
|
|
private void ChangeOption(int d)
|
|
{
|
|
option += d;
|
|
if (option < 0)
|
|
{
|
|
option = maxOption - 1;
|
|
}
|
|
else if (option >= maxOption)
|
|
{
|
|
option = 0;
|
|
}
|
|
Audio.PlaySound(Audio.commonSounds[0]);
|
|
}
|
|
|
|
public static IEnumerator Heal(Battlers target, int amt, bool playParticles = true, bool doColor = true, bool showText = true, bool playSound = true)
|
|
{
|
|
if (playParticles)
|
|
{
|
|
((Node2D)Main.Particle("HealParts", target.entity.GlobalPosition + target.center, null, current, localSpace: false)).ZIndex = 3000;
|
|
}
|
|
if (playSound)
|
|
{
|
|
Audio.PlaySound("snd_power.wav");
|
|
}
|
|
bool flag = target.HP <= 0;
|
|
target.HP = Mathf.Clamp(target.HP + amt, -target.MAXHP, target.MAXHP);
|
|
if (!target.enemy)
|
|
{
|
|
Party.UpdateHUD();
|
|
}
|
|
if (amt >= 50000)
|
|
{
|
|
amt -= 50000;
|
|
for (int i = 0; i < current.party.Count; i++)
|
|
{
|
|
if (current.party[i] != target)
|
|
{
|
|
Coroutine.Start(Heal(current.party[i], amt, playParticles, doColor, showText, playSound: false));
|
|
}
|
|
}
|
|
}
|
|
if (!target.enemy && target.HP > 0 && flag)
|
|
{
|
|
target.entity.currentAnim = Entity.Animations.BattleIdle;
|
|
if (showText)
|
|
{
|
|
ShowFloatingText(Texts.common[125], target.entity.GlobalPosition, Main.colorGreen);
|
|
}
|
|
}
|
|
else if (target.HP >= target.MAXHP)
|
|
{
|
|
if (showText)
|
|
{
|
|
ShowFloatingText(Texts.common[126], target.entity.GlobalPosition, Main.colorGreen);
|
|
}
|
|
}
|
|
else if (showText)
|
|
{
|
|
ShowFloatingText(amt.ToString(), target.entity.GlobalPosition, Main.colorGreen);
|
|
}
|
|
if (doColor)
|
|
{
|
|
for (float a = 0f; a < 30f; a += Main.deltaTime)
|
|
{
|
|
target.entity.Modulate = Main.colorGreen.Lerp(Main.colorWhite, a / 30f);
|
|
yield return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void DoDamage(Battlers attacker, Battlers target, float multiplier = 1f, bool miss = false, bool noTP = false, bool dontKill = false, bool showNumber = true, int? overrideDamage = null)
|
|
{
|
|
bool flag = !attacker.enemy && attacker.selectedAction != null && attacker.selectedAction[0] == 1 && Texts.skills[(Acts.IDs)attacker.selectedAction[2]].onlyOnExecutable;
|
|
Vector2 pos = target.entity.GlobalPosition + Vector2.Up * 16f * attacker.posID + Vector2.Left * Main.RandomRange(-16, 3);
|
|
int num = ((attacker.atkMod != null) ? attacker.atkMod[1] : 0);
|
|
int num2 = ((target.defMod != null) ? target.defMod[1] : 0);
|
|
int valueOrDefault = overrideDamage.GetValueOrDefault();
|
|
if (!overrideDamage.HasValue)
|
|
{
|
|
valueOrDefault = attacker.ATK;
|
|
overrideDamage = valueOrDefault;
|
|
}
|
|
int num3 = Mathf.Clamp(Mathf.RoundToInt((float)(overrideDamage.Value + num) * multiplier * (1f + Main.RandomRange(-0.1f, 0.1f))) - (target.DEF + num2), 0, 999);
|
|
Color value = Main.colorWhite;
|
|
string text = "";
|
|
target.hpLastTurn = target.HP;
|
|
if (!attacker.enemy)
|
|
{
|
|
value = Main.instance.partyColors[attacker.internalID];
|
|
if (!miss && !noTP)
|
|
{
|
|
TP = Mathf.Clamp(TP + Mathf.FloorToInt((float)num3 / 10f), 0, 100);
|
|
}
|
|
}
|
|
if (miss)
|
|
{
|
|
text = Texts.common[122];
|
|
}
|
|
else
|
|
{
|
|
target.entity.shake = 20f;
|
|
text = num3.ToString();
|
|
}
|
|
if (!miss)
|
|
{
|
|
Audio.PlaySound("snd_damage.wav");
|
|
target.HP = Mathf.Clamp(target.HP - num3, dontKill ? 1 : 0, target.MAXHP);
|
|
if (num3 > 0)
|
|
{
|
|
target.entity.currentAnim = Entity.Animations.Hurt;
|
|
}
|
|
Coroutine.Stop(target.animRoutine);
|
|
if (target.HP <= 0)
|
|
{
|
|
if (lastResult != EndState.Special)
|
|
{
|
|
if (flag)
|
|
{
|
|
fleeing.Add(Coroutine.Start(KillAnim(target)));
|
|
}
|
|
else if (target.callEventOnDefeat != Acts.IDs.None && (events == null || events.done))
|
|
{
|
|
events = Acts.DoActRoutine(target.callEventOnDefeat.ToString(), target, new Battlers[1] { attacker });
|
|
}
|
|
else if (!target.fleeing)
|
|
{
|
|
fleeing.Add(Coroutine.Start(Flee(target)));
|
|
}
|
|
}
|
|
else if (flag)
|
|
{
|
|
RemoveEnemy(target, EndState.Executed);
|
|
}
|
|
else
|
|
{
|
|
RemoveEnemy(target, EndState.Defeated);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
target.animRoutine = Coroutine.Start(target.entity.DelayedAnim(30f, Entity.Animations.Idle));
|
|
}
|
|
}
|
|
if (showNumber)
|
|
{
|
|
ShowFloatingText(text, pos, value);
|
|
}
|
|
}
|
|
|
|
public static Control ShowFloatingText(string text, Vector2 pos, Color? color = null)
|
|
{
|
|
Color valueOrDefault = color.GetValueOrDefault();
|
|
if (!color.HasValue)
|
|
{
|
|
valueOrDefault = Main.colorWhite;
|
|
color = valueOrDefault;
|
|
}
|
|
Control control = GD.Load<PackedScene>("res://Objects/UI/DamageNumberDR.tscn").Instantiate<Control>(PackedScene.GenEditState.Disabled);
|
|
control.GetChild<RichTextLabel>(0).Text = text;
|
|
control.Modulate = color.Value;
|
|
if (current != null)
|
|
{
|
|
current.AddChild(control, forceReadableName: false, InternalMode.Disabled);
|
|
}
|
|
else if (Room.current != null)
|
|
{
|
|
Room.current.AddChild(control, forceReadableName: false, InternalMode.Disabled);
|
|
}
|
|
else
|
|
{
|
|
Main.instance.AddChild(control, forceReadableName: false, InternalMode.Disabled);
|
|
}
|
|
control.GlobalPosition = pos;
|
|
return control;
|
|
}
|
|
|
|
private void UpdateMenu(int mod = 0)
|
|
{
|
|
bool flag = extended.Contains(state);
|
|
DWMenu.instance.battleText.VisibleRatio = 99f;
|
|
DWMenu.instance.battleText2.Visible = flag;
|
|
DWMenu.instance.battleDesc.GetParent<Control>().Visible = flag;
|
|
DWMenu.instance.itemArrow.Visible = state == State.SelectItem && SaveFile.current.dwItems.Count > 6;
|
|
if (!flag)
|
|
{
|
|
tpPreview = 0;
|
|
}
|
|
switch (state)
|
|
{
|
|
case State.PlayerTurn:
|
|
DWMenu.instance.partyHUDs[currentActor].UpdateOpt(option);
|
|
soul.Visible = false;
|
|
DWMenu.instance.battleText.Text = Texts.battleMes[battleMes][lastMes].text;
|
|
if (!firstMes)
|
|
{
|
|
DWMenu.instance.battleText.VisibleRatio = 0f;
|
|
}
|
|
firstMes = true;
|
|
break;
|
|
case State.SelectTarget:
|
|
if (mod == 0 || mod == 2)
|
|
{
|
|
maxOption = ((mod == 2) ? party.Count : enemies.Count);
|
|
soul.Visible = true;
|
|
string text4 = "\t\t";
|
|
string text5 = "";
|
|
for (int l = 0; l < maxOption; l++)
|
|
{
|
|
if (mod == 2)
|
|
{
|
|
text4 += party[l].name;
|
|
text5 = text5 + GetTextBar(party[l].HPPercent()) + "[color=black].\t\t\n";
|
|
}
|
|
else
|
|
{
|
|
bool num = enemies[l].CanSpare();
|
|
if (num)
|
|
{
|
|
text4 += "[color=yellow]";
|
|
}
|
|
text4 += enemies[l].name;
|
|
if (num)
|
|
{
|
|
text4 += "[/color]";
|
|
}
|
|
text5 = text5 + GetTextBar(enemies[l].HPPercent()) + "\t\t";
|
|
if (!enemies[l].noMercy)
|
|
{
|
|
text5 = text5 + GetTextBar((float)enemies[l].spare / 100f, Main.colorYellow) + "\n";
|
|
}
|
|
}
|
|
text4 += "\n\t\t";
|
|
}
|
|
DWMenu.instance.battleText2.Text = text5;
|
|
DWMenu.instance.battleText2.VisibleCharacters = -1;
|
|
DWMenu.instance.battleText.Text = text4;
|
|
}
|
|
DWMenu.instance.battleText2.Visible = true;
|
|
soul.Position = new Vector2(-147f, 78 + option * 17);
|
|
break;
|
|
case State.SelectItem:
|
|
{
|
|
int num2 = ((option >= 6) ? 6 : 0);
|
|
string text6 = "";
|
|
string text7 = "";
|
|
for (int m = 0; m < 6 && m < SaveFile.current.dwItems.Count - num2; m++)
|
|
{
|
|
if (m % 2 == 0)
|
|
{
|
|
text6 = text6 + "\t\t" + Texts.items[SaveFile.current.dwItems[m + num2]].name + "\n";
|
|
}
|
|
else
|
|
{
|
|
text7 = text7 + "\t\t" + Texts.items[SaveFile.current.dwItems[m + num2]].name + "\n";
|
|
}
|
|
}
|
|
DWMenu.instance.itemArrow.FlipV = option >= 6;
|
|
DWMenu.instance.itemArrow.Position = new Vector2(DWMenu.instance.itemArrow.Position.X, (option >= 6) ? 12 : 44);
|
|
DWMenu.instance.battleText.Text = text6;
|
|
DWMenu.instance.battleText2.Text = text7;
|
|
DWMenu.instance.battleText2.VisibleCharacters = -1;
|
|
DWMenu.instance.battleText2.Visible = true;
|
|
maxOption = SaveFile.current.dwItems.Count;
|
|
DWMenu.instance.battleDesc.Text = "[color=gray]" + (Texts.items[SaveFile.current.dwItems[option]].shopDesc ?? Texts.items[SaveFile.current.dwItems[option]].shortDesc);
|
|
soul.Visible = true;
|
|
soul.Position = new Vector2(((option - num2) % 2 == 0) ? (-147) : (-41), 78 + Mathf.FloorToInt((float)(option - num2) / 2f) * 17);
|
|
break;
|
|
}
|
|
case State.SelectSkill:
|
|
case State.SelectAct:
|
|
if (mod == 0)
|
|
{
|
|
List<int> list = new List<int>(GetPossibleActs());
|
|
if (state == State.SelectAct)
|
|
{
|
|
for (int i = 0; i < enemies[allBattlers[currentActor].selectedAction[1]].acts.Count; i++)
|
|
{
|
|
Acts.IDs ds = enemies[allBattlers[currentActor].selectedAction[1]].acts[i];
|
|
if (CanUseAct(ds))
|
|
{
|
|
list.Add((int)ds);
|
|
}
|
|
}
|
|
}
|
|
possible = list.ToArray();
|
|
string text = "";
|
|
string text2 = "";
|
|
for (int j = 0; j < possible.Length; j++)
|
|
{
|
|
if (j % 2 == 0)
|
|
{
|
|
text = text + "\t\t" + Texts.skills[(Acts.IDs)possible[j]].name + "\n";
|
|
}
|
|
else
|
|
{
|
|
text2 = text2 + "\t\t" + Texts.skills[(Acts.IDs)possible[j]].name + "\n";
|
|
}
|
|
}
|
|
DWMenu.instance.battleText.Text = text;
|
|
DWMenu.instance.battleText2.Text = text2;
|
|
DWMenu.instance.battleText2.VisibleCharacters = -1;
|
|
DWMenu.instance.battleText2.Visible = true;
|
|
maxOption = possible.Length;
|
|
}
|
|
if (Texts.skills[(Acts.IDs)possible[option]].spAction)
|
|
{
|
|
string text3 = "";
|
|
for (int k = 0; k < enemies.Count; k++)
|
|
{
|
|
text3 = text3 + "* " + Texts.skills[enemies[k].acts[enemies[allBattlers[currentActor].selectedAction[1]].partyAction[0]]].name + "\n";
|
|
}
|
|
DWMenu.instance.battleDesc.Text = "[color=gray]" + text3;
|
|
}
|
|
else if (Texts.skills[(Acts.IDs)possible[option]].desc != null)
|
|
{
|
|
DWMenu.instance.battleDesc.Text = "[color=gray]" + Texts.skills[(Acts.IDs)possible[option]].desc;
|
|
if (Texts.skills[(Acts.IDs)possible[option]].TP > 0)
|
|
{
|
|
RichTextLabel battleDesc = DWMenu.instance.battleDesc;
|
|
battleDesc.Text = battleDesc.Text + "\n[color=#ED7117]" + Texts.skills[(Acts.IDs)possible[option]].TP + "% TP";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DWMenu.instance.battleDesc.Text = "";
|
|
}
|
|
soul.Visible = true;
|
|
soul.Position = new Vector2((option % 2 == 0) ? (-147) : (-41), 78 + Mathf.FloorToInt((float)option / 2f) * 17);
|
|
tpPreview = Texts.skills[(Acts.IDs)possible[option]].TP;
|
|
break;
|
|
case State.DoSpells:
|
|
case State.DoAttack:
|
|
case State.DoEnemy:
|
|
case State.EndTurn:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
}
|