public async Task <ServiceResponce <AttackResultDTO> > WeaponAttack(WeaponAttackDTO request)
{
ServiceResponce <AttackResultDTO> responce = new ServiceResponce <AttackResultDTO>();
try
{
Charecter attacker = await _context.Charecters
.Include(c => c.Weapon).FirstOrDefaultAsync(c => c.Id == request.AttackerId);
Charecter opponent = await _context.Charecters.FirstOrDefaultAsync(c => c.Id == request.OpponentId);
int damage = DoWeaponAttack(attacker, opponent);
if (opponent.HitPoints <= 0)
{
responce.Message = $"{opponent.Name} has been defeated!";
}
_context.Charecters.Update(opponent);
await _context.SaveChangesAsync();
responce.Data = new AttackResultDTO
{
Attacker = attacker.Name,
AttackerHp = attacker.HitPoints,
Opponent = opponent.Name,
OpponentHp = opponent.HitPoints,
Damage = damage
};
}
catch (Exception ex)
{
responce.Success = false;
responce.Message = ex.Message;
}
return(responce);
}
public async Task <ServiceResponse <AttackResultDTO> > WeaponAttack(WeaponAttackDTO attack)
{
var response = new ServiceResponse <AttackResultDTO>();
var attacker = await context.Characters
.Include(c => c.Weapon)
.FirstOrDefaultAsync(c => c.Id == attack.AttackerId);
var opponent = await context.Characters
.FirstOrDefaultAsync(c => c.Id == attack.OpponentId);
int damage = DoWeaponAttack(attacker, opponent);
if (opponent.HitPoint <= 0)
{
response.Message = $"{opponent.Name} has been defeatead";
}
context.Characters.Update(opponent);
await context.SaveChangesAsync();
response.Data = new AttackResultDTO
{
Attacker = attacker.Name,
AttackerHP = attacker.HitPoint,
Opponent = opponent.Name,
OpponentHP = opponent.HitPoint,
Damage = damage
};
return(response);
}
public async Task <ServiceResponse <AttackResultDTO> > WeaponAttack(WeaponAttackDTO request)
{
var response = new ServiceResponse <AttackResultDTO>();
try
{
var c = await _context.Characters
.Include(c => c.Weapon)
.FirstOrDefaultAsync(c => c.Id == request.AttackerId);
if (c == null)
{
throw new System.Exception("Attacking character not found");
}
var enemy = await _context.Characters
.FirstOrDefaultAsync(c => c.Id == request.EnemyId);
if (enemy == null)
{
throw new System.Exception("Oponnent character not found");
}
int dmg = WeaponAttackDamage(c, enemy);
if (enemy.HitPoints <= 0)
{
response.Message = $"{enemy.Name} has been defeated";
}
_context.Characters.Update(enemy);
await _context.SaveChangesAsync();
response.Data = new AttackResultDTO
{
Attacker = c.Name,
AttackerHP = c.HitPoints,
Enemy = enemy.Name,
EnemyHp = enemy.HitPoints,
Damage = dmg
};
}
catch (System.Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
public async Task <serviceResponse <AttackResultDTo> > WeaponAttack(WeaponAttackDTO request)
{
serviceResponse <AttackResultDTo> response = new serviceResponse <AttackResultDTo>();
try
{
Character attacker = await _context.Characters
.Include(c => c.Weapon)
.FirstOrDefaultAsync(c => c.Id == request.AttackerId);
Character opponent = await _context.Characters
.Include(c => c.Weapon)
.FirstOrDefaultAsync(c => c.Id == request.OpponentId);
int damage = DoWeaponAttack(attacker, opponent);
if (opponent.HitPoints <= 0)
{
response.Message = "Fighters health is 0 you LOSE";
opponent.Defeats = opponent.Defeats + 1;
}
_context.Characters.Update(opponent);
await _context.SaveChangesAsync();
response.Data = new AttackResultDTo
{
Attacker = attacker.Name,
AttackerHp = attacker.HitPoints,
Oppenent = opponent.Name,
OpponentHp = opponent.HitPoints,
Damage = damage
};
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
public async Task <ServiceResponse <AttackResultDTO> > WeaponAttack(WeaponAttackDTO fightDTO)
{
ServiceResponse <AttackResultDTO> serviceResponse = new ServiceResponse <AttackResultDTO>();
try
{
Character CharacterAttacker = await _dataContext.Characters
.Include(x => x.weapon)
.FirstOrDefaultAsync(x => x.Id == fightDTO.AttackerId);
Character CharacterDefender = await _dataContext.Characters
.Include(x => x.weapon)
.FirstOrDefaultAsync(x => x.Id == fightDTO.DefenderId);
int damage = CharacterAttacker.weapon.Damage + (new Random().Next(CharacterAttacker.Strenght));
damage -= new Random().Next(CharacterDefender.Defense);
ProcessFight(damage, CharacterAttacker, CharacterDefender, serviceResponse);
_dataContext.Characters.Update(CharacterAttacker);
_dataContext.Characters.Update(CharacterDefender);
await _dataContext.SaveChangesAsync();
serviceResponse.Data = new AttackResultDTO
{
Attacker = CharacterAttacker.Name,
Defender = CharacterDefender.Name,
AttackerHP = CharacterAttacker.HitPoints,
DefenderHP = CharacterDefender.HitPoints,
Damage = damage
};
return(serviceResponse);
}
catch (Exception ex)
{
serviceResponse.Success = false;
serviceResponse.Message = ex.Message;
}
return(serviceResponse);
}
public async Task <IActionResult> WeaponAttack(WeaponAttackDTO request)
{
return(Ok(await _fightService.WeaponAttack(request)));
}
public async Task <IActionResult> Weapon(WeaponAttackDTO attack)
{
return(Ok(await this.fightService.WeaponAttack(attack)));
}
