/// <summary> /// /// </summary> /// <param name="entity"></param> public void Loot(AdventureEntity entity) { // only allow mogwais to loot if (!(this is Mogwai.Mogwai mogwai)) { return; } if (entity.LootState == LootState.None || entity.LootState == LootState.Looted) { return; } var activity = ActivityLog.Create(ActivityLog.ActivityType.Loot, ActivityLog.ActivityState.None, new int[] { }, null); Mogwai.Mogwai.History.Add(LogType.Info, activity); Adventure?.Enqueue(AdventureLog.Info(this, entity, activity)); if (entity.Treasure != null) { activity = ActivityLog.Create(ActivityLog.ActivityType.Treasure, ActivityLog.ActivityState.Success, new int[] { }, null); Mogwai.Mogwai.History.Add(LogType.Info, activity); Adventure?.Enqueue(AdventureLog.Info(this, entity, activity)); mogwai.AddGold(entity.Treasure.Gold); } else { activity = ActivityLog.Create(ActivityLog.ActivityType.Treasure, ActivityLog.ActivityState.Fail, new int[] { }, null); Mogwai.Mogwai.History.Add(LogType.Info, activity); Adventure?.Enqueue(AdventureLog.Info(this, entity, activity)); } entity.LootState = LootState.Looted; }
/// <summary> /// Move an entity /// </summary> /// <param name="entity"></param> /// <param name="destination"></param> public void MoveEntity(Combatant entity, Coord destination) { if (!WalkabilityMap[destination]) { throw new Exception(); } if (EntityMap[entity.Coordinate] == null) { throw new Exception(); } EntityMap[entity.Coordinate].Remove(entity); WalkabilityMap[entity.Coordinate] = EntityMap[entity.Coordinate].IsPassable; // clean up seems not needed //if (!EntityMap[entity.Coordinate].Has<AdventureEntity>()) //{ // EntityMap[entity.Coordinate] = null; //} if (EntityMap[destination] == null) { EntityMap[destination] = new AdventureEntityContainer(); } EntityMap[destination].Add(entity); WalkabilityMap[destination] = EntityMap[destination].IsPassable; entity.Coordinate = destination; entity.FovCoords = CalculateFoV(entity.Coordinate, entity is Mogwai); Adventure.Enqueue(AdventureLog.EntityMoved(entity, destination)); }
/// <summary> /// /// </summary> /// <param name="spellCast"></param> /// <returns></returns> private bool Cast(SpellCast spellCast) { var spell = spellCast.Spell; if (spellCast.Target is Entity target) { // TODO: https://github.com/WorldOfMogwais/WoMNetCore/issues/22 var concentrateRoll = 10; Adventure.Enqueue(AdventureLog.Info(this, target, ActivityLog.Create(ActivityLog.ActivityType.Cast, ActivityLog.ActivityState.Init, concentrateRoll, spell))); if (concentrateRoll > 1 && concentrateRoll > spell.Level) { Adventure.Enqueue(AdventureLog.Info(this, target, ActivityLog.Create(ActivityLog.ActivityType.Cast, ActivityLog.ActivityState.Success, concentrateRoll, spell))); spell.SpellEffect(this, target); } else { Adventure.Enqueue(AdventureLog.Info(this, target, ActivityLog.Create(ActivityLog.ActivityType.Cast, ActivityLog.ActivityState.Fail, concentrateRoll, spell))); } Adventure.Enqueue(AdventureLog.Attacked(this, target)); return(true); } return(false); }
/// <summary> /// /// </summary> /// <param name="damageAmount"></param> /// <param name="damageType"></param> public void Damage(int damageAmount, DamageType damageType) { // no damage return or same for dead entities if (damageAmount <= 0 || IsDead) { return; } var activity = ActivityLog.Create(ActivityLog.ActivityType.Damage, ActivityLog.ActivityState.None, new int[] { damageAmount, (int)damageType }, null); Mogwai.Mogwai.History.Add(LogType.Info, activity); Adventure?.Enqueue(AdventureLog.Info(this, null, activity)); CurrentHitPoints -= damageAmount; if (!CanAct) { activity = ActivityLog.Create(ActivityLog.ActivityType.HealthState, ActivityLog.ActivityState.None, new int[] { (int)HealthState }, null); Mogwai.Mogwai.History.Add(LogType.Info, activity); Adventure?.Enqueue(AdventureLog.Info(this, null, activity)); } if (IsDead) { activity = ActivityLog.Create(ActivityLog.ActivityType.HealthState, ActivityLog.ActivityState.None, new int[] { (int)HealthState }, null); Mogwai.Mogwai.History.Add(LogType.Info, activity); Adventure?.Enqueue(AdventureLog.Info(this, null, activity)); Map.DeadEntity(this); } }
public async Task PostAdventureLogTest(string url) { // Arrange var client = _factory.CreateClient(); var itemToSend = new AdventureLog { UserId = null, LogTitle = "Session 22: More Stuff", LogBody = "<p><b>The elf jumped over the lazy dwarf.</b></p>" }; var sentContent = JsonConvert.SerializeObject(itemToSend); string beforeLogCountQueryResult = _queryHelper.SelectQuery("SELECT TOP 1 HistoricalLogCount FROM HistoricalAdventureLogCounts", "HistoricalLogCount"); int beforeLogCount = int.Parse(beforeLogCountQueryResult); // Act var send = await client.PostAsync(url, new StringContent(sentContent, Encoding.UTF8, "application/json")); string afterLogCountQueryResult = _queryHelper.SelectQuery("SELECT TOP 1 HistoricalLogCount FROM HistoricalAdventureLogCounts", "HistoricalLogCount"); int afterLogCount = int.Parse(afterLogCountQueryResult); string createdLogTitleQueryResult = _queryHelper.SelectQuery($"SELECT LogTitle FROM AdventureLogs WHERE AdventureLogID = {afterLogCount}", "LogTitle"); string createdLogBodyQueryResult = _queryHelper.SelectQuery($"SELECT LogBody FROM AdventureLogs WHERE AdventureLogID = {afterLogCount}", "LogBody"); // Assert send.EnsureSuccessStatusCode(); // Status Code 200-299 Assert.Equal("application/json; charset=utf-8", send.Content.Headers.ContentType.ToString()); Assert.Equal(itemToSend.LogTitle, createdLogTitleQueryResult); Assert.Equal(itemToSend.LogBody, createdLogBodyQueryResult); Assert.NotEqual(beforeLogCount, afterLogCount); }
public AdventureLog SelectAdventureLogQuery(int id) { string query = $"SELECT * FROM AdventureLogs WHERE AdventureLogID = {id}"; AdventureLog adventureLog = new AdventureLog(); using (SqlConnection connection = new SqlConnection(_connectionString)) { SqlCommand command = new SqlCommand(query, connection); connection.Open(); SqlDataReader reader = command.ExecuteReader(); try { while (reader.Read()) { if (reader.HasRows) { adventureLog = new AdventureLog() { AdventureLogID = id, UserId = reader["UserId"].ToString(), LogTitle = reader["LogTitle"].ToString(), LogBody = reader["LogBody"].ToString(), LogDate = DateTime.Parse(reader["LogDate"].ToString()) }; } } } catch (Exception exc) { //_logger.AddSystemLog($"Failed to read query results: {exc}"); } return(adventureLog); } }
/// <summary> /// Add entity to the map /// </summary> /// <param name="entity"></param> /// <param name="x"></param> /// <param name="y"></param> public void AddEntity(AdventureEntity entity, int x, int y) { // can't add an entity to invalid position if (!WalkabilityMap[x, y]) { throw new Exception(); } if (!entity.IsPassable) { WalkabilityMap[x, y] = false; } entity.Map = this; entity.Coordinate = new Coord(x, y); if (EntityMap[x, y] == null) { EntityMap[x, y] = new AdventureEntityContainer(); } EntityMap[x, y].Add(entity); if (entity is Combatant combatant) { // calculate fov combatant.FovCoords = CalculateFoV(entity.Coordinate, entity is Mogwai); } // add entity to list Entities.Add(entity); Adventure.Enqueue(AdventureLog.EntityCreated(entity)); }
public async Task <ActionResult <AdventureLog> > PostAdventureLog([FromBody] AdventureLog adventureLog) { try { adventureLog.UserId = User.FindFirstValue(ClaimTypes.NameIdentifier); if (string.IsNullOrWhiteSpace(adventureLog.LogTitle)) { adventureLog.LogTitle = "Untitled"; } if (string.IsNullOrWhiteSpace(adventureLog.LogBody)) { adventureLog.LogBody = "Nothing seems to be here!"; } adventureLog = Utilities.NewCreateDateFormatted(adventureLog); await _context.AdventureLogs.AddAsync(adventureLog); _context.SaveChanges(); return(CreatedAtAction("GetAdventureLog", new { id = adventureLog.AdventureLogID }, adventureLog)); } catch (Exception exc) { _logController.AddSystemLog($"ERROR: {exc.Message}"); return(BadRequest()); } }
/// <summary> /// /// </summary> /// <param name="weaponAttack"></param> /// <returns></returns> private void Attack(WeaponAttack weaponAttack) { var attackTimes = weaponAttack.ActionType == ActionType.Full ? BaseAttackBonus.Length : 1; var weapon = weaponAttack.Weapon; var target = weaponAttack.Target as Entity; //Console.WriteLine($"{Name}: is attacking {attackTimes} times"); // all attacks are calculated Parallel.For(0, attackTimes, (attackIndex, state) => { // break when target is null or dead, no more attacks on dead monsters. if (target == null || target.IsDead) { state.Break(); } var attackRolls = AttackRolls(attackIndex, weapon.CriticalMinRoll); var attack = AttackRoll(attackRolls, target.ArmorClass, out var criticalCounts); Adventure.Enqueue(AdventureLog.Info(this, target, ActivityLog.Create(ActivityLog.ActivityType.Attack, ActivityLog.ActivityState.Init, new int[] { attackIndex, attack, criticalCounts }, weaponAttack))); if (attack > target.ArmorClass || criticalCounts > 0) { var damage = DamageRoll(weapon, Dice); var criticalDamage = 0; if (criticalCounts > 0) { for (var i = 0; i < weapon.CriticalMultiplier - 1; i++) { criticalDamage += DamageRoll(weapon, Dice); } } Adventure.Enqueue(AdventureLog.Info(this, target, ActivityLog.Create(ActivityLog.ActivityType.Attack, ActivityLog.ActivityState.Success, new int[] { attackIndex, attack, criticalCounts, damage, criticalDamage, (int)DamageType.Weapon }, weaponAttack))); target.Damage(damage + criticalDamage, DamageType.Weapon); } else { Adventure.Enqueue(AdventureLog.Info(this, target, ActivityLog.Create(ActivityLog.ActivityType.Attack, ActivityLog.ActivityState.Fail, new int[] { attackIndex, attack, criticalCounts }, weaponAttack))); } Adventure.Enqueue(AdventureLog.Attacked(this, target)); }); }
private void Awake() { if (Instance == null) { DontDestroyOnLoad(gameObject); Instance = this; } else if (Instance != this) { Destroy(gameObject); } }
public static AdventureLog NewCreateDateFormatted(AdventureLog adventureLog) { DateTime createTime = DateTime.Now; string stringVersion = createTime.ToString("M/d/yyyy"); createTime = DateTime.Parse(stringVersion); adventureLog.DisplayLogDate = stringVersion; adventureLog.LogDate = createTime; return(adventureLog); }
/// <summary> /// Passive level up, includes for example hit point roles. /// </summary> private void LevelUp() { var activity = ActivityLog.Create(ActivityLog.ActivityType.Level, ActivityLog.ActivityState.None, new int[] { CurrentLevel }, null); History.Add(LogType.Info, activity); Adventure?.Enqueue(AdventureLog.Info(this, null, activity)); // level up grant free revive SpecialAction(SpecialType.Reviving); // level up grant free heal SpecialAction(SpecialType.Heal); }
public async Task <ActionResult <AdventureLog> > DeleteAdventureLog(int id) { AdventureLog adventureLog = await _context.AdventureLogs.FindAsync(id); if (adventureLog == null || adventureLog.UserId != User.FindFirstValue(ClaimTypes.NameIdentifier)) { return(NotFound()); } _context.AdventureLogs.Remove(adventureLog); await _context.SaveChangesAsync(); return(adventureLog); }
/// <inheritdoc /> public override void AddGold(int gold) { var activity = ActivityLog.Create(ActivityLog.ActivityType.Gold, ActivityLog.ActivityState.None, new int[] { gold }, null); History.Add(LogType.Info, activity); if (Adventure != null) { Adventure.Enqueue(AdventureLog.Info(this, null, activity)); Adventure.AdventureStats[AdventureStats.Gold] = Adventure.AdventureStats[AdventureStats.Gold] + gold; } Wealth.Gold += gold; }
/// <summary> /// /// </summary> /// <param name="entity"></param> public void DeadEntity(Combatant entity) { if (EntityMap[entity.Coordinate] == null) { throw new Exception(); } // dead bodies are passable entity.IsPassable = true; WalkabilityMap[entity.Coordinate] = EntityMap[entity.Coordinate].IsPassable; Adventure.Enqueue(AdventureLog.Died(entity)); }
/// <summary> /// Remove entity from the map /// </summary> /// <param name="entity"></param> public void RemoveEntity(Combatant entity) { if (EntityMap[entity.Coordinate] == null) { throw new Exception(); } if (!entity.IsPassable) { WalkabilityMap[entity.Coordinate] = true; } EntityMap[entity.Coordinate] = null; // remove entity to list Entities.Remove(entity); Adventure.Enqueue(AdventureLog.EntityRemoved(entity)); }
/// <summary> /// /// </summary> /// <param name="healAmount"></param> /// <param name="healType"></param> public void Heal(int healAmount, HealType healType) { var missingHealth = MaxHitPoints - CurrentHitPoints; if (missingHealth <= 0 || healAmount <= 0) { return; } if (missingHealth < healAmount) { healAmount = missingHealth; } var activity = ActivityLog.Create(ActivityLog.ActivityType.Heal, ActivityLog.ActivityState.None, new int[] { healAmount, (int)healType }, null); Mogwai.Mogwai.History.Add(LogType.Info, activity); Adventure?.Enqueue(AdventureLog.Info(this, null, activity)); CurrentHitPoints += healAmount; }
/// <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(); } }
/// <summary> /// /// </summary> /// <param name="classType"></param> private void LevelClass(ClassType classType) { if (!CanLevelClass(out _)) { Log.Warn("Not allowed class leveling action."); return; } var classes = Classes.FirstOrDefault(p => p.ClassType == classType); if (Classes.Count == 0 || classes == null) { Classes.Insert(0, Model.Classes.Classes.GetClasses(classType)); } else if (Classes.Remove(classes)) { Classes.Insert(0, classes); } var classesLevels = Classes.Sum(p => p.ClassLevel); // do the class level up Classes[0].ClassLevelUp(); var dice = Shifts[LevelShifts[classesLevels]].MogwaiDice; // level class now LevelClass(dice); // initial class level if (classesLevels == 0) { AddGold(dice.Roll(Classes[0].WealthDiceRollEvent)); } var activity = ActivityLog.Create(ActivityLog.ActivityType.LevelClass, ActivityLog.ActivityState.None, new int[] { (int)classType }, null); History.Add(LogType.Info, activity); Adventure?.Enqueue(AdventureLog.Info(this, null, activity)); }
public async Task <IActionResult> PutAdventureLog(int id, AdventureLog sentAdventureLog) { string requestingUser = User.FindFirstValue(ClaimTypes.NameIdentifier); AdventureLog adventureLog = await _context.AdventureLogs.FindAsync(id); if (id != sentAdventureLog.AdventureLogID || adventureLog.UserId != requestingUser) { return(BadRequest()); } if (!string.IsNullOrWhiteSpace(sentAdventureLog.LogTitle)) { adventureLog.LogTitle = sentAdventureLog.LogTitle; } if (!string.IsNullOrWhiteSpace(sentAdventureLog.LogBody)) { adventureLog.LogBody = sentAdventureLog.LogBody; } _context.Entry(adventureLog).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!AdventureLogExists(id)) { _logController.AddSystemLog($"WARNING: User {requestingUser} has caused a DbUpdateConcurrencyException"); return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task PutAdventureLogTest(string url) { //Arrange var client = _factory.CreateClient(); string adventureLogIdResult = _queryHelper.SelectQuery("SELECT TOP 1 AdventureLogID FROM AdventureLogs ORDER BY AdventureLogID DESC", "AdventureLogID"); int adventureLogId = int.Parse(adventureLogIdResult); var itemToSend = new AdventureLog { AdventureLogID = adventureLogId, UserId = null, LogTitle = "Session 23: I changed my mind", LogBody = "<p><b>The dwarf punched the stupid elf.</b></p>" }; var sentContent = JsonConvert.SerializeObject(itemToSend); // Act await client.PutAsync(url, new StringContent(sentContent, Encoding.UTF8, "application/json")); AdventureLog adventureLog = _queryHelper.SelectAdventureLogQuery(adventureLogId); // Assert Assert.Equal(itemToSend.LogTitle, adventureLog.LogTitle); Assert.Equal(itemToSend.LogBody, adventureLog.LogBody); }
public async Task <IActionResult> NewAdventureLog([FromQuery] int adventureLogID) { AdventureLog log = await _context.AdventureLogs.FindAsync(adventureLogID); return(View(log)); }