private void InvokeSkill(ProjectSingleAttackSkill skill)
{
int randomIndex = Random.Range(0, Programmers.Count());
var programmer = NotVacationProgrammers.ElementAt(randomIndex);
ApplyDamage(programmer, skill.Damage);
}
private static string GetOptionalFirstArg(Programmers programmer, Langs lang)
{
switch (lang)
{
case Langs.Java:
if (programmer == Programmers.Andrew)
{
return(andrewCodePath + "Main" + "\"");
}
else
{
return(codyCodePath + "Program" + "\"");
}
case Langs.Python:
if (programmer == Programmers.Andrew)
{
return(andrewCodePath + "Sort.py" + "\"");
}
else
{
return(codyCodePath + "sort.py" + "\"");
}
}
return("");
}
private void InitializeProgrammers()
{
Programmers.Clear();
HashSet <Vector3> programmerPositions = new HashSet <Vector3>();
foreach (var programmerSpec in CurrentStage.ProgrammerSpecs)
{
programmerSpec.Status.DisposeRegisteredEvents();
var newProgrammer = Instantiate(programmerTemplate);
var randomVector = StageField.GetRandomVector();
while (programmerPositions.Contains(randomVector))
{
randomVector = StageField.GetRandomVector();
}
newProgrammer.transform.position = randomVector;
newProgrammer.Ability = programmerSpec.Ability;
foreach (var activeSkill in newProgrammer.Ability.AcquiredActiveSkills)
{
activeSkill.ResetStageParameters();
}
newProgrammer.Status = programmerSpec.Status;
newProgrammer.Status.ResetStageParameters();
programmerPositions.Add(randomVector);
Programmers.Add(newProgrammer);
}
}
private void InvokeSkill(ProjectSingleDeburfSkill skill)
{
int ramdomIndex = Random.Range(0, Programmers.Count());
var targetProgrammer = NotVacationProgrammers.ElementAt(ramdomIndex);
AttachBurfToProgrammer(targetProgrammer, skill.Deburf);
}
public MainWindow()
{
DataContext = this;
InitializeComponent();
var descriptor = DependencyPropertyDescriptor.FromProperty(ArduinoPathProperty, typeof(Control));
//NOTE this would be a concerning memory leak, if this was not the main window that ran the entire lifetime of the app anyways.
//essentially, it attaches a reference to this window to the static dependency property, which prevents garbage collection. If this were a helper window,
//we'd have to wrap this in a weak reference.
descriptor.AddValueChanged(this, delegate {
ProgrammerInfo[] programmers = GetAllProgrammers(ArduinoPath).ToArray();
ProgrammerInfo oldSelectedProgrammer = SelectedProgrammer;
Programmers = programmers;
SelectedProgrammer = oldSelectedProgrammer != null ? Programmers.FirstOrDefault(p => p.Name == oldSelectedProgrammer.Name) : null;
UpdateValidationState();
});
descriptor = DependencyPropertyDescriptor.FromProperty(SelectedProgrammerProperty, typeof(Control));
descriptor.AddValueChanged(this, delegate
{
UpdateValidationState();
});
descriptor = DependencyPropertyDescriptor.FromProperty(SelectedPortProperty, typeof(Control));
descriptor.AddValueChanged(this, delegate
{
UpdateValidationState();
});
}
private void RemoveDeadPlayerIfTurnChangedToPlayer(TurnState turn)
{
if (turn == TurnState.Player)
{
int totalSeverancePay = 0;
var deadProgrammers = Programmers.Where(programmer => programmer.IsAlive == false)
.ToList();
foreach (var programmer in deadProgrammers)
{
CommonLogger.LogFormat("UnitManager::RemoveDeadPlayerIfTurnChangedToPlayer => 프로그래머 {0}가 사망하여 스테이지 내에서 제외됨.", programmer.Status.Name);
programmerActingDictionary.Remove(programmer);
totalSeverancePay += programmer.Status.Cost.Fire;
}
if (totalSeverancePay > 0)
{
if (Turn != TurnState.GameEnd)
{
StageManager.Instance.StageUi.RenderDeathText(deadProgrammers);
}
// TODO: Spend money!
}
}
}
private static long RunSort(Programmers programmer, Langs lang, sortAlgos algo, string pathToInput)
{
var watch = System.Diagnostics.Stopwatch.StartNew();
//String command = programPath + "\" " + NameFromAlgo(algo) + " " + pathToInput;
Process process = new Process();
process.StartInfo.FileName = GetProgramPath(programmer, lang);
if (programmer == Programmers.Andrew)
{
process.StartInfo.Arguments = GetOptionalFirstArg(programmer, lang) + " " + NameFromAlgo(programmer, algo) + " " + pathToInput;
}
else
{
process.StartInfo.Arguments = GetOptionalFirstArg(programmer, lang) + " " + pathToInput + " " + NameFromAlgo(programmer, algo);
}
process.Start();
/*ProcessStartInfo cmdsi = new ProcessStartInfo("cmd.exe");
* cmdsi.Arguments = command;
* Process cmd = Process.Start(cmdsi);*/
process.WaitForExit();
watch.Stop();
long elapsedMs = watch.ElapsedMilliseconds;
return(elapsedMs);
}
/// <summary>
/// Najme tolik programatoru kolik cini kapacita firmy.
/// IMPLEMENTUJTE TUDO METODU
/// Z parametru programmers vyberte prvnich Capacity programatoru
/// v poradi podle nejvyhodnejsiho pomeru jejich rychlosti k jejich cene.
/// V tomto poradi je vlozte do kolekce Programmers.
///
/// Poznamka k trideni: toto je mozne implementovat vice zpusoby. Vyberte si libovolny, s tim
/// ze je povoleno kvuli tomuto trideni napr. vytvorit novou tridu nebo modifikovat nejakou stavajici.
/// </summary>
public void AllocateProgrammers(List <Programmer> programmers)
{
programmers.Sort((prg1, prg2) => prg1.Ratio.CompareTo(prg2.Ratio));
for (int x = 0; x < Capacity; x++)
{
Programmers.Add(programmers[(programmers.Count - x - 1)]);
}
}
private void InitializeProgrammers()
{
Programmers.Clear();
var newProgrammers = MakeProgrammers(LobbyManager.Instance.SelectedStage.ProgrammerSpecs);
foreach (var newProgrammer in newProgrammers)
{
Programmers.Add(newProgrammer);
}
}
public void AddEmployee(Employee employee)
{
if (employee is Programmer)
{
Programmers.Add((Programmer)employee);
}
else if (employee is Tester)
{
Testers.Add((Tester)employee);
}
}
private void RemoveDeadPlayerIfTurnChangedToPlayer(TurnState turn)
{
if (turn == TurnState.Player)
{
foreach (var programmer in Programmers.Where(programmer => programmer.IsAlive == false)
.ToList())
{
CommonLogger.LogFormat("UnitManager::RemoveDeadPlayerIfTurnChangedToPlayer => 프로그래머 {0}가 사망하여 스테이지 내에서 제외됨.", programmer.Status.Name);
programmerActingDictionary.Remove(programmer);
}
}
}
/// <summary>
/// Najme tolik programatoru kolik cini kapacita firmy.
/// IMPLEMENTUJTE TUDO METODU
/// Z parametru programmers vyberte prvnich Capacity programatoru
/// v poradi podle nejvyhodnejsiho pomeru jejich rychlosti k jejich cene.
/// V tomto poradi je vlozte do kolekce Programmers.
///
/// Poznamka k trideni: toto je mozne implementovat vice zpusoby. Vyberte si libovolny, s tim
/// ze je povoleno kvuli tomuto trideni napr. vytvorit novou tridu nebo modifikovat nejakou stavajici.
/// </summary>
public void AllocateProgrammers(List <Programmer> programmers)
{
foreach (var programmer in programmers)
{
SortedProgrammersByEffectivity.Add(programmer);
}
SortedProgrammersByEffectivity = SortedProgrammersByEffectivity.OrderBy(p => p.Effectivity).ToList();
for (int i = 0; i < Capacity; i++)
{
Programmers.Add(SortedProgrammersByEffectivity[i]);
}
}
private void SubscribeToProgrammers()
{
foreach (var programmer in programmerActingDictionary.Keys)
{
programmer.OnActionStarted += () =>
{
StageManager.Instance.StageField.BlockCellClicking();
foreach (var prog in Programmers)
{
prog.gameObject.layer = 2;
}
};
programmer.OnActionFinished += () =>
{
StageManager.Instance.StageField.UnblockCellClicking();
foreach (var prog in Programmers)
{
prog.gameObject.layer = Programmer.Layer;
}
programmerActingDictionary[programmer] = true;
CheckProgrammerFormation(Vector3.zero);
ChangeTurnToBossIfAllProgrammersPerformAction();
};
programmer.OnDeath += () =>
{
var currentProgrammers = Programmers.ToList();
if (currentProgrammers.All(stageProgrammer => stageProgrammer.IsAlive == false) &&
Turn != TurnState.GameEnd)
{
Turn = TurnState.GameEnd;
StageManager.Instance.StageUi.TransitionToFailure("프로젝트에 투입된 모든 프로그래머가 퇴사했습니다!");
}
var deadProgrammerSpec = LobbyManager.Instance.CurrentPlayer
.ProgrammerSpecs
.Where(spec => spec.Ability.Equals(programmer.Ability) &&
spec.Status.Equals(programmer.Status))
.Single();
LobbyManager.Instance.CurrentPlayer.ProgrammerSpecs.Remove(deadProgrammerSpec);
};
CheckProgrammerFormation(programmer.transform.position);
}
}
/// <summary>
/// Najme tolik programatoru kolik cini kapacita firmy.
/// IMPLEMENTUJTE TUDO METODU
/// Z parametru programmers vyberte prvnich Capacity programatoru
/// v poradi podle nejvyhodnejsiho pomeru jejich rychlosti k jejich cene.
/// V tomto poradi je vlozte do kolekce Programmers.
///
/// Poznamka k trideni: toto je mozne implementovat vice zpusoby. Vyberte si libovolny, s tim
/// ze je povoleno kvuli tomuto trideni napr. vytvorit novou tridu nebo modifikovat nejakou stavajici.
/// </summary>
public void AllocateProgrammers(List <Programmer> programmers)
{
IEnumerable <Programmer> sortedProgrammers = from programmer in programmers
orderby programmer.Speed
//orderby programmer.Project.Price
select programmer;
List <Programmer> sortedOnes = sortedProgrammers.ToList();
for (int i = 0; i < Capacity; i++)
{
Programmers.Add(sortedOnes[i]);
}
sortedOnes.RemoveRange(0, Capacity);
}
public void Should_calculate_programmer_rank_shown_in_example_1()
{
var programmerA = new Programmer("A", null);
var programmerB = new Programmer("B", null);
programmerA.Recommends(programmerB);
programmerB.Recommends(programmerA);
var rankedProgrammers = new Programmers(new List <IProgrammer> {
programmerA, programmerB
});
rankedProgrammers.Calculate();
Assert.That(programmerA.Rank, Is.EqualTo(1m).Within(0.00001m));
Assert.That(programmerB.Rank, Is.EqualTo(1m).Within(0.00001m));
}
void Window_Loaded(object sender, RoutedEventArgs e)
{
if (Settings.Default.CheckForUpdates)
{
CheckForUpdates();
}
//Temp
ProgrammerInfo[] programmers = GetAllProgrammers(Settings.Default.ArduinoPath).ToArray();
Programmers = programmers;
string[] ports = SerialPort.GetPortNames();
ProgrammerPorts = ports;
//end temp
if (Settings.Default.WindowWidth > 0)
{
Width = Settings.Default.WindowWidth;
}
if (Settings.Default.WindowHeight > 0)
{
Height = Settings.Default.WindowHeight;
}
if (Settings.Default.WindowIsMaximized)
{
WindowState = WindowState.Maximized;
}
AppVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString();
ArduinoPath = Settings.Default.ArduinoPath;
SelectedProgrammer = Programmers.FirstOrDefault(p => p.Name == Settings.Default.SelectedPogrammer);
SelectedPort = Settings.Default.SelectedPort;
_browser.UseHttpActivityObserver = true;
_browser.AddMessageEventListener("isAppHosted", (string s) => NotifyWebAppisHosted(s));
_browser.CreateWindow += _browser_CreateWindow;
_browser.EnableJavascriptDebugger();
string fullWebRoot =
IOPath.Combine(IOPath.GetDirectoryName(Assembly.GetExecutingAssembly().Location), StaticConfig.LocalWebRootPath);
_browser.Navigate("file:///" + fullWebRoot);
}
private void DecreaseActiveSkillCooldownIfTurnChangedToPlayer(TurnState turn)
{
if (turn == TurnState.Player)
{
foreach (var activeSkill in Programmers.SelectMany(programmer => programmer.Ability.AcquiredActiveSkills))
{
if (activeSkill is ICooldownRequired)
{
(activeSkill as ICooldownRequired).DecreaseCooldown();
}
foreach (var passiveSkill in activeSkill.FlattenContainingPassiveSkills()
.Where(passiveSkill => passiveSkill is ICooldownRequired)
.Select(passiveSkill => passiveSkill as ICooldownRequired))
{
passiveSkill.DecreaseCooldown();
}
}
}
}
static void Main(string[] args)
{
Random rand = new Random();
int[,,] numTimesRun = new int[3, 2, 3];
System.Console.WriteLine("algo\tprog\tlang\tresult");
while (!Finished(numTimesRun, numIterations))
{
int algoNum;
int progNum;
int langNum;
// Generate values randomly, ignoring them if they've already been done
do
{
algoNum = rand.Next(0, 3);
progNum = rand.Next(0, 2);
langNum = rand.Next(0, 3);
} while (ComboDone(numTimesRun, numIterations, algoNum, progNum, langNum));
numTimesRun[algoNum, progNum, langNum]++;
sortAlgos algo = (sortAlgos)algoNum;
Programmers prog = (Programmers)progNum;
Langs lang = (Langs)langNum;
long result = RunSort(prog, lang, algo, inputPath);
System.Console.Write(algo.ToString() + "\t");
System.Console.Write(prog.ToString() + "\t");
System.Console.Write(lang.ToString() + "\t");
System.Console.WriteLine(result);
}
System.Console.ReadKey();
System.Console.ReadKey();
System.Console.ReadKey();
}
/// <summary>
/// Открывает диалог выбора файлов программ
/// </summary>
private void ProgramSelect_Click(object sender, RoutedEventArgs e)
{
OpenFile("All files (*.*)|*.*|Text documents (.txt)|*.txt", (name) =>
{
var id = ((ComboBoxItem)LanguageSelect.SelectedItem).Tag.ToString();
if (id == "AUTO")
{
id = System.IO.Path.GetExtension(name);
}
Programmer coder;
if (id != ".exe")
{
try
{
coder = new Programmer(
Languages[id],
name,
System.IO.Path.GetFileName(name)
);
}
catch (KeyNotFoundException)
{
MessageBox.Show($"{System.IO.Path.GetFileName(name)}: " +
"не удалось автоматически определить язык программирования",
"Ошибка определения языка",
MessageBoxButton.OK, MessageBoxImage.Error);
coder = new Programmer(name, System.IO.Path.GetFileName(name));
}
}
else
{
coder = new Programmer(name, System.IO.Path.GetFileName(name));
}
Programmers.Add(coder);
ProgrammerSelectAdd(coder);
ProgrammerSelect.SelectedIndex = Programmers.Count - 1;
});
}
private static string NameFromAlgo(Programmers programmer, sortAlgos algo)
{
if (programmer == Programmers.Andrew)
{
switch (algo)
{
case sortAlgos.Insertion:
return("insertion");
case sortAlgos.Bubble:
return("bubble");
case sortAlgos.Merge:
return("merge");
case sortAlgos.Selection:
return("selection");
}
}
else
{
switch (algo)
{
case sortAlgos.Insertion:
return("1");
case sortAlgos.Bubble:
return("2");
case sortAlgos.Merge:
return("4");
case sortAlgos.Selection:
return("3");
}
}
return("");
}
private static string GetProgramPath(Programmers programmer, Langs lang)
{
switch (lang)
{
case Langs.Java:
if (programmer == Programmers.Andrew)
{
return("java");
}
else
{
return("java");
}
case Langs.CSharp:
if (programmer == Programmers.Andrew)
{
return(andrewCodePath + "CSharpSort" + "\"");
}
else
{
return(codyCodePath + "SortProject" + "\"");
}
case Langs.Python:
if (programmer == Programmers.Andrew)
{
return("python");
}
else
{
return("python");
}
}
return("");
}
public void Should_calculate_programmer_rank_shown_in_example_2()
{
var programmerA = new Programmer("A", null);
var programmerB = new Programmer("B", null);
var programmerC = new Programmer("C", null);
var programmerD = new Programmer("D", null);
programmerA.Recommends(programmerB);
programmerA.Recommends(programmerC);
programmerB.Recommends(programmerC);
programmerC.Recommends(programmerA);
programmerD.Recommends(programmerC);
var rankedProgrammers = new Programmers(new List <IProgrammer> {
programmerA, programmerB, programmerC, programmerD
});
rankedProgrammers.Calculate();
Assert.That(programmerA.Rank, Is.EqualTo(1.49010m).Within(0.00001m));
Assert.That(programmerB.Rank, Is.EqualTo(0.78329m).Within(0.00001m));
Assert.That(programmerC.Rank, Is.EqualTo(1.57659m).Within(0.00001m));
Assert.That(programmerD.Rank, Is.EqualTo(0.15m).Within(0.00001m));
}
/// <summary>
/// Создает элемент списка программистов
/// </summary>
/// <param name="programmer">Программист, которому будет принадлежать созданный элемент</param>
void ProgrammerSelectAdd(Programmer programmer)
{
var grid = new Grid() as IAddChild;
Button closeButton;
grid.AddChild(closeButton = new Button
{
Name = "CloseButton",
Content = "X",
Width = 18,
Padding = new Thickness(0, -1, 0, 0),
Background = new SolidColorBrush(Color.FromArgb(0xFF, 0xE2, 0x16, 0x0A)),
FontFamily = new FontFamily("Segoe UI Symbol"),
FontWeight = FontWeights.Bold,
HorizontalAlignment = HorizontalAlignment.Right,
Margin = new Thickness(0)
});
grid.AddChild(new TextBlock
{
Name = $"coder{programmer.ID}",
Text = $"{programmer.ID}: {programmer.Name}",
Margin = new Thickness(0, 0, 124, 0)
});
var languages = new ComboBox
{
HorizontalAlignment = HorizontalAlignment.Right,
Width = 70,
Margin = new Thickness(0, 0, 18, 0),
VerticalContentAlignment = VerticalAlignment.Center,
HorizontalContentAlignment = HorizontalAlignment.Center,
Padding = new Thickness(4, 0, 4, 0)
};
foreach (var id in Languages)
{
var lang = id.Value;
ComboBoxItem item = new ComboBoxItem
{
Name = lang.ID,
Tag = id.Key,
Content = lang.Name,
Width = 70,
Height = 18,
Padding = new Thickness(4, -4, 4, 0)
};
languages.Items.Add(item);
}
if (programmer.IsExe)
{
languages.SelectedIndex = -1;
languages.IsEnabled = false;
}
else if (programmer.language == null)
{
languages.SelectedIndex = -1;
}
else
{
languages.SelectedItem = languages.Items
.Cast <ComboBoxItem>()
.Where((item) => item.Name == programmer.language.ID)
.First();
}
languages.SelectionChanged += (s, e) => programmer.language = Languages
.ElementAt(languages.SelectedIndex).Value;
grid.AddChild(languages);
TextBox resultText;
grid.AddChild(resultText = new TextBox
{
Text = "0%",
Width = 34,
Margin = new Thickness(0, 0, 90, 0),
HorizontalContentAlignment = HorizontalAlignment.Stretch,
VerticalContentAlignment = VerticalAlignment.Center,
HorizontalAlignment = HorizontalAlignment.Right,
TextAlignment = TextAlignment.Center,
FontWeight = FontWeights.Bold,
Padding = new Thickness(-2, 0, 0, 0),
BorderBrush = new SolidColorBrush(Color.FromArgb(0xFF, 0x72, 0x72, 0x72)),
Foreground = new SolidColorBrush(Colors.Black),
VerticalScrollBarVisibility = ScrollBarVisibility.Disabled,
IsUndoEnabled = false,
IsReadOnly = true,
Background = new SolidColorBrush(Color.FromArgb(0xFF, 0xDA, 0xD3, 0xD3)),
MaxLines = 1,
BorderThickness = new Thickness(1),
IsEnabled = false
});
programmer.ResultValueChanged += () => resultText.Text = $"{programmer.Result}%";
ListBoxItem listBoxItem;
ProgrammerSelect.Items.Add(listBoxItem = new ListBoxItem
{
Height = 20,
Padding = new Thickness(0),
HorizontalAlignment = HorizontalAlignment.Left,
HorizontalContentAlignment = HorizontalAlignment.Stretch,
Width = ProgrammerSelect.Width - 22,
VerticalContentAlignment = VerticalAlignment.Stretch,
Content = grid
});
closeButton.Click += (s, args) =>
{
Programmers.Remove(programmer);
ProgrammerSelect.Items.Remove(listBoxItem);
};
}
void UpdateValidationState()
{
var newErrors = new List <KeyValuePair <string, string> >();
if (string.IsNullOrWhiteSpace(ArduinoPath) || !File.Exists(ArduinoPath))
{
newErrors.Add(new KeyValuePair <string, string>("ArduinoPath", "The path to your Arduino IDE is invalid"));
}
else
{
if (new FileInfo(ArduinoPath).Extension.ToLowerInvariant() != ".exe")
{
newErrors.Add(new KeyValuePair <string, string>("ArduinoPath", "The path to your Arduino IDE must point to 'Arduino.exe'"));
}
else
{
//Check the arduino version
string arduinoDir = IOPath.GetDirectoryName(ArduinoPath);
string revisionsPath = IOPath.Combine(arduinoDir, "revisions.txt");
if (File.Exists(revisionsPath))
{
List <string> lines = new List <string>();
using (var s = File.OpenText(revisionsPath))
{
while (!s.EndOfStream)
{
string line = s.ReadLine().Trim();
int arduinoKeyIndex = line.ToUpper().IndexOf("ARDUINO");
if (arduinoKeyIndex >= 0)
{
var version = line.Substring(8);
var versions = version.Split('.');
int major;
int minor;
if (int.TryParse(versions[0], out major) && int.TryParse(versions[1], out minor))
{
if (major == 1 && minor < 6)
{
newErrors.Add(new KeyValuePair <string, string>("ArduinoPath", "Your Arduino version is too old, please use version 1.6 or higher!"));
}
}
break;
}
lines.Add(s.ReadLine().Trim());
}
}
}
}
}
//not all programmers require ports,
if (SelectedProgrammer == null || string.IsNullOrWhiteSpace(SelectedProgrammer.Name) || !Programmers.Any(s => s.Name == SelectedProgrammer.Name))
{
newErrors.Add(new KeyValuePair <string, string>("Programmers", "Please select a programmer that matches your hardware"));
}
else
{
if (SelectedProgrammer.UsesSerial)
{
if (string.IsNullOrWhiteSpace(SelectedPort) || !ProgrammerPorts.Contains(SelectedPort))
{
newErrors.Add(new KeyValuePair <string, string>("SelectedPort", "You need to set a port to use with the selected programmer"));
}
}
}
var oldErrors = errors;
errors = newErrors;
if (errors.Count > 0)
{
errors.Add(new KeyValuePair <string, string>("OptionHeaderText", "There are problems with your setup!"));
OptionHeaderText = "Options [PROBLEMS DETECTECTED]";
}
else
{
OptionHeaderText = "Options";
}
if (ErrorsChanged != null)
{
foreach (var property in (from e in errors select e.Key).Concat(from e in oldErrors select e.Key).Distinct())
{
ErrorsChanged(this, new DataErrorsChangedEventArgs(property));
}
}
}
private void RequestBossActionIfTurnChangedToBoss(TurnState turn)
{
if (Turn == TurnState.Boss)
{
if (Programmers.Where(programmer => programmer.Status.IsOnVacation).Count() ==
Programmers.Count())
{
CommonLogger.Log("UnitManager::RequestBossActionIfTurnChangedToBoss => 보스에게 행동을 요청하려 했으나, 모든 프로그래머가 휴가 중이므로 취소됨.");
StageManager.Instance.StageUi.RenderPlayerText("프로젝트가 아무런 행동도 수행하지 않았습니다.");
boss.InvokeFinished();
return;
}
CommonLogger.Log("UnitManager::RequestBossActionIfTurnChangedToBoss => 보스에게 행동을 요청함.");
//Decrease Boss Skill Cool
foreach (ProjectSkill iter in Boss.Ability.ProjectSkills)
{
iter.DecreaseCooldown();
}
//Decrease Boss Burf Cool and Remove if it's Cool down
for (int i = 0, delete = 0; i < Boss.Status.Burf.Count; i++)
{
Boss.Status.Burf[i - delete].DecreaseTurn();
if (Boss.Status.Burf[i - delete].Turn < 1)
{
Boss.Status.Burf.RemoveAt(i - delete);
delete++;
}
}
if (UnityEngine.Random.Range(0, 12) > 9)
{
//MOVE
StageManager.Instance.MoveBoss();
StageManager.Instance.StageUi.RenderPlayerText("프로젝트의 방향이 전환되었습니다!");
}
else
{
//DO Attack or Skill
var usedSkill = boss.Invoke();
if (usedSkill is ISoundProducible)
{
var clip = (usedSkill as ISoundProducible).EffectSound;
SoundManager.Instance.FetchAvailableSource().PlayOneShot(clip);
}
StageManager.Instance.StageUi.RenderBossSkillNotice(usedSkill);
CommonLogger.LogFormat("UnitManager::RequestBossActionIfTurnChangedToBoss => 보스가 {0} 스킬을 사용함.", usedSkill.Information.Name);
switch (usedSkill.Information.Type)
{
case ProjectSkillType.SingleAttack:
InvokeSkill((ProjectSingleAttackSkill)usedSkill);
break;
case ProjectSkillType.MultiAttack:
InvokeSkill((ProjectMultiAttackSkill)usedSkill);
break;
case ProjectSkillType.SingleDeburf:
InvokeSkill((ProjectSingleDeburfSkill)usedSkill);
break;
case ProjectSkillType.MultiDeburf:
InvokeSkill((ProjectMultiDeburfSkill)usedSkill);
break;
case ProjectSkillType.Burf:
InvokeSkill((ProjectBurfSkill)usedSkill);
break;
}
}
if (Turn != TurnState.GameEnd)
{
boss.InvokeFinished();
}
}
}
