private SpecialAttack DeploySpecialAttack() { if (Service.SimTimeEngine.IsPaused()) { return(null); } BattleController battleController = Service.BattleController; if (battleController.BattleEndProcessing) { return(null); } if (battleController.GetPlayerDeployableSpecialAttackCount(this.currentSpecialAttackType.Uid) == 0) { Service.EventManager.SendEvent(EventId.TroopNotPlacedInvalidTroop, this.currentWorldPosition); return(null); } if (this.currentSpecialAttackType != null) { TeamType teamType = TeamType.Attacker; if (battleController.GetCurrentBattle().Type == BattleType.PveDefend) { teamType = TeamType.Defender; } SpecialAttack specialAttack = Service.SpecialAttackController.DeploySpecialAttack(this.currentSpecialAttackType, teamType, this.currentWorldPosition, true); if (specialAttack != null) { IntPosition boardPosition = Units.WorldToBoardIntPosition(this.currentWorldPosition); battleController.OnSpecialAttackDeployed(this.currentSpecialAttackType.Uid, teamType, boardPosition); Service.EventManager.SendEvent(EventId.SpecialAttackDeployed, specialAttack); return(specialAttack); } } return(null); }
public SmartEntity SpawnTroop(TroopTypeVO troopType, TeamType teamType, IntPosition boardPosition, TroopSpawnMode spawnMode, bool sendPlacedEvent, bool forceAllow) { Entity spawnBuilding = null; BoardCell <Entity> boardCell = null; if (!this.FinalizeSafeBoardPosition(troopType, ref spawnBuilding, ref boardPosition, ref boardCell, teamType, spawnMode, forceAllow)) { return(null); } SmartEntity smartEntity = Service.Get <EntityFactory>().CreateTroopEntity(troopType, teamType, boardPosition, spawnBuilding, spawnMode, true, true); if (smartEntity == null) { return(null); } BoardItemComponent boardItemComp = smartEntity.BoardItemComp; BoardItem <Entity> boardItem = boardItemComp.BoardItem; if (Service.Get <BoardController>().Board.AddChild(boardItem, boardCell.X, boardCell.Z, null, false, !forceAllow && troopType.Type != TroopType.Champion) == null) { return(null); } Service.Get <EntityController>().AddEntity(smartEntity); Service.Get <TroopAbilityController>().OnTroopSpawned(smartEntity); if (troopType.Type != TroopType.Champion || teamType == TeamType.Attacker) { base.EnsureBattlePlayState(); } if (sendPlacedEvent) { Service.Get <EventManager>().SendEvent(EventId.TroopPlacedOnBoard, smartEntity); } return(smartEntity); }
/// <summary> /// Execute stuff when a slot is clicked /// </summary> /// <param name="sender">Component who sent the event</param> /// <param name="e">Event</param> public void OnSlotClicked(object sender, EventArgs e) { Slot slot = sender as Slot; IntPosition position = slot.GetPosition(); PlayMove(position); }
private void DeployTroopGroup(int index, TroopTypeVO troop, DefenseTroopGroup group) { int degrees = group.Direction; if (group.Quantity > 1) { degrees = group.Direction + group.Spread * index / (group.Quantity - 1) - group.Spread / 2; } int locX = 0; int locZ = 0; DefensiveBattleController.GetBoardEdge(degrees, group.Range, out locX, out locZ); IntPosition nearestValidBoardPosition = this.GetNearestValidBoardPosition(locX, locZ); bool sendPlacedEvent = index == 0; Entity entity = this.troopController.SpawnTroop(troop, TeamType.Attacker, nearestValidBoardPosition, TroopSpawnMode.Unleashed, sendPlacedEvent); if (entity != null) { if (!troop.IsHealer) { this.waves[this.currentWaveIndex].Troops.Add(entity); } Service.BattleController.OnTroopDeployed(troop.Uid, TeamType.Attacker, nearestValidBoardPosition); Service.EventManager.SendEvent(EventId.TroopDeployed, entity); } }
public void DeploySquadTroops(IntPosition boardPos) { this.Reset(); this.spawnPosition = boardPos; IDataController dataController = Service.Get <IDataController>(); this.spawnQueue = new List <TroopTypeVO>(); List <SquadDonatedTroop> troops = Service.Get <SquadController>().StateManager.Troops; if (troops != null) { int i = 0; int count = troops.Count; while (i < count) { TroopTypeVO item = dataController.Get <TroopTypeVO>(troops[i].TroopUid); int j = 0; int totalAmount = troops[i].GetTotalAmount(); while (j < totalAmount) { this.spawnQueue.Add(item); j++; } i++; } } this.OnDeploy(); }
public SpecialAttack DeploySpecialAttack(SpecialAttackTypeVO specialAttackType, TeamType teamType, Vector3 worldPosition, bool playerDeployed) { this.boardPosition = Units.WorldToBoardIntPosition(worldPosition); if ((specialAttackType.IsDropship || specialAttackType.HasDropoff) && teamType == TeamType.Attacker) { if (Service.ShieldController.IsTargetCellUnderShield(worldPosition)) { Service.EventManager.SendEvent(EventId.TroopPlacedInsideShieldError, this.boardPosition); return(null); } if (!Service.TroopController.FindValidDropShipTroopPlacementCell(this.boardPosition, teamType, 1, out this.boardPosition)) { Service.EventManager.SendEvent(EventId.TroopPlacedInsideBuildingError, this.boardPosition); return(null); } } BoardCell cellAt = Service.BoardController.Board.GetCellAt(this.boardPosition.x, this.boardPosition.z); if (cellAt == null) { Service.EventManager.SendEvent(EventId.TroopNotPlacedInvalidArea, this.boardPosition); return(null); } base.EnsureBattlePlayState(); Vector3 targetWorldPos = Units.BoardToWorldVec(this.boardPosition); SpecialAttack specialAttack = new SpecialAttack(specialAttackType, teamType, targetWorldPos, cellAt.X, cellAt.Z, playerDeployed); specialAttack.TargetShield = Service.ShieldController.GetActiveShieldAffectingBoardPos(specialAttack.TargetBoardX, specialAttack.TargetBoardZ); this.specialAttacksDeployed.Enqueue(specialAttack); Service.EventManager.SendEvent(EventId.SpecialAttackSpawned, specialAttack); return(specialAttack); }
private SmartEntity DeployChampion(TroopTypeVO troopType) { if (Service.Get <SimTimeEngine>().IsPaused()) { return(null); } BattleController battleController = Service.Get <BattleController>(); if (battleController.BattleEndProcessing) { return(null); } if (battleController.GetPlayerDeployableChampionCount(troopType.Uid) == 0) { Service.Get <EventManager>().SendEvent(EventId.TroopNotPlacedInvalidTroop, this.currentWorldPosition); return(null); } TeamType teamType = TeamType.Attacker; if (battleController.GetCurrentBattle().Type == BattleType.PveDefend) { teamType = TeamType.Defender; } IntPosition boardPosition = Units.WorldToBoardIntDeployPosition(this.currentWorldPosition); SmartEntity smartEntity = Service.Get <TroopController>().SpawnChampion(troopType, teamType, boardPosition); if (smartEntity != null) { base.PlaySpawnEffect(smartEntity); battleController.OnChampionDeployed(troopType.Uid, teamType, boardPosition); Service.Get <EventManager>().SendEvent(EventId.ChampionDeployed, smartEntity); } return(smartEntity); }
/// <summary> /// Simple alpha-beta algorithm /// </summary> /// <param name="nodeBoard">A particular game state</param> /// <param name="depth">The maximum tree depth</param> /// <param name="parentValue"></param> /// <param name="maximizingPlayer"></param> /// <returns></returns> private Tuple <int, IntPosition> AlphaBeta(AIBoard nodeBoard, int depth, int parentValue, bool maximizingPlayer) { if (depth == 0 || nodeBoard.IsTerminal()) { return(new Tuple <int, IntPosition>(nodeBoard.CurrentPlayerData.NumberOfPawns, new IntPosition(-1, -1))); } else { int optVal = maximizingPlayer ? -int.MaxValue : int.MaxValue; IntPosition optOp = new IntPosition(-1, -1); var childPositions = nodeBoard.GetAllPossibleMoves(); foreach (var child in childPositions) { var returnVal = AlphaBeta(PosToBoard(child, nodeBoard), depth - 1, optVal, !maximizingPlayer); int minOrMax = maximizingPlayer ? 1 : -1; if (returnVal.Item1 * minOrMax > optVal * minOrMax) { optVal = returnVal.Item1; optOp = child; if (optVal * minOrMax > parentValue * minOrMax) { break; } } } return(new Tuple <int, IntPosition>(optVal, optOp)); } }
private SmartEntity CreateDefensiveChampionEntityForBattle(TroopTypeVO championType, SmartEntity building) { TransformComponent transformComp = building.TransformComp; IntPosition boardPosition = new IntPosition(transformComp.CenterGridX(), transformComp.CenterGridZ()); return(Service.Get <TroopController>().SpawnChampion(championType, TeamType.Defender, boardPosition)); }
public TroopSpawnData(TroopTypeVO troop, IntPosition position, TroopSpawnMode mode, int amount) { this.TroopType = troop; this.BoardPosition = position; this.SpawnMode = mode; this.Amount = amount; }
// ---------------------------------------------------------------------------------------------------- // -- Construtors // ---------------------------------------------------------------------------------------------------- public TerminalRenderer(int charsX, int charsY) { sizeX = charsX; sizeY = charsY; charactersPositions = new Vector3[sizeY, sizeX]; charactersBuffer = new TerminalCharacter[sizeY, sizeX]; negativeCharactersIndices = new IntPosition[sizeY * sizeX]; // load resources theme = new TangoTheme( ); cursor = new TerminalCursor(this); defaultMaterial = ReadMaterial("VARP/DebugDraw/GLFontZOff"); defaultFont = ReadFont("VARP/DebugDraw/GLFont"); backgroundMaterial = ReadMaterial("VARP/DebugDraw/GLlineZOff"); // get font's information CharacterInfo space; defaultFont.GetCharacterInfo(' ', out space); lineHeight = defaultFont.lineHeight; charWidth = space.advance; textRectangle = new Rect(0, 0, charWidth * sizeX, lineHeight * sizeY); backgroundRectangle = new Rect(textRectangle.min - backgrounOffset, textRectangle.max + backgrounOffset); // fill buffer coordiates for (var y = 0; y < sizeY; y++) { for (var x = 0; x < sizeX; x++) { charactersPositions[y, x] = new Vector3((float)x * charWidth, (float)y * lineHeight, 0); } } // clear screen Clear( ); }
public void RenderScreen( ) { GL.invertCulling = true; GL.PushMatrix( ); GL.LoadPixelMatrix( ); GL.Begin(GL.QUADS); // Render background backgroundMaterial.SetPass(0); if (isBackgroundVisible) { GL.Color(backgroundColor); GL.Vertex(new Vector3(backgroundRectangle.min.x, backgroundRectangle.max.y, 0)); GL.Vertex(new Vector3(backgroundRectangle.max.x, backgroundRectangle.max.y, 0)); GL.Vertex(new Vector3(backgroundRectangle.max.x, backgroundRectangle.min.y, 0)); GL.Vertex(new Vector3(backgroundRectangle.min.x, backgroundRectangle.min.y, 0)); } // Render text buffer defaultMaterial.SetPass(0); var negativeCharsCount = 0; for (var y = 0; y < sizeY; y++) { for (var x = 0; x < sizeX; x++) { if (charactersBuffer[y, x].isNegative) { negativeCharactersIndices[negativeCharsCount++] = new IntPosition(x, y); } RenderCharacter(charactersPositions[y, x], charactersBuffer[y, x].character, charactersBuffer[y, x].foreground); } } // Render negative characters backgroundMaterial.SetPass(0); GL.Color(theme.selectionColor); for (var i = 0; i < negativeCharsCount; i++) { var xyidx = negativeCharactersIndices[i]; var min = charactersPositions[xyidx.y, xyidx.x]; var max = GetCursorSize( ); GL.Vertex(new Vector3(min.x, max.y, 0)); GL.Vertex(new Vector3(max.x, max.y, 0)); GL.Vertex(new Vector3(max.x, min.y, 0)); GL.Vertex(new Vector3(min.x, min.y, 0)); } // Render cursor if (isCursorVisible) { var min = GetCursorCoordinates( ); var max = min + GetCursorSize( ); GL.Color(theme.cursorColor); GL.Vertex(new Vector3(min.x, max.y, 0)); GL.Vertex(new Vector3(max.x, max.y, 0)); GL.Vertex(new Vector3(max.x, min.y, 0)); GL.Vertex(new Vector3(min.x, min.y, 0)); } GL.End( ); GL.PopMatrix( ); GL.invertCulling = false; }
private void SquadTroopPlacedActionCallback(uint id, object cookie) { SquadTroopPlacedAction squadTroopPlacedAction = cookie as SquadTroopPlacedAction; IntPosition boardPos = new IntPosition(squadTroopPlacedAction.BoardX, squadTroopPlacedAction.BoardZ); Dictionary <string, int> attackerGuildTroopsAvailable = this.battleController.GetCurrentBattle().AttackerGuildTroopsAvailable; Service.Get <SquadTroopAttackController>().DeploySquadTroops(boardPos, attackerGuildTroopsAvailable); }
void OnTextChanged(object sender, System.EventArgs e) { Position currentPosition = new IntPosition(richTextBox1.SelectionStart); Position start = GetPrevWordPosition(currentPosition); Position end = controller.GetNextPosition(currentPosition); FindErrors(start, end); }
public override EatResponse OnRelease() { if (base.IsNotDraggedAndReleasingOwnPress() && !Service.Get <SquadTroopAttackController>().Spawning&& !Service.Get <SimTimeEngine>().IsPaused() && !Service.Get <BattleController>().BattleEndProcessing&& Service.Get <BattleController>().CanPlayerDeploySquadTroops()) { IntPosition boardPos = Units.WorldToBoardIntDeployPosition(this.currentWorldPosition); Service.Get <SquadTroopAttackController>().DeploySquadTroops(boardPos); } return(EatResponse.NotEaten); }
public override void Perform() { Service.BotRunner.Performing = true; Service.BotRunner.Log("Deploying Squad Troops", new object[0]); IntPosition boardPos = new IntPosition(22, 22); Service.SquadTroopAttackController.DeploySquadTroops(boardPos); Service.ViewTimerManager.CreateViewTimer(1f, false, new TimerDelegate(this.DelayComplete), null); }
private void OnSpawnDropshipTroopsTimer(uint id, object cookie) { SpecialAttack specialAttack = cookie as SpecialAttack; IntPosition spawnPosition = Units.WorldToBoardIntPosition(specialAttack.TargetWorldPos); if (Service.GameStateMachine.CurrentState is BattlePlayState || Service.GameStateMachine.CurrentState is BattlePlaybackState) { this.DeployDropShipTroops(spawnPosition, specialAttack.VO.LinkedUnit, specialAttack.VO.UnitCount, specialAttack.TeamType); } }
public SmartEntity CreateChampionEntity(TroopTypeVO championType, IntPosition position) { SmartEntity smartEntity = this.CreateWalkerBaseEntity(position, championType.SizeX, championType.SizeY); smartEntity.TransformComp.Rotation = 90f; smartEntity.Add(new ChampionComponent(championType)); smartEntity.Add(new WalkerComponent(championType.AssetName, championType)); Service.Get <EntityViewManager>().LoadEntityAsset(smartEntity); return(smartEntity); }
private void ChampionDeployedActionCallback(uint id, object cookie) { ChampionDeployedAction championDeployedAction = cookie as ChampionDeployedAction; IDataController dataController = Service.Get <IDataController>(); TroopTypeVO troopTypeVO = dataController.Get <TroopTypeVO>(championDeployedAction.TroopUid); IntPosition boardPosition = new IntPosition(championDeployedAction.BoardX, championDeployedAction.BoardZ); Service.Get <TroopController>().SpawnChampion(troopTypeVO, championDeployedAction.TeamType, boardPosition); this.battleController.OnChampionDeployed(troopTypeVO.Uid, championDeployedAction.TeamType, boardPosition); }
private void TroopPlacedActionCallback(uint id, object cookie) { TroopPlacedAction troopPlacedAction = cookie as TroopPlacedAction; IDataController dataController = Service.Get <IDataController>(); TroopTypeVO troopTypeVO = dataController.Get <TroopTypeVO>(troopPlacedAction.TroopId); IntPosition boardPosition = new IntPosition(troopPlacedAction.BoardX, troopPlacedAction.BoardZ); Service.Get <TroopController>().SpawnTroop(troopTypeVO, troopPlacedAction.TeamType, boardPosition, (troopPlacedAction.TeamType == TeamType.Defender) ? TroopSpawnMode.LeashedToBuilding : TroopSpawnMode.Unleashed, true); this.battleController.OnTroopDeployed(troopTypeVO.Uid, troopPlacedAction.TeamType, boardPosition); }
public Entity CreateDroidEntity(CivilianTypeVO droidType, IntPosition position) { Entity entity = this.CreateWalkerBaseEntity(position, droidType.SizeX, droidType.SizeY); DroidComponent component = new DroidComponent(); entity.Add(component); entity.Add(new CivilianComponent(droidType)); Service.Get <EntityViewManager>().LoadEntityAsset(entity); return(entity); }
public void HandleSquadTroopsDeployedEvent(object cookie) { IntPosition intPosition = (IntPosition)cookie; SquadTroopPlacedAction squadTroopPlacedAction = new SquadTroopPlacedAction(); squadTroopPlacedAction.Time = this.GetActionTime(); squadTroopPlacedAction.BoardX = intPosition.x; squadTroopPlacedAction.BoardZ = intPosition.z; this.battleRecord.Add(squadTroopPlacedAction); }
public bool IsPlayable(int column, int line, bool isWhite) { Player currentPlayer = PlayerTurn; PlayerTurn = isWhite ? Player.White : Player.Black; IntPosition positionToCheck = new IntPosition(column, line); List <IntPosition> playableSlots = GetAllPossibleMoves(); PlayerTurn = currentPlayer; return(playableSlots.Contains(positionToCheck)); }
private void HeroDeployedActionCallback(uint id, object cookie) { HeroDeployedAction heroDeployedAction = cookie as HeroDeployedAction; IDataController dataController = Service.Get <IDataController>(); TroopTypeVO troopTypeVO = dataController.Get <TroopTypeVO>(heroDeployedAction.TroopUid); IntPosition boardPosition = new IntPosition(heroDeployedAction.BoardX, heroDeployedAction.BoardZ); SmartEntity cookie2 = Service.Get <TroopController>().SpawnHero(troopTypeVO, heroDeployedAction.TeamType, boardPosition); Service.Get <EventManager>().SendEvent(EventId.AddDecalToTroop, cookie2); this.battleController.OnHeroDeployed(troopTypeVO.Uid, heroDeployedAction.TeamType, boardPosition); }
/// <summary> /// Creates an AIBoard class given the position of a move to play /// and the board where the move has to be played. /// </summary> /// <param name="position">The position of the pawn to play on the board</param> /// <param name="sourceBoard">The board where the move takes place</param> /// <returns>A new AIBoard with the updated game state</returns> private AIBoard PosToBoard(IntPosition position, AIBoard sourceBoard) { AIBoard newBoard = new AIBoard { GameBoard = sourceBoard.GameBoard, PlayerTurn = sourceBoard.PlayerTurn }; newBoard.PlayMove(position.Column, position.Row, PlayerTurn == Player.White); return(newBoard); }
public SmartEntity SpawnChampion(TroopTypeVO troopType, TeamType teamType, IntPosition boardPosition) { TroopSpawnMode spawnMode = (teamType == TeamType.Defender) ? TroopSpawnMode.LeashedToBuilding : TroopSpawnMode.Unleashed; SmartEntity smartEntity = this.SpawnTroop(troopType, teamType, boardPosition, spawnMode, true, teamType == TeamType.Defender); if (smartEntity != null) { smartEntity.Add(new ChampionComponent(troopType)); } return(smartEntity); }
public static IntPosition NormalizeDeployPosition(IntPosition boardPosition) { if (boardPosition.z <= -23) { boardPosition.z = -22; } if (boardPosition.x <= -23) { boardPosition.x = -22; } return(boardPosition); }
private void SpecialAttackDeployedActionCallback(uint id, object cookie) { SpecialAttackDeployedAction specialAttackDeployedAction = cookie as SpecialAttackDeployedAction; IDataController dataController = Service.Get <IDataController>(); SpecialAttackTypeVO specialAttackTypeVO = dataController.Get <SpecialAttackTypeVO>(specialAttackDeployedAction.SpecialAttackId); Vector3 vector = new Vector3(Units.BoardToWorldX(specialAttackDeployedAction.BoardX), 0f, Units.BoardToWorldZ(specialAttackDeployedAction.BoardZ)); Service.Get <SpecialAttackController>().DeploySpecialAttack(specialAttackTypeVO, specialAttackDeployedAction.TeamType, vector); IntPosition boardPosition = Units.WorldToBoardIntPosition(vector); this.battleController.OnSpecialAttackDeployed(specialAttackTypeVO.Uid, specialAttackDeployedAction.TeamType, boardPosition); }
private SmartEntity DeployHero(TroopTypeVO troopType) { if (Service.Get <SimTimeEngine>().IsPaused()) { return(null); } if (!this.CanDeploy) { return(null); } BattleController battleController = Service.Get <BattleController>(); if (battleController.BattleEndProcessing) { return(null); } if (battleController.GetPlayerDeployableHeroCount(troopType.Uid) == 0) { this.CanDeploy = false; Service.Get <EventManager>().SendEvent(EventId.TroopNotPlacedInvalidTroop, this.currentWorldPosition); return(null); } TeamType teamType = TeamType.Attacker; if (battleController.GetCurrentBattle().Type == BattleType.PveDefend) { teamType = TeamType.Defender; } IntPosition intPosition = Units.WorldToBoardIntDeployPosition(this.currentWorldPosition); TroopController troopController = Service.Get <TroopController>(); if (battleController.GetCurrentBattle().IsRaidDefense()) { Entity entity = null; BoardCell <Entity> boardCell = null; if (!troopController.FinalizeSafeBoardPosition(troopType, ref entity, ref intPosition, ref boardCell, TeamType.Attacker, TroopSpawnMode.Unleashed, false)) { Service.Get <EventManager>().SendEvent(EventId.TroopNotPlacedInvalidArea, intPosition); return(null); } } SmartEntity smartEntity = troopController.SpawnHero(troopType, teamType, intPosition, false); if (smartEntity != null) { base.PlaySpawnEffect(smartEntity); this.CanDeploy = false; battleController.OnHeroDeployed(troopType.Uid, teamType, intPosition); Service.Get <EventManager>().SendEvent(EventId.HeroDeployed, smartEntity); } return(smartEntity); }
public bool PlayMove(int column, int line, bool isWhite) { PlayerTurn = isWhite ? Player.White : Player.Black; bool IsMoveValid = IsPlayable(column, line, isWhite); if (IsMoveValid) { IntPosition slotPosition = new IntPosition(column, line); List <IntPosition> pawnsToFlip = GetPawnsToFlip(slotPosition); pawnsToFlip.Add(slotPosition); UpdateSlots(pawnsToFlip); } return(IsMoveValid); }