public void ClickOnActive(ActiveButton _active)
{
Unselection();
selectedActive = _active;
HeroPiece piece = _active.Piece;
Ability activeAbility = piece.Hero.Active;
if (activeAbility.Targetting == e_targetting.Default)
{
activeList.Add(board[piece.Position.x, piece.Position.y]);
activeList = utility.GetRange(activeList, piece.Hero.Active);
foreach (Square s in activeList)
{
s.HighLight(1);
}
}
else if (activeAbility.Targetting == e_targetting.AutomaticTarget)
{
activeList.Add(board[piece.Position.x, piece.Position.y]);
activeList = utility.GetRange(activeList, piece.Hero.Active);
piece.ActivePower(activeList.ToArray());
Unselection();
}
else
{
piece.ActivePower(null);
Unselection();
}
}
public override void Use(Square[] _targets, HeroPiece _user)
{
for (int i = 0; i < Value; i++)
{
GameplayManager.Instance.DeckManager.DrawCard();
}
}
public void ClickOnBoard(Square _square)
{
if (step == e_step.Placement)
{
PlacementBoard(_square);
return;
}
if (selectedPiece != null)
{
if (movementList.Contains(_square) && !_square.Occupied)
{
selectedPiece.NotifyMovement(_square, true);
selectedPiece.HighLight(false);
selectedPiece = null;
Unselection();
}
else
{
Unselection();
}
}
else if (selectedActive != null)
{
if (activeList.Contains(_square))
{
Square[] targets = new Square[] { _square };
selectedActive.Piece.ActivePower(targets);
Unselection();
}
}
}
public void Unselection()
{
if (selectedPiece != null)
{
Square square = board[selectedPiece.Position.x, selectedPiece.Position.y];
if (step != e_step.Placement)
{
selectedPiece.NotifyMovement(square, false);
}
else
{
MoveHeroPiece(selectedPiece.Index, square.Position, false);
}
selectedPiece.HighLight(false);
}
selectedPiece = null;
selectedActive = null;
canUnselect = false;
toDrag = null;
movementList.Clear();
attackList.Clear();
activeList.Clear();
if (step != e_step.Placement)
{
foreach (Square s in board)
{
s.UnHighLight();
}
}
}
public virtual void Use(Square[] _targets, HeroPiece _user)
{
foreach (Effect f in Effects)
{
f.Use(_targets, _user);
}
}
public void Setup(HeroPiece _piece)
{
piece = _piece;
transform.localScale = Vector3.zero;
text.text = piece.Hero.Active.Cost.ToString();
text.transform.localScale = Vector3.zero;
}
public void Setup(HeroPiece _piece, Color _color)
{
heroPiece = _piece;
active.Setup(heroPiece);
healthBar.color = _color;
healthBarText.color = _color;
}
public void TargetHero(HeroPiece _piece)
{
Square square = utility.Board[_piece.Position.x, _piece.Position.y];
if (inRange.Contains(square))
{
Square[] targets = new Square[] { square };
selectedCard.Card.Use(targets, null);
UsedCard();
}
}
public void ChangeOccupied(HeroPiece _piece)
{
piece = _piece;
if (piece == null)
{
occupied = false;
}
else
{
occupied = true;
}
}
private void PlacementBoard(Square _square)
{
if (selectedPiece != null)
{
if (!_square.Occupied && _square.Team == gameplayManager.Team)
{
MoveHeroPiece(selectedPiece.Index, _square.Position, false);
selectedPiece.HighLight(false);
selectedPiece = null;
}
Unselection();
}
}
public override void Use(Square[] _targets, HeroPiece _user)
{
List <Square> targets = new List <Square>();
targets.AddRange(_targets);
targets = GameplayManager.Instance.Utility.GetAOE(targets, this);
foreach (Square s in targets)
{
if (s.Piece != null)
{
s.Piece.NotifyStat(Stat, Value, Duration, Tick);
}
}
}
public override void DragEnd()
{
base.DragEnd();
Vector2 mousePos = mainCamera.ScreenToWorldPoint(Input.mousePosition);
Collider2D[] cols = Physics2D.OverlapCircleAll(mousePos, 0.2f);
HeroPiece _piece = null;
Square _square = null;
if (cols.Length > 1)
{
foreach (Collider2D c in cols)
{
if (c.GetComponent <HeroPiece>())
{
if (c.GetComponent <HeroPiece>() != selectedPiece)
{
_piece = c.GetComponent <HeroPiece>();
}
}
else if (c.GetComponent <Square>())
{
_square = c.GetComponent <Square>();
}
}
if (_piece != null)
{
ClickOnHero(_piece);
}
else if (_square != null)
{
ClickOnBoard(_square);
}
}
else
{
Unselection();
}
}
public void Decrease(HeroPiece _piece)
{
if (tick > 0)
{
tick--;
_piece.ModifyStat(key, tickValue, buffDuration, tick);
return;
}
if (buffDuration > 0)
{
buffDuration--;
}
if (key != e_stats.Health && tick == 0 && buffDuration == 0)
{
currentValue = baseValue;
}
}
private void CreateHeroPiece(int _heroIndex, e_teams _team, Vector2Int _position)
{
Square start = board[_position.x, _position.y];
GameObject instance = Instantiate(heroePiecePrefab, start.transform.position, Quaternion.identity, null);
HeroUI ui = gameplayManager.UIManager.CreateHeroUI();
HeroPiece piece = instance.GetComponent <HeroPiece>();
piece.Setup(gameplayManager.Data.Heroes[_heroIndex], _team, pieces.Count, _position, ui);
start.ChangeOccupied(instance.GetComponent <HeroPiece>());
if (gameplayManager.Team == _team)
{
gameplayManager.OnYourTurn += piece.TurnDebute;
}
else
{
gameplayManager.OnEnnemyTurn += piece.TurnDebute;
}
pieces.Add(piece);
}
//Placement
private void PlacementHero(HeroPiece _piece)
{
if (selectedPiece != null)
{
if (_piece == selectedPiece)
{
canUnselect = true;
}
else if (_piece != selectedPiece)
{
Unselection();
}
}
else if (_piece.Team == gameplayManager.Team)
{
Unselection();
ClickDrag(_piece.transform);
selectedPiece = _piece;
selectedPiece.HighLight(true);
canUnselect = false;
}
}
public override void Use(Square[] _targets, HeroPiece _user)
{
Square desti = _targets[0];
if (desti == null)
{
return;
}
if (Effect == e_positionEffects.Teleport)
{
HeroPiece piece = desti.Piece;
piece.NotifyMovement(board[_user.Position.x, _user.Position.y], false);
_user.NotifyMovement(desti, false);
}
else
{
Vector2Int direction = desti.Position - _user.Position;
int x = direction.x != 0 ? (int)Mathf.Sign(direction.x) : 0;
int y = direction.y != 0 ? (int)Mathf.Sign(direction.y) : 0;
direction = new Vector2Int(x, y);
if (Effect == e_positionEffects.Push)
{
Square square = utility.GetFinalSquareInDirection(desti, direction, Distance + 1);
desti.Piece.NotifyMovement(square, false);
}
else if (Effect == e_positionEffects.Pull)
{
Square square = utility.GetFinalSquareInDirection(desti, -direction, Distance + 1);
desti.Piece.NotifyMovement(square, false);
}
}
}
public void RemoveHeroPiece(HeroPiece _piece)
{
board[_piece.Position.x, _piece.Position.y].ChangeOccupied(null);
pieces[_piece.Index] = null;
if (_piece.Team == gameplayManager.Team)
{
gameplayManager.OnYourTurn -= _piece.TurnDebute;
foreach (HeroPiece p in pieces)
{
if (p != null && p.Team == gameplayManager.Team)
{
return;
}
}
gameplayManager.OnlineManager.Defeat();
}
else
{
gameplayManager.OnEnnemyTurn -= _piece.TurnDebute;
}
}
protected override void Down()
{
GameObject ui = DetectUI(Input.mousePosition);
GameObject col = DetectCollider(Input.mousePosition);
//UIs
CardPiece _card = null;
ActiveButton _active = null;
if (ui != null)
{
_card = ui.GetComponent <CardPiece>();
_active = ui.GetComponent <ActiveButton>();
ui.GetComponent <Clickable>()?.Onclick();
}
//Colliders
HeroPiece _piece = null;
Square _square = null;
if (col != null)
{
_piece = col.GetComponent <HeroPiece>();
_square = col.GetComponent <Square>();
col.GetComponent <Clickable>()?.Onclick();
}
//Steps
if (step == e_step.Placement)
{
if (_piece != null)
{
boardManager.ClickOnHero(_piece);
}
else if (_square != null)
{
boardManager.ClickOnBoard(_square);
}
}
else if (step == e_step.Card)
{
if (_card != null)
{
deckManager.ClickOnCard(_card);
}
else
{
UnselectAll();
}
}
else if (step == e_step.UseCard)
{
if (_piece != null)
{
deckManager.TargetHero(_piece);
}
else if (_square != null)
{
deckManager.TargetBoard(_square);
}
}
else if (step == e_step.Board)
{
if (_active != null && _active.Piece.Team == team && _active.CheckMana() && _active.Piece.CanActive > 0)
{
boardManager.ClickOnActive(_active);
}
else if (_piece != null)
{
boardManager.ClickOnHero(_piece);
}
else if (_square != null)
{
boardManager.ClickOnBoard(_square);
}
else
{
UnselectAll();
}
}
else if (step == e_step.Ennemy)
{
if (_piece != null)
{
//Afficher les stats quand ce sera fait
}
else if (_card != null)
{
//Afficher les stats quand ce sera fait
}
}
}
public virtual void Use(Square[] _targets, HeroPiece _user)
{
}
//InGame
public void ClickOnHero(HeroPiece _piece)
{
if (step == e_step.Placement)
{
PlacementHero(_piece);
return;
}
if (selectedActive != null)
{
if (_piece == selectedActive.Piece)
{
Unselection();
}
else
{
Square square = board[_piece.Position.x, _piece.Position.y];
if (activeList.Contains(square))
{
Square[] targets = new Square[] { square };
selectedActive.Piece.ActivePower(targets);
Unselection();
}
}
}
else if (selectedPiece != null)
{
if (_piece == selectedPiece)
{
canUnselect = true;
}
else if (_piece.Team != gameplayManager.Team)
{
Square square = board[_piece.Position.x, _piece.Position.y];
if (attackList.Contains(square))
{
if (selectedPiece.CanMove > 0)
{
selectedPiece.NotifyMovement(AttackPath(square), true);
}
Square[] targets = new Square[] { square };
selectedPiece.Attack(targets);
selectedPiece.HighLight(false);
selectedPiece = null;
}
Unselection();
}
else if (_piece != selectedPiece)
{
Unselection();
}
}
else if (_piece.Team == gameplayManager.Team)
{
if (_piece.CanMove > 0 || _piece.CanAct > 0)
{
Unselection();
selectedPiece = _piece;
selectedPiece.HighLight(true);
canUnselect = false;
ClickDrag(_piece.transform);
Ability atck = selectedPiece.Hero.Attack;
EffectStat ef = (EffectStat)atck.Effects[0];
ef.Value = -selectedPiece.Stats[e_stats.Damage].CurrentValue;
atck.Range = selectedPiece.Stats[e_stats.Range].CurrentValue;
atck.GetOccupied = true;
Ability mov = selectedPiece.Hero.Move;
List <e_squareType> exceps = new List <e_squareType>();
if (selectedPiece.Hero.Fly == false)
{
exceps.Add(e_squareType.Obstacle);
}
mov.Range = selectedPiece.Stats[e_stats.Speed].CurrentValue;
mov.GetOccupied = false;
mov.Exceptions = exceps;
HighlightHeroRanges();
}
}
}
