private void ChooseInitialCardsForNextFaction() {
++cardChoosingFactionIdx;
if (cardChoosingFactionIdx < factionList.Count) {
Debug.LogWarning("Choosing cards for faction " + cardChoosingFactionIdx);
if(factionList[cardChoosingFactionIdx].isPlayerFaction){
// Debug.LogWarning("deck size = " + factionList[cardChoosingFactionIdx].allUnitList.Select(unit => unit.reserveAbilityIDList.Count).Sum());
numAbilitiesChosen = 0;
abilitySelections = new List<Unit.AbilitySelection>();
for (int i = 0; i < abilitySelectionButtons.Count; ++i)
{
// Debug.LogWarning("Choosing card " + i);
Unit.AbilitySelection abilitySelection = Unit.DrawCard(factionList[cardChoosingFactionIdx].allUnitList);
abilitySelections.Add(abilitySelection);
if (abilitySelection != null){
// Debug.LogWarning("selection " + abilitySelection.abilityId + " " + abilitySelection.cardOwner.unitName);
UnitAbility ability=AbilityManagerUnit.GetAbilityBasedOnID(abilitySelection.abilityId);
abilitySelectionButtons[i].Init();
// Debug.LogWarning("ability = " + ability.name);
// Debug.LogWarning(abilitySelectionButtons[i]);
// Debug.LogWarning(abilitySelectionButtons[i].imgIcon);
// Debug.LogWarning(abilitySelectionButtons[i].label);
abilitySelectionButtons[i].imgIcon.sprite= ability.icon;
abilitySelectionButtons[i].label.text = ability.GetCost().ToString();
abilitySelectionButtons[i].SetActive(true);
}
}
chooseInitialCardsUI.gameObject.SetActive(true);
} else {
ChooseInitialCardsForNextFaction();
}
} else {
chooseInitialCardsUI.gameObject.SetActive(false);
GameControl.OnFinishedCardChoice();
}
}
public void _PerkUnlockNewAbility(List <int> unitIDList, int abID, int abIDSub)
{
int dbIndex = GetAbilityDBIndex(abID);
if (dbIndex == -1 && abIDSub == -1)
{
return;
}
List <Unit> unitList = FactionManager.GetAllUnit();
for (int i = 0; i < unitList.Count; i++)
{
Unit unit = unitList[i];
if (unit.isAIUnit)
{
continue;
}
if (unitIDList == null || unitIDList.Contains(unit.prefabID))
{
int replaceIndex = -1;
if (abIDSub >= 0)
{
for (int n = 0; n < unit.abilityList.Count; n++)
{
if (unit.abilityList[n].prefabID == abIDSub)
{
replaceIndex = n; //cached the replaceIndex to be used for adding the new ability later
break;
}
}
}
if (dbIndex >= 0) //add the new ability
{
UnitAbility unitAbility = unitAbilityDBList[dbIndex].Clone();
unitAbility.Init(unit);
if (replaceIndex >= 0) //if we need to replacing something that alreayd existed
{
unit.abilityIDList[replaceIndex] = abID;
unit.abilityList[replaceIndex] = unitAbility;
}
else //otherwise just add the new ability
{
unit.abilityIDList.Add(abID);
unit.abilityList.Add(unitAbility);
}
}
}
}
GameControl.ReselectUnit(); //reselect current unit to refresh the UI
if (dbIndex >= 0)
{
TBTK.OnNewUnitAbility(unitAbilityDBList[dbIndex].Clone());
}
}
void ShiftItem(int dir)
{
UnitAbility ability = uAbilityDB.abilityList[selectID];
uAbilityDB.abilityList[selectID] = uAbilityDB.abilityList[selectID + dir];
uAbilityDB.abilityList[selectID + dir] = ability;
selectID += dir;
}
private Vector2 DrawAbilityConfigurator(float startX, float startY, UnitAbility ability)
{
TBEditor.DrawSprite(new Rect(startX, startY, 60, 60), ability.icon);
startX += 65;
cont = new GUIContent("Name:", "The ability name to be displayed in game");
EditorGUI.LabelField(new Rect(startX, startY += spaceY / 4, width, height), cont);
ability.name = EditorGUI.TextField(new Rect(startX + spaceX - 65, startY, width - 5, height), ability.name);
if (GUI.changed)
{
UpdateLabel_UnitAbility();
}
cont = new GUIContent("Icon:", "The ability icon to be displayed in game, must be a sprite");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
ability.icon = (Sprite)EditorGUI.ObjectField(new Rect(startX + spaceX - 65, startY, width - 5, height), ability.icon, typeof(Sprite), false);
cont = new GUIContent("AbilityID:", "The ID used to associate a perk item in perk menu to a perk when configuring perk menu manually");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
EditorGUI.LabelField(new Rect(startX + spaceX - 65, startY, width - 5, height), ability.prefabID.ToString());
startX -= 65;
startY += 10 + spaceY - spaceY / 2; //cachedY=startY;
cont = new GUIContent("Only Available Via Perk:", "Check if the ability can only be added by perk ");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
ability.onlyAvailableViaPerk = EditorGUI.Toggle(new Rect(startX + spaceX + 20, startY, widthS, height), ability.onlyAvailableViaPerk);
startY += 10;
startY = DrawGeneralSetting(startX, startY + spaceY, ability);
startY = DrawTargetingSetting(startX, startY + spaceY, ability);
startY = DrawAbilityVisualEffect(startX, startY + spaceY, ability);
startY = DrawAbilityEffect(startX, startY + spaceY, ability);
startY += 10;
GUIStyle style = new GUIStyle("TextArea");
style.wordWrap = true;
cont = new GUIContent("Description (for runtime and editor): ", "");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, 400, 20), cont);
ability.desp = EditorGUI.TextArea(new Rect(startX, startY + spaceY - 3, 270, 100), ability.desp, style);
return(new Vector2(startX, startY + spaceY + 100));
}
public UnitAbility Clone(bool useDefaultValue = false)
{
UnitAbility uAB = new UnitAbility();
uAB.type = type;
uAB.applyToAllUnit = applyToAllUnit;
uAB.chanceToHit = chanceToHit;
uAB.normalAttack = normalAttack;
uAB.requireDirectLOS = requireDirectLOS;
uAB.unit = unit;
uAB.Copy(this, useDefaultValue);
uAB.effect = effect.Clone();
return(uAB);
}
protected float DrawGeneralSetting(float startX, float startY, UnitAbility ability)
{
string text = "General Setting " + (!foldGeneral ? "(show)" : "(hide)");
foldGeneral = EditorGUI.Foldout(new Rect(startX, startY, width, height), foldGeneral, text, foldoutStyle);
if (foldGeneral)
{
startX += 15;
cont = new GUIContent("Cost (AP):", "AP cost to use the ability");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
ability.cost = EditorGUI.FloatField(new Rect(startX + spaceX, startY, widthS, height), ability.cost);
cont = new GUIContent("Cooldown:", "The cooldown period (in turn) of the ability after used");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
ability.cooldown = EditorGUI.IntField(new Rect(startX + spaceX, startY, widthS, height), ability.cooldown);
cont = new GUIContent("Use Limit:", "How many time the ability can be used in a single battle");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
ability.useLimit = EditorGUI.IntField(new Rect(startX + spaceX, startY, widthS, height), ability.useLimit);
cont = new GUIContent("Hit Chance Multiplier:", "0.5 => this ability hits with half of the unit's normal hit chance");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
ability.chanceToHit = EditorGUI.FloatField(new Rect(startX + spaceX, startY, widthS, height), ability.chanceToHit);
startY += 10;
cont = new GUIContent("Enable Move After Cast:", "Check if the unit can't move after using this ability");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
ability.enableMoveAfterCast = EditorGUI.Toggle(new Rect(startX + spaceX + 30, startY, widthS, height), ability.enableMoveAfterCast);
cont = new GUIContent("Enable Attack After Cast:", "Check if the unit can't move after using this ability");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
ability.enableAttackAfterCast = EditorGUI.Toggle(new Rect(startX + spaceX + 30, startY, widthS, height), ability.enableAttackAfterCast);
cont = new GUIContent("Enable Ability After Cast:", "Check if the unit can't use other ability after using this ability");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
ability.enableAbilityAfterCast = EditorGUI.Toggle(new Rect(startX + spaceX + 30, startY, widthS, height), ability.enableAbilityAfterCast);
}
return(startY + spaceY);
}
int NewItem(int cloneID = -1)
{
UnitAbility ability = null;
if (cloneID == -1)
{
ability = new UnitAbility();
ability.name = "New Ability";
}
else
{
ability = uAbilityDB.abilityList[selectID].Clone();
}
ability.prefabID = GenerateNewID(uAbilityIDList);
uAbilityIDList.Add(ability.prefabID);
uAbilityDB.abilityList.Add(ability);
UpdateLabel_UnitAbility();
return(uAbilityDB.abilityList.Count - 1);
}
public static void ActivateTargetMode(Tile tile, UnitAbility ability, int abIndex, TargetModeCallBack sCallBack, ExitTargetModeCallBack eCallBack)
{
instance.ActivateTargetModeUnit(tile, ability, abIndex, sCallBack, eCallBack);
}
protected float DrawAbilityEffect(float startX, float startY, UnitAbility ability)
{
string text = "Ability Effects Setting " + (!foldEffect ? "(show)" : "(hide)");
foldEffect = EditorGUI.Foldout(new Rect(startX, startY, width, height), foldEffect, text, foldoutStyle);
if (foldEffect)
{
startX += 15;
//~ cont=new GUIContent("Use Default Effect:", "Check if the ability use default TBTK effect.\n\nAlternatively you can use your own custom effect by putting a custom script to on the spawn visual effect object");
//~ EditorGUI.LabelField(new Rect(startX, startY+=spaceY, width, height), cont);
//~ ability.useDefaultEffect=EditorGUI.Toggle(new Rect(startX+spaceX, startY, widthS, height), ability.useDefaultEffect);
if (ability.useDefaultEffect)
{
cont = new GUIContent("Effect Delay:", "Delay in second before the effect actually take place.\nThis is for the visual effect to kicks in");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
if (ability.type == UnitAbility._AbilityType.None)
{
EditorGUI.LabelField(new Rect(startX + spaceX, startY, widthS, height), "-");
}
ability.effectDelayDuration = EditorGUI.FloatField(new Rect(startX + spaceX, startY, widthS, height), ability.effectDelayDuration);
startY += 5;
int type = (int)ability.type;
cont = new GUIContent("Ability Effect Type:", "Type of the ability's effect. Define what the ability do");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
contL = new GUIContent[abilityTypeLabel.Length];
for (int i = 0; i < contL.Length; i++)
{
contL[i] = new GUIContent(abilityTypeLabel[i], abilityTypeTooltip[i]);
}
type = EditorGUI.Popup(new Rect(startX + spaceX, startY, width, height), new GUIContent(""), type, contL);
ability.type = (UnitAbility._AbilityType)type;
//startX+=15; spaceX-=15;
if (ability.type == UnitAbility._AbilityType.Generic) // || ability.type==UnitAbility._AbilityType.ChargeAttack || ability.type==UnitAbility._AbilityType.LineAttack){
{
startY = DrawEffect(startX, startY + spaceY, ability.effect);
}
if (ability.type == UnitAbility._AbilityType.Teleport)
{
GUI.Label(new Rect(startX + spaceX, startY += spaceY, width, height), "- No input required -");
}
if (ability.type == UnitAbility._AbilityType.ScanFogOfWar)
{
//GUI.Label(new Rect(startX+spaceX, startY+=spaceY, width, height), "- No input required -");
cont = new GUIContent(" - Duration:", "");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
ability.effect.duration = EditorGUI.IntField(new Rect(startX + spaceX, startY, widthS, height), ability.effect.duration);
}
if (ability.type == UnitAbility._AbilityType.SpawnNew)
{
cont = new GUIContent(" - Unit To Spawn:", "Unit to be spawned");
GUI.Label(new Rect(startX, startY += spaceY, width, height), cont);
int index = ability.spawnUnit != null?TBEditor.GetUnitIndex(ability.spawnUnit.prefabID) : 0;
index = EditorGUI.Popup(new Rect(startX + spaceX, startY, width, height), index, unitLabel);
if (index > 0)
{
ability.spawnUnit = unitDB.unitList[index - 1];
}
else if (index == 0)
{
ability.spawnUnit = null;
}
}
if (ability.type == UnitAbility._AbilityType.Teleport || ability.type == UnitAbility._AbilityType.SpawnNew || ability.type == UnitAbility._AbilityType.ScanFogOfWar)
{
if (ability.targetType != _TargetType.EmptyTile)
{
Debug.LogWarning(ability.type + " ability must have 'EmptyTile' TargetType");
}
if (!ability.requireTargetSelection)
{
Debug.LogWarning(ability.type + " ability requires target selection");
}
if (ability.type != UnitAbility._AbilityType.ScanFogOfWar && ability.aoeRange > 0)
{
Debug.LogWarning(ability.type + " ability's aoe-range must be zero");
}
ability.targetType = _TargetType.EmptyTile;
ability.requireTargetSelection = true;
if (ability.type != UnitAbility._AbilityType.ScanFogOfWar)
{
ability.aoeRange = 0;
}
}
if (ability.type == UnitAbility._AbilityType.Overwatch)
{
if (ability.requireTargetSelection)
{
Debug.LogWarning(ability.type + " ability doesn't require target selection");
}
if (ability.aoeRange > 0)
{
Debug.LogWarning(ability.type + " ability's aoe-range must be zero");
}
ability.requireTargetSelection = false;
ability.aoeRange = 0;
}
//startX-=15; spaceX+=15;
}
}
return(startY + spaceY);
}
protected float DrawTargetingSetting(float startX, float startY, UnitAbility ability)
{
string text = "Targeting Setting " + (!foldTargeting ? "(show)" : "(hide)");
foldTargeting = EditorGUI.Foldout(new Rect(startX, startY, width, height), foldTargeting, text, foldoutStyle);
if (foldTargeting)
{
startX += 15;
int effTargetType = (int)ability.effTargetType;
cont = new GUIContent("Effect Target:", "Specify which target the ability's effect can be applied to");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
if (ability.type != UnitAbility._AbilityType.Overwatch)
{
contL = new GUIContent[effTargetTypeLabel.Length];
for (int i = 0; i < contL.Length; i++)
{
contL[i] = new GUIContent(effTargetTypeLabel[i], effTargetTypeTooltip[i]);
}
effTargetType = EditorGUI.Popup(new Rect(startX + spaceX, startY, width - 40, 15), new GUIContent(""), effTargetType, contL);
ability.effTargetType = (_EffectTargetType)effTargetType;
}
else
{
EditorGUI.LabelField(new Rect(startX + spaceX, startY, width - 40, 15), "-");
}
startY += 10;
cont = new GUIContent("Apply To Whole Grid:", "Check if the ability will automatically applies to all units/tiles on the grid.\nSubject to effect target");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
ability.applyToAllUnit = EditorGUI.Toggle(new Rect(startX + spaceX + 30, startY, widthS, height), ability.applyToAllUnit);
startY += 10;
cont = new GUIContent("Require Target Selection:", "Check if the ability require target selection. Otherwise the ability will be apply to the unit which uses it.");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
if (ability.type != UnitAbility._AbilityType.Overwatch && !ability.applyToAllUnit)
{
ability.requireTargetSelection = EditorGUI.Toggle(new Rect(startX + spaceX + 30, startY, widthS, height), ability.requireTargetSelection);
}
else
{
EditorGUI.LabelField(new Rect(startX + spaceX + 30, startY, widthS, height), "-");
}
cont = new GUIContent(" - Target Type:", "Indicate what tile can be constitued as a valid target during target selection");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
if (ability.requireTargetSelection && ability.type != UnitAbility._AbilityType.Overwatch && !ability.applyToAllUnit)
{
int targetType = (int)ability.targetType;
contL = new GUIContent[targetTypeLabel.Length];
for (int i = 0; i < contL.Length; i++)
{
contL[i] = new GUIContent(targetTypeLabel[i], targetTypeTooltip[i]);
}
targetType = EditorGUI.Popup(new Rect(startX + spaceX, startY, width - 40, 15), new GUIContent(""), targetType, contL);
ability.targetType = (_TargetType)targetType;
}
else
{
EditorGUI.LabelField(new Rect(startX + spaceX, startY, widthS, height), "-");
}
cont = new GUIContent(" - Range:", "How far the target (in term of tile) from the casting unit");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
if (ability.requireTargetSelection && !ability.applyToAllUnit)
{
ability.range = EditorGUI.IntField(new Rect(startX + spaceX, startY, widthS, height), ability.range);
}
else
{
EditorGUI.LabelField(new Rect(startX + spaceX, startY, widthS, height), "-");
}
cont = new GUIContent(" - Normal Attack:", "Check to have the ability subject to normal attack rules. The target select will be restricted by fog-of-war (if enabled), obstacle and what not.");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
if (ability.requireTargetSelection && !ability.applyToAllUnit)
{
ability.normalAttack = EditorGUI.Toggle(new Rect(startX + spaceX, startY, widthS, height), ability.normalAttack);
}
else
{
EditorGUI.LabelField(new Rect(startX + spaceX, startY, widthS, height), "-");
}
cont = new GUIContent(" - RequireDirectLOS:", "Check if the ability require direct Line-of-sight to hit target. Otherwise the ability will be able get the target by relying on a friendly unit's sight. Only applies when fog-of-war is enabled");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
if (ability.requireTargetSelection && !ability.applyToAllUnit && ability.normalAttack)
{
ability.requireDirectLOS = EditorGUI.Toggle(new Rect(startX + spaceX, startY, widthS, height), ability.requireDirectLOS);
}
else
{
EditorGUI.LabelField(new Rect(startX + spaceX, startY, widthS, height), "-");
}
cont = new GUIContent(" - ShootObject:", "The shoot object to use if the ability involve shooting");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
if (ability.requireTargetSelection && !ability.applyToAllUnit && ability.normalAttack)
{
ability.shootObject = (GameObject)EditorGUI.ObjectField(new Rect(startX + spaceX, startY, width - 15, height), ability.shootObject, typeof(GameObject), false);
}
else
{
EditorGUI.LabelField(new Rect(startX + spaceX, startY, widthS, height), "-");
}
startY += 10;
cont = new GUIContent("AOE Range:", "Check if the ability require target selection");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
if (ability.type != UnitAbility._AbilityType.Overwatch && !ability.applyToAllUnit)
{
ability.aoeRange = EditorGUI.IntField(new Rect(startX + spaceX, startY, widthS, height), ability.aoeRange);
}
else
{
EditorGUI.LabelField(new Rect(startX + spaceX, startY, widthS, height), "-");
}
}
return(startY + spaceY);
}
//~ public void ActivateTargetModeUnit(Tile tile, int range, int AOE, bool normalAttack, bool requireDirectLOS, _TargetType type, TargetModeCallBack sCallBack, TargetModeCallBack eCallBack){
public void ActivateTargetModeUnit(Tile tile, UnitAbility ability, int abIndex, TargetModeCallBack sCallBack, ExitTargetModeCallBack eCallBack)
{
TBTK.OnUnitABTargetMode(abIndex);
_ActivateTargetMode(abIndex, ability.GetAOERange(), ability.targetType, sCallBack, eCallBack);
if (!ability.AttackInLine())
{
if (!ability.normalAttack)
{
if (targetModeType == _TargetType.EmptyTile)
{
targetModeTileList = GridManager.GetTilesWithinDistance(tile, ability.GetRange(), true);
}
else
{
targetModeTileList = GridManager.GetTilesWithinDistance(tile, ability.GetRange());
}
}
else
{
targetModeTileList = new List <Tile>();
List <Tile> tilesInRangeList = GridManager.GetTilesWithinDistance(tile, ability.GetRange());
int sight = tile.unit.GetSight();
List <Unit> allFriendlyUnitList = FactionManager.GetAllUnitsOfFaction(tile.unit.factionID);
for (int i = 0; i < tilesInRangeList.Count; i++)
{
Tile targetTile = tilesInRangeList[i];
if (!GameControl.EnableFogOfWar() && !GameControl.AttackThroughObstacle())
{
if (!FogOfWar.InLOS(tile, targetTile, 0))
{
continue;
}
}
bool inSight = GameControl.EnableFogOfWar() ? false : true;
if (GameControl.EnableFogOfWar())
{
if (FogOfWar.InLOS(tile, targetTile) && GridManager.GetDistance(tile, targetTile) <= sight)
{
inSight = true;
}
else if (!ability.requireDirectLOS)
{
for (int n = 0; n < allFriendlyUnitList.Count; n++)
{
if (allFriendlyUnitList[n] == tile.unit)
{
continue;
}
if (GridManager.GetDistance(allFriendlyUnitList[n].tile, targetTile) > allFriendlyUnitList[n].GetSight())
{
continue;
}
if (FogOfWar.InLOS(allFriendlyUnitList[n].tile, targetTile))
{
inSight = true;
break;
}
}
}
}
if (inSight)
{
targetModeTileList.Add(targetTile);
}
}
}
}
else
{
/*
* List<Tile> neighbourList=tile.GetNeighbourList();
* for(int i=0; i<neighbourList.Count; i++){
* bool walkableOnly=(ability.type==UnitAbility._AbilityType.ChargeAttack);
* List<Tile> tileList=GridManager.GetTilesInALine(tile, neighbourList[i], ability.GetRange(), walkableOnly);
*
* if(tileList.Count>0){
* if(targetModeType!=_TargetType.EmptyTile) targetModeTileList.Add(tileList[tileList.Count-1]);
* else if (tileList[tileList.Count-1].unit==null) targetModeTileList.Add(tileList[tileList.Count-1]);
* }
* }
*/
}
//for(int i=0; i<targetModeTileList.Count; i++) targetModeTileList[i].SetState(_TileState.Range);
OverlayManager.ShowAbilityRangeIndicator(targetModeTileList);
}
