public IList <DdrPs2FileDataTableEntry> Read(HeuristicResult heuristicResult, Stream stream) { var table = _ddrPs2FileDataTableChunkStreamReader.GetUnbound(stream); var decoded = _ddrPs2FileDataUnboundTableDecoder.Decode(table); return(decoded); }
string PrintHeuristic(HeuristicResult hr) { System.Reflection.FieldInfo[] fieldInfos = hr.GetType().GetFields(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic); string output = "======" + hr.m_Unit + "'s " + hr.m_Node.m_NodeHighlight.name + "======\n"; foreach (var item in fieldInfos) { try { output += $"{item.Name}: {item.GetValue(hr)}\n"; } catch (ArgumentException) { output += $"{item.Name}: unobtainable\n"; } } return(output); }
/// <summary> /// Updates the movement values of a heuristic result or adds one if it doesn't exist /// </summary> /// <param name="value"></param> /// <param name="n"></param> /// <param name="u"></param> /// <param name="distance"></param> private void AddOrUpdateHeuristic(float value, Node node, Unit unit) { HeuristicResult hr = FindHeuristic(node, unit); if (hr != null) // If the heuristic already exists, update it { // If the existing heuristic already a better score, move on if (hr.m_MovementValue >= value) { return; } // Otherwise set values hr.m_MovementValue = value; } else // Otherwise create a new heuristic with the values { m_HeuristicResults.Add(new HeuristicResult(unit, node, value)); } }
/// <summary> /// Updates the movement values of a heuristic result or adds one if it doesn't exist /// </summary> /// <param name="value"></param> /// <param name="n"></param> /// <param name="u"></param> /// <param name="distance"></param> private void AddOrUpdateHeuristic(int distance, Node node, Unit unit) { HeuristicResult hr = FindHeuristic(node, unit); if (hr != null) // If the heuristic already exists, update it { // If the existing heuristic already a lower distance score if (hr.m_MoveDistance < distance) { return; } // Otherwise set values hr.m_MoveDistance = distance; } else // Otherwise create a new heuristic with the values { m_HeuristicResults.Add(new HeuristicResult(unit, node, distance)); } }
private void FindPath(ref List <IPathResult> sequence, PathingData data) { List <HeuristicResult> results = new List <HeuristicResult>(m_generators.Count); foreach (var gen in m_generators) { gen.Initialise(data); float heuristicOuput = gen.Execute(); results.Add(new HeuristicResult { HeuristicValue = heuristicOuput, Node = gen }); //This means we have found a perfect result. if (1.0f == heuristicOuput) { break; } } //sort by heuricitc results = results.OrderBy(r => r.HeuristicValue).ToList(); //get the first value as this should be the best result. HeuristicResult res = results[0]; IPathResult path = res.Node.Path; sequence.Add(path); //if we haven't reached our destination keep going. if (path.EndPoint != data.TargetLocation) { data.CurrentPosition = path.EndPoint; data.CurrentTime = path.EndPointTime; data.FacingDir = path.FacingDir; FindPath(ref sequence, data); } }
public SvagContainer Read(HeuristicResult result, Stream stream) { if (!(result is VagHeuristicResult info)) { return(null); } if (info.Start != null) { stream.TryRead(0, (int)info.Start); } var output = _vagStreamReader.Read(stream, info.Channels ?? 1, info.Interleave ?? 0); output.Volume = info.Volume; output.SampleRate = info.SampleRate; output.Length = info.Length; return(new SvagContainer { SampleRate = info.SampleRate, VagChunk = output }); }
public VagChunk Read(HeuristicResult result, Stream stream) { if (!(result is VagHeuristicResult info)) { return(null); } var decryptStream = info.Key != null ? new BeatmaniaPs2NewAudioDecryptStream(stream, info.Key) : stream; if (info.Start != null) { stream.TryRead(0, (int)info.Start); } var output = _vagStreamReader.Read(decryptStream, info.Channels ?? 1, info.Interleave ?? 0); output.Volume = info.Volume; output.SampleRate = info.SampleRate; output.Length = info.Length; return(output); }
public IEnumerable <SsqChunk> Read(HeuristicResult heuristicResult, Stream stream) { return(_ssqStreamReader.Read(stream)); }
public TimImage Read(HeuristicResult heuristicResult, Stream stream) { return(_timStreamReader.Read(stream)); }
public VagChunk Read(HeuristicResult result, Stream stream) { var info = result as VagHeuristicResult; return(_vagStreamReader.Read(stream, info?.Channels ?? 1, info?.Interleave ?? 0)); }
/// <summary> /// Makes all AI units take their turns /// </summary> public void TakeAITurn() { if (UnitsManager.m_Instance.m_ActiveEnemyUnits.Count == 0) { Debug.Log("<color=#471d1d>[AI]</color> No enemies. Ending turn"); BattleManager.m_Instance.EndCurrentTurn(); return; } if (!m_CurrentAIUnit) // If no AI unit is currently taking their turn { m_HeuristicResults.Clear(); // Get rid of the cached heuristics // Calculate all the new heuristics for each unit foreach (Unit unit in UnitsManager.m_Instance.m_ActiveEnemyUnits) { // Only calculate movement heuristics if the unit can move if (unit.GetCurrentMovement() > 0) { Debug.Log($"<color=#8440a8>[Movement]</color> {unit.name} has {unit.GetCurrentMovement()} movement"); // Movement Heuristics DoMovementHeuristics(unit); } // Only calculate skill heuristics if the unit has actions if (unit.GetActionPoints() > 0) { foreach (BaseSkill skill in unit.GetSkills()) { // Make sure the skill isn't on cooldown. if (skill.GetCurrentCooldown() > 0) { continue; } List <Node> nodesWithUnits = Grid.m_Instance.GetNodesWithinRadius( skill.m_AffectedRange + skill.m_CastableDistance + unit.GetCurrentMovement(), Grid.m_Instance.GetNode(unit.transform.position), true ).Where(n => n.unit != null).ToList(); switch (skill) { case StatusSkill ss: DoStatusHeuristic(nodesWithUnits, ss, unit); break; case DamageSkill ds: DoAttackHeuristic(nodesWithUnits, ds, unit); break; case HealSkill hs: DoHealHeuristic(nodesWithUnits, hs, unit); break; default: Debug.LogError("<color=#9c4141>[Skill]</color><color=#6e4747> Bad skill!</color>", skill); break; } } } } // Remove all the empty choices made by setting the movement costs m_HeuristicResults = m_HeuristicResults.Where(c => c.SumHeuristics() != 0).ToList(); if (m_HeuristicResults.Count == 0) { // No AI moves left, end your turn. BattleManager.m_Instance.EndCurrentTurn(); return; } // Sort all the moves regardless of whether they're reachable List <HeuristicResult> sortedChoices = m_HeuristicResults.OrderByDescending(hr => hr.SumHeuristics()).ToList(); foreach (HeuristicResult choice in sortedChoices) { if (choice.SumHeuristics() == 0) { continue; } Unit aiUnit = choice.m_Unit; // Get all the nodes the unit could move to. List <Node> nodesInMovement = Grid.m_Instance.GetNodesWithinRadius(aiUnit.GetCurrentMovement(), Grid.m_Instance.GetNode(aiUnit.transform.position)); // Check if the current best node is within the movement range of the unit. if (nodesInMovement.Contains(choice.m_Node)) { m_BestOption = choice; m_CurrentAIUnit = m_BestOption.m_Unit; Debug.Log($"===={m_CurrentAIUnit.name} taking turn===="); Debug.Log($"<color=#3f5c9e>[Heuristics]</color> Found best option: {m_CurrentAIUnit.name} moving to {m_BestOption.m_Node.m_NodeHighlight.name} from {Grid.m_Instance.GetNode(m_CurrentAIUnit.transform.position).m_NodeHighlight.name}"); m_MakingAction = true; PlayerManager.m_Instance.SetSelectedUnit(m_CurrentAIUnit); if (m_BestOption.m_MoveDistance != 0) { m_CurrentAIUnit.DecreaseCurrentMovement(m_BestOption.m_MoveDistance); FindPathToOptimalNode(); } else { // There's no movement, so just run the function that runs at the end of moving OnFinishMoving(); } return; } else { Debug.Log($"<color=#3f5c9e>[Heuristics]</color><color=#6e4747> A better move for {aiUnit.name} was found outside of the movable area</color>"); } } if (!m_CurrentAIUnit) { // Assume no more units left. BattleManager.m_Instance.EndCurrentTurn(); return; } } }