public AttackCustomWindow(Battle battle)
{
InitializeComponent();
_battle = battle;
comboBox1.ItemsSource = _battle.Members;
comboBox2.ItemsSource = _battle.Members;
}
/// <summary>
/// Constructor.
/// </summary>
public BattleScreen(Battle.BattleInfo battleInfo)
{
TransitionOnTime = TimeSpan.FromSeconds(1.5);
TransitionOffTime = TimeSpan.FromSeconds(0.5);
BattleInfo = battleInfo;
}
public Think(Battle battle)
: base(battle)
{
CurrentThinkActionType = ThinkActionType.None;
currentThinkAction = null;
CurrentOptionNameIndex = 0;
MenuOptions = null;
inOuterMenu = true;
CurrentOuterMenuOptionIndex = 0;
weaponMenuOptions = new Dictionary<CharacterClass, List<ThinkMenuOption>>();
foreach (CharacterClass characterClass in Enum.GetValues(typeof(CharacterClass)))
weaponMenuOptions.Add(characterClass, new List<ThinkMenuOption>());
shieldMenuOptions = new List<ThinkMenuOption>();
itemMenuOptions = new List<ThinkMenuOption>();
Actions = new List<ThinkAction>(battle.PlayerParty.Count);
inputButtonListener = new InputButtonListener(new Dictionary<InputButton, ButtonEventHandlers> {
{ InputButton.Up, new ButtonEventHandlers(down: upHandler) },
{ InputButton.Down, new ButtonEventHandlers(down: downHandler) },
{ InputButton.Left, new ButtonEventHandlers(down: leftHandler) },
{ InputButton.Right, new ButtonEventHandlers(down: rightHandler) },
{ InputButton.A, new ButtonEventHandlers(up: selectOption) },
{ InputButton.B, new ButtonEventHandlers(up: cancelAction) }
});
}
public NewCharacterWindow(Battle.Core.BattlelordsSession session)
{
this.session = session;
this.SetDefaultSize(400,300);
this.SetPosition(WindowPosition.Center);
this.build();
}
public bool TryPerform(Battle context)
{
Debug.Assert(!IsRunning);
if (IsBeforeDelaying)
{
Debug.LogError("now before delaying.");
return false;
}
if (_boss.IsDead)
return false;
if (_boss.Data.Skills.Empty())
{
Debug.LogError("has no skill.");
return false;
}
var data = SampleOrGetDebugSkillData(context);
if (data == null)
return false;
Running = _skillFactory.Create(data, context, _boss);
Running.OnStop += OnStop;
Running.Start();
Events.Boss.OnSkillStart.CheckAndCall(_boss, Running);
return true;
}
public override void Interact(Entity other)
{
if (other is Combatant) {
Combatant otherCombatant = (Combatant)other;
// If interacting with an enemy
if (!Team.IsFriendly(otherCombatant.Team)) {
IsEngaged = true;
// Join the enemy's battle, or create a new one
if (otherCombatant.battle == null) {
battle = new Battle();
} else {
battle = otherCombatant.battle;
}
// Add fighters to the battle
foreach (Fighter f in Fighters) {
battle.AddFighter(f);
}
// We want the battle to notify us when it ends,
// so we can disengage
battle.Ended += OnBattleEnd;
// Notify
JoinedBattle(this, new CombatantEventArgs {
Battle = battle
});
}
}
}
public override void Encounter()
{
int level = rng.Next(3, 6);
int level2 = rng.Next(4, 7);
int species = rng.Next(1, 101);
Battle battle = new Battle();
if (species > 75)
{
battle.Wild(generator.Create("Caterpie", level));
}
else if (species > 50)
{
battle.Wild(generator.Create("Weedle", level));
}
else if (species > 30)
{
battle.Wild(generator.Create("Pidgey", level));
}
else if (species > 15)
{
battle.Wild(generator.Create("Metapod", level2));
}
else
{
battle.Wild(generator.Create("Kakuna", level2));
}
}
public void OnExecuteCommand(Battle.MessageConstants.ExecuteCommandHook hook)
{
var executer = AllPartyManager.Instance.ActiveTimeMaxBattleCharacter;
var selectCommandData = executer.SelectCommandData;
selectCommandData.Impact.Damage = CalcurateDamage.Range( this.data.PowerMinToInt, this.data.PowerMaxToInt );
selectCommandData.Impact.Target.TakeDamage( selectCommandData.Impact.Damage );
}
///////////////////////////////////////////////////////////////////////////////
// Function
///////////////////////////////////////////////////////////////////////////////
new void Awake() {
base.Awake();
levelName = GameLevel.Battle.ToString();
instance = this;
input = GetComponent<GameInput>();
input.enabled = false;
}
public override void Encounter()
{
int level = rng.Next(3, 5);
int species = rng.Next(1, 101);
Battle battle = new Battle();
if (species > 65)
{
battle.Wild(generator.Create("Rattata", level));
}
else if (species > 30)
{
battle.Wild(generator.Create("Pidgey", level));
}
else if (species > 15)
{
battle.Wild(generator.Create("Weedle", level));
}
else
{
battle.Wild(generator.Create("Caterpie", level));
}
return;
}
public Regulus.Project.Crystal.Game.Core CreateUser(Regulus.Remoting.ISoulBinder binder, IStorage storage, IMap zone , Battle.IZone battle)
{
var core = new Regulus.Project.Crystal.Game.Core(binder, storage, zone, battle);
_Users.AddFramework(core);
core.InactiveEvent += () => { _Users.RemoveFramework(core); };
return core;
}
// Use this for initialization
void Start()
{
//Dictionary<Storage.UnitTypes, uint> dUnits = new Dictionary<Storage.UnitTypes, uint>();
//Dictionary<Storage.BuildingTypes, uint> dBuildings = new Dictionary<Storage.BuildingTypes, uint>();
missionsToComplete = 0;
GameInformation info = GameObject.Find("GameInformationObject").GetComponent<GameInformation>();
battle = info.GetBattle();
foreach (Battle.MissionDefinition mission in battle.GetMissions())
{
switch (mission.purpose)
{
case Battle.MissionType.DESTROY:
switch (mission.target)
{
case Storage.EntityType.UNIT:
destroyedUnitsWinners.Add(mission.targetType.unit, 0);
//dUnits.Add(mission.targetType.unit, mission.amount);
missionsToComplete++;
break;
case Storage.EntityType.BUILDING:
destroyedBuildingsWinners.Add(mission.targetType.building, 0);
//dBuildings.Add(mission.targetType.building, mission.amount);
missionsToComplete++;
break;
}
break;
}
}
}
static void Main( string[] args )
{
Messenger.Input = Console.ReadLine;
Messenger.Message.Subscribe( MessageWriter );
var hero = new HeroBattler( Messenger, "勇者", 20, 20 );
var witch = new HeroBattler( Messenger, "魔女", 18, 18 );
var enemy = new Battler( Messenger, "スキュラ", 20, 20 );
var enemy2 = new Battler( Messenger, "モノアイ", 16, 16 );
var atackSkill = new Skill( "攻撃", 1, 1, Atack );
var pluralAtackSkill = new Skill( "連続攻撃", 1, 1, PluralAtack );
var starSkill = new Skill( "星を落とす魔法", 1, 3, StarMagic );
var fireSkill = new Skill( "炎の剣", 2, 1, FireSlash );
hero.AddSkill( atackSkill );
hero.AddSkill( pluralAtackSkill );
hero.AddSkill( fireSkill );
witch.AddSkill( atackSkill );
witch.AddSkill( starSkill );
enemy.AddSkill( atackSkill );
enemy.AddSkill( pluralAtackSkill );
enemy2.AddSkill( atackSkill );
var battle = new Battle( Messenger, new[] { hero, witch }, new[] { enemy, enemy2 } );
var sub = battle.Run().ToMicrothread();
while( sub.Current == BattleState.Fighting )
{
sub.Yield();
}
Console.WriteLine( "End" );
Console.ReadLine();
}
public MainWindow(Battle.Core.BattlelordsSession session)
: base("Battle")
{
this.session = session;
this.build();
this.DeleteEvent += HandleHandleDeleteEvent;
}
/*
public void Click(){
battle = GetComponentInParent<Battle>();
Debug.Log("click Atk");
//battle.act1 = Accion.CreateAccion("AttackGeneric");
battle.act1 = Accion.CreateAccion(battle.userMon.GetMov(battle.userMon.lv)[0],battle.opoMon);
}*/
public void Click()
{
battle = GetComponentInParent<Battle>();
battle.user.nroMovimiento = 0;
battle.user.target = battle.opoMon;
battle.user.clicks = accionesEntrenador.Ataque;
}
public AttackWindow(Character attacker, Character defender, Battle battle)
{
InitializeComponent();
_attacker = attacker;
_defender = defender;
_battle = battle;
Refresh();
}
void Awake()
{
_battle = this;
StateMachine.RegediStateCallBack("Battle", "Round", StateCallBackType.TypeOnEnter, BattleRoundEnter);
StateMachine.RegediStateCallBack("Round", "RoundStart", StateCallBackType.TypeOnEnter, BattleStartEnter);
StateMachine.RegediStateCallBack("Round", "BeforeDamage", StateCallBackType.TypeOnEnter, RoundBeforeDamageEnter);
Message.RegeditMessageHandle<string>("QuickBattle", SetPassFlag);
}
public DoDamageWindow(Character target, Battle battle)
{
InitializeComponent();
_target = target;
_battle = battle;
textBox1.Focus();
textBox1.SelectAll();
}
internal virtual RaidColorCreater createRaidColorCreater(Battle battle, IBattleTemplateService tempService)
{
int _stageId = battle.BattleSource.RaidStageId;
Template.Auto.Raid.RaidStageTemplate _temp = tempService.getRaidStageTemp(_stageId);
RaidColorCreater _creater = new RaidColorCreater(battle);
_creater.build(_temp.ColorRate);
return _creater;
}
public void OnExecuteCommand( Battle.MessageConstants.ExecuteCommandHook hook )
{
var executer = AllPartyManager.Instance.ActiveTimeMaxBattleCharacter;
var selectCommandData = executer.SelectCommandData;
var target = selectCommandData.Impact.Target;
var value = target.AddSpeedPercentage( CalcurateDamage.Range( this.data.PowerMin, this.data.PowerMax ) );
selectCommandData.Impact.Speed = value;
}
public void OnExecuteCommand(Battle.MessageConstants.ExecuteCommandHook hook)
{
this.Initialize();
var selectCommandData = AllPartyManager.Instance.ActiveTimeMaxBattleCharacter.SelectCommandData;
selectCommandData.SetTarget( this.targetCharacter );
SetTargetCharacter();
}
public Outro(EncounterState encounterState, Battle battle)
: base(battle)
{
Battle.OverworldEncounter.State = encounterState;
Logger.Log(battle.PlayerPartyItemsUsed.ToString() + " items were used");
BattleStateRenderer = new IntroOutroRenderer(this);
Time = FadeTimeInSeconds * (encounterState == EncounterState.Won ? (1.0f - WinRenderer.MaxOverlayAlpha) : 1.0f);
}
public override IBattleExecuter createBattleExecuter(Battle battle, IBattleTemplateService tempService)
{
GreenhandColorCreater _colorCreater = new GreenhandColorCreater(battle);
GreenhandPVEBattleExecuter _executer = new GreenhandPVEBattleExecuter(battle, _colorCreater);
Template.Auto.Greenhand.GreenhandTemplate _temp = tempService.BattleGreenhandTemplate;
_executer.initTemplInfo(_temp);
return _executer;
}
public BattleMemberAddWindow(Helper helper, Battle battle)
{
InitializeComponent();
_helper = helper;
_battle = battle;
listBox1.ItemsSource = _helper.Groups;
listBox1.DisplayMemberPath = "GroupName";
listBox3.ItemsSource = _battle.Members;
}
public void OnExecuteCommand( Battle.MessageConstants.ExecuteCommandHook hook )
{
var executer = AllPartyManager.Instance.ActiveTimeMaxBattleCharacter;
var selectCommandData = executer.SelectCommandData;
var target = selectCommandData.Impact.Target;
selectCommandData.Impact.Damage = CalcurateDamage.Range( data.PowerMinToInt, data.PowerMaxToInt );
selectCommandData.Impact.IsCritical = Random.Range( 0, 100 ) < 1; Development.TODO( "会心の術の実装." );
target.Recovery( selectCommandData.Impact.Damage );
}
public UseItem(Battle battle, ThinkAction thinkAction)
: base(battle)
{
if (thinkAction == null)
throw new Exception("ThinkAction cannot be null");
this.thinkAction = thinkAction;
scriptRunner = null;
item = null;
}
public HandleStatusEffects(Battle battle, StatusEffectEvent statusEffectEvent, ThinkAction thinkAction = null, PartyMember partyMember = null)
: base(battle)
{
if (thinkAction == null && partyMember == null)
throw new Exception("Either ThinkAction or PartyMember must not be null");
this.thinkAction = thinkAction;
this.partyMember = partyMember ?? thinkAction.Actor;
this.statusEffectEvent = statusEffectEvent;
}
private bool GetBattleAndFounder(out Battle battle, out User founder)
{
founder = null;
if (Program.TasClient.ExistingBattles.TryGetValue(battleID, out battle)) {
founder = battle.Founder;
return true;
}
return false;
}
public void OnPVE(Battle.EModel model)
{
//协议包
LoginMsg.C2SPVP msg = new LoginMsg.C2SPVP();
msg.type = (int)model;
msg.mapid = 10001;
LoginServerManager.Instance.Server.SendMessage(ActorManager.Instance.controlActor.info.guid, ICmdNum.CmdNum.CS_PVP, msg, LoginServerManager.Instance.sendTime.interval_1, LoginServerManager.Instance.sendTime.count_1, false);
Global.Instance.SetPopupWaitUI(PopupWaitUI.EState.PVP);
}
public override HeroTeam createAttackerTeam(Battle battle)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.List<com.kx.sglm.gs.battle.share.data.FighterInfo> _heroList = com.kx.sglm.gs.battle.share.factory.creater.BattleFighterCreater.getSideFighter(battle, com.kx.sglm.gs.battle.share.enums.BattleSideEnum.SIDE_LEFT);
List<FighterInfo> _heroList = BattleFighterCreater.getSideFighter(battle, BattleSideEnum.SIDE_LEFT);
HeroTeam _heroTeam = BattleFighterCreater.createHeroTeam(battle, _heroList, BattleSideEnum.SIDE_LEFT);
_heroTeam.BattleSide = BattleSideEnum.SIDE_LEFT;
return _heroTeam;
}
public Selection MakeForcedSwitchSelection(Battle battle, Side actorSide)
{
throw new NotImplementedException();
}
public async override Task StartProcessingJobAsync(string logFilePath, Battle eqBattle)
{
// WatchFile = false;
Log.Debug($"Starting to process EQBattle. ({this.GetType().Name})");
var ctSource = CancelSource;
var cp = new ChannelProcessor(ctSource.Token);
var datumTask = cp.Process(_rawLinesChannel.Reader, _logLinesChannel.Writer, item => TransformLogLineToDatum(item), "Datum");
var dtCancel = datumTask.ContinueWith(_ => Log.Verbose("DatumTask cancelled"), TaskContinuationOptions.OnlyOnCanceled);
var dtComplete = datumTask.ContinueWith(_ => Log.Verbose("DatumTask complete"), TaskContinuationOptions.OnlyOnRanToCompletion);
var dtContinue = datumTask.ContinueWith(_ =>
{
Log.Verbose($"DatumTask done. {_datumLineCount:N0} datum lines, {_sw.Elapsed} elapsed");
_logLinesChannel.Writer.TryComplete();
});
var parseTask = cp.Process(_logLinesChannel.Reader, _parsedLinesChannel.Writer, item => TransformDatumToLine(item), "Parser");
var ptCancel = parseTask.ContinueWith(_ => Log.Verbose("ParseTask cancelled"), TaskContinuationOptions.OnlyOnCanceled);
var ptComplete = parseTask.ContinueWith(_ => Log.Verbose("ParseTask complete"), TaskContinuationOptions.OnlyOnRanToCompletion);
var ptContinue = parseTask.ContinueWith(_ =>
{
Log.Verbose($"ParseTask done. {_parsedLineCount:N0} parse lines, {_sw.Elapsed} elapsed");
_parsedLinesChannel.Writer.TryComplete();
});
var battleTask = cp.Process(_parsedLinesChannel.Reader, item => AddLineToBattle(item, eqBattle), "Battle");
var btCancel = battleTask.ContinueWith(_ => Log.Verbose("BattleTask cancelled"), TaskContinuationOptions.OnlyOnCanceled);
var btComplete = battleTask.ContinueWith(_ => Log.Verbose("BattleTask complete"), TaskContinuationOptions.OnlyOnRanToCompletion);
var btContinue = battleTask.ContinueWith(_ =>
{
Log.Verbose($"BattleTask done. {_battleLinesCount:N0} battle lines, {_sw.Elapsed} elapsed");
});
// Start our main guy up, this starts the whole pipeline flow going
_sw.Start();
// var readTask = cp.Process(_rawLinesChannel.Writer, ct => ReadLogLines(logFilePath, ct));
var readTask = ReadLogLinesWrapper(_rawLinesChannel.Writer, logFilePath, ctSource.Token, 250);
var rtCancel = readTask.ContinueWith(_ => Log.Verbose("ReadTask cancelled"), TaskContinuationOptions.OnlyOnCanceled);
var rtComplete = readTask.ContinueWith(_ => Log.Verbose("ReadTask complete"), TaskContinuationOptions.OnlyOnRanToCompletion);
var rtContinue = readTask.ContinueWith(_ =>
{
Log.Verbose($"ReadTask done. {_rawLineCount:N0} read lines, {_sw.Elapsed} elapsed");
_rawLinesChannel.Writer.TryComplete();
});
try
{
// Wait for everything to finish up
await Task.WhenAll(readTask, datumTask, parseTask, battleTask);
Log.Verbose("All tasks that we're waiting for are done");
}
catch (OperationCanceledException)
{
Log.Verbose("EQ Job Operation Cancelled");
throw;
}
catch (Exception ex)
{
Log.Error(ex, "EQ Job");
throw;
}
finally
{
Log.Verbose("Job done");
// Give all continuation tasks a chance to finish
await Task.WhenAll(rtContinue, dtContinue, ptContinue, btContinue);
DumpTaskInfo(readTask, "readTask");
DumpTaskInfo(datumTask, "datumTask");
DumpTaskInfo(parseTask, "parseTask");
DumpTaskInfo(battleTask, "battleTask");
DumpChannelInfo(_rawLinesChannel, "_rawLinesChannel");
DumpChannelInfo(_logLinesChannel, "_logLinesChannel");
DumpChannelInfo(_parsedLinesChannel, "_parsedLinesChannel");
Log.Debug($"Total processing EQBattle, {_sw.Elapsed} elapsed");
Log.Verbose($"LastLineNumber read: {_lastLineNumber:N0}");
Log.Verbose($"LastLineNumber added to Battle: {_lastLineAddedToBattle?.LogLine.LineNumber:N0}");
}
}
public BattleGameEvent(Battle battle, BattleStatusEnum battleStatus, GameTime time)
: base(EventTypeEnum.Battle, time.Day, time.Time)
{
BattleID = battle.ID;
BattleStatus = battleStatus;
}
public async Task <BattleDto> CreateBattle(int initiatorId, int opponentId)
{
var initiator = await _heroService.FindById(initiatorId);
var opponent = await _heroService.FindById(opponentId);
var diff = DateTime.Now.Subtract(initiator.LastTimeMoved);
if (diff.TotalMinutes < _appSettings.MinutesToWait)
{
var remainingSeconds = 300 - Math.Floor(diff.TotalSeconds);
throw new InvalidTravel($"You still need to wait {remainingSeconds} seconds");
}
Battle newBattle = new Battle
{
InitiatorId = initiatorId,
Latitude = opponent.Latitude,
Longitude = opponent.Longitude
};
_context.Heroes.Update(initiator);
await _context.SaveChangesAsync();
var participants = await _heroService.GetHeroesInRange(opponentId);
var heroInitiator = participants.FirstOrDefault(participant => participant.Id == initiatorId);
if (heroInitiator == null)
{
participants.Add(initiator);
}
newBattle.Heroes = CreateHeroBattles(participants, newBattle);
await _context.AddAsync(newBattle);
await _context.SaveChangesAsync();
BattleDto battleDto = new BattleDto
{
Id = newBattle.Id,
InitiatorId = newBattle.InitiatorId,
OpponentId = opponentId,
Latitude = newBattle.Latitude,
Longitude = newBattle.Longitude
};
var participantsList = participants.ToList();
participantsList.ForEach(participant => participant.Badges = null);
participantsList.ForEach(participant => participant.Battles = null);
battleDto.Heroes = GetHeroesOfBattle(newBattle);
battleDto.Villains = GetVillainsOfBattle(newBattle);
battleDto.HeroesStrength = battleDto.Heroes.Sum(v => v.OverallStrength);
battleDto.VillainsStrength = battleDto.Villains.Sum(v => v.OverallStrength);
return(battleDto);
}
public static int Buff(Battle battle)
{
return(battle.Opponents[0].Buff);
}
public PlayerBatlleCharacter(Player pl, int HP, string status, Battle battle, IBattleEvent Action) : base("Player", HP, status, battle)
{
player = pl;
}
// this should take a battle memory at some point
public void Setup(string battleKey)
{
battle = Resources.Load <Battle>("Database/Battles/" + battleKey);
Debug.Assert(battle != null, "Unknown battle key " + battleKey);
}
private void spring_SpringStarted(object sender, EventArgs e)
{
battle = tas.GetBattle();
players = new Dictionary <string, Player>();
startTime = DateTime.Now;
}
BattleIcon GetBattleIcon(Battle battle)
{
return(BattleIcons.SingleOrDefault(b => b.Battle == battle));
}
void TasClient_BattleFound(object sender, Battle battle)
{
var battleIcon = AddBattle(battle);
BattleAdded(this, new EventArgs <BattleIcon>(battleIcon));
}
void TasClient_BattleEnded(object sender, Battle battle)
{
RemoveBattleIcon(battle);
}
public void StartBattle()
{
battle1 = GameObject.Find("BattleManager").GetComponent <Battle>();
battle1.OnBattleInitalise(ally_player, enemy_player);
}
public static void setBattle(Battle bat)
{
mainBattle = bat;
}
private void PrintBattles()
{
Battle unnotableDeathBattle = null; //Temporarily make the battle that the HF died in Notable so it shows up.
if (HistoricalFigure.Battles.Count > 0 && HistoricalFigure.Battles.Last().Collection.OfType <HFDied>().Count(death => death.HistoricalFigure == HistoricalFigure) == 1 && !HistoricalFigure.Battles.Last().Notable)
{
unnotableDeathBattle = HistoricalFigure.Battles.Last();
unnotableDeathBattle.Notable = true;
}
if (HistoricalFigure.Battles.Count(battle => !World.FilterBattles || battle.Notable) > 0)
{
HTML.AppendLine(Bold("Battles") + MakeLink("[Load]", LinkOption.LoadHFBattles));
if (World.FilterBattles)
{
HTML.Append(" (Notable)");
}
HTML.Append(LineBreak);
TableMaker battleTable = new TableMaker(true);
foreach (Battle battle in HistoricalFigure.Battles.Where(battle => (!World.FilterBattles || battle.Notable) || battle.Collection.OfType <HFDied>().Count(death => death.HistoricalFigure == HistoricalFigure) > 0))
{
battleTable.StartRow();
battleTable.AddData(battle.StartYear.ToString());
battleTable.AddData(battle.ToLink());
if (battle.ParentCollection != null)
{
battleTable.AddData("as part of");
battleTable.AddData(battle.ParentCollection.ToLink());
}
string involvement = "";
if (battle.NotableAttackers.Count > 0 && battle.NotableAttackers.Contains(HistoricalFigure))
{
if (battle.Collection.OfType <FieldBattle>().Any(fieldBattle => fieldBattle.AttackerGeneral == HistoricalFigure) ||
battle.Collection.OfType <AttackedSite>().Any(attack => attack.AttackerGeneral == HistoricalFigure))
{
involvement += "Led the attack";
}
else
{
involvement += "Fought in the attack";
}
}
else if (battle.NotableDefenders.Count > 0 && battle.NotableDefenders.Contains(HistoricalFigure))
{
if (battle.Collection.OfType <FieldBattle>().Any(fieldBattle => fieldBattle.DefenderGeneral == HistoricalFigure) ||
battle.Collection.OfType <AttackedSite>().Any(attack => attack.DefenderGeneral == HistoricalFigure))
{
involvement += "Led the defense";
}
else
{
involvement += "Aided in the defense";
}
}
else
{
involvement += "A non combatant";
}
if (battle.GetSubEvents().OfType <HFDied>().Any(death => death.HistoricalFigure == HistoricalFigure))
{
involvement += " and died";
}
battleTable.AddData(involvement);
if (battle.NotableAttackers.Contains(HistoricalFigure))
{
battleTable.AddData("against");
battleTable.AddData(battle.Defender.PrintEntity(), 0, TableDataAlign.Right);
if (battle.Victor == battle.Attacker)
{
battleTable.AddData("and won");
}
else
{
battleTable.AddData("and lost");
}
}
else if (battle.NotableDefenders.Contains(HistoricalFigure))
{
battleTable.AddData("against");
battleTable.AddData(battle.Attacker.PrintEntity(), 0, TableDataAlign.Right);
if (battle.Victor == battle.Defender)
{
battleTable.AddData("and won");
}
else
{
battleTable.AddData("and lost");
}
}
battleTable.AddData("Deaths: " + (battle.AttackerDeathCount + battle.DefenderDeathCount) + ")");
battleTable.EndRow();
}
HTML.AppendLine(battleTable.GetTable() + LineBreak);
}
if (World.FilterBattles && HistoricalFigure.Battles.Count(battle => !battle.Notable) > 0)
{
HTML.AppendLine(Bold("Battles") + " (Unnotable): " + HistoricalFigure.Battles.Where(battle => !battle.Notable).Count() + LineBreak + LineBreak);
}
if (unnotableDeathBattle != null)
{
unnotableDeathBattle.Notable = false;
}
}
// Update is called once per frame
void FixedUpdate()
{
if (Game.Instance().battleObject.activeInHierarchy || Game.Instance().techTree.activeInHierarchy || Game.Instance().messageObject.activeInHierarchy)
{
lastTime = Time.time + 5 * moveSpcae;
return;
}
if (Time.time - lastTime < moveSpcae)
{
return;
}
lastTime = Time.time;
float t_x = 0;
float t_y = 0;
if (Input.GetKey(KeyCode.D))
{
t_x = 1;
}
else if (Input.GetKey(KeyCode.A))
{
t_x = -1;
}
else if (Input.GetKey(KeyCode.W))
{
t_y = 1;
}
else if (Input.GetKey(KeyCode.S))
{
t_y = -1;
}
int direct = (t_x == 0) ? ((t_y == 0) ? -1 : ((t_y > 0) ? 1 : 2)) : ((t_x > 0) ? 0 : 3);
if (direct != -1)
{
int x = (int)transform.position.x + pos_x[direct];
int y = (int)transform.position.y + pos_y[direct];
if (x >= Level.width || x < 0 || y >= Level.height || y < 0)
{
return;
}
Cell cell = Level.Instance().cells[x, y];
if (cell.IsRoad())
{
transform.position = new Vector3(x, y, -1);
if (sound && Game.sound)
{
sound.Play();
}
}
else if (cell.IsUpFloor())
{
transform.position = new Vector3(x, y, -1);
if (Game.Instance().SetLevel(Game.currentLevel + 1))
{
transform.position = new Vector3(0, 0, -1);
}
}
else if (cell.IsDownFloor())
{
transform.position = new Vector3(x, y, -1);
if (Game.Instance().SetLevel(Game.currentLevel - 1))
{
transform.position = new Vector3(Level.width - 1, Level.height - 1, -1);
}
}
else if (cell.IsMonster())
{
if (!cell.gameObject.GetComponent <MonsterHpComponent>())
{
cell.gameObject.AddComponent <MonsterHpComponent>();
}
MonsterData m = MonsterData.GetMonsterDataFromDB(cell.id);
cell.monster.id = cell.id;
cell.monster.hpComponent.SetHp(m.hp);
cell.monster.characterName = m.name;
cell.monster.SetAttack(m.attack);
cell.monster.SetDefence(m.defence);
cell.monster.gold = m.gold;
Battle.Instance().battle(Player.Instance(), cell.monster);
}
else if (cell.IsItem())
{
ItemData itemData = ItemData.GetItemDataFromDB(cell.item.id + 9);
Player.Instance().GetItem(itemData);
cell.GetComponent <SpriteRenderer>().sprite = null;
cell.id = (int)CellType.ROAD;
if (Game.Instance().winAudioSource&& Game.sound)
{
Game.Instance().winAudioSource.Play();
}
}
}
}
private Selection MakeRandomFightSelection(Battle battle, Side actorSide)
{
return(Selection.MakeFight(actorSide.CurrentBattleBitmon,
battle.PlayerSide.CurrentBattleBitmon,
PickRandomMove(actorSide)));
}
public void Dispose()
{
Battle.DeleteAll();
}
public static int Hit(Battle battle)
{
return(battle.Opponents[0].Damage);
}
public static IEnumerable <ITab_Pawn_Log_Utility.LogLineDisplayable> GenerateLogLinesFor(Pawn pawn, bool showAll, bool showCombat, bool showSocial)
{
LogEntry[] nonCombatLines = (!showSocial) ? new LogEntry[0] : (from e in Find.PlayLog.AllEntries
where e.Concerns(pawn)
select e).ToArray <LogEntry>();
int nonCombatIndex = 0;
Battle currentBattle = null;
if (showCombat)
{
bool atTop = true;
foreach (Battle battle in Find.BattleLog.Battles)
{
if (battle.Concerns(pawn))
{
foreach (LogEntry entry in battle.Entries)
{
if (entry.Concerns(pawn) && (showAll || entry.ShowInCompactView()))
{
while (nonCombatIndex < nonCombatLines.Length && nonCombatLines[nonCombatIndex].Age < entry.Age)
{
if (currentBattle != null && currentBattle != battle)
{
yield return(new ITab_Pawn_Log_Utility.LogLineDisplayableGap(ITab_Pawn_Log_Utility.BattleBottomPadding));
currentBattle = null;
}
LogEntry[] array = nonCombatLines;
int num;
nonCombatIndex = (num = nonCombatIndex) + 1;
yield return(new ITab_Pawn_Log_Utility.LogLineDisplayableLog(array[num], pawn));
atTop = false;
}
if (currentBattle != battle)
{
if (!atTop)
{
yield return(new ITab_Pawn_Log_Utility.LogLineDisplayableGap(ITab_Pawn_Log_Utility.BattleBottomPadding));
}
yield return(new ITab_Pawn_Log_Utility.LogLineDisplayableHeader(battle.GetName()));
currentBattle = battle;
atTop = false;
}
yield return(new ITab_Pawn_Log_Utility.LogLineDisplayableLog(entry, pawn));
}
}
}
}
}
while (nonCombatIndex < nonCombatLines.Length)
{
if (currentBattle != null)
{
yield return(new ITab_Pawn_Log_Utility.LogLineDisplayableGap(ITab_Pawn_Log_Utility.BattleBottomPadding));
currentBattle = null;
}
LogEntry[] array2 = nonCombatLines;
int num;
nonCombatIndex = (num = nonCombatIndex) + 1;
yield return(new ITab_Pawn_Log_Utility.LogLineDisplayableLog(array2[num], pawn));
}
yield break;
}
public override void Turn(Battle battle)
{
battle.EndTurn();
}
private int cardNum; // This is currently unused
public BattleInput(Battle battle)
{
this.battle = battle;
}
private void onBattleEnd(Battle b)
{
Run();
}
public BattlePrinter(Battle battle, World world)
{
_battle = battle;
_world = world;
}
public static void Apply(object[] parameters)
{
Actor spellCaster = parameters[0] as Actor;
List <Effects.ZoneEffect.ZoneEffectTemplate> affectedPlayers = parameters[1] as List <Effects.ZoneEffect.ZoneEffectTemplate>;
int spellID = (int)parameters[2];
Actor.effects effect = parameters[3] as Actor.effects;
bool cd = Convert.ToBoolean(parameters[4]);
Point spellPos = parameters[5] as Point;
Actor.SpellsInformations infos_sorts = spellCaster.sorts.Find(f => f.SpellId == spellID);
mysql.spells spell_Template = (DataBase.DataTables.spells as List <mysql.spells>).Find(f => f.spellID == spellID && f.level == infos_sorts.Level);
Battle _battle = Battle.Battles.Find(f => f.IdBattle == spellCaster.idBattle);
#region inscription dans les envoutements
//// ajout du sort dans la liste des envoutements systeme "non debufable"
if (spellCaster.BuffsList.Exists(f => f.SortID == spellID && f.system))
{
// sort trouvé
Actor.Buff piEnv = spellCaster.BuffsList.Find(f => f.SortID == spellID && f.system);
foreach (Effects.ZoneEffect.ZoneEffectTemplate affectedPlayerTemplate in affectedPlayers)
{
if (affectedPlayerTemplate.AffectedActor != null)
{
piEnv.playerRoxed.Add(affectedPlayerTemplate.AffectedActor.Pseudo);
}
else
{
piEnv.playerRoxed.Add("null");
}
}
}
else
{
// ajout du sort dans les envoutements
Actor.Buff piEnv1 = new Actor.Buff();
piEnv1.SortID = spellID;
piEnv1.title = spell_Template.spellName;
piEnv1.Debuffable = false;
piEnv1.VisibleToPlayers = false;
if (affectedPlayers.Count > 0)
{
foreach (Effects.ZoneEffect.ZoneEffectTemplate affectedPlayerTemplate in affectedPlayers)
{
if (affectedPlayerTemplate.AffectedActor != null)
{
piEnv1.playerRoxed.Add(affectedPlayerTemplate.AffectedActor.Pseudo);
}
else
{
piEnv1.playerRoxed.Add("null");
}
}
}
else
{
piEnv1.playerRoxed.Add("null");
}
piEnv1.relanceInterval = spell_Template.relanceInterval;
piEnv1.BuffState = Enums.Buff.State.Fin;
piEnv1.relanceParTour = spell_Template.relanceParTour;
piEnv1.system = true;
piEnv1.Cd = cd;
piEnv1.Player = spellCaster.Pseudo;
spellCaster.BuffsList.Add(piEnv1);
}
#endregion
}
public void Init(Battle controlBattle)
{
battle = controlBattle;
}
private ICollection <HeroBattle> CreateHeroBattles(ICollection <Hero> participants, Battle battle)
{
var heroBattles = new List <HeroBattle>();
var heroes = _context.Heroes
.Include(h => h.Powers).ThenInclude(hp => hp.Power)
.Include(h => h.Type)
.Include(h => h.Badges).ThenInclude(hp => hp.Badge);
foreach (var hero in participants)
{
heroBattles.Add(new HeroBattle
{
Hero = heroes.FirstOrDefault(h => h.Id == hero.Id),
Battle = battle
});
}
return(heroBattles);
}
private void launchBattle()
{
GameViewModel.Instance.EnnemyCastle.Army.GenerateEnnemyArmy();
Battle newBattle = new Battle(attackingArmy, defendingArmy, attackedCastle, attackingCastle);
}
public static void Generate(string filename, Battle b, out List <Battle.GrPlayer> players)
{
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
StringBuilder s = new StringBuilder();
s.AppendLine("[GAME]");
s.AppendLine("{");
s.AppendFormat(" Mapname={0};\n", b.Map.Name);
s.AppendFormat(" StartMetal={0};\n", b.Details.StartingMetal);
s.AppendFormat(" StartEnergy={0};\n", b.Details.StartingEnergy);
s.AppendFormat(" MaxUnits={0};\n", b.Details.MaxUnits);
s.AppendFormat(" StartPosType={0};\n", (int)b.Details.StartPos);
s.AppendFormat(" GameMode={0};\n", (int)b.Details.EndCondition);
s.AppendFormat(" GameType={0};\n", b.Mod.ArchiveName);
s.AppendFormat(" LimitDGun={0};\n", b.Details.LimitDgun);
s.AppendFormat(" DiminishingMMs={0};\n", b.Details.DiminishingMM);
s.AppendFormat(" GhostedBuildings={0};\n", b.Details.GhostedBuildings);
s.AppendLine();
s.AppendFormat(" HostIP={0};\n", "127.0.0.1");
s.AppendFormat(" HostPort={0};\n", b.HostPort);
//s.AppendFormat(" MinSpeed={0};\n", 1);
//s.AppendFormat(" MaxSpeed={0};\n", 1);
s.AppendLine();
s.AppendFormat(" MyPlayerNum={0};\n", 0);
//List<Battle.GrPlayer> players;
List <Battle.GrTeam> teams;
List <Battle.GrAlly> alliances;
b.GroupData(out players, out teams, out alliances);
s.AppendLine();
s.AppendFormat(" NumPlayers={0};\n", players.Count);
s.AppendFormat(" NumTeams={0};\n", teams.Count);
s.AppendFormat(" NumAllyTeams={0};\n", alliances.Count);
s.AppendLine();
// PLAYERS
for (int i = 0; i < players.Count; ++i)
{
UserBattleStatus u = players[i].user;
s.AppendFormat(" [PLAYER{0}]\n", i);
s.AppendLine(" {");
s.AppendFormat(" name={0};\n", u.name);
s.AppendFormat(" Spectator={0};\n", u.IsSpectator ? 1 : 0);
if (!u.IsSpectator)
{
s.AppendFormat(" team={0};\n", u.TeamNumber);
}
s.AppendLine(" }");
}
// TEAMS
s.AppendLine();
for (int i = 0; i < teams.Count; ++i)
{
s.AppendFormat(" [TEAM{0}]\n", i);
s.AppendLine(" {");
s.AppendFormat(" TeamLeader={0};\n", teams[i].leader);
UserBattleStatus u = players[teams[i].leader].user;
s.AppendFormat(" AllyTeam={0};\n", u.AllyNumber);
s.AppendFormat(" RGBColor={0:F5} {1:F5} {2:F5};\n", (u.TeamColor & 255) / 255.0, ((u.TeamColor >> 8) & 255) / 255.0, ((u.TeamColor >> 16) & 255) / 255.0);
s.AppendFormat(" Side={0};\n", b.Mod.Sides[u.Side]);
s.AppendFormat(" Handicap={0};\n", 0);
s.AppendLine(" }");
}
// ALLYS
s.AppendLine();
for (int i = 0; i < alliances.Count; ++i)
{
s.AppendFormat("[ALLYTEAM{0}]\n", i);
s.AppendLine("{");
s.AppendFormat(" NumAllies={0};\n", 0);
double left, top, right, bottom;
alliances[i].rect.ToFractions(out left, out top, out right, out bottom);
s.AppendFormat(" StartRectLeft={0};\n", left);
s.AppendFormat(" StartRectTop={0};\n", top);
s.AppendFormat(" StartRectRight={0};\n", right);
s.AppendFormat(" StartRectBottom={0};\n", bottom);
s.AppendLine("}");
}
s.AppendLine();
s.AppendFormat(" NumRestrictions={0};\n", b.DisabledUnits.Count);
s.AppendLine(" [RESTRICT]");
s.AppendLine(" {");
for (int i = 0; i < b.DisabledUnits.Count; ++i)
{
s.AppendFormat(" Unit{0}={1};\n", i, b.DisabledUnits[i]);
s.AppendFormat(" Limit{0}=0;\n", i);
}
s.AppendLine(" }");
s.AppendLine(" [modoptions]");
s.AppendLine(" {");
foreach (UnitSync.Option o in b.Mod.Options)
{
string v = o.Default;
if (b.ModOptions.ContainsKey(o.Key))
{
v = b.ModOptions[o.Key];
}
s.AppendFormat(" {0}={1};\n", o.Key, v);
}
s.AppendLine(" }");
s.AppendLine("}");
StreamWriter f = File.CreateText(filename);
f.Write(s.ToString());
f.Flush();
f.Close();
}
private void OnBattleEnd(object sender, EventArgs eventArgs)
{
battle = null;
IsEngaged = false;
}
protected override void ActiveEffect(CharacterStats player, Stats enemy)
{
player.Health += healthRestore;
Battle.WritePlayerHealthGain(Name, healthRestore, player);
}