public override void Activate(List <GameObject> targets)
{
List <int> inventory = GameDataTracker.playerData.Inventory;
//These adds are only here for debugging.
if (inventory.Count == 0)
{
inventory.Add(0);
inventory.Add(1);
inventory.Add(2);
inventory.Add(0);
inventory.Add(3);
inventory.Add(1);
}
Sprite[] itemSprite = new Sprite[inventory.Count];
GameObject[] moveArray = new GameObject[inventory.Count];
for (int inv_idx = 0; inv_idx < inventory.Count; inv_idx++)
{
GameObject item = ItemMapping.itemMap[inventory[inv_idx]];
itemSprite[inv_idx] = item.GetComponent <ItemTemplate>().itemImage;
moveArray[inv_idx] = item;
}
FighterClass stats = character.GetComponent <FighterClass>();
BattleMenu menu = ScriptableObject.CreateInstance <BattleMenu>();
menu.characterTarget = character;
menu.characterHeight = stats.CharacterHeight;
menu.characterWidth = stats.CharacterWidth;
menu.movesList = moveArray;
menu.spriteList = itemSprite;
GameDataTracker.combatExecutor.AddMenu(menu);
}
public static int GetEvadeByLevel(int level, FighterClass fighterClass = FighterClass.None)
{
//base of 10, then goes up by 2 every 5 levels
//return ((level / 5) * 2) + 10;
return(5);
}
public DancerBoss(FighterClass fighterClass, int level, IChanceService chanceService)
: base("",
level,
LevelUpManager.GetHealthByLevel <DancerBoss>(level, fighterClass),
LevelUpManager.GetManaByLevel <DancerBoss>(level, fighterClass),
LevelUpManager.GetStrengthByLevel <DancerBoss>(level, fighterClass),
LevelUpManager.GetDefenseByLevel <DancerBoss>(level, fighterClass),
LevelUpManager.GetSpeedByLevel <DancerBoss>(level, fighterClass),
LevelUpManager.GetEvadeByLevel <DancerBoss>(level, fighterClass),
LevelUpManager.GetLuckByLevel <DancerBoss>(level, fighterClass),
chanceService,
SpellFactory.GetSpellsByLevel <DancerBoss>(level, fighterClass: fighterClass)
, MoveFactory.GetMovesByLevel <DancerBoss>(level, fighterClass: fighterClass))
{
if (fighterClass == FighterClass.BossDancerKiki)
{
BaseName = "Kiki";
}
else if (fighterClass == FighterClass.BossDancerRiki)
{
BaseName = "Riki";
}
else
{
throw new ArgumentOutOfRangeException(nameof(fighterClass), "DancerBoss class can only be initialized with Kiki or Riki fighter class!");
}
}
public override bool Activate()
{
blockOffset = CombatExecutor.blockOffset;
gridHeight = CombatExecutor.gridHeight;
characterGrid = CombatExecutor.characterGrid;
source = parent.GetComponent <FighterClass>();
//source.RemoveObjectFromGrid();
Vector3 currentPosition = GridManager.GridToPosition(source.pos, source.TileSize);
MoveToLocation moveTo = ScriptableObject.CreateInstance <MoveToLocation>();
if (parent.GetComponent <SpriteFlipper>().targetLeft)
{
EndPos = source.pos + new Vector2Int(-1, 0);
moveTo.endPosition = currentPosition - new Vector3(GridManager.blockOffset.x / 2f, 0, 0);
}
else
{
EndPos = source.pos + new Vector2Int(1, 0);
moveTo.endPosition = currentPosition + new Vector3(GridManager.blockOffset.x / 2f, 0, 0);
}
moveTo.parent = parent;
moveTo.speed = source.WalkSpeed;
cutscene = moveTo;
return(true);
}
public void Debug(
FighterClass character,
Vector2Int StartPosition,
List <Vector2Int> goalCoordinates
)
{
this.characterInfo = character;
this.goalCoordinates = goalCoordinates;
NextMove(StartPosition);
for (int row = 0; row < CombatExecutor.mapShape.x; row++)
{
for (int col = 0; col < CombatExecutor.mapShape.y; col++)
{
if (!(routeMap[row, col] is null))
{
GameObject debugText = new GameObject("debugText");
debugText.transform.position = CombatExecutor.blockGrid[row, col].transform.position + new Vector3(0, 0.5f, 0);
TextMeshPro tx = debugText.AddComponent <TextMeshPro>();
tx.text = routeMap[row, col].totalCost.ToString();
tx.fontSize = 10;
tx.verticalAlignment = VerticalAlignmentOptions.Middle;
tx.horizontalAlignment = HorizontalAlignmentOptions.Center;
}
}
}
}
public static int GetSpeedByLevel(int level, FighterClass fighterClass = FighterClass.None)
{
//base of 2 and goes up by 1 every even level (level 1- 2, level 2- 3, level 3- 3, level 4- 4)
//return (level / 2) + 2;
return(level);
}
public static int GetLuckByLevel(int level, FighterClass fighterClass = FighterClass.None)
{
//base of 5, then up by 1 every 3 levels
//return (level / 3) + 5;
return(10);
}
public static int GetDefenseByLevel(int level, FighterClass fighterClass = FighterClass.None)
{
//goes up by 1 every 2 out of 3 levels. (level 1- 1 def, level 2- 2 def, level 3- 2 def)
//var div = level/3;
//return (level % 3) + (div * 2);
return(Math.Max(0, level - 1));
}
IEnumerator hitDelay(FighterClass player)
{
yield return(new WaitForSeconds(1f));
player.canRecieveDamage = true;
player.canMove = true;
player.canAttack = true;
}
public override void TileEntered(FighterClass enteredCharacter)
{
base.TileEntered(enteredCharacter);
if (enteredCharacter.objectID <= 10)
{
active = true;
}
}
/*
* private struct AStarNode
* {
* public float g;
* public float h;
* public float totalCost;
* public bool expanded;
* public Vector2 coordinates;
* public Vector2 parent;
* public FighterClass.CharacterPosition move;
* }
*/
public (Vector2Int, FighterClass.CharacterPosition, bool) GetNextTile(
FighterClass character,
Vector2Int StartPosition,
List <Vector2Int> goalCoordinates
)
{
this.characterInfo = character;
this.goalCoordinates = goalCoordinates;
return(NextMove(StartPosition));
}
// Use this for initialization
void Start()
{
player = GetComponentInParent <FighterClass>();
if (player.teamNumber == 1)
{
attacker = "attack2";
}
else
{
attacker = "attack1";
}
}
public static int GetEvadeByLevel <T>(int level, FighterClass fighterClass = FighterClass.None) where T : EnemyFighter
{
var type = typeof(T);
int ret;
/*if (type == typeof(Fairy))
* {
* ret = 50 + ((level < 10) ? 0 : 15 );
* }
* else if (type == typeof(Goblin))
* {
* //base of 5, but up 3 every 5 levels
* ret = 5 + (3 * (level/5));
* }
* else if (type == typeof(Golem) ||
* type == typeof(Ogre))
* {
* //5 every 10 levels
* ret = 5 * (level / 10);
*
* if (ret > 30)
* {
* ret = 30;
* }
* }
* else if (type == typeof(MegaChicken))
* {
* ret = 20 + (5 * (level / 3));
* if (ret > 50)
* {
* ret = 50;
* }
* }*/
if (type == typeof(Fairy))
{
ret = 20;
}
else if (type == typeof(Golem))
{
ret = 0;
}
else if (type == typeof(Warrior) || type == typeof(Barbarian))
{
ret = 10;
}
else
{
ret = 5;
}
return(ret);
}
public static int GetLuckByLevel <T>(int level, FighterClass fighterClass = FighterClass.None) where T : EnemyFighter
{
var type = typeof(T);
int ret;
/*if (type == typeof(Fairy))
* {
* //base of 15, up by 10 every 5 levels
* ret = 15 + ((level /5) * 10);
* if (ret > 90)
* {
* ret = 90;
* }
* }
* else if (type == typeof(Goblin))
* {
* //up by 10 every 7 levels
* ret = 10 * (level / 7);
*
* if (ret > 50)
* {
* ret = 50;
* }
* }
* else if (type == typeof(Golem))
* {
* ret = 0;
* }
* else if (type == typeof(Ogre))
* {
* ret = 20 + (4 * (level/5));
* }
* else if (type == typeof(MegaChicken))
* {
* ret = 0;
* }*/
if (type == typeof(Fairy))
{
ret = 25;
}
else if (type == typeof(Goblin))
{
//slight boost over default
ret = 15;
}
else
{
ret = 10;
}
return(ret);
}
public virtual void TileEntered(FighterClass enteredCharacter)
{
foreach (PlayerEnterTriggerInfo playerEnterTrigger in PlayerEnterTriggers)
{
if (enteredCharacter.objectID == 0 && playerEnterTrigger.Clip || (enteredCharacter.objectID <= 10 && enteredCharacter.objectID > 0 && playerEnterTrigger.Partner))
{
if (CombatExecutor.CutsceneDataManager.TriggerATrigger(playerEnterTrigger.Label))
{
GameDataTracker.combatExecutor.AddCutsceneToQueue(Resources.Load <DialogueContainer>(playerEnterTrigger.CutscenePath), name, gameObject);
}
}
}
}
public void onCombatStart()
{
GameObject target = GameDataTracker.combatExecutor.Clip;
FighterClass targetInfo = target.GetComponent <FighterClass>();
SayDialogue dialogueCutscene = ScriptableObject.CreateInstance <SayDialogue>();
TextAsset textAsset = new TextAsset("Test test hello.");
dialogueCutscene.inputText = textAsset;
dialogueCutscene.heightOverSpeaker = targetInfo.CharacterHeight + 0.5f;
dialogueCutscene.speakerName = targetInfo.name;
CutsceneController.addCutsceneEvent(dialogueCutscene, target, true, GameDataTracker.cutsceneModeOptions.Cutscene);
}
private void Start()
{
playerInfo = GetComponent <FighterClass>();
if (leftFoot != null)
{
hitBoxes.Add(leftFoot);
}
if (rightFoot != null)
{
hitBoxes.Add(rightFoot);
}
if (leftKnee != null)
{
hitBoxes.Add(leftKnee);
}
if (rightKnee != null)
{
hitBoxes.Add(rightKnee);
}
if (leftHand != null)
{
hitBoxes.Add(leftHand);
}
if (rightHand != null)
{
hitBoxes.Add(rightHand);
}
if (leftElbow != null)
{
hitBoxes.Add(leftElbow);
}
if (rightElbow != null)
{
hitBoxes.Add(rightElbow);
}
if (chest != null)
{
hitBoxes.Add(chest);
}
if (head != null)
{
hitBoxes.Add(head);
}
foreach (GameObject g in hitBoxes)
{
string attackLabel = "attack" + playerInfo.teamNumber;
g.tag = attackLabel;
g.SetActive(false);
}
}
private void Start()
{
rigid = gameObject.GetComponent <Rigidbody>();
character = gameObject.GetComponent <CharacterController>();
fighter = this.gameObject.GetComponent <FighterClass> ();
for (int i = 0; i < 2; i++)
{
centerArray[i] = character.center - new Vector3(0, centerOffset, 0);
radiusArray[i] = character.radius / (i + 1);
heightArray[i] = character.height / (i + 1);
centerOffset = 0.25f;
}
}
public bool AttemptPush(List <Vector2Int> pushTargets, int HorChange, int VerChange, float Speed, int pushStrength)
{
List <FighterClass> charactersToPush = new List <FighterClass>();
List <CombatObject> objectsToPush = new List <CombatObject>();
foreach (Vector2Int pushTarget in pushTargets)
{
if (!BattleMapProcesses.isThisOnTheGrid(pushTarget))
{
return(false);
}
if (CombatExecutor.characterGrid[pushTarget.x, pushTarget.y] != null)
{
FighterClass characterToPush = CombatExecutor.characterGrid[pushTarget.x, pushTarget.y].GetComponent <FighterClass>();
if (!CombatExecutor.characterGrid[pushTarget.x, pushTarget.y].GetComponent <CombatObject>().PushObjectCheck(HorChange, VerChange, Speed, pushStrength - 1))
{
return(false);
}
if (!charactersToPush.Contains(characterToPush))
{
objectsToPush.Add(characterToPush);
}
}
if (CombatExecutor.objectGrid[pushTarget.x, pushTarget.y] != null)
{
if (!CombatExecutor.objectGrid[pushTarget.x, pushTarget.y].GetComponent <CombatObject>().Passable)
{
CombatObject objectToPush = CombatExecutor.objectGrid[pushTarget.x, pushTarget.y].GetComponent <CombatObject>();
if (!CombatExecutor.objectGrid[pushTarget.x, pushTarget.y].GetComponent <CombatObject>().PushObjectCheck(HorChange, VerChange, Speed, pushStrength - 1))
{
return(false);
}
if (!objectsToPush.Contains(objectToPush))
{
objectsToPush.Add(objectToPush);
}
}
}
}
foreach (CombatObject characterToPush in charactersToPush)
{
characterToPush.MoveCharacterExecute(new Vector2Int(characterToPush.pos.x + HorChange, characterToPush.pos.y + VerChange), Speed, Speed, CombatExecutor.characterGrid);
}
foreach (CombatObject objectToPush in objectsToPush)
{
objectToPush.MoveCharacterExecute(new Vector2Int(objectToPush.pos.x + HorChange, objectToPush.pos.y + VerChange), Speed, Speed, CombatExecutor.objectGrid);
}
return(true);
}
public static int GetStrengthByLevel <T>(int level, FighterClass fighterClass = FighterClass.None) where T : EnemyFighter
{
var type = typeof(T);
int ret;
/*if (type == typeof(Fairy))
* {
* ret = level;
* }
* else if (type == typeof(Goblin))
* {
* ret = 1 + (2 * level);
* }
* else if (type == typeof(Golem))
* {
* //1 plus level, plus an extra 3 every 5 levels
* ret = 1 + level + (3 * (level / 5));
* }
* else if (type == typeof(Ogre))
* {
* //base of 3, 2 per level plus a bonus each 4
* ret = 3 + (2 * level) + (level / 4);
* }
* else if (type == typeof(MegaChicken))
* {
* ret = 0;
* }
* else if (type == typeof(Warrior))
* {
* ret = 6 + level*2;
* }*/
if (type == typeof(Ogre))
{
ret = level + 2;
}
else if (type == typeof(Goblin) || type == typeof(Warrior))
{
ret = level + 1;
}
else if (type == typeof(Barbarian))
{
ret = level + 3;
}
else
{
ret = level;
}
return(ret);
}
public static int GetManaByLevel <T>(int level, FighterClass fighterClass = FighterClass.None) where T : EnemyFighter
{
var type = typeof(T);
int ret;
/*if (type == typeof(Fairy))
* {
* ret = 6 + (4 * level);
* }
* else if (type == typeof(Goblin))
* {
* ret = (level/3) * 2;
* }
* else if (type == typeof(Golem))
* {
* ret = 0;
* }
* else if (type == typeof(Ogre))
* {
* ret = level + ((level - 1) / 4);
* }
*
* else if (type == typeof(Ogre))
* {
* ret = 5 + (3*level);
* }
* else if (type == typeof(MegaChicken))
* {
* ret = level * 5;
* }*/
if (type == typeof(Fairy))
{
ret = level * 4;
}
else if (type == typeof(Goblin))
{
ret = level * 3;
}
else if (type == typeof(Warrior) || type == typeof(ShieldGuy) || type == typeof(Barbarian))
{
ret = level;
}
else
{
ret = level * 2;
}
return(ret);
}
/// <summary>
/// Gets all the spells a particular class learns by level up by the time they reach a particular level.
/// Optionally only returns the list of spells they would learn within a range of levels.
/// (e.g. if FooFighter learns a new spell at levels 2-5, and min level is specified at 4, only 2 spells are returned)
/// </summary>
/// <typeparam name="T">The Fighter class that will learn the spells</typeparam>
/// <param name="level">The max level for the range of spells they will learn</param>
/// <param name="minLevel">The min level for the range of spells they will learn.
/// Omit this to get all spells learned by the given level</param>
/// <param name="fighterClass">An optional parameter that may determine what spells a fighter may learn depending on their class</param>
/// <returns>all the spells a particular class learns by level up between one level and another</returns>
public static List <Spell> GetSpellsByLevel <T>(int level, int minLevel = 1, FighterClass fighterClass = FighterClass.None) where T : IFighter
{
var ret = new List <Spell>();
var type = typeof(T);
if (_masterSpellList.ContainsKey(type))
{
var list = _masterSpellList[type];
ret.AddRange(list.Where(sbl => sbl.Level >= minLevel && sbl.Level <= level).Select(sbl => sbl.Spell));
}
return(ret);
}
void CreateButtons()
{
//current = logic.getActor();
current = Logic.getActor();
int buttonNum = 0;
for(buttonNum = 0; buttonNum < numberOfMoves; buttonNum++) {
Vector3 buttonPos = new Vector3(200, 160*(buttonNum+1), 0);
//GameObject newButton = Instantiate(genericButton, buttonPos, quat) as GameObject;
buttons[buttonNum] = Instantiate(genericButton, buttonPos, quat) as GameObject;
buttons[buttonNum].transform.SetParent(gameObject.transform);
//buttons[buttonNum].AddComponent<Text>().text = current.moveList[buttonNum].ToString();
buttons[buttonNum].GetComponent<ButtonScript>().setButtonMove(current.moveList[buttonNum]);
//Debug.Log(buttons[buttonNum].GetComponent<ButtonScript>().move.moveName);
}
}
public static int GetHealthByLevel <T>(int level, FighterClass fighterClass = FighterClass.None) where T : EnemyFighter
{
var type = typeof(T);
int ret;
if (type == typeof(Fairy))
{ //reduced health to make up for high speed and evasion
ret = level * 3;
}
else if (type == typeof(Golem))
{
//reduced health to make up for high defense
ret = level * 4;
}
else if (type == typeof(Shade))
{
ret = 2 + (level * 2);
}
else if (type == typeof(Goblin))
{
//increased health- goblin's specialty to make up for high defense
ret = level * 7;
}
else if (type == typeof(MegaChicken))
{
//note: may need to update this is anything other
ret = 15;
}
else if (type == typeof(Warrior))
{
ret = level * 6;
}
else if (type == typeof(Barbarian))
{
ret = 40;
}
else if (type == typeof(ShieldGuy))
{
ret = level * 3;
}
else
{
ret = level * 5;
}
return(ret);
}
/************************FindClassStatValues**********************************
* In: classSelection
* Out: ToString for the given class
* Purpose:
* **************************************************************************/
private string FindClassStatValues(int classIndex)
{
if (classIndex == 4)
{
BaseClass tempClass = new FighterClass();
return tempClass.ToString(); //returns overridden ToString for class
}
else if (classIndex == 10)
{
BaseClass tempClass = new WizardClass();
return tempClass.ToString();
}
else
{
return "No Stats Available";
}
}
/************************FindClassStatValues**********************************
* In: classSelection
* Out: ToString for the given class
* Purpose:
* **************************************************************************/
private string FindClassStatValues(int classIndex)
{
if (classIndex == 4)
{
BaseClass tempClass = new FighterClass();
return(tempClass.ToString()); //returns overridden ToString for class
}
else if (classIndex == 10)
{
BaseClass tempClass = new WizardClass();
return(tempClass.ToString());
}
else
{
return("No Stats Available");
}
}
public static int GetDefenseByLevel <T>(int level, FighterClass fighterClass = FighterClass.None) where T : EnemyFighter
{
var type = typeof(T);
int ret;
/*if (type == typeof(Fairy))
* {
* ret = (level / 2) - 1;
* }
* else if (type == typeof(Goblin))
* {
* //base of 2, then up by 2 every third level level
* ret = 2 + (2 * (level/3));
* }
* else if (type == typeof(Golem))
* {
* //3 every level
* ret = 3 * level;
* }
* else if (type == typeof(Ogre))
* {
* ret = level / 2;
* }
* else if (type == typeof(MegaChicken))
* {
* ret = level;
* }
* else if (type == typeof(Warrior))
* {
* ret = level + 2;
* }*/
if (type == typeof(Fairy) || type == typeof(ShieldGuy) || type == typeof(Shade))
{
ret = Math.Max(0, level - 2);
}
else if (type == typeof(Golem) || type == typeof(Barbarian))
{
ret = level;
}
else
{
ret = Math.Max(0, level - 1);
}
return(ret);
}
/************************FindClassDescription*********************************
* In: classSelection
* Out: tempClass.ClassDescription
* Purpose: find ad display class description for the player.
* TODO: Combine FindClassDescription & FindClassStats to a single
* function.
* **************************************************************************/
private string FindClassDescription(int classIndex)
{
if (classIndex == 4)
{
BaseClass tempClass = new FighterClass();
return tempClass.ClassDescription;
}
else if (classIndex == 10)
{
BaseClass tempClass = new WizardClass();
return tempClass.ClassDescription;
}
else
{
return "This class not yet implemented," +
" Implemented classes are Fighter and Wizard.";
}
}
/************************FindClassDescription*********************************
* In: classSelection
* Out: tempClass.ClassDescription
* Purpose: find ad display class description for the player.
* TODO: Combine FindClassDescription & FindClassStats to a single
* function.
* **************************************************************************/
private string FindClassDescription(int classIndex)
{
if (classIndex == 4)
{
BaseClass tempClass = new FighterClass();
return(tempClass.ClassDescription);
}
else if (classIndex == 10)
{
BaseClass tempClass = new WizardClass();
return(tempClass.ClassDescription);
}
else
{
return("This class not yet implemented," +
" Implemented classes are Fighter and Wizard.");
}
}
public override bool Activate()
{
combatData = GameDataTracker.combatExecutor;
blockOffset = CombatExecutor.blockOffset;
gridHeight = CombatExecutor.gridHeight;
characterGrid = CombatExecutor.characterGrid;
source = parent.GetComponent <FighterClass>();
EndPos = BattleMapProcesses.findNearestTileFullyFitsObject(source.TileSize, target.pos);
source.RemoveObjectFromGrid();
JumpToLocation jumpTo = ScriptableObject.CreateInstance <JumpToLocation>();
jumpTo.endPosition = GridManager.GridToPosition(EndPos, source.TileSize);
jumpTo.parent = parent;
jumpTo.heightOverHighestCharacter = 2.5f;
jumpTo.speed = source.JumpSpeed;
cutscene = jumpTo;
return(true);
}
public static int GetSpeedByLevel <T>(int level, FighterClass fighterClass = FighterClass.None) where T : EnemyFighter
{
var type = typeof(T);
int ret;
/*if (type == typeof(Fairy))
* {
* ret = 2 + (3*level);
* }
* else if (type == typeof(Goblin))
* {
* ret = level;
* }
* else if (type == typeof(Golem))
* {
* //base of 1, 1 every level with a +1 bonus every 4 levels
* ret = 1 + level + (1 * (level / 4));
* }
* else if (type == typeof(Ogre))
* {
* ret = 2 * (level / 3);
* }
* else if (type == typeof(MegaChicken))
* {
* ret = 4 + (2 * level);
* }*/
if (type == typeof(Fairy) || type == typeof(ShieldGuy))
{
ret = level + 1;
}
else if (type == typeof(Golem))
{
ret = Math.Max(0, level - 1);
}
else
{
ret = level;
}
return(ret);
}
public static IFighter GetFighter(FighterType type,
int level,
string name = null,
MagicType magicType = MagicType.None,
FighterClass fighterClass = FighterClass.None,
IMenuFactory menuFactory = null)
{
IFighter ret;
switch (type)
{
case FighterType.Goblin:
ret = new Goblin(level, ChanceService);
break;
case FighterType.Golem: //high defense, low attack, low speed, low health
ret = new Golem(level, ChanceService);
break;
case FighterType.Ogre: //high attack, low speed, low defense
ret = new Ogre(level, ChanceService);
break;
case FighterType.Fairy: //high speed, high evade, low attack, low defense
ret = new Fairy(level, ChanceService);
break;
case FighterType.HumanControlledPlayer:
ret = new HumanFighter(name ?? "Player", level);
GodRelationshipManager?.InitializeForFighter((HumanFighter)ret);
break;
case FighterType.HumanControlledEnemy:
ret = new HumanControlledEnemyFighter(name ?? "Player", Input, Output, menuFactory ?? Globals.MenuFactory);
break;
case FighterType.MegaChicken:
ret = new MegaChicken(level, ChanceService);
break;
case FighterType.Egg:
if (magicType == MagicType.None)
{
int magicIndex = ChanceService.WhichEventOccurs(Globals.EggMagicTypes.Length);
magicType = Globals.EggMagicTypes[magicIndex];
}
ret = new Egg(magicType);
break;
case FighterType.DancerBoss:
ret = new DancerBoss(fighterClass, level, ChanceService);
break;
case FighterType.Zombie:
ret = new Zombie(level, ChanceService);
break;
case FighterType.Warrior:
ret = new Warrior(level, ChanceService);
break;
case FighterType.ShieldGuy:
ret = new ShieldGuy(level, ChanceService);
break;
case FighterType.Barbarian:
ret = new Barbarian(level, ChanceService);
break;
case FighterType.Shade:
ret = GetShade(level, name);
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type,
"The specified type is invalid for FighterFactory to initialize!");
}
return(ret);
}
public override void EndTurnOn(FighterClass target)
{
target.postBufferAttackEffect(3, FighterClass.attackType.Normal, FighterClass.statusEffects.None, FighterClass.attackLocation.Ground, gameObject);
}
public PlayerClass(FighterClass fighter, Color color)
{
Fighters = new List<FighterClass>();
Fighters.Add (fighter);
playerColor = color;
}
