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!");
}
}
private void Awake()
{
if (instance == null)
{
instance = this;
}
}
public HumanFighter(string name, int level, List <Spell> spells = null, List <SpecialMove> specialMoves = null)
: base(name
, level
, LevelUpManager.GetHealthByLevel(level)
, LevelUpManager.GetManaByLevel(level)
, LevelUpManager.GetStrengthByLevel(level)
, LevelUpManager.GetDefenseByLevel(level)
, LevelUpManager.GetSpeedByLevel(level)
, LevelUpManager.GetEvadeByLevel(level)
, LevelUpManager.GetLuckByLevel(level)
, SpellFactory.GetSpellsByLevel <HumanFighter>(level)
, MoveFactory.GetMovesByLevel <HumanFighter>(level)
)
{
if (spells != null)
{
Spells.AddRange(spells);
}
if (specialMoves != null)
{
SpecialMoves.AddRange(specialMoves);
}
_extraSpecialMoves = new List <BattleMove>();
CurrentExp = LevelUpManager.GetExpForLevel(level);
_expToNextLevel = LevelUpManager.GetExpForLevel(level + 1);
}
// Use this for initialization
void Start()
{
level = 1; // Level start at 1
totalXP = 0;
currentXP = 0;
XPToNextLevel = XPForFirstLevel;
levelUpManager = GameObject.Find("LevelUpScreen").GetComponent <LevelUpManager>();
}
// Use this for initialization
void Start()
{
level = 1; // Level start at 1
totalXP = 0;
currentXP = 0;
XPToNextLevel = XPForFirstLevel;
levelUpManager = GameObject.Find("LevelUpScreen").GetComponent<LevelUpManager>();
}
void Start()
{
if (!isTutorial)
{
lum = GameObject.Find("Level Up Manager").GetComponent <LevelUpManager>();
lgm = GameObject.Find("Level Generation Manager").GetComponent <LevelGenerationManager>();
}
currentMovementSpeed = firstMovementSpeed;
}
public void TestDefenseBoostByLevelMethod_PerLevel()
{
int[] boosts = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
for (var i = 1; i < 11; ++i)
{
Assert.AreEqual(boosts[i - 1], LevelUpManager.DefenseBoostByLevel(i));
}
}
public void TestGetSpeedByLevelMethod()
{
int[] expected = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
for (var i = 0; i < 11; ++i)
{
Assert.AreEqual(expected[i], LevelUpManager.GetSpeedByLevel(i));
}
}
public void TestSpeedBoostByLevelMethod_PerLevel()
{
var boosts = new[] { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
for (var i = 1; i < 11; ++i)
{
Assert.AreEqual(boosts[i - 1], LevelUpManager.SpeedBoostByLevel(i));
}
}
public void TestSpeedBoostByLevelMethod_BySum()
{
int total = 0;
for (var i = 1; i < 11; ++i)
{
total += LevelUpManager.SpeedBoostByLevel(i);
var totalByLevel = LevelUpManager.GetSpeedByLevel(i);
Assert.AreEqual(total, totalByLevel);
}
}
public void TestDefenseBoostByLevelMethod_BySum()
{
var total = LevelUpManager.DefenseBoostByLevel(1);
for (var i = 1; i < 11; ++i)
{
total += LevelUpManager.DefenseBoostByLevel(i);
var foo = LevelUpManager.GetDefenseByLevel(i);
Assert.AreEqual(total, foo);
}
}
//Constructor function for this class
public PlayerProgress(GameData gameData_, TileMapManager tileGrid_, LevelUpManager levelUpManager_, CharacterManager charManager_, QuestTracker questTracker_)
{
//Setting the GameData.cs variables
this.difficulty = gameData_.currentDifficulty;
this.allowNewUnlockables = gameData_.allowNewUnlockables;
this.folderName = gameData_.saveFolder;
this.randState = Random.state;
//Setting the CreateTileGrid.cs variables
this.gridCols = tileGrid_.cols;
this.gridRows = tileGrid_.rows;
//Setting the HUDChallengeRampUpTimer.cs variables
this.currentDifficulty = HUDChallengeRampUpTimer.globalReference.currentDifficulty;
this.currentDifficultyTimer = HUDChallengeRampUpTimer.globalReference.currentTimer;
//Setting the LevelUpManager variable
this.characterLevel = levelUpManager_.characterLevel;
//Setting the PartyGroup.cs variables
this.partyGroup1 = new PartySaveData(PartyGroup.globalReference);
//Looping through all of the dead character info in CharacterManager.cs
this.deadCharacters = new List <DeadCharacterInfo>();
for (int d = 0; d < charManager_.deadCharacters.Count; ++d)
{
this.deadCharacters.Add(charManager_.deadCharacters[d]);
}
//Looping through all of the enemy tile encounters in CharacterManager.cs
this.enemyTileEncounters = new List <EnemyTileEncounterInfo>();
for (int e = 0; e < CharacterManager.globalReference.tileEnemyEncounters.Count; ++e)
{
//Making sure the encounter isn't null first
if (CharacterManager.globalReference.tileEnemyEncounters[e] != null)
{
//Creating a new tile encounter info for the enemy
EnemyTileEncounterInfo enemyInfo = new EnemyTileEncounterInfo(CharacterManager.globalReference.tileEnemyEncounters[e]);
//Adding the enemy encounter info to our list to serialize
this.enemyTileEncounters.Add(enemyInfo);
}
}
//Looping through all of the quests in our quest log
this.questLog = new List <string>();
foreach (Quest q in questTracker_.questLog)
{
this.questLog.Add(JsonUtility.ToJson(new QuestSaveData(q), true));
}
//Saving all of the finished quest names
this.finishedQuests = questTracker_.completedQuestNames;
}
//Function called when this object is created
private void Awake()
{
//Setting the static reference
if (globalReference == null)
{
globalReference = this;
}
//If a static reference already exists, this component is destroyed
else
{
Destroy(this);
}
}
private void Awake()
{
if (instance == null)
{
instance = this;
}
else
{
Destroy(this);
}
highestLevel = 1;
needsLevelUp = new Stack <CharacterPlayer>();
levelUpPanel.SetActive(false);
}
public Ogre(int level, IChanceService chanceService)
: base("Ogre",
level,
LevelUpManager.GetHealthByLevel <Ogre>(level),
LevelUpManager.GetManaByLevel <Ogre>(level),
LevelUpManager.GetStrengthByLevel <Ogre>(level),
LevelUpManager.GetDefenseByLevel <Ogre>(level),
LevelUpManager.GetSpeedByLevel <Ogre>(level),
LevelUpManager.GetEvadeByLevel <Ogre>(level),
LevelUpManager.GetLuckByLevel <Ogre>(level),
chanceService,
SpellFactory.GetSpellsByLevel <Ogre>(level)
, MoveFactory.GetMovesByLevel <Ogre>(level))
{
}
public Barbarian(int level, IChanceService chanceService, string name = null) :
base(name ?? "Barbarian"
, level
, LevelUpManager.GetHealthByLevel <Barbarian>(level)
, LevelUpManager.GetManaByLevel <Barbarian>(level)
, LevelUpManager.GetStrengthByLevel <Barbarian>(level)
, LevelUpManager.GetDefenseByLevel <Barbarian>(level)
, LevelUpManager.GetSpeedByLevel <Barbarian>(level)
, LevelUpManager.GetEvadeByLevel <Barbarian>(level)
, LevelUpManager.GetLuckByLevel <Barbarian>(level)
, chanceService
, SpellFactory.GetSpellsByLevel <Barbarian>(level)
, MoveFactory.GetMovesByLevel <Barbarian>(level))
{
_shieldBusterFails = 0;
}
public void GainExpMethod_AppropriatelyRaisesEvents_WhenFighterDoesNotLevelUp()
{
var expAmount = LevelUpManager.GetExpForLevel(_fighter.Level + 1) - 1;
_fighter.GainExp(expAmount);
var logs = _logger.Logs;
Assert.AreEqual(1, logs.Count);
Assert.AreEqual(EventType.ExpGained, logs[0].Type);
Assert.AreEqual(_fighter, logs[0].Sender);
var e = logs[0].E as ExpGainedEventArgs;
Assert.That(e, Is.Not.Null);
Assert.AreEqual(expAmount, e.AmountGained);
}
//Function called when this object is created
private void Awake()
{
//Setting the static reference
if (globalReference == null)
{
globalReference = this;
}
//If a static reference already exists, this component is destroyed
else
{
Destroy(this);
}
//Initializes the Delegate Event for the Event Manager
this.trackTimePassageEVT = new DelegateEvent <EVTData>(this.TrackTimePassage);
}
private static void InitializeLevelUpManager()
{
if (mustDebug)
{
Game.PrintChat("InitializeLevelUpManager Start");
}
var priority1 = new int[] { 3, 2, 3, 1, 3, 4, 3, 1, 3, 1, 4, 1, 1, 2, 2, 4, 2, 2 };
levelUpManager = new LevelUpManager();
levelUpManager.Add("E > W > E > Q ", priority1);
if (mustDebug)
{
Game.PrintChat("InitializeLevelUpManager Finish");
}
}
private static void InitializeLevelUpManager()
{
if (mustDebug)
{
Chat.Print("InitializeLevelUpManager Start");
}
var priority1 = new int[] { 2, 1, 3, 2, 2, 4, 2, 1, 2, 1, 4, 1, 1, 3, 3, 4, 3, 3 };
levelUpManager = new LevelUpManager();
levelUpManager.Add("W > Q > E > W ", priority1);
if (mustDebug)
{
Chat.Print("InitializeLevelUpManager Finish");
}
}
public Zombie(int level, IChanceService chanceService)
: base("Zombie",
level,
LevelUpManager.GetHealthByLevel <Zombie>(level),
LevelUpManager.GetManaByLevel <Zombie>(level),
LevelUpManager.GetStrengthByLevel <Zombie>(level),
LevelUpManager.GetDefenseByLevel <Zombie>(level),
LevelUpManager.GetSpeedByLevel <Zombie>(level),
LevelUpManager.GetEvadeByLevel <Zombie>(level),
LevelUpManager.GetLuckByLevel <Zombie>(level),
chanceService,
SpellFactory.GetSpellsByLevel <Zombie>(level)
, MoveFactory.GetMovesByLevel <Zombie>(level))
{
ReviveCounter = 0;
Killed = _setReviveCounter;
TurnEnded += _turnEnded;
}
public ShieldGuy(int level, IChanceService chanceService, string name = null) :
base(name ?? "Shield Guy"
, level
, LevelUpManager.GetHealthByLevel <ShieldGuy>(level)
, LevelUpManager.GetManaByLevel <ShieldGuy>(level)
, LevelUpManager.GetStrengthByLevel <ShieldGuy>(level)
, LevelUpManager.GetDefenseByLevel <ShieldGuy>(level)
, LevelUpManager.GetSpeedByLevel <ShieldGuy>(level)
, LevelUpManager.GetEvadeByLevel <ShieldGuy>(level)
, LevelUpManager.GetLuckByLevel <ShieldGuy>(level)
, chanceService
, SpellFactory.GetSpellsByLevel <ShieldGuy>(level)
, MoveFactory.GetMovesByLevel <ShieldGuy>(level))
{
_basicAttack = AvailableMoves.FirstOrDefault(bm => bm.MoveType == BattleMoveType.Attack);
_ironShieldMove = AvailableMoves.FirstOrDefault(bm => bm is ShieldMove) as ShieldMove;
_healShield = AvailableMoves.FirstOrDefault(bm => bm is ShieldFortifyingMove && ((ShieldFortifyingMove)bm).FortifyingType == ShieldFortifyingType.Health) as ShieldFortifyingMove;
_fortifyShield = AvailableMoves.FirstOrDefault(bm => bm is ShieldFortifyingMove && ((ShieldFortifyingMove)bm).FortifyingType == ShieldFortifyingType.Defense) as ShieldFortifyingMove;
}
private static void InitializeLevelUpManager()
{
if (mustDebug)
{
Game.PrintChat("InitializeLevelUpManager Start");
}
var priority1 = new int[] { 0, 2, 2, 1, 2, 3, 2, 0, 2, 0, 3, 0, 0, 1, 2, 3, 1, 1 };
var priority2 = new int[] { 0, 2, 1, 2, 2, 3, 2, 0, 2, 0, 3, 0, 0, 1, 1, 3, 1, 1 };
levelUpManager = new LevelUpManager();
levelUpManager.Add("Q > E > E > W ", priority1);
levelUpManager.Add("Q > E > W > E ", priority2);
if (mustDebug)
{
Game.PrintChat("InitializeLevelUpManager Finish");
}
}
public BasePlayableCharacter(string name, int strengthPotential, int intelligencePotential, int defensePotential,
int willPotential, int speedPotential, int agilityPotential) : base(name)
{
CurrLevel = 0;
CurrExp = 1;
ExpToNextLevel = 1;
StrengthPotential = strengthPotential;
IntelligencePotential = intelligencePotential;
DefensePotential = defensePotential;
WillPotential = willPotential;
SpeedPotential = speedPotential;
AgilityPotential = agilityPotential;
LevelUpManager.LevelUp(this);
CurrHp = MaxHp;
CurrMp = MaxMp;
}
public void LevelInitializater_CorrectlyInitializesStatsBasedOnLevel([Values(1, 2, 5)] int level)
{
var fighter = new HumanFighter("Foo the Magnificent", level);
Assert.AreEqual(level, fighter.Level);
Assert.AreEqual(LevelUpManager.GetHealthByLevel(level), fighter.CurrentHealth);
Assert.AreEqual(LevelUpManager.GetHealthByLevel(level), fighter.MaxHealth);
Assert.AreEqual(LevelUpManager.GetManaByLevel(level), fighter.CurrentMana);
Assert.AreEqual(LevelUpManager.GetManaByLevel(level), fighter.MaxMana);
Assert.AreEqual(LevelUpManager.GetStrengthByLevel(level), fighter.Strength);
Assert.AreEqual(LevelUpManager.GetDefenseByLevel(level), fighter.Defense);
Assert.AreEqual(LevelUpManager.GetSpeedByLevel(level), fighter.Speed);
Assert.AreEqual(LevelUpManager.GetEvadeByLevel(level), fighter.Evade);
Assert.AreEqual(LevelUpManager.GetLuckByLevel(level), fighter.Luck);
var spells = GetSpellsByLevel(level);
Assert.AreEqual(spells.Count, fighter.Spells.Count);
Assert.IsTrue(spells.TrueForAll(s => fighter.Spells.SingleOrDefault(fs => fs.Description == s.Description) != null));
}
/// <summary>
/// Assumes CurrentExp has already been updated
/// </summary>
private void LevelUp()
{
var continuer = true;
for (var i = Level + 1; i <= LevelUpManager.MAX_LEVEL && continuer; ++i)
{
if (CurrentExp >= LevelUpManager.GetExpForLevel(i))
{
++Level;
CurrentHealth = LevelUpManager.GetHealthByLevel(Level);
MaxHealth = LevelUpManager.GetHealthByLevel(Level);
CurrentMana = LevelUpManager.GetManaByLevel(Level);
MaxMana = LevelUpManager.GetManaByLevel(Level);
Strength = LevelUpManager.GetStrengthByLevel(Level);
Defense = LevelUpManager.GetDefenseByLevel(Level);
Speed = LevelUpManager.GetSpeedByLevel(Level);
Evade = LevelUpManager.GetEvadeByLevel(Level);
Luck = LevelUpManager.GetLuckByLevel(Level);
OnLeveledUp(new LeveledUpEventArgs(
Level
, LevelUpManager.HealthBoostByLevel(Level)
, LevelUpManager.ManaBoostByLevel(Level)
, LevelUpManager.StrengthBoostByLevel(Level)
, LevelUpManager.DefenseBoostByLevel(Level)
, LevelUpManager.SpeedBoostByLevel(Level)));
var spells = SpellFactory.GetSpellsByLevel <HumanFighter>(Level, Level);
if (spells.Count > 0)
{
AddSpells(spells);
}
}
else
{
continuer = false;
}
}
_expToNextLevel = LevelUpManager.GetExpForLevel(Level + 1);
}
void Start()
{
// level
PlayerPrefs.SetInt(this.name + " level", PlayerPrefs.GetInt(this.name + " level", 1));
// experience
PlayerPrefs.SetInt(this.name + " experience", PlayerPrefs.GetInt(this.name + " experience", 0));
LevelUpManager levelUpManager = GameObject.Find("LevelUpManager").GetComponent <LevelUpManager>();
playerXPNextLevel = levelUpManager.GetXPNextLevel(PlayerPrefs.GetInt(this.name + " level"));
PlayerPrefs.SetInt(this.name + " experienceNext", playerXPNextLevel);
// show level of player
playerLevelText = transform.Find("Canvas/Level").GetComponent <Text>();
playerLevelText.text = "Lvl " + PlayerPrefs.GetInt(this.name + " level");
// show experience points of player
playerXPText = transform.Find("Canvas/Experience").GetComponent <Text>();
playerXPText.text = "XP " + PlayerPrefs.GetInt(this.name + " experience") + "/" + playerXPNextLevel;
}
public Shade(int level, IChanceService chanceService, int shadeExperience)
: base("Shade",
level,
LevelUpManager.GetHealthByLevel <Shade>(level),
LevelUpManager.GetManaByLevel <Shade>(level),
LevelUpManager.GetStrengthByLevel <Shade>(level),
LevelUpManager.GetDefenseByLevel <Shade>(level),
LevelUpManager.GetSpeedByLevel <Shade>(level),
LevelUpManager.GetEvadeByLevel <Shade>(level),
LevelUpManager.GetLuckByLevel <Shade>(level),
chanceService,
SpellFactory.GetSpellsByLevel <Shade>(level)
, MoveFactory.GetMovesByLevel <Shade>(level))
{
ShadeExperience = shadeExperience;
_malevolenceCounter = 0;
_chargeMove = AvailableMoves.FirstOrDefault(bm => bm.MoveType == BattleMoveType.Special);
_malevolenceAttackMove = AvailableMoves.FirstOrDefault(bm => bm.MoveType == BattleMoveType.ConditionalPowerAttack);
}
public Warrior(int level, IChanceService chanceService, string name = null) :
base(name ?? "Warrior"
, level
, LevelUpManager.GetHealthByLevel <Warrior>(level)
, LevelUpManager.GetManaByLevel <Warrior>(level)
, LevelUpManager.GetStrengthByLevel <Warrior>(level)
, LevelUpManager.GetDefenseByLevel <Warrior>(level)
, LevelUpManager.GetSpeedByLevel <Warrior>(level)
, LevelUpManager.GetEvadeByLevel <Warrior>(level)
, LevelUpManager.GetLuckByLevel <Warrior>(level)
, chanceService
, SpellFactory.GetSpellsByLevel <Warrior>(level)
, MoveFactory.GetMovesByLevel <Warrior>(level))
{
_attackIndex = AvailableMoves.FindIndex(bm => bm.MoveType == BattleMoveType.Attack);
_evadeIndex = AvailableMoves.FindIndex(bm => bm.MoveType == BattleMoveType.Status && (bm as StatusMove)?.Status is AutoEvadeStatus && !((AutoEvadeStatus)((StatusMove)bm).Status).ShouldCounterAttack);
_evadeAndCounterIndex = AvailableMoves.FindIndex(bm => bm.MoveType == BattleMoveType.Status && (bm as StatusMove)?.Status is AutoEvadeStatus && ((AutoEvadeStatus)((StatusMove)bm).Status).ShouldCounterAttack);
_attackBoostIndex = AvailableMoves.FindIndex(bm => bm.MoveType == BattleMoveType.Status && (bm as StatusMove)?.Status is StatMultiplierStatus);
_attackBoostMove = AvailableMoves[_attackBoostIndex] as StatusMove;
}
public MegaChicken(int level, IChanceService chanceService)
: base("Mega Chicken",
level,
LevelUpManager.GetHealthByLevel <MegaChicken>(level),
LevelUpManager.GetManaByLevel <MegaChicken>(level),
LevelUpManager.GetStrengthByLevel <MegaChicken>(level),
LevelUpManager.GetDefenseByLevel <MegaChicken>(level),
LevelUpManager.GetSpeedByLevel <MegaChicken>(level),
LevelUpManager.GetEvadeByLevel <MegaChicken>(level),
LevelUpManager.GetLuckByLevel <MegaChicken>(level),
chanceService,
SpellFactory.GetSpellsByLevel <MegaChicken>(level)
, MoveFactory.GetMovesByLevel <MegaChicken>(level))
{
MagicStrength = 3;
ExpGivenOnDefeat = 20 + level * 5;
_layEgg = new SpecialMove("lay egg", BattleMoveType.Special, TargetType.Self, null);
_lay2Eggs = new SpecialMove("lay 2 eggs", BattleMoveType.Special, TargetType.Self, null);
_castEggs = new SpecialMove("cast eggs", BattleMoveType.Special, TargetType.Self, null);
_eggs = new List <Egg>();
}
public void GainExpMethod_AppropriatelyRaisesLevel([Values(2, 4)] int level)
{
var expAmount = (level == 2) ? _expToLevel2 : _expToLevel4;
Assert.AreEqual(0, _fighter.CurrentExp);
_fighter.GainExp(expAmount);
Assert.AreEqual(expAmount, _fighter.CurrentExp);
Assert.AreEqual(level, _fighter.Level);
Assert.AreEqual(LevelUpManager.GetHealthByLevel(level), _fighter.CurrentHealth);
Assert.AreEqual(LevelUpManager.GetHealthByLevel(level), _fighter.MaxHealth);
Assert.AreEqual(LevelUpManager.GetManaByLevel(level), _fighter.CurrentMana);
Assert.AreEqual(LevelUpManager.GetManaByLevel(level), _fighter.MaxMana);
Assert.AreEqual(LevelUpManager.GetStrengthByLevel(level), _fighter.Strength);
Assert.AreEqual(LevelUpManager.GetDefenseByLevel(level), _fighter.Defense);
Assert.AreEqual(LevelUpManager.GetSpeedByLevel(level), _fighter.Speed);
Assert.AreEqual(LevelUpManager.GetEvadeByLevel(level), _fighter.Evade);
Assert.AreEqual(LevelUpManager.GetLuckByLevel(level), _fighter.Luck);
var spells = GetSpellsByLevel(level);
Assert.AreEqual(spells.Count, _fighter.Spells.Count);
Assert.IsTrue(spells.TrueForAll(s => _fighter.Spells.SingleOrDefault(fs => fs.Description == s.Description) != null));
}
