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; }