public void CreateRandomCharacter()
{
CharInventory = new Inventory();
Features = new FeatureList();
Spells = new SpellBook();
CharWallet = new Wallet();
Proficiencies = new List <string>();
if (CharStats == null)
{
CharStats = new Stats();
}
if (CharInfo == null)
{
CharInfo = new CharacterInfo();
}
if (CharSkills == null)
{
CharSkills = new Skills();
}
if (SavingThrows == null)
{
SavingThrows = new SaveThrows();
}
CharStats.RollRandomStats();
CharInfo.GenerateRandomCharacterInfo(this);
CharStats.CalculateModifiers();
}
private void LoadPlayerStats(CharStats charStats)
{
string playerName = "Player_" + charStats.charName;
if (PlayerPrefs.GetInt($"{playerName}_active") == 0)
{
charStats.gameObject.SetActive(false);
}
else
{
charStats.gameObject.SetActive(true);
}
charStats.playerLevel = PlayerPrefs.GetInt($"{playerName}_Level");
charStats.currentExp = PlayerPrefs.GetInt($"{playerName}_CurrentExp");
charStats.currentHp = PlayerPrefs.GetInt($"{playerName}_CurrentHp");
charStats.currentMp = PlayerPrefs.GetInt($"{playerName}_CurrentMp");
charStats.maxLevel = PlayerPrefs.GetInt($"{playerName}_MaxLevel");
charStats.maxHp = PlayerPrefs.GetInt($"{playerName}_MaxHp");
charStats.maxMp = PlayerPrefs.GetInt($"{playerName}_MaxMp");
charStats.strength = PlayerPrefs.GetInt($"{playerName}_Strength");
charStats.defense = PlayerPrefs.GetInt($"{playerName}_Defense");
charStats.equippedArmor = PlayerPrefs.GetString($"{playerName}_EquippedArmor");
charStats.equippedWeapon = PlayerPrefs.GetString($"{playerName}_EquippedWeapon");
}
public bool Roll(CharacterStats roll, CharStats targetStats)
{
int d20 = (int)Random.RandomRange(1f, 21f);
int tD20 = (int)Random.RandomRange(1f, 21f);
switch (roll)
{
case CharacterStats.Dexterity:
return((d20 + dexterity) >= (tD20 + targetStats.dexterity));
case CharacterStats.Strength:
return((d20 + strength) >= (tD20 + targetStats.strength));
case CharacterStats.Wits:
return((d20 + wits) >= (tD20 + targetStats.wits));
case CharacterStats.Charisma:
return((d20 + charisma) >= (tD20 + targetStats.charisma));
case CharacterStats.Speed:
return((d20 + speed) >= (tD20 + targetStats.speed));
default:
return(d20 >= tD20);
}
}
private bool AttackByRaycast()
{
Transform candidateTarget = GetInfront();
if (candidateTarget != null)
{
if (candidateTarget.gameObject.tag == "Enemy")
{
target = candidateTarget;
float distance = Vector3.Distance(target.position, rb.transform.position);
if (distance <= lookRadius)
{
CharStats targetStats = target.GetComponent <CharStats>();
if (targetStats != null)
{
combat.Attack(targetStats);
}
return(true);
}
return(false);
}
}
return(false);
}
private void SavePlayerStats(CharStats charStats)
{
string playerName = "Player_" + charStats.charName;
if (charStats.gameObject.activeInHierarchy)
{
PlayerPrefs.SetInt($"{playerName}_active", 1);
}
else
{
PlayerPrefs.SetInt($"{playerName}_active", 0);
}
PlayerPrefs.SetInt($"{playerName}_Level", charStats.playerLevel);
PlayerPrefs.SetInt($"{playerName}_CurrentExp", charStats.currentExp);
PlayerPrefs.SetInt($"{playerName}_CurrentHp", charStats.currentHp);
PlayerPrefs.SetInt($"{playerName}_CurrentMp", charStats.currentMp);
PlayerPrefs.SetInt($"{playerName}_MaxLevel", charStats.maxLevel);
PlayerPrefs.SetInt($"{playerName}_MaxHp", charStats.maxHp);
PlayerPrefs.SetInt($"{playerName}_MaxMp", charStats.maxMp);
PlayerPrefs.SetInt($"{playerName}_Strength", charStats.strength);
PlayerPrefs.SetInt($"{playerName}_Defense", charStats.defense);
PlayerPrefs.SetInt($"{playerName}_WeaponPower", charStats.weaponPower);
PlayerPrefs.SetInt($"{playerName}_ArmorPower", charStats.armorPower);
PlayerPrefs.SetString($"{playerName}_EquippedWeapon", charStats.equippedWeapon);
PlayerPrefs.SetString($"{playerName}_EquippedArmor", charStats.equippedArmor);
}
public Character(CharAttacks attacks, CharBio bio, CharInv inv, CharStats stats)
{
this.attacks = attacks;
this.bio = bio;
this.inv = inv;
this.stats = stats;
}
public override string Use(BasicChar user)
{
CharStats fert = user.PregnancySystem.Fertility;
fert.BaseValue -= 1;
return($" {fert.Value}");
}
// Update is called once per frame
void Start()
{
RandomizeRace();
continueTimer = false;
type = this.gameObject.GetComponent <CharStats>();
if (type.LiarChance() == false)
{
itemLookingFor = GameObject.FindGameObjectWithTag("Weapons");
//create a type of person based on the weapon.)
}
drinkGiven = false;
centerTrigger = GameObject.Find("CenterTrigger").gameObject;
exitTrigger = GameObject.Find("ExitTrigger").gameObject;
lostAndFoundAnswer = false;
/*
* If player wants lost and found item behind counter, show text bubble asking for it.
* Wait for answer
*/
speech = GetComponent <SpeechBubble>();
poisioned = false;
}
public override string Use(BasicChar user)
{
CharStats fert = user.PregnancySystem.Fertility;
fert.AddTempMod(contraMod);
return($" {fert.Value}");
}
//public virtual hostUser Logon { get; set; }
public virtual void RefreshCharacterStats(ISession sess)
{
bool bContains;
//create default stats
IList <sysBaseStatistic> allstats = sess.CreateCriteria(typeof(sysBaseStatistic))
.List <sysBaseStatistic>();
foreach (sysBaseStatistic s in allstats)
{
bContains = false;
foreach (hostCharStat c in this.CharStats)
{
if (c.stat == s)
{
bContains = true;
break;
}
}
if (!bContains)
{
hostCharStat sv = new hostCharStat(s, this, s.defvalue);
CharStats.Add(sv);
}
else
{
Debug.Print("Character:" + this.LongName + " has a stat for:" + s.LongName);
}
}
}
public void OnUserSelected(int pos)
{
CharStats selectedUser = GameManager.Instance.GetCharacterAt(pos);
ItemManager.Instance.UseItem(display.CurrentPossessor, display.SelectedPos, selectedUser);
display.DisplayAll();
// Decrease number of remaining items
numOfRemaining--;
// If there aren't any remaining items
if (numOfRemaining == 0)
{
Cancel();
gameObject.SetActive(false);
return;
}
// Else
UpdateRemaining();
if (isHPMP)
{
HPMP temp = GetHPMP(changingAttr, selectedUser);
userButtons[pos].DisplayStat(temp.current, temp.max);
}
else
{
userButtons[pos].DisplayStat(GetStat(changingAttr, selectedUser));
}
}
private void OnPlayerCreation(object sender, EventPlayerCreationArgs e)
{
tmpAddedPoint = new CharStats(0);
target = e.player.GetComponent <StatsManager>();
targetArmor = e.player.GetComponent <ArmorManager>();
target.OnLevelUp += OnStatsChanged;
if (strengthLabel != null)
{
strengthLabel.Initialize(OnButtonPressed, target.UnspentPoints != 0);
}
if (defenseLabel != null)
{
defenseLabel.Initialize(OnButtonPressed, target.UnspentPoints != 0);
}
if (staminaLabel != null)
{
staminaLabel.Initialize(OnButtonPressed, target.UnspentPoints != 0);
}
if (energyLabel != null)
{
energyLabel.Initialize(OnButtonPressed, target.UnspentPoints != 0);
}
tmpAddedPoint.OnStatsChange += OnStatsChanged;
target.Stats.OnStatsChange += OnStatsChanged;
OnStatsChanged(this, new EventArgs());
}
// Update is called once per frame
void Update()
{
float distance = Vector3.Distance(target.position, transform.position);
if (distance <= lookRadius)
{
// Debug.Log("Player in Range");
agent.SetDestination(target.position);
}
if (distance <= agent.stoppingDistance)
{
CharStats targetStats = target.GetComponent <CharStats>();
FaceTarget();
if (targetStats != null)
{
animate.SetBool("IsAttacking", true);
combat.Attack(targetStats);
}
else
{
animate.SetBool("IsAttacking", false);
}
}
else
{
animate.SetBool("IsAttacking", false);
}
}
private void SpawnPlayers()
{
for (int i = 0; i < playerPositions.Length; i++)
{
// Only put them in if they are active.
if (GameManager.instance.playerStats[i].gameObject.activeInHierarchy)
{
for (int j = 0; j < playerPrefabs.Length; j++)
{
if (playerPrefabs[j].charName == GameManager.instance.playerStats[i].charName)
{
BattleChar newPlayer = Instantiate(
playerPrefabs[j],
playerPositions[i].position,
playerPositions[i].rotation);
// Creates reference to the position of the instantiated player.
newPlayer.transform.parent = playerPositions[i];
activeBattlers.Add(newPlayer);
// Set all the stats on the prefabs
CharStats thePlayer = GameManager.instance.playerStats[i];
activeBattlers[i].currentHP = thePlayer.currentHP;
activeBattlers[i].maxHP = thePlayer.maxHP;
activeBattlers[i].currentMP = thePlayer.currentMP;
activeBattlers[i].maxMP = thePlayer.maxMP;
activeBattlers[i].strength = thePlayer.strength;
activeBattlers[i].defence = thePlayer.defence;
activeBattlers[i].weaponPower = thePlayer.weaponPower;
activeBattlers[i].armorPower = thePlayer.armorPower;
}
}
}
}
}
public override string Use(BasicChar user)
{
CharStats viri = user.PregnancySystem.Virility;
viri.AddTempMod(contraMod);
return($" {viri.Value}");
}
public static CharStats GetPossessor(ItemPossessor possessor)
{
int converted = GetCharPos(possessor);
switch (converted)
{
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
CharStats temp = GameManager.Instance.PlayerStats[converted];
if (temp.gameObject.activeInHierarchy)
{
return(temp);
}
else
{
return(null);
}
default:
return(null);
}
}
//función que hace que el item se equipe en la letra K o L
public void Use(int btnNum)
{
CharStats playerStat = GameManager.instance.playerStats;
string itemProv;
//boton K
if (btnNum == 0)
{
if (playerStat.itemL == itemName)
{
itemProv = playerStat.itemL;
playerStat.itemL = playerStat.itemK;
playerStat.itemK = itemProv;
}
else
{
playerStat.itemK = itemName;
}
}
//boton L
if (btnNum == 1)
{
if (playerStat.itemK == itemName)
{
itemProv = playerStat.itemK;
playerStat.itemK = playerStat.itemL;
playerStat.itemL = itemProv;
}
else
{
playerStat.itemL = itemName;
}
}
}
public void TryScalePStats(CharStats stats)
{
if (this.Data.Stat.Equals(EPrimaryStat.Agility))
{
stats.ScaleStat(EPrimaryStat.Agility, this);
}
else if (this.Data.Stat.Equals(EPrimaryStat.Constitution))
{
stats.ScaleStat(EPrimaryStat.Constitution, this);
}
else if (this.Data.Stat.Equals(EPrimaryStat.Intelligence))
{
stats.ScaleStat(EPrimaryStat.Intelligence, this);
}
else if (this.Data.Stat.Equals(EPrimaryStat.Might))
{
stats.ScaleStat(EPrimaryStat.Might, this);
}
else if (this.Data.Stat.Equals(EPrimaryStat.Perception))
{
stats.ScaleStat(EPrimaryStat.Perception, this);
}
else if (this.Data.Stat.Equals(EPrimaryStat.Resolve))
{
stats.ScaleStat(EPrimaryStat.Resolve, this);
}
}
public override string Use(BasicChar user)
{
CharStats viri = user.PregnancySystem.Virility;
viri.BaseValue -= 1;
return($" {viri.Value}");
}
public void BattleStart(string[] enemiesToSpawn, bool setCannotFlee)
{
if (!battleActive)
{
cannotFlee = setCannotFlee;
battleActive = true;
GameManager.instance.battleActive = true;
transform.position = new Vector3(Camera.main.transform.position.x, Camera.main.transform.position.y, transform.position.z);
battleScene.SetActive(true);
AudioManager.instance.PlayBGM(0);
for (int i = 0; i < playerPositions.Length; i++)
{
if (GameManager.instance.playerStats[i].gameObject.activeInHierarchy)
{
for (int j = 0; j < playerPrefabs.Length; j++)
{
if (playerPrefabs[j].charName == GameManager.instance.playerStats[i].charName)
{
BattleChar newPlayer = Instantiate(playerPrefabs[j], playerPositions[i].position, playerPositions[i].rotation);
newPlayer.transform.parent = playerPositions[i];
activeBattlers.Add(newPlayer);
CharStats thePlayer = GameManager.instance.playerStats[i];
activeBattlers[i].currentHP = thePlayer.currentHP;
activeBattlers[i].maxHP = thePlayer.maxHP;
activeBattlers[i].currentMP = thePlayer.currentMP;
activeBattlers[i].maxMP = thePlayer.maxMP;
activeBattlers[i].strength = thePlayer.strenght;
activeBattlers[i].defence = thePlayer.defence;
activeBattlers[i].wpnPower = thePlayer.wpnPwr;
activeBattlers[i].armrPower = thePlayer.armrPwr;
}
}
}
}
for (int i = 0; i < enemiesToSpawn.Length; i++)
{
if (enemiesToSpawn[i] != "")
{
for (int j = 0; j < enemyPrefabs.Length; j++)
{
if (enemyPrefabs[j].charName == enemiesToSpawn[i])
{
BattleChar newEnemy = Instantiate(enemyPrefabs[j], enemyPositions[i].position, enemyPositions[i].rotation);
newEnemy.transform.parent = enemyPositions[i];
activeBattlers.Add(newEnemy);
}
}
}
}
turnWaiting = true;
curretTurn = Random.Range(0, activeBattlers.Count);
UpdateUIStats();
}
}
public static string GetPossessorName(ItemPossessor possessor)
{
int converted = GetCharPos(possessor);
switch (converted)
{
case BAG:
return(bagPossessor);
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
CharStats temp = GameManager.Instance.PlayerStats[converted];
if (temp.gameObject.activeInHierarchy)
{
return(temp.CharacterName);
}
else
{
return("");
}
default:
return("");
}
}
public override object Read(ES2Reader reader)
{
CharStats data = GetOrCreate <CharStats>();
Read(reader, data);
return(data);
}
public void Use(int characterToUseOn)
{
CharStats selectedCharacter = GameManager.Instance().playerStats[characterToUseOn];
if (isItem)
{
if (affectsHp)
{
selectedCharacter.currentHp += amountToChange;
if (selectedCharacter.currentHp > selectedCharacter.maxHp)
{
selectedCharacter.currentHp = selectedCharacter.maxHp;
}
}
if (affectsMp)
{
selectedCharacter.currentMp += amountToChange;
if (selectedCharacter.currentMp > selectedCharacter.maxMp)
{
selectedCharacter.currentMp = selectedCharacter.maxMp;
}
}
if (affectsStrength)
{
selectedCharacter.strength += amountToChange;
}
if (affectsDefense)
{
selectedCharacter.defense += amountToChange;
}
}
if (isWeapon)
{
if (selectedCharacter.equippedWeaponName != "")
{
GameManager.Instance().AddItem(selectedCharacter.equippedWeaponName);
}
selectedCharacter.equippedWeaponName = itemName;
selectedCharacter.weaponPower = weaponPower;
}
if (isArmor)
{
if (selectedCharacter.equippedArmor != "")
{
GameManager.Instance().AddItem(selectedCharacter.equippedArmor);
}
selectedCharacter.equippedArmor = itemName;
selectedCharacter.armorPower = armorPower;
}
GameManager.Instance().RemoveItem(itemName);
}
public Buff(bool percent, int duration, AttributeStats attributes, CharStats charStats, CombatStats combatStats)
{
this.percent = percent;
this.duration = duration;
this.attributes = attributes;
this.charStats = charStats;
this.combatStats = combatStats;
}
public void Attack(CharStats target)
{
if (atkCoolDown <= 0)
{
target.TakeDamage(statsSelf);
atkCoolDown = 100f / statsSelf.atkSpeed.GetValue();
}
}
public void Use(int charToUseOn)
{
CharStats selectedChar = GameManager.instance.playerStats[charToUseOn];
if (isItem)
{
if (affectHP)
{
selectedChar.currentHP += amountToChange;
if (selectedChar.currentHP > selectedChar.maxHP)
{
selectedChar.currentHP = selectedChar.maxHP;
}
}
if (affectMP)
{
selectedChar.currentMP += amountToChange;
if (selectedChar.currentMP > selectedChar.maximumMP)
{
selectedChar.currentMP = selectedChar.maximumMP;
}
}
if (affectStr)
{
selectedChar.strength += amountToChange;
}
}
if (isWeapon)
{
if (selectedChar.equippedWpn != "")
{
GameManager.instance.AddItem(selectedChar.equippedWpn);
}
selectedChar.equippedWpn = itemName;
selectedChar.wpnPower = weaponStrength;
}
if (isArmor)
{
if (selectedChar.equippedArmor != "")
{
GameManager.instance.AddItem(selectedChar.equippedArmor);
}
selectedChar.equippedArmor = itemName;
selectedChar.armorPower = armorStrength;
}
//Debug.Log("item to be passed " + itemName);
GameManager.instance.RemoveItem(itemName);
}
IEnumerator DoDamage(CharStats stats, float delay)
{
yield return(new WaitForSeconds(delay));
stats.TakeDamage(myStats.damage.GetValue());
//SFXPlaying.instance.PlaySound (SFXPlaying.instance.Attack);
AudioManager.instance.PlaySound("EnemySound", transform.position);
}
// get the rewards for winning then move to the next scene
// increment the week
// if it's the final week and they pass, display an end scene
public void GetWinRewards()
{
EventController controller = GameObject.Find("EventController").GetComponent <EventController>();
Wave wave = controller.weekData.weeks.Find(x => x.weekNum == controller.weekNum).waves[controller.waveNum];
foreach (Character player in controller.players)
{
player.exp += wave.exp;
player.LevelUp();
}
int money = wave.coins;
UpdateProgress(money);
List <CharStats> statsList = new List <CharStats>();
//Update the player's level
foreach (Character player in controller.players)
{
CharStats stats = new CharStats();
stats.level = player.level;
stats.exp = player.exp;
stats.id = player.id;
statsList.Add(stats);
}
ProgressTracker.GetTracker().charStats = statsList;
if (controller.waveNum != controller.weekData.weeks.Find(x => x.weekNum == controller.weekNum).waves.Count - 1)
{
controller.ClearSpawners();
controller.waveNum++;
controller.StartWave();
Object.Destroy(gameObject);
}
else
{
// see if we need to progress to next week
var tracker = ProgressTracker.GetTracker();
if (tracker.CurCombatType == SceneTypeEnum.WEEKLY_COMBAT)
{
int curWeek = tracker.WeekNum;
if (curWeek == ProgressTracker.finalWeekNum)
{
SceneLoader.LoadEndScene();
return;
}
else
{
tracker.NextWeek();
}
}
SceneLoader.LoadHomeScene();
}
}
//-------------------------------------------------------------------------
public void CloneCharStats(CharStats srcStats, CharStats destStats)
{
if (srcStats.CruelDiff)
destStats.CruelDiff = true;
else if (srcStats.MercilessDiff)
destStats.MercilessDiff = true;
else
destStats.NormalDiff = true;
if (srcStats.BanditsAllResistReward)
destStats.BanditsAllResistReward = true;
else if (srcStats.BanditsLifeReward)
destStats.BanditsLifeReward = true;
else if (srcStats.BanditsManaReward)
destStats.BanditsManaReward = true;
else
destStats.NormalBanditsKillAll = true;
if (srcStats.BanditsASReward)
destStats.BanditsASReward = true;
else if (srcStats.BanditsCSReward)
destStats.BanditsCSReward = true;
else if (srcStats.BanditsPDReward)
destStats.BanditsPDReward = true;
else
destStats.CruelBanditsKillAll = true;
if (srcStats.BanditsFCReward)
destStats.BanditsFCReward = true;
else if (srcStats.BanditsPCReward)
destStats.BanditsPCReward = true;
else if (srcStats.BanditsECReward)
destStats.BanditsECReward = true;
else
destStats.MercilessBanditsKillAll = true;
destStats.ActiveSkillGem = srcStats.ActiveSkillGem;
destStats.SupportGems = srcStats.SupportGems;
destStats.CurrentEndurance = srcStats.CurrentEndurance;
destStats.CurrentFrenzy = srcStats.CurrentFrenzy;
destStats.CurrentPower = srcStats.CurrentPower;
destStats.AngerLvl = srcStats.AngerLvl;
destStats.HatredLvl = srcStats.HatredLvl;
destStats.WrathLvl = srcStats.WrathLvl;
destStats.VitalityLvl = srcStats.VitalityLvl;
destStats.HasteLvl = srcStats.HasteLvl;
destStats.DisciplineLvl = srcStats.DisciplineLvl;
destStats.DeterminationLvl = srcStats.DeterminationLvl;
destStats.GraceLvl = srcStats.GraceLvl;
destStats.ClarityLvl = srcStats.ClarityLvl;
destStats.PurityofElementsLvl = srcStats.PurityofElementsLvl;
destStats.PurityofFireLvl = srcStats.PurityofFireLvl;
destStats.PurityofIceLvl = srcStats.PurityofIceLvl;
destStats.PurityofLightningLvl = srcStats.PurityofLightningLvl;
UpdateStatComparer();
}
public CharStats(CharStats cs)
{
FieldInfo[] fields1 = GetType().GetFields();
FieldInfo[] fields2 = cs.GetType().GetFields();
for (int i = 0; i < fields1.Length; i++)
{
fields1[i].SetValue(this, (float)fields2[i].GetValue(cs));
}
}
public void Use(int character, bool isInBattle)
{
CharStats selectedChar = GameManager.instance.playersStats[character];
if (isInBattle)
{
selectedChar.currentHp = BattleManager.instance.activeBattlers[character].currentHp;
selectedChar.currentMp = BattleManager.instance.activeBattlers[character].currentMp;
}
if (isItem)
{
if (affectHp)
{
selectedChar.currentHp += amountToChange;
if (selectedChar.currentHp > selectedChar.maxHp)
{
selectedChar.currentHp = selectedChar.maxHp;
}
}
if (affectMp)
{
selectedChar.currentMp += amountToChange;
if (selectedChar.currentMp > selectedChar.maxMp)
{
selectedChar.currentMp = selectedChar.maxMp;
}
}
if (affectStrength)
{
selectedChar.strength += amountToChange;
}
}
if (isWeapon)
{
if (selectedChar.equippedWeapon != "")
{
GameManager.instance.AddItem(selectedChar.equippedWeapon);
}
selectedChar.equippedWeapon = itemName;
selectedChar.weaponPower = weaponStrength;
}
if (isArmor)
{
if (selectedChar.equippedArmor != "")
{
GameManager.instance.AddItem(selectedChar.equippedArmor);
}
selectedChar.equippedArmor = itemName;
selectedChar.armorPower = armorStrength;
}
GameManager.instance.RemoveItem(itemName);
if (isInBattle)
{
BattleManager.instance.UpdateStats(BattleManager.instance.activeBattlers[character], selectedChar);
BattleManager.instance.UpdateUIStats();
}
}
public override void Invoke(CharStats stats)
{
stats.CurrentMP += changeAmount;
if (stats.CurrentMP > stats.MaxMP)
{
stats.CurrentMP = stats.MaxMP;
}
}
//--------------------------Constructor-----------------------------
public StatsWindow(SkillTree tree, CharItemData itemAttributes)
{
InitializeComponent();
this.Tree = tree;
ItemAttributes = itemAttributes;
requiredStats = new CharStats.VIPStats(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
characterStats = new CharStats(Tree);
statsComparer = new StatsComparer(Tree);
changeStatsGroupBox.DataContext = statsComparer;
UpdateStatComparer();
InitListViews();
intitializationFinished = true;
buildRecords = new Dictionary<HashSet<ushort>, CharStats.VIPStats>();
}
public Enemy(CharAttacks attacks, CharBio bio, CharInv inv, CharStats stats)
: base(attacks, bio, inv, stats)
{
}
public PlayerCharacter(CharAttacks attacks, CharBio bio, CharInv inv, CharStats stats, Equipment equipment)
: base(attacks, bio, inv, stats)
{
this.equipment = equipment;
}
