// Damage Calculation to be implemented
// This is the retaliation damage done to other enemies
List <AttackLog> ApplyAndRecordDamage(Piece piece, ICollection <MoveData> attackerMoveDatas)
{
int baseDamage = piece.attack;
List <AttackLog> attackLogs = new List <AttackLog>();
foreach (MoveData attackerMoveData in attackerMoveDatas)
{
double damage = baseDamage;
// apply enemy specific multipliers here
// damage dampening if outnumbered
switch (attackerMoveDatas.Count)
{
case 2: // 40% on 2 enemies
damage *= 0.4; break;
case 3: // 20% on 3 enemies
damage *= 0.2; break;
case 4: // 5% on 4 enemies
damage *= 0.05; break;
}
if (piece.IsCounteredBy(attackerMoveData.piece))
{
damage *= 1.2;
}
damage *= piece.health / (double)piece.maxHealth;
Piece attacker = attackerMoveData.piece;
attacker.health -= (damage < 1) ? 1 : (int)damage; // at least deal 1 dmg
Move.Direction directionOfRetaliation = Move.OppositeDirection(attackerMoveData.direction);
AttackLog attackLog = new AttackLog((int)damage, directionOfRetaliation);
attackLogs.Add(attackLog);
}
return(attackLogs);
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
AttackLog attackLog = await db.AttackLogs.FindAsync(id);
db.AttackLogs.Remove(attackLog);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public async Task <ActionResult> Edit([Bind(Include = "AttackLogId,TimeOfAttack,WasAttacked,Message,UserId")] AttackLog attackLog)
{
if (ModelState.IsValid)
{
db.Entry(attackLog).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.UserId = new SelectList(db.Users, "Id", "UserName", attackLog.UserId);
return(View(attackLog));
}
// GET: AttackLogs/Details/5
public async Task <ActionResult> Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
AttackLog attackLog = await db.AttackLogs.FindAsync(id);
if (attackLog == null)
{
return(HttpNotFound());
}
return(View(attackLog));
}
// GET: AttackLogs/Edit/5
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
AttackLog attackLog = await db.AttackLogs.FindAsync(id);
if (attackLog == null)
{
return(HttpNotFound());
}
ViewBag.UserId = new SelectList(db.Users, "Id", "UserName", attackLog.UserId);
return(View(attackLog));
}
protected void Page_Load(object sender, EventArgs e)
{
using (
SqlConnection connection =
new SqlConnection(ConfigurationManager.ConnectionStrings["WarehouseContext"].ConnectionString))
{
SqlDataReader retObj;
connection.Open();
string query = @" SELECT TOP (1000) [TargetID]
,[ActorID]
,[Spell]
,[ID]
,[createdAt]
,[mark]
FROM [WebDota].[dbo].[MagicLogs]" ;
SqlCommand command = new SqlCommand(query, connection)
{
CommandTimeout = 0
};
retObj = command.ExecuteReader();
MagicLog.DataSource = retObj;
MagicLog.DataBind();
}
using (
SqlConnection connection =
new SqlConnection(ConfigurationManager.ConnectionStrings["WarehouseContext"].ConnectionString))
{
SqlDataReader retObj;
connection.Open();
string query = @"/****** Script for SelectTopNRows command from SSMS ******/
SELECT TOP (1000) [ActorID]
,[TargetID]
,[AttackAmount]
,[ID]
,[AttackRecieved]
,[createdAt]
,[mark]
FROM [WebDota].[dbo].[AttackLog]";
SqlCommand command = new SqlCommand(query, connection)
{
CommandTimeout = 0
};
retObj = command.ExecuteReader();
AttackLog.DataSource = retObj;
AttackLog.DataBind();
}
}
public bool InsertAttackLog(AttackLog attackLog)
{
using (db = dbFactory.Open())
{
try
{
var flag = db.Insert <AttackLog>(attackLog);
if (flag >= 0)
{
return(true);
}
}
catch (Exception)
{
}
return(false);
}
}
public void ProcessEvents(ApplicationDbContext db, ApplicationUser user)
{
var territory = db.Territories
.Include(x => x.Players)
.FirstOrDefault(x => x.TerritoryId == user.TerritoryId);
var now = DateTime.Now;
if (territory != null)
{
// check resource updates
if (territory.LastResourceCollection < DateTime.Now.AddHours(-1))
{
// determine how many intervals
var elapsed = DateTime.Now - territory.LastResourceCollection;
var hoursElapsed = elapsed.Hours;
// Get boosts from technology
var techBoosts = db.UserTechnologies
.Include(x => x.Technology)
.Where(x => x.UserId.Equals(user.Id) && x.StatusId == UserTechnologyStatusTypes.Researched)
.ToList();
var civPop = territory.CivilianPopulation;
// todo: this sucks, refactor allocations into a table or something
var resourceMeta = db.Items.Where(x => x.IsCore.Equals(true))
.Select(x => new ResourceMeta
{
ItemId = x.ItemId,
// this will be filled out momentarily
NewQuantity = 0,
})
.ToList();
var userItems = user.Items
.OrderByDescending(x => x.Item.MaxBoost)
.ToList();
foreach (var resource in db.Items.Where(x => x.IsCore.Equals(true)))
{
var allocation = 0.0m;
// todo: this sucks, refactor allocations into a table or something
switch (resource.ItemId)
{
case 1: allocation = territory.WaterAllocation; break;
case 2: allocation = territory.FoodAllocation; break;
case 3: allocation = territory.WoodAllocation; break;
case 4: allocation = territory.StoneAllocation; break;
case 5: allocation = territory.OilAllocation; break;
case 6: allocation = territory.IronAllocation; break;
}
// get the useritem record
var resourceItem = user.Items.Single(x => x.ItemId == resource.ItemId);
// start with the boost from technologies
var boost = techBoosts
.Where(x => x.Technology.BoostTypeId.Equals((BoostTypes)resource.ItemId))
.Sum(x => x.Technology.BoostAmount);
// add any boost from items
var boostItems = userItems
.Where(x => x.Item.BoostType == (BoostTypes)resource.ItemId)
.Select(x => new BoostItem
{
BoostType = x.Item.BoostType,
MaxBoost = x.Item.MaxBoost,
Quantity = x.Quantity,
});
if (boostItems.Any())
{
boost += GetItemBoost((BoostTypes)resource.ItemId, boostItems.ToList(), allocation, civPop);
}
// do resource collection
resourceItem.Quantity += (int)((allocation + boost) * civPop * hoursElapsed);
resourceMeta.Single(x => x.ItemId == resource.ItemId).NewQuantity = resourceItem.Quantity;
}
// reset update time to the most recent hour to account for partial intervals
territory.LastResourceCollection = new DateTime(now.Year, now.Month, now.Day, now.Hour, 0, 0);
// queue a message to check for badges
var qm = new QueueManager();
qm.QueueResourceCollection(user.Id,
resourceMeta.Single(x => x.ItemId == (int)ResourceTypes.Water).NewQuantity,
resourceMeta.Single(x => x.ItemId == (int)ResourceTypes.Food).NewQuantity,
resourceMeta.Single(x => x.ItemId == (int)ResourceTypes.Wood).NewQuantity,
resourceMeta.Single(x => x.ItemId == (int)ResourceTypes.Stone).NewQuantity,
resourceMeta.Single(x => x.ItemId == (int)ResourceTypes.Oil).NewQuantity,
resourceMeta.Single(x => x.ItemId == (int)ResourceTypes.Iron).NewQuantity);
}
// check territory population growth
if (territory.LastPopulationUpdate < DateTime.Now.AddHours(-24))
{
var elapsed = DateTime.Now - territory.LastPopulationUpdate;
var daysElapsed = elapsed.Days;
var noteText = string.Empty;
// Get boosts from technology
var populationBoosts = db.UserTechnologies.Where(x => x.UserId.Equals(user.Id) &&
x.StatusId == UserTechnologyStatusTypes.Researched &&
x.Technology.BoostTypeId == BoostTypes.Population)
.Select(x => x.Technology.BoostAmount).ToList();
var growth = (int)(territory.CivilianPopulation * (territory.PopulationGrowthRate + populationBoosts.Sum()) * daysElapsed);
territory.CivilianPopulation += growth;
// reset update time to account for partial intervals
territory.LastPopulationUpdate = new DateTime(now.Year, now.Month, now.Day);
// notify user
var timeText = daysElapsed > 1 ? "recently" : "last night";
noteText = $"A few people from the outskirts found their way into your territory {timeText}. " +
$"Your population grew by {growth} to {territory.CivilianPopulation}. " +
"Your increased population will automatically help you gather more resources.";
var note = CommunicationService.CreateNotification(
user.Id,
$"Your civilian population grew by {growth} last night!",
noteText);
db.Notes.Add(note);
}
// check nightly attacks
if (territory.LastNightlyAttack < DateTime.Now.AddHours(-24))
{
var elapsed = DateTime.Now - territory.LastNightlyAttack;
var daysElapsed = elapsed.Days;
var rand = new Random();
var log = new AttackLog
{
UserId = user.Id,
};
var survivals = 0;
var attacks = 0;
var populationLoss = 0;
var resourceLossText = string.Empty;
// Calculate winPercentage
var defenseBoosts = db.UserTechnologies.Where(x => x.UserId.Equals(user.Id) &&
x.StatusId == UserTechnologyStatusTypes.Researched &&
x.Technology.BoostTypeId == BoostTypes.Defense)
.Select(x => x.Technology.BoostAmount).ToList();
var winPercentage = 67 + (defenseBoosts.Sum() * 100);
for (var i = 0; i < daysElapsed; i++)
{
if (rand.Next(0, 100) > winPercentage)
{
attacks++;
log.WasAttacked = true;
// 1-2 nightly population loss for right now
// todo: boosts
populationLoss += rand.Next(0, 2) + 1;
// lose random resources
resourceLossText = ResourceService.RandomResource(user, false, false, 0.05);
}
else
{
survivals++;
}
}
// total population loss since last calculation
territory.CivilianPopulation -= populationLoss;
// reset update time to account for partial intervals
territory.LastNightlyAttack = new DateTime(now.Year, now.Month, now.Day);
if (attacks > 1)
{
log.Message = string.Format(
"Zombies have been pillaging your territory while you were away. You lost {0} {1}. {2}" +
$"Zombie Attacks: {attacks}. Thwarted attempts: {survivals}"
, populationLoss
, populationLoss == 1 ? "person" : "people"
, "You lost too many resources to count!");
}
else if (attacks == 1)
{
log.Message = string.Format(
"Zombies attacked your territory last night. You lost {0} {1}. {2}"
, populationLoss
, populationLoss == 1 ? "person" : "people"
, resourceLossText);
}
else if (attacks == 0)
{
log.Message = "Your territory survived all recent zombie attacks.";
}
var note = CommunicationService.CreateNotification(
user.Id,
"Recent Zombie Activity",
log.Message);
db.Notes.Add(note);
db.AttackLogs.Add(log);
}
}
}
protected virtual void OnAttack(GameActionEventArgs a, GameLogEventArgs l)
{
Attack?.Invoke(this, a);
AttackLog?.Invoke(this, l);
}
