public override void _Ready()
{
_team = (Team)GetNode("Team");
_team.CurrentTeamCode = _defaultTeamCode;
_captureTeamCode = _team.CurrentTeamCode;
_unitDisplayLabel = ((Label)(GetNode("UnitDisplay/Name")));
_unitDisplay = (UnitDisplay)GetNode("UnitDisplay");
_collisionShape = (CollisionShape2D)GetNode("CollisionShape2D");
_rng = new RandomNumberGenerator();
_rng.Randomize();
_base = (Sprite)GetNode("Base");
_boundry = (Sprite)GetNode("Boundry");
_timer = (Timer)GetNode("CaptureTimer");
agentsEntered = new Godot.Collections.Array();
for (int index = 0; index < Enum.GetNames(typeof(Team.TeamCode)).Length; index++)
{
agentsEntered.Add(0);
}
// Update unit display
SetCaptureBaseTeam(_team.CurrentTeamCode);
}
public List <Point> GetPositionsForRangeAttack(UnitDisplay attacker, Point fromPosition)
{
var radiusPoints = this.FindPointsInRadius(fromPosition, attacker.CardData.abilities.range.range, attacker.CardData.abilities.range.minRange);
var points = new List <Point>();
foreach (var radiusPoint in radiusPoints)
{
var canUnitStandsAtThisPoint = true;
var area = this.Areas[radiusPoint.x, radiusPoint.y];
if (area != null && !area.GetComponent <AreaDisplay>().areaData.canUnitsWalkThoughtIt)
{
canUnitStandsAtThisPoint = false;
}
var canAttackToThisPoint = this.CheckRangeAttackBetweenPoints(fromPosition, radiusPoint);
if (canAttackToThisPoint && canUnitStandsAtThisPoint)
{
points.Add(radiusPoint);
}
}
return(points);
}
public void EmmitCardToAimAction(UnitDisplay unit)
{
Unibus.Dispatch <SimpleAbilityCardAction>(ActionEmmiter.CARD_TO_AIM, new SimpleAbilityCardAction
{
cardId = unit.CardData.id
});
}
public void EmmitCardUseManaAbilityAction(UnitDisplay unit)
{
Unibus.Dispatch <SimpleAbilityCardAction>(ActionEmmiter.CARD_USE_MANA_ABILITY, new SimpleAbilityCardAction
{
cardId = unit.CardData.id
});
}
private void OnUnitMouseExitOnBoard(UnitDisplay unit)
{
this.boardCreator.RemoveAllBlinks();
unit.CardDisplay.OverHighlightOff();
CursorController.SetDefault();
}
private void InteractWithUnit(UnitDisplay clickedUnitDisplay)
{
if (clickedUnitDisplay.CardDisplay.IsAlly)
{
if (!clickedUnitDisplay.CardData.tapped)
{
this.ChangeSelectedToAnotherAlly(clickedUnitDisplay);
}
}
else
{
if (this.selectedUnit.CardData.abilities.push != null)
{
this.EnableSelectingPushTargetState(clickedUnitDisplay);
}
else if (this.selectedUnit.CardData.abilities.ricochet && this.boardCreator.UnitHaveRicochetTargetNearby(clickedUnitDisplay))
{
this.EnableSelectingRicochetTargetState(clickedUnitDisplay);
}
else
{
this.AttackEnemy(clickedUnitDisplay);
}
}
}
private void OnUnitMouseExitOnBoard(UnitDisplay unit)
{
unit.CardDisplay.OverHighlightOff();
CursorController.SetDefault();
this.boardCreator.RemoveAllBlinks();
this.boardCreator.ShowPathReach(this.selectedUnit);
}
private void UpdatePositions(UnitDisplay unitDisplay, Point position)
{
Point oldPosition = GetUnitPosition(unitDisplay);
Units[oldPosition.x, oldPosition.y] = null;
Units[position.x, position.y] = unitDisplay.gameObject as GameObject;
}
private void OnSelectProfile(object sender, SelectionChangedEventArgs e)
{
if (ProfileBox.SelectedItem == null)
{
return;
}
MissionProfile selectProfile = _missionProfiles[(string)ProfileBox.SelectedItem];
CraftBox.Items.Clear();
CommandBox.Items.Clear();
PropertyBox.Items.Clear();
foreach (string craftName in selectProfile.Commands.Keys)
{
CraftBox.Items.Add(craftName);
}
DateTime launchDate = selectProfile.Config.GetLaunchDate();
VehicleName.Content = selectProfile.Config.VehicleType;
PlanetName.Content = selectProfile.Config.ParentPlanet;
PayloadName.Content = UnitDisplay.Mass(selectProfile.Config.PayloadMass);
LocalTimeName.Content = $"{launchDate.ToShortDateString()} {launchDate.ToShortTimeString()}";
}
private void OnUnitSelectedOnBoard(UnitDisplay clickedUnitDisplay)
{
if (!clickedUnitDisplay.CardDisplay.IsAlly)
{
this.actionEmmiter.EmmitCardAttackAction(this.attackerSelectedUnit, this.attackedSelectedUnit, null, clickedUnitDisplay);
this.EnableNoSelectionsState();
}
}
public void EmmitCardHealingAction(UnitDisplay healerUnit, UnitDisplay healedUnit)
{
Unibus.Dispatch <HealCardAction>(ActionEmmiter.CARD_HEAL, new HealCardAction
{
healerCardId = healerUnit.CardData.id,
healedCardId = healedUnit.CardData.id
});
}
public void PushUnit(CardDisplay cardDisplay, Point position)
{
UnitDisplay unitDisplay = cardDisplay.UnitDisplay;
unitDisplay.transform.DOLocalJump(PointerToIcometric(position, tileWidth, tileHeight), 0.5f, 1, 0.5f);
this.UpdatePositions(unitDisplay, position);
}
private void OnUnitSelectedOnBoard(UnitDisplay clickedUnitDisplay)
{
if (clickedUnitDisplay.CardDisplay.IsAlly)
{
this.actionEmmiter.EmmitCardHealingAction(this.selectedUnit, clickedUnitDisplay);
this.EnableNoSelectionsState();
}
}
public void EmmitCardMoveAction(UnitDisplay movingUnit, Point point)
{
Unibus.Dispatch <MoveCardAction>(ActionEmmiter.CARD_MOVE, new MoveCardAction
{
cardId = movingUnit.CardData.id,
x = point.x.ToString(),
y = point.y.ToString()
});
}
public void Render(Graphics graphics, RectangleD cameraBounds)
{
double scale = cameraBounds.Width * _widthPercentage;
graphics.FillRectangle(new SolidBrush(Color.White), _center.X - 50, _center.Y - 2, 100, 4);
graphics.FillRectangle(new SolidBrush(Color.White), _center.X - 51, _center.Y - _size, 4, 20);
graphics.FillRectangle(new SolidBrush(Color.White), _center.X + 51, _center.Y - _size, 4, 20);
graphics.DrawString(UnitDisplay.Distance(scale), _font, new SolidBrush(Color.White), _center.X + 65, _center.Y - _size);
}
public void KillUnit(CardDisplay cardDisplay)
{
UnitDisplay unitDisplay = cardDisplay.UnitDisplay;
Point position = GetUnitPosition(unitDisplay);
Units[position.x, position.y] = null;
unitDisplay.ToKill();
}
private void ShowRangeAttackReach(UnitDisplay unit, Point fromPosition = null)
{
if (unit.CardData.abilities.range != null)
{
if (fromPosition == null)
{
fromPosition = this.boardCreator.GetUnitPosition(unit);
}
this.boardCreator.ShowRangeAttackReach(unit, fromPosition);
}
}
public List <Point> ShowPathReach(UnitDisplay unitDisplay)
{
var reachChecker = this.CreateReachChecker();
Point unitPosition = this.GetUnitPosition(unitDisplay);
var points = reachChecker.CheckReach(unitPosition, unitDisplay.CardData.currentMovingPoints);
this.HighlightPathInTilesByPoints(points);
return(points);
}
public List <Point> ShowPushReach(UnitDisplay attacker, UnitDisplay attacked)
{
var reachChecker = this.CreateReachChecker(true, true, true);
Point unitPosition = this.GetUnitPosition(attacked);
var points = reachChecker.CheckReach(unitPosition, attacker.CardData.abilities.push.range);
this.HighlightPathInTilesByPoints(points);
return(points);
}
public void Prime(List <Unit> units)
{
clearDisplays();
foreach (var unit in units)
{
UnitDisplay display = (UnitDisplay)Instantiate(unitDisplayPrefab);
display.transform.SetParent(targetTransform, false);
display.Prime(unit);
display.onClick += Display_onClick;
unitDisplays.Add(display);
}
}
private void OnUnitMouseEnterOnBoard(UnitDisplay unit)
{
if (unit.CardDisplay.IsAlly && this.boardCreator.CheckUnitInPoints(unit, this.points))
{
CursorController.SetPointer();
unit.OverHighlightOn();
}
else
{
CursorController.SetPointerForbidden();
}
}
public TileDisplay GetTileByUnit(UnitDisplay unitDisplay)
{
Point unitPosition = GetUnitPosition(unitDisplay);
var tile = Tiles[unitPosition.x, unitPosition.y];
if (tile)
{
return(tile.GetComponent <TileDisplay>());
}
return(null);
}
public void MoveUnit(CardDisplay cardDisplay, Point position, Point[] path)
{
UnitDisplay unitDisplay = cardDisplay.UnitDisplay;
List <Vector3> waypoints = new List <Vector3>();
foreach (var point in path)
{
waypoints.Add(PointerToIcometric(point, tileWidth, tileHeight));
}
unitDisplay.transform.DOLocalPath(waypoints.ToArray(), 0.3f * waypoints.Count);
this.UpdatePositions(unitDisplay, position);
}
public void CreateUnit(CardDisplay cardDisplay, Point position)
{
GameObject unit = Instantiate <GameObject>(UnitPrefab, this.transform);
unit.transform.SetParent(this.transform);
unit.transform.localPosition = PointerToIcometric(position, tileWidth, tileHeight);
UnitDisplay unitDisplay = unit.GetComponent <UnitDisplay>();
unitDisplay.CardData = cardDisplay.cardData;
unitDisplay.CardDisplay = cardDisplay;
cardDisplay.UnitDisplay = unitDisplay;
Units[position.x, position.y] = unit as GameObject;
}
public void Enable(UnitDisplay selectedUnit, HealingAbility healingAbility)
{
this.Enable();
this.selectedUnit = selectedUnit;
this.points = this.boardCreator.BlinkHealTargets(selectedUnit, healingAbility.range);
CursorController.SetPointer();
Dialog.instance.ShowDialog("Choose ally unit to heal (Heal ability)", "Cancel", this.EnableNoSelectionsState);
Unibus.Subscribe <UnitDisplay>(BoardCreator.UNIT_CLICKED_ON_BOARD, OnUnitSelectedOnBoard);
Unibus.Subscribe <UnitDisplay>(BoardCreator.UNIT_MOUSE_ENTER_ON_BOARD, OnUnitMouseEnterOnBoard);
Unibus.Subscribe <UnitDisplay>(BoardCreator.UNIT_MOUSE_EXIT_ON_BOARD, OnUnitMouseExitOnBoard);
}
void OnTileMouseLeftClick(Point position)
{
GameObject unit = Units[position.x, position.y];
if (unit)
{
UnitDisplay unitDisplay = unit.GetComponent <UnitDisplay>();
Unibus.Dispatch <UnitDisplay>(UNIT_CLICKED_ON_BOARD, unitDisplay);
}
else
{
Unibus.Dispatch <Point>(CLICKED_ON_VOID_TILE, position);
}
}
public bool CheckCardsAdjacency(UnitDisplay firstCard, UnitDisplay secondCard)
{
Point firstCardPoint = GetUnitPosition(firstCard);
Point secondCardPoint = GetUnitPosition(secondCard);
int xDistance = Math.Abs(firstCardPoint.x - secondCardPoint.x);
int yDistance = Math.Abs(firstCardPoint.y - secondCardPoint.y);
if (xDistance + yDistance < 2)
{
return(true);
}
return(false);
}
public Point GetUnitPosition(UnitDisplay unitDisplay)
{
for (int x = 1; x <= Width; x++)
{
for (int y = 1; y <= Height; y++)
{
if (Units[x, y] == unitDisplay.gameObject)
{
return(new Point(x, y));
}
}
}
return(null);
}
public void ShowRangeAttackReach(UnitDisplay attacker, Point fromPosition)
{
var points = this.GetPositionsForRangeAttack(attacker, fromPosition);
this.HighlightRangeAttackReachInTilesByPoints(points);
List <UnitDisplay> units = this.GetUnitsByPoints(points);
foreach (var unit in units)
{
if (!unit.CardDisplay.IsAlly)
{
unit.ShowTarget();
}
}
}
private void OnUnitMouseEnterOnBoard(UnitDisplay unit)
{
if (unit.CardDisplay.IsAlly && !unit.CardDisplay.cardData.tapped)
{
unit.CardDisplay.OverHighlightOn();
this.boardCreator.ShowPathReach(unit);
if (unit.CardData.abilities.range != null)
{
Point attackerPosition = this.boardCreator.GetUnitPosition(unit);
this.boardCreator.ShowRangeAttackReach(unit, attackerPosition);
}
CursorController.SetPointer();
}
}
