public async Task <serviceResponse <List <GetCharacterDTO> > > DeleteCharacter(int id)
{
serviceResponse <List <GetCharacterDTO> > serviceResponse = new serviceResponse <List <GetCharacterDTO> >();
try
{
Character dbCharacter = await _context.Characters.FirstOrDefaultAsync(c => c.Id == id && c.User.id == GetUserId());
if (dbCharacter != null)
{
_context.Characters.Remove(dbCharacter);
await _context.SaveChangesAsync();
serviceResponse.Data = (_context.Characters.Where(C => C.User.id == GetUserId())
.Select(c => _mapper.Map <GetCharacterDTO>(c))).ToList();
}
else
{
serviceResponse.Success = false;
serviceResponse.Message = "Character Not Found";
}
}
catch (Exception ex)
{
serviceResponse.Success = false;
serviceResponse.Message = ex.Message;
}
return(serviceResponse);
}
public async Task <serviceResponse <GetCharacterDTO> > GetCharacterById(int id)
{
serviceResponse <GetCharacterDTO> serviceResponse = new serviceResponse <GetCharacterDTO>();
Character dbCharacter = await _context.Characters.
FirstOrDefaultAsync(c => c.Id == id && c.User.id == GetUserId());
serviceResponse.Data = _mapper.Map <GetCharacterDTO>(dbCharacter);
return(serviceResponse);
}
public async Task <serviceResponse <List <GetCharacterDTO> > > GetAllCharacters()
{
serviceResponse <List <GetCharacterDTO> > serviceResponse = new serviceResponse <List <GetCharacterDTO> >();
//Get Characters from the database
List <Character> dbCharacters = await _context.Characters.Where(c => c.User.id == GetUserId()).ToListAsync();
//Grab Characters list from the database and then display to web server
serviceResponse.Data = (dbCharacters.Select(c => _mapper.Map <GetCharacterDTO>(c))).ToList();
return(serviceResponse);
}
public async Task <IActionResult> UpdateCharacter(UpdateCharacterDTO updateCharacter)
{
serviceResponse <GetCharacterDTO> response = await _characterService.UpdateCharacter(updateCharacter);
if (response.Data == null)
{
return(NotFound(response));
}
return(Ok(response));
}
public async Task <IActionResult> Delete(int id)
{
serviceResponse <List <GetCharacterDTO> > response = await _characterService.DeleteCharacter(id);
if (response.Data == null)
{
return(NotFound(response));
}
return(Ok(response));
}
public async Task <IActionResult> Register(UserDTO request)
{
serviceResponse <int> response = await _Auth.Register(
new User { Username = request.Username }, request.Password
);
if (!response.Success)
{
return(BadRequest(response));
}
return(Ok(response));
}
public async Task <IActionResult> Login(UserLoginDTO request)
{
serviceResponse <string> response = await _Auth.Login(
request.username, request.password
);
if (!response.Success)
{
return(BadRequest(response));
}
return(Ok(response));
}
public async Task <serviceResponse <AttackResultDTo> > skillAttack(SkillAttackDTo request)
{
serviceResponse <AttackResultDTo> response = new serviceResponse <AttackResultDTo>();
try
{
Character attacker = await _context.Characters
.Include(c => c.CharacterSkills).ThenInclude(cs => cs.Skill)
.FirstOrDefaultAsync(c => c.Id == request.AttackerId);
Character opponent = await _context.Characters
.FirstOrDefaultAsync(c => c.Id == request.OpponentId);
CharacterSkill character = attacker.CharacterSkills.FirstOrDefault(cs => cs.Skill.Id == request.SkillId);
if (character == null)
{
response.Success = false;
response.Message = $" {attacker.Name} does not know that skill.";
}
int damage = SkillAttack(attacker, opponent, character);
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 <GetCharacterDTO> > AddCharacterSkill(AddCharacterSkillDto newCharacterSkill)
{
serviceResponse <GetCharacterDTO> response = new serviceResponse <GetCharacterDTO>();
try
{
Character character = await _context.Characters
.Include(c => c.Weapon)
.Include(c => c.CharacterSkills).ThenInclude(cs => cs.Skill)
.FirstOrDefaultAsync(c => c.Id == newCharacterSkill.CharacterId &&
c.User.id == int.Parse(_httpContextAccessor.HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier)));
if (character == null)
{
response.Success = false;
response.Message = "Character not found.";
return(response);
}
Skill skill = await _context.Skills
.FirstOrDefaultAsync(s => s.Id == newCharacterSkill.SkillId);
if (skill == null)
{
response.Success = false;
response.Message = "Skills Not Found";
return(response);
}
CharacterSkill characterSkill = new CharacterSkill
{
Character = character,
Skill = skill
};
await _context.CharacterSkills.AddAsync(characterSkill);
await _context.SaveChangesAsync();
response.Data = _mapper.Map <GetCharacterDTO>(character);
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
public async Task <serviceResponse <List <HighScoreDTO> > > HighScore()
{
List <Character> characters = await _context.Characters
.Where(c => c.Fights > 0)
.OrderByDescending(c => c.Wins)
.ThenBy(c => c.Defeats)
.ToListAsync();
var response = new serviceResponse <List <HighScoreDTO> >
{
Data = characters.Select(c => _mapper.Map <HighScoreDTO>(c)).ToList()
};
return(response);
}
public async Task <serviceResponse <List <GetCharacterDTO> > > AddCharacter(AddCharacterDTO newCharacter)
{
serviceResponse <List <GetCharacterDTO> > serviceResponse = new serviceResponse <List <GetCharacterDTO> >();
Character character = _mapper.Map <Character>(newCharacter);
//Adds new character into db using AddAsync and then Save changes
character.User = await _context.Users.FirstOrDefaultAsync(u => u.id == GetUserId());
await _context.Characters.AddAsync(character);
await _context.SaveChangesAsync();
//Return Data to web server
serviceResponse.Data = (_context.Characters.Where(C => C.User.id == GetUserId()).Select(c => _mapper.Map <GetCharacterDTO>(c))).ToList();
return(serviceResponse);
}
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);
}
private bool VerifyPassword(string password, byte[] passwordHash, byte [] passwordSalt)
{
serviceResponse <int> response = new serviceResponse <int>();
using (var hmac = new System.Security.Cryptography.HMACSHA512(passwordSalt))
{
var computedHash = hmac.ComputeHash(System.Text.Encoding.UTF8.GetBytes(password));
for (int i = 0; i < computedHash.Length; i++)
{
if (computedHash[i] != passwordHash[i])
{
response.Success = false;
response.Message = "Password or Username is incorrect";
return(false);
}
}
return(true);
}
}
public async Task <serviceResponse <int> > Register(User user, string password)
{
serviceResponse <int> response = new serviceResponse <int>();
if (await UserExists(user.Username))
{
response.Success = false;
response.Message = "User Already Exist";
}
CreatePasswordHash(password, out byte[] passwordHash, out byte[] passwordSalt);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
await _context.Users.AddAsync(user);
await _context.SaveChangesAsync();
response.Data = user.id;
return(response);
}
public async Task <serviceResponse <string> > Login(string username, string password)
{
serviceResponse <string> response = new serviceResponse <string>();
User user = await _context.Users.FirstOrDefaultAsync(x => x.Username.ToLower().Equals(username.ToLower()));
if (user == null)
{
response.Success = false;
response.Message = "User not Found";
}
else if (!VerifyPassword(password, user.PasswordHash, user.PasswordSalt))
{
response.Success = false;
response.Message = "Wrong password";
}
else
{
response.Data = CreateToken(user);
}
return(response);
}
public async Task <serviceResponse <GetCharacterDTO> > AddWeapon(WeaponDTO newWeapon)
{
serviceResponse <GetCharacterDTO> response = new serviceResponse <GetCharacterDTO>();
try
{
Character character = await _context.Characters.FirstOrDefaultAsync(c => c.Id == newWeapon.CharacterId &&
c.User.id == int.Parse(_httpContextAccessor.HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier)));
if (character == null)
{
response.Success = false;
response.Message = "No Character was found";
}
WeaponModel Weapons = new WeaponModel
{
Name = newWeapon.Name,
Damage = newWeapon.Damage,
Character = character
};
await _context.Weapons.AddAsync(Weapons);
await _context.SaveChangesAsync();
response.Data = _mapper.Map <GetCharacterDTO>(character);
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
public async Task <serviceResponse <GetCharacterDTO> > UpdateCharacter(UpdateCharacterDTO updateCharacter)
{
serviceResponse <GetCharacterDTO> serviceResponse = new serviceResponse <GetCharacterDTO>();
try
{
Character character = await _context.Characters.Include(c => c.User).FirstOrDefaultAsync(c => c.Id == updateCharacter.Id);
if (updateCharacter.Id == GetUserId())
{
character.Name = updateCharacter.Name;
character.Class = updateCharacter.Class;
character.Defense = updateCharacter.Defense;
character.HitPoints = updateCharacter.HitPoints;
character.Intellegence = updateCharacter.Intellegence;
character.Strength = updateCharacter.Strength;
_context.Characters.Update(character);
await _context.SaveChangesAsync();
serviceResponse.Data = _mapper.Map <GetCharacterDTO>(character);
}
else
{
serviceResponse.Success = false;
serviceResponse.Message = "User not found";
}
}
catch (Exception ex)
{
serviceResponse.Success = false;
serviceResponse.Message = ex.Message;
}
return(serviceResponse);
}
public async Task <serviceResponse <FightResultDTO> > Fight(FightRequestDTO request)
{
serviceResponse <FightResultDTO> response = new serviceResponse <FightResultDTO>
{
Data = new FightResultDTO()
};
try
{
List <Character> Character =
await _context.Characters
.Include(c => c.Weapon)
.Include(c => c.CharacterSkills).ThenInclude(c => c.Skill)
.Where(c => request.CharacterIds.Contains(c.Id)).ToListAsync();
bool defeated = false;
while (!defeated)
{
foreach (Character attacker in Character)
{
List <Character> opponents = Character.Where(c => c.Id != attacker.Id).ToList();
Character opponent = opponents[new Random().Next(opponents.Count)];
int damage = 0;
string attackUsed = string.Empty;
bool useWeapon = new Random().Next(2) == 0;
if (useWeapon)
{
attackUsed = attacker.Weapon.Name;
damage = DoWeaponAttack(attacker, opponent);
}
else
{
int randomSkill = new Random().Next(attacker.CharacterSkills.Count);
attackUsed = attacker.CharacterSkills[randomSkill].Skill.Name;
damage = SkillAttack(attacker, opponent, attacker.CharacterSkills[randomSkill]);
}
response.Data.Log.Add($"{attacker.Name} attacked {opponent.Name} with {attackUsed} with damage {(damage >= 0 ? damage : 0)} damage.");
if (opponent.HitPoints <= 0)
{
defeated = true;
attacker.Wins++;
opponent.Defeats++;
response.Data.Log.Add($"{opponent.Name} was defeated by {attacker.Name} ");
break;
}
}
}
Character.ForEach(c =>
{
c.Fights++;
c.HitPoints = 100;
});
_context.Characters.UpdateRange(Character);
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
