public static void Register()
{
Suite suite = new Suite();
suite.Name = "monster/attack";
suite.SetSetup(delegate() {
Monster.Monster_Race r = UnitTest_Data.R_Human();
m = new Monster.Monster();
m.Race = r;
m.r_idx = (short)r.ridx;
Misc.r_info = new Monster.Monster_Race[] { r };
Player.Player.instance = null;
Random.fix(100);
});
suite.NoTeardown();
suite.AddTest("blows", test_blows);
suite.AddTest("effects", test_effects);
UnitTest_Main.AddSuite(suite);
}
//===================================================================================================================================================================================
// Skriver ut information och Stats efter att ett monster blivit besegrat.
//===================================================================================================================================================================================
public static void DefetedMonsterGains(Monster.Monster monster)
{
if (monster.Hp <= 0)
{
Console.Write($"You defeted the ");
Tools.MagnetaTextWr($"{monster.Name}\n");
Tools.MagnetaTextW($"\n{monster.Name} ");
Console.Write("dropped ");
Tools.YellowTextWr($"{monster.GoldDrop} Gold");
playerOne.Gold += monster.GoldDrop;
Console.Write($"Your gold ammount is: ");
Tools.YellowTextWr($"{playerOne.Gold}\n");
playerOne.Exp += monster.Exp;
Console.WriteLine($"You gained {monster.Exp} exp.");
Console.WriteLine($"Exp: {playerOne.Exp} / {playerOne.ExpLevelUp} to next level.");
if (playerOne.Exp == playerOne.ExpLevelUp)
{
playerOne.Exp = default;
playerOne.Level += 1;
monster.Level = playerOne.Level;
playerOne.ExpLevelUp += 100;
Console.WriteLine($"\nNice! You are level {playerOne.Level} now.");
LevelTen(); // När level 10 är uppnåt måste användaren skriva in ett lösenord för att kunna fortsätta
}
Console.ReadLine();
}
}
/**
* Extract the multiplier from a given object hitting a given monster.
*
* \param o_ptr is the object being used to attack
* \param m_ptr is the monster being attacked
* \param best_s_ptr is the best applicable slay_table entry, or null if no
* slay already known
* \param real is whether this is a real attack (where we update lore) or a
* simulation (where we don't)
* \param known_only is whether we are using all the object flags, or only
* the ones we *already* know about
*/
//Best_s_ptr was slay**
public static void improve_attack_modifier(Object o_ptr, Monster.Monster m_ptr,
ref Slay best_s_ptr, bool real, bool known_only)
{
Monster_Race r_ptr = Misc.r_info[m_ptr.r_idx];
Monster_Lore l_ptr = Misc.l_list[m_ptr.r_idx];
Bitflag f = new Bitflag(Object_Flag.SIZE);
Bitflag known_f = new Bitflag(Object_Flag.SIZE);
Bitflag note_f = new Bitflag(Object_Flag.SIZE);
int i;
o_ptr.object_flags(ref f);
o_ptr.object_flags_known(ref known_f);
for (i = 0; i < Slay.MAX.value; i++)
{
Slay s_ptr = list[i];
if ((known_only && !known_f.has(s_ptr.object_flag.value)) || (!known_only && !f.has(s_ptr.object_flag.value)))
{
continue;
}
/* In a real attack, learn about monster resistance or slay match if:
* EITHER the slay flag on the object is known,
* OR the monster is vulnerable to the slay/brand
*/
if (real && (known_f.has(s_ptr.object_flag.value) || (s_ptr.monster_flag != Monster_Flag.NONE &&
r_ptr.flags.has(s_ptr.monster_flag.value)) ||
(s_ptr.resist_flag != Monster_Flag.NONE && !r_ptr.flags.has(s_ptr.resist_flag.value))))
{
/* notice any brand or slay that would affect monster */
note_f.wipe();
note_f.on(s_ptr.object_flag.value);
object_notice_slays(o_ptr, note_f);
if (m_ptr.ml && s_ptr.monster_flag != Monster_Flag.NONE)
{
l_ptr.flags.on(s_ptr.monster_flag.value);
}
if (m_ptr.ml && s_ptr.resist_flag != Monster_Flag.NONE)
{
l_ptr.flags.on(s_ptr.resist_flag.value);
}
}
/* If the monster doesn't resist or the slay flag matches */
if ((s_ptr.brand != null && s_ptr.brand.Length != 0 &&
!r_ptr.flags.has(s_ptr.resist_flag.value)) ||
(s_ptr.monster_flag != Monster_Flag.NONE &&
r_ptr.flags.has(s_ptr.monster_flag.value)))
{
/* compare multipliers to determine best attack */
if ((best_s_ptr == null) || ((best_s_ptr).mult < s_ptr.mult))
{
best_s_ptr = s_ptr;
}
}
}
}
//===================================================================================================================================================================================
// Beroende på vilken level monster är på ändras monstrets randomDmg max skada, random guld droppas av monstret
//===================================================================================================================================================================================
public static void MonsterRandomDmgAndGoldDrop(Monster.Monster monster)
{
int randomMonsterDmg;
if (monster.Level == 1)
{
randomMonsterDmg = rand.Next(1, 10);
monster.AtkDmg = randomMonsterDmg;
}
else if (monster.Level == 2)
{
randomMonsterDmg = rand.Next(1, 20);
monster.AtkDmg = randomMonsterDmg;
}
else if (monster.Level == 3)
{
randomMonsterDmg = rand.Next(1, 30);
monster.AtkDmg = randomMonsterDmg;
}
else if (monster.Level == 4)
{
randomMonsterDmg = rand.Next(1, 40);
monster.AtkDmg = randomMonsterDmg;
}
else if (monster.Level == 5)
{
randomMonsterDmg = rand.Next(1, 50);
monster.AtkDmg = randomMonsterDmg;
}
else if (monster.Level == 6)
{
randomMonsterDmg = rand.Next(1, 60);
monster.AtkDmg = randomMonsterDmg;
}
else if (monster.Level == 7)
{
randomMonsterDmg = rand.Next(1, 70);
monster.AtkDmg = randomMonsterDmg;
}
else if (monster.Level == 8)
{
randomMonsterDmg = rand.Next(1, 80);
monster.AtkDmg = randomMonsterDmg;
}
else if (monster.Level == 9)
{
randomMonsterDmg = rand.Next(1, 90);
monster.AtkDmg = randomMonsterDmg;
}
else if (monster.Level == 10)
{
randomMonsterDmg = rand.Next(1, 100);
monster.AtkDmg = randomMonsterDmg;
}
int randomMonsterGoldDrop = rand.Next(0, 100);
monster.GoldDrop = randomMonsterGoldDrop;
}
/// <summary>
/// Moster can interact with the Hotel based by it's type
/// </summary>
/// <param name="monster"></param>
public void Interact(Monster.Monster monster)
{
if (monster is Godzilla)
{
DestroyLocationTypes();
InitialiseHotelDimension();
}
}
public override void Move(Monster.Monster monster)
{
var coordinates = gameManager.GetCoordinates();
monster.Position++;
var coordinatesByPosition = coordinates.FirstOrDefault(x => x.CoordinateIndex == monster.Position);
monster.XCoordinate = coordinatesByPosition != null ? coordinatesByPosition.XCoordinate : 0;
monster.YCoordinate = coordinatesByPosition != null ? coordinatesByPosition.YCoordinate : 0;
}
//===================================================================================================================================================================================
// En metod som tar in metoder som styr battle systemet
//===================================================================================================================================================================================
public static void NewBattle(Monster.Monster monster)
{
Tools.DarkYellowTextWr("=========================================================================");
PlayerBattleDmg(monster); // Skriver ut vilket monster som attackeras och hur mycket Dmg player slår
MonsterBattleHp(monster); // Skriver ut hur mycket Hp monstret har efter den blivit skadad
Tools.DarkYellowTextWr("=========================================================================\n\n");
Tools.DarkYellowTextWr("=========================================================================");
MonsterBattleDmg(monster); // Skriver ut vilket monster som attackerar och hur mycket Dmg monstret slår
PlayerBattleHp(); // Skriver ut hur mycket Hp player har efter den blivit skadad
Tools.DarkYellowTextWr("=========================================================================\n");
BattleHitWonLose(monster); // Beroende på player och monsters Hp skrivs något av dessa if statments ut
}
static int take1(Player.Player p, Monster.Monster m, RBM blow, RBE eff)
{
int oldv, newv;
m.Race.blow[0].effect = eff;
m.Race.blow[0].method = blow;
p.chp = p.mhp;
oldv = p.chp;
m.make_attack_normal(p);
newv = p.chp;
p.chp = p.mhp;
return(oldv - newv);
}
//===================================================================================================================================================================================
// Skriver ut vilket monster som attackeras och hur mycket Dmg player slår
//===================================================================================================================================================================================
private static void PlayerBattleDmg(Monster.Monster monster)
{
Console.Write($"You attack the ");
Tools.MagnetaTextW($"{monster.Name} ");
Console.Write("with your ");
Tools.MagnetaTextW($"{playerOne.WeponName} ");
Console.Write("and deal ");
Tools.BlueTextW($"{playerOne.Dmg} ");
Console.Write("(");
Tools.BlueTextW($"+{playerOne.Strenght}");
Console.WriteLine(") damage.");
monster.Hp = monster.Hp - playerOne.Dmg - playerOne.Strenght;
}
public void AddDeadMonster(Monster.Monster monster)
{
notNullReference.Check(monster, "monster");
if (monster.EntityRole() == EntityRole.Environment)
{
return;
}
deadMonstersSoFarIncludingOnesSpawnedByOthers.Add(monster);
if (monster.SpawnSource().Source == SpawnSource.Dungeon_System)
{
deadMonstersSoFar.Add(monster);
}
}
private static void AttackMonster(Monster.Monster monster)
{
int randomPlayerDmg = rand.Next(1, 50);
Player.Player.player.PlayerDmg = randomPlayerDmg;
int randomMonsterDmg = rand.Next(1, 25);
monster.MonsterAtkDmg = randomMonsterDmg;
Console.WriteLine($"You attack the {monster.MonsterName} with your {Player.Player.player.PlayerWepon} and deal {Player.Player.player.PlayerDmg} damage.");
monster.MonsterHp = monster.MonsterHp - Player.Player.player.PlayerDmg;
Console.WriteLine($"The {monster.MonsterName} life is {monster.MonsterHp} / {monster.MonsterMaxHp}.\n");
Console.WriteLine($"The {monster.MonsterName} attack you with {monster.MonsterAtkName} and deal {monster.MonsterAtkDmg}.");
Player.Player.player.PlayerHp = Player.Player.player.PlayerHp - monster.MonsterAtkDmg;
Console.WriteLine($"Your life is {Player.Player.player.PlayerHp} / 100 ");
Console.ReadLine();
}
//===================================================================================================================================================================================
// Skriver ut hur mycket Hp monstret har efter den blivit skadad
//===================================================================================================================================================================================
private static void MonsterBattleHp(Monster.Monster monster)
{
if (monster.Hp > 0)
{
Console.Write($"The {monster.Name} life is ");
Tools.RedTextW($"{monster.Hp} ");
Console.Write("/");
Tools.GreenTextWr($" {monster.MaxHp}.");
}
else if (monster.Hp <= 0)
{
Console.Write($"The {monster.Name} life is ");
Tools.RedTextW($"0 ");
Console.Write("/");
Tools.GreenTextWr($" {monster.MaxHp}.");
}
}
/// <inheritdoc />
public override void AddExp(double exp, Monster.Monster monster = null)
{
string msg = monster == null
? $"You just earned +{Coloring.Exp(exp)} experience!"
: $"The {Coloring.Name(monster.Name)} gave you +{Coloring.Exp(exp)}!";
History.Add(LogType.Info, msg);
Adventure?.LogEntries.Enqueue(new LogEntry(LogType.Info, msg));
Exp += exp;
while (Exp >= XpToLevelUp)
{
CurrentLevel += 1;
LevelShifts.Add(_currentShift.Height);
LevelUp();
}
}
//===================================================================================================================================================================================
// Beroende på player och monsters Hp skrivs något av dessa if statments ut
//===================================================================================================================================================================================
private static void BattleHitWonLose(Monster.Monster monster)
{
if (monster.Hp > 0 && playerOne.Hp > 0)
{
Console.Write("Press ENTER to hit again! HIT: ");
}
else if (monster.Hp <= 0 && playerOne.Hp > 0)
{
Tools.GreenTextWr("You Won The Battle!");
}
else if (playerOne.Hp <= 0)
{
Tools.RedTextWr("YOU DIED");
Console.ReadLine();
Console.Clear();
Tools.Exit();
}
}
//===================================================================================================================================================================================
// Skriver ut vilket monster som attackerar och hur mycket Dmg monstret slår
//===================================================================================================================================================================================
private static void MonsterBattleDmg(Monster.Monster monster)
{
if (monster.Hp > 0)
{
Console.Write($"The ");
Tools.MagnetaTextW($"{monster.Name} ");
Console.Write("attack you with ");
Tools.MagnetaTextW($"{monster.AtkName} ");
Console.Write("and deal ");
Tools.BlueTextW($"{monster.AtkDmg} ");
Console.WriteLine("damage.");
playerOne.Hp -= monster.AtkDmg;
}
else if (monster.Hp <= 0)
{
Console.Write($"The ");
Tools.MagnetaTextW($"{monster.Name} ");
Console.Write("died before it could hit you. ");
}
}
public bool AreAllBeatableMonstersFromCurrentStageDead()
{
int numberOfSpawnMonsterThatIsDead = 0;
for (int spawnMonsterIndex = 0; spawnMonsterIndex < spawnedMonstersThatAreNotEnvironmentRole.Count; spawnMonsterIndex++)
{
long spawnMonsterUniqueId = spawnedMonstersThatAreNotEnvironmentRole[spawnMonsterIndex];
for (int deadMonsterIndex = 0; deadMonsterIndex < deadMonstersSoFarIncludingOnesSpawnedByOthers.Count; deadMonsterIndex++)
{
Monster.Monster deadMonster = deadMonstersSoFarIncludingOnesSpawnedByOthers[deadMonsterIndex];
if (spawnMonsterUniqueId == deadMonster.UniqueId())
{
numberOfSpawnMonsterThatIsDead += 1;
}
}
}
return(numberOfSpawnMonsterThatIsDead >= spawnedMonstersThatAreNotEnvironmentRole.Count);
}
/// <inheritdoc />
public override void AddExp(double exp, Monster.Monster monster = null)
{
var activity = ActivityLog.Create(ActivityLog.ActivityType.Exp, ActivityLog.ActivityState.None, new int[] { (int)exp }, monster);
History.Add(LogType.Info, activity);
if (Adventure != null)
{
Adventure.Enqueue(AdventureLog.Info(this, null, activity));
Adventure.AdventureStats[AdventureStats.Experience] = Adventure.AdventureStats[AdventureStats.Experience] + exp;
}
Exp += exp;
while (Exp >= XpToLevelUp)
{
CurrentLevel += 1;
LevelShifts.Add(_currentShift.Height);
LevelUp();
}
}
//===================================================================================================================================================================================
// Styr hela flödet av battlesystemet
//===================================================================================================================================================================================
private static void PlayerVsMonster(Monster.Monster monster)
{
do
{
int randomPlayerDmg = random.Next(1, 60); // Sätter playerDmg till random
playerOne.Dmg = randomPlayerDmg;
Battle.MonsterRandomDmgAndGoldDrop(monster); // Beroende på vilken level monster är på ändras monstrets randomDmg max skada, random guld droppas av monstret
if (monster.Hp == 0)
{
break;
}
Battle.NewBattle(monster); // En metod som tar in metoder som styr battle systemet
Console.ReadLine();
Console.Clear();
} while (monster.Hp > 0);
Battle.DefetedMonsterGains(monster); // Skriver ut information och Stats efter att ett monster blivit besegrat.
}
public int Attack(Monster.Monster monster)
{
int damage;
if (EquippedWeapon.type == WeaponType.Sword)
{
damage = EquippedWeapon.StrengthModifier + (int)(Strength * 0.25);
}
else if (EquippedWeapon.type == WeaponType.Bow)
{
damage = EquippedWeapon.DexterityModifier + (int)(Dexterity * 0.25);
}
else if (EquippedWeapon.type == WeaponType.Staff)
{
damage = EquippedWeapon.IntelligenceModifier + (int)(Intelligence * 0.25);
}
else
{
damage = (int)(Strength * 0.25);
}
return(damage);
}
public static void Register()
{
Suite suite = new Suite();
suite.Name = "monster/attack";
suite.SetSetup(delegate() {
Monster.Monster_Race r = UnitTest_Data.R_Human();
m = new Monster.Monster();
m.Race = r;
m.r_idx = (short)r.ridx;
Misc.r_info = new Monster.Monster_Race[] {r};
Player.Player.instance = null;
Random.fix(100);
});
suite.NoTeardown();
suite.AddTest("blows", test_blows);
suite.AddTest("effects", test_effects);
UnitTest_Main.AddSuite(suite);
}
public Pitch GetPitch()
{
double margin = 0.0d;
for (int i = 0; i < FieldArray.Length; i++)
{
if (i == 0 || i == GameController.PITCH_X - 1)
{
if (i == 0)
{
Monster.Monster monster = new Monster.Monster(50, 100, playerOne);
monster.CurrentField = FieldArray[i];
monster.TargetField = FieldArray[i + 1];
playerOne.MonsterList.Add(monster);
FieldArray[i].Monster = monster;
FieldArray[i].AddChildren(monster);
}
else
{
Monster.Monster monster = new Monster.Monster(50, 100, playerTwo);
monster.CurrentField = FieldArray[i];
monster.TargetField = FieldArray[i - 1];
playerTwo.MonsterList.Add(monster);
FieldArray[i].Monster = monster;
FieldArray[i].AddChildren(monster);
}
};
Canvas.SetLeft(FieldArray[i], margin);
Children.Add(FieldArray[i]);
margin += 50.0d;
}
return this;
}
public void AddChildren(UIElement uiElement)
{
IsSet = true;
this.Monster = (Monster.Monster)uiElement;
base.Children.Add(uiElement);
}
/**
* Calculate the rating for a given slay combination
*/
int slay_power(bool verbose, StreamWriter log_file, bool known)
{
Bitflag s_index = new Bitflag(Object_Flag.SIZE);
Bitflag f = new Bitflag(Object_Flag.SIZE);
Bitflag f2 = new Bitflag(Object_Flag.SIZE);
int sv = 0; //uint
int i, j;
int mult;
Slay best_s_ptr = null;
Monster_Race r_ptr;
Monster.Monster m_ptr;
//monster_type monster_type_body;
string[] desc = new string[Slay.MAX.value];// = { 0 }, *
string[] brand = new string[Slay.MAX.value];// = { 0 };
int[] s_mult = new int[Slay.MAX.value];// = { 0 };
if (known)
object_flags(ref f);
else
object_flags_known(ref f);
/* Combine the slay bytes into an index value, return if there are none */
s_index.copy(f);
Object_Flag.create_mask(f2, false, Object_Flag.object_flag_type.SLAY,
Object_Flag.object_flag_type.KILL, Object_Flag.object_flag_type.BRAND);
if (!s_index.is_inter(f2))
return Eval.tot_mon_power;
else
s_index.inter(f2);
/* Look in the cache to see if we know this one yet */
sv = Slay.check_slay_cache(s_index);
/* If it's cached (or there are no slays), return the value */
if (sv != 0) {
//file_putf(log_file, "Slay cache hit\n");
return sv;
}
/*
* Otherwise we need to calculate the expected average multiplier
* for this combination (multiplied by the total number of
* monsters, which we'll divide out later).
*/
for (i = 0; i < Misc.z_info.r_max; i++) {
best_s_ptr = null;
mult = 1;
r_ptr = Misc.r_info[i];
if(r_ptr == null)
continue;
m_ptr = new Monster.Monster();
m_ptr.r_idx = (short)i;
/* Find the best multiplier against this monster */
Slay.improve_attack_modifier(this, m_ptr, ref best_s_ptr, false, !known);
if (best_s_ptr != null)
mult = best_s_ptr.mult;
/* Add the multiple to sv */
sv += (int)(mult * r_ptr.scaled_power);
}
/*
* To get the expected damage for this weapon, multiply the
* average damage from base dice by sv, and divide by the
* total number of monsters.
*/
if (verbose) {
/* Write info about the slay combination and multiplier */
//file_putf(log_file, "Slay multiplier for: ");
j = Slay.list_slays(s_index, s_index, desc, brand, s_mult, false);
//for (i = 0; i < j; i++) {
// if (brand[i]) {
// file_putf(log_file, brand[i]);
// } else {
// file_putf(log_file, desc[i]);
// }
// file_putf(log_file, "x%d ", s_mult[i]);
//}
//file_putf(log_file, "\nsv is: %d\n", sv);
//file_putf(log_file, " and t_m_p is: %d \n", tot_mon_power);
//file_putf(log_file, "times 1000 is: %d\n", (1000 * sv) / tot_mon_power);
}
/* Add to the cache */
if(Slay.fill_slay_cache(s_index, sv)) {
//file_putf(log_file, "Added to slay cache\n");
}
return sv;
}
static int mdam(Monster.Monster m)
{
return(m.Race.blow[0].d_dice);
}
public void Battle(Player player1, Monster.Monster Monster1)
{
bool ValidInput = false;
bool Flee = false;
bool monsterdead = false;
int damage = 0;
while (!Flee && (player1.HP > 0 && !monsterdead))
{
Console.WriteLine("New Round");
Console.WriteLine("Monster is dead: " + monsterdead);
while (!ValidInput)
{
Console.WriteLine(" Its your turn what do you want to do /n 1) Fight /n 2) Use Item /n 3)Flee");
string input = Console.ReadLine();
int choice;
if (int.TryParse(input, out choice))
{
if (choice == 1)
{
if (Monster1.type == "Goblin" && player1.EquippedWeapon.type == WeaponType.Staff)
{
if (player1.Intelligence - Monster1.dexterity < 0)
{
damage = (int)Math.Round((1.1 * player1.Attack()));
}
else
{
damage = (int)Math.Round((1.1 + (0.05 * (player1.Intelligence - Monster1.dexterity))) * player1.Attack());
}
}
else if (Monster1.type == "Orc" && player1.EquippedWeapon.type == WeaponType.Bow)
{
if (player1.Dexterity - Monster1.strength < 0)
{
damage = (int)Math.Round((1.1 * player1.Attack()));
}
else
{
damage = (int)Math.Round((1.1 + (0.05 * (player1.Dexterity - Monster1.strength))) * player1.Attack());
}
}
else if (Monster1.type == "Witch" && player1.EquippedWeapon.type == WeaponType.Sword)
{
if (player1.Strength - Monster1.intellect < 0)
{
damage = (int)Math.Round((1.1 * player1.Attack()));
}
else
{
damage = (int)Math.Round((1.1 + (0.05 * (player1.Strength - Monster1.intellect))) * player1.Attack());
}
}
else if (Monster1.type == "Goblin" && player1.EquippedWeapon.type == WeaponType.Sword)
{
if (player1.Strength - Monster1.dexterity < 0)
{
damage = (int)Math.Round((.9 * player1.Attack()));
}
else
{
damage = (int)Math.Round((.9 - (0.02 * (player1.Strength - Monster1.dexterity))) * player1.Attack());
}
}
else if (Monster1.type == "Orc" && player1.EquippedWeapon.type == WeaponType.Staff)
{
if (player1.Intelligence - Monster1.strength < 0)
{
damage = (int)Math.Round((.9 * player1.Attack()));
}
else
{
damage = (int)Math.Round((.9 - (0.02 * (player1.Strength - Monster1.dexterity))) * player1.Attack());
}
}
else if (Monster1.type == "Witch" && player1.EquippedWeapon.type == WeaponType.Bow)
{
if (player1.Dexterity - Monster1.intellect < 0)
{
damage = (int)Math.Round((.9 * player1.Attack()));
}
else
{
damage = (int)Math.Round((.9 - (0.02 * (player1.Intelligence - Monster1.strength))) * player1.Attack());
}
}
else if (Monster1.type == "Goblin" && player1.EquippedWeapon.type == WeaponType.Bow)
{
damage = (player1.Attack());
}
else if (Monster1.type == "Orc" && player1.EquippedWeapon.type == WeaponType.Sword)
{
damage = (player1.Attack());
}
else if (Monster1.type == "Witch" && player1.EquippedWeapon.type == WeaponType.Staff)
{
damage = (player1.Attack());
}
monsterdead = Monster1.takeDamage(damage);
Console.WriteLine("You swing and hit the " + Monster1.type + " for " + damage + " Damage. Remaining hp: " + Monster1.hp);
}
if (choice == 2)
{
Classes.Items.Type conType = (Classes.Items.Type)((player1.Level % 12) / 2 + (player1.Level % 12) % 2);
int grade = player1.Level / 12;
Item consume = new Consumable(grade, conType, "uncreative");
player1.UseConsumable(consume);
Console.WriteLine(conType + "+" + grade + " type consumable restored " + ((Consumable)consume).HealthRegen + " hp. Hp is now " + player1.HP);
}
if (choice == 3)
{
Random rand = new Random();
int FleeTry = rand.Next(0, 11);
Console.WriteLine(FleeTry);
if (Monster1.Level > player1.Level)
{
if (FleeTry > 6)
{
Flee = true;
}
}
if (Monster1.Level < player1.Level)
{
if (FleeTry > 3)
{
Flee = true;
}
}
if (Monster1.Level == player1.Level)
{
if (FleeTry > 4)
{
Flee = true;
}
}
Console.WriteLine(Flee);
}
ValidInput = true;
if (choice > 3)
{
ValidInput = false;
}
}
else
{
Console.WriteLine("That is not valid input");
}
}
if (!monsterdead)
{
if (Monster1.type == "Goblin" && player1.EquippedWeapon.type == WeaponType.Staff)
{
if (Monster1.dexterity - player1.Intelligence < 0)
{
damage = (int)Math.Round((1.1 * Monster1.damage));
}
else
{
damage = (int)Math.Round((1.1 + (0.05 * (Monster1.dexterity - player1.Intelligence) / 10)) * Monster1.damage);
}
}
else if (Monster1.type == "Orc" && player1.EquippedWeapon.type == WeaponType.Bow)
{
if (Monster1.strength - player1.Dexterity < 0)
{
damage = (int)Math.Round((1.1 * Monster1.damage));
}
else
{
damage = (int)Math.Round((1.1 + (0.05 * (Monster1.strength - player1.Dexterity) / 10)) * Monster1.damage);
}
}
else if (Monster1.type == "Witch" && player1.EquippedWeapon.type == WeaponType.Sword)
{
if (Monster1.intellect - player1.Strength < 0)
{
damage = (int)Math.Round((1.1 * Monster1.damage));
}
else
{
damage = (int)Math.Round((1.1 + (0.05 * (Monster1.intellect - player1.Strength))) * Monster1.damage);
}
}
else if (Monster1.type == "Goblin" && player1.EquippedWeapon.type == WeaponType.Sword)
{
if (Monster1.dexterity - player1.Strength < 0)
{
damage = (int)Math.Round((.9 * Monster1.damage));
}
else
{
damage = (int)Math.Round((.9 - (0.02 * (Monster1.dexterity - player1.Strength) / 10)) * Monster1.damage);
}
}
else if (Monster1.type == "Orc" && player1.EquippedWeapon.type == WeaponType.Staff)
{
if (player1.Intelligence - Monster1.strength < 0)
{
damage = (int)Math.Round((.9 * Monster1.damage));
}
else
{
damage = (int)Math.Round((.9 - (0.02 * (player1.Strength - Monster1.dexterity) / 10)) * Monster1.damage);
}
}
else if (Monster1.type == "Witch" && player1.EquippedWeapon.type == WeaponType.Bow)
{
if (player1.Dexterity - Monster1.intellect < 0)
{
damage = (int)Math.Round((.9 * Monster1.damage));
}
else
{
damage = (int)Math.Round((.9 - (0.02 * (player1.Intelligence - Monster1.strength) / 10)) * Monster1.damage);
}
}
else if (Monster1.type == "Goblin" && player1.EquippedWeapon.type == WeaponType.Bow)
{
damage = (Monster1.damage);
}
else if (Monster1.type == "Orc" && player1.EquippedWeapon.type == WeaponType.Sword)
{
damage = (Monster1.damage);
}
else if (Monster1.type == "Witch" && player1.EquippedWeapon.type == WeaponType.Staff)
{
damage = (Monster1.damage);
}
player1.HP -= damage;
Console.WriteLine("The " + Monster1.type + " Swings and hits you for " + damage + " Damage. Remaining hp: " + player1.HP);
Console.WriteLine();
}
ValidInput = false;
}
if (!Flee)
{
if (monsterdead)
{
player1.gainExperience(Monster1.experience);
Console.WriteLine("You have slain the enemy");
}
if (player1.HP <= 0)
{
Console.WriteLine("The monster Has killed you. Told you he died at the end!");
}
}
}
//===================================================================================================================================================================================
// Återställer full Hp för player och monster
//===================================================================================================================================================================================
public static void PlayerMOnsterFullHp(Monster.Monster monster)
{
playerOne.Hp = 100;
monster.Hp = monster.MaxHp;
}
public abstract void Move(Monster.Monster monster);
private static void PlayerMOnsterFUllHp(Monster.Monster monster)
{
Player.Player.player.PlayerHp = 100;
monster.MonsterHp = monster.MonsterMaxHp;
}
public void RemoveChild(UIElement uiElement)
{
IsSet = false;
this.Monster = null;
base.Children.Remove(uiElement);
}
private static void MonsterAppear(Monster.Monster monster)
{
Console.WriteLine($"Watch out! An ancient {monster.MonsterName} level {monster.MonsterLevel} is blocking your way\n");
}
/**
* Calculate the rating for a given slay combination
*/
int slay_power(bool verbose, StreamWriter log_file, bool known)
{
Bitflag s_index = new Bitflag(Object_Flag.SIZE);
Bitflag f = new Bitflag(Object_Flag.SIZE);
Bitflag f2 = new Bitflag(Object_Flag.SIZE);
int sv = 0; //uint
int i, j;
int mult;
Slay best_s_ptr = null;
Monster_Race r_ptr;
Monster.Monster m_ptr;
//monster_type monster_type_body;
string[] desc = new string[Slay.MAX.value]; // = { 0 }, *
string[] brand = new string[Slay.MAX.value]; // = { 0 };
int[] s_mult = new int[Slay.MAX.value]; // = { 0 };
if (known)
{
object_flags(ref f);
}
else
{
object_flags_known(ref f);
}
/* Combine the slay bytes into an index value, return if there are none */
s_index.copy(f);
Object_Flag.create_mask(f2, false, Object_Flag.object_flag_type.SLAY,
Object_Flag.object_flag_type.KILL, Object_Flag.object_flag_type.BRAND);
if (!s_index.is_inter(f2))
{
return(Eval.tot_mon_power);
}
else
{
s_index.inter(f2);
}
/* Look in the cache to see if we know this one yet */
sv = Slay.check_slay_cache(s_index);
/* If it's cached (or there are no slays), return the value */
if (sv != 0)
{
//file_putf(log_file, "Slay cache hit\n");
return(sv);
}
/*
* Otherwise we need to calculate the expected average multiplier
* for this combination (multiplied by the total number of
* monsters, which we'll divide out later).
*/
for (i = 0; i < Misc.z_info.r_max; i++)
{
best_s_ptr = null;
mult = 1;
r_ptr = Misc.r_info[i];
if (r_ptr == null)
{
continue;
}
m_ptr = new Monster.Monster();
m_ptr.r_idx = (short)i;
/* Find the best multiplier against this monster */
Slay.improve_attack_modifier(this, m_ptr, ref best_s_ptr, false, !known);
if (best_s_ptr != null)
{
mult = best_s_ptr.mult;
}
/* Add the multiple to sv */
sv += (int)(mult * r_ptr.scaled_power);
}
/*
* To get the expected damage for this weapon, multiply the
* average damage from base dice by sv, and divide by the
* total number of monsters.
*/
if (verbose)
{
/* Write info about the slay combination and multiplier */
//file_putf(log_file, "Slay multiplier for: ");
j = Slay.list_slays(s_index, s_index, desc, brand, s_mult, false);
//for (i = 0; i < j; i++) {
// if (brand[i]) {
// file_putf(log_file, brand[i]);
// } else {
// file_putf(log_file, desc[i]);
// }
// file_putf(log_file, "x%d ", s_mult[i]);
//}
//file_putf(log_file, "\nsv is: %d\n", sv);
//file_putf(log_file, " and t_m_p is: %d \n", tot_mon_power);
//file_putf(log_file, "times 1000 is: %d\n", (1000 * sv) / tot_mon_power);
}
/* Add to the cache */
if (Slay.fill_slay_cache(s_index, sv))
{
//file_putf(log_file, "Added to slay cache\n");
}
return(sv);
}
