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 <List <GetCharecterDto> > > deleteCharecter(int id)
{
ServiceResponse <List <GetCharecterDto> > serviceResponse = new ServiceResponse <List <GetCharecterDto> >();
try
{
Charecter chars = await _contect.charecters.FirstOrDefaultAsync(da => da.Id == id && da.Users.Id == GetUserID());
if (chars != null)
{
_contect.charecters.Remove(chars);
await _contect.SaveChangesAsync();
serviceResponse.data = (_contect.charecters.Where(c => c.Users.Id == GetUserID()).Select(ob => _mapper.Map <GetCharecterDto>(ob))).ToList();
}
else
{
serviceResponse.Success = false;
serviceResponse.Message = "Charecter not found";
}
}
catch (Exception ex)
{
serviceResponse.Success = false;
serviceResponse.Message = ex.Message;
}
return(serviceResponse);
}
public override void CallSelecetdAttack(Charecter Target)
{
if (SelectedAttack <= skills.Count)
{
skills [SelectedAttack] (Target);
}
}
public async Task <ServiceResponce <GetCharecterDTO> > UpdateCharecter(UpdateCharecterDTO updateCharecter)
{
ServiceResponce <GetCharecterDTO> serviceResponce = new ServiceResponce <GetCharecterDTO>();
try
{
Charecter charecter = await _context.Charecters.Include(c => c.User.Id).FirstOrDefaultAsync(c => c.Id == updateCharecter.Id);
if (charecter.User.Id == GetUserId())
{
charecter.Name = updateCharecter.Name;
charecter.Class = updateCharecter.Class;
charecter.Defence = updateCharecter.Defence;
charecter.Intelligence = updateCharecter.Intelligence;
charecter.HitPoints = updateCharecter.HitPoints;
charecter.Strength = updateCharecter.Strength;
_context.Charecters.Update(charecter);
await _context.SaveChangesAsync();
serviceResponce.Data = _mapper.Map <GetCharecterDTO>(charecter);
}
else
{
serviceResponce.Success = false;
serviceResponce.Message = "Charecter not found.";
}
}
catch (Exception ex)
{
serviceResponce.Success = false;
serviceResponce.Message = ex.Message;
}
return(serviceResponce);
}
public void SetToMove()
{
Charecter monster = currentSelectedUnit.GetComponent <Charecter> ();
monster.setToMove = true;
monster.setToAttack = false;
}
public async Task <ServiceResponce <GetCharecterDTO> > AddWeapon(AddWeaponDTO newWeapon)
{
ServiceResponce <GetCharecterDTO> responce = new ServiceResponce <GetCharecterDTO>();
try{
Charecter charecter = await _context.Charecters.FirstOrDefaultAsync(c => c.Id == newWeapon.CharecterId &&
c.User.Id == int.Parse(_httpContextAccessor.HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier)));
if (charecter == null)
{
responce.Success = false;
responce.Message = "Charecter is not found.";
return(responce);
}
Weapon weapon = new Weapon()
{
Name = newWeapon.Name,
Damage = newWeapon.Damage,
Charecter = charecter
};
await _context.Weapons.AddAsync(weapon);
await _context.SaveChangesAsync();
responce.Data = _mapper.Map <GetCharecterDTO>(charecter);
}
catch (Exception ex) {
responce.Success = false;
responce.Message = ex.Message;
}
return(responce);
}
public async Task <ServiceResponse <GetCharecterDto> > updateCharecter(UpdateCharecterDto obj)
{
ServiceResponse <GetCharecterDto> serviceResponse = new ServiceResponse <GetCharecterDto>();
try
{
Charecter chars = await _contect.charecters.Include(u => u.Users).FirstOrDefaultAsync(da => da.Id == obj.Id);
if (chars.Users.Id == GetUserID())
{
chars.Name = obj.Name;
chars.Intelligence = obj.Intelligence;
chars.Class = obj.Class;
chars.Defence = obj.Defence;
chars.HitPoints = obj.HitPoints;
chars.Strength = obj.Strength;
_contect.Update(chars);
await _contect.SaveChangesAsync();
serviceResponse.data = _mapper.Map <GetCharecterDto>(chars);
}
else
{
serviceResponse.Success = false;
serviceResponse.Message = "Charecter not found";
}
}
catch (Exception ex)
{
serviceResponse.Success = false;
serviceResponse.Message = ex.Message;
}
return(serviceResponse);
}
public async Task <ServiceResponse <GetCharecterDto> > AddWeapons(AddWeaponDto addWeapon)
{
ServiceResponse <GetCharecterDto> response = new ServiceResponse <GetCharecterDto>();
try
{
int userid = GetUserID();
Charecter chars = await _context.charecters.
FirstOrDefaultAsync(x => x.Id == addWeapon.CharecterId && x.Users.Id == GetUserID());
if (chars == null)
{
response.Success = false;
response.Message = "Charecter not found";
return(response);
}
Weapon weapon = new Weapon {
Name = addWeapon.Name,
Damage = addWeapon.Damage,
charecter = chars
};
await _context.Weapons.AddAsync(weapon);
await _context.SaveChangesAsync();
response.data = _mapper.Map <GetCharecterDto>(chars);
}
catch (Exception e)
{
response.Success = false;
response.Message = e.Message;
}
return(response);
}
public async Task <ServiceResponce <List <GetCharecterDTO> > > DeleteCharecter(int id)
{
ServiceResponce <List <GetCharecterDTO> > serviceResponce = new ServiceResponce <List <GetCharecterDTO> >();
try
{
Charecter charecter = await _context.Charecters.FirstOrDefaultAsync(c => c.Id == id && c.User.Id == GetUserId());
if (charecter != null)
{
_context.Charecters.Remove(charecter);
await _context.SaveChangesAsync();
serviceResponce.Data = (_context.Charecters.Where(c => c.User.Id == GetUserId()).Select(c => _mapper.Map <GetCharecterDTO>(c))).ToList();
}
else
{
serviceResponce.Success = false;
serviceResponce.Message = "Charecter not found.";
}
}
catch (Exception ex)
{
serviceResponce.Success = false;
serviceResponce.Message = ex.Message;
}
return(serviceResponce);
}
// Use this for initialization
void Start()
{
GameObject[] foundMonsters = GameObject.FindGameObjectsWithTag("Monster");
Debug.Log(foundMonsters);
foreach (GameObject monster in foundMonsters)
{
Charecter found = monster.GetComponent <Charecter> ();
found.RollInitiative();
TurnOrder.Add(found);
//TurnOrder2.
}
TurnOrder.Sort((Char1, Char2) =>
{
return(Char2.initiative.CompareTo(Char1.initiative));
});
grid.currentSelectedUnit = TurnOrder[0].transform.gameObject;
if (!TurnOrder [0].isPlayerUnit)
{
//implement some AI logic here
AI.BasicAILogic(TurnOrder [0]);
EndCurrentUnitTurn();
}
}
public virtual bool BasicAttack(Charecter Target, bool isAIAttack = false)
{
bool success = false;
if (equipedWeapon.Range == 1)
{
Debug.Log(Target);
if (((Target.posX - posX) >= -1 && (Target.posX - posX) <= 1) && ((Target.posY - posY) >= -1 && (Target.posY - posY) <= 1))
{
success = true;
}
}
else
{
if (pathfinder.FindPath(Target) <= equipedWeapon.Range)
{
success = true;
}
}
attemptingAttack = 0;
pathfinder.ClearLines();
if (success)
{
if (Target.isPlayerUnit && !isAIAttack)
{
return(false);
}
hasAttackedForTurn = true;
Target.TakeDamege(equipedWeapon.Attack);
}
return(success);
}
public void EndCurrentUnitTurn()
{
Charecter temp = TurnOrder [0];
temp.EndOfTurnEffects();
TurnOrder.RemoveAt(0);
if (temp.gameObject.activeSelf)
{
TurnOrder.Add(temp);
}
grid.currentSelectedUnit = TurnOrder [0].transform.gameObject;
if (TurnOrder[0].stunned)
{
EndCurrentUnitTurn();
}
if (!TurnOrder [0].isPlayerUnit)
{
//implement some AI logic here
if (AI.busy)
{
waitingForAIToFinish = true;
return;
}
AI.BasicAILogic(TurnOrder [0]);
//Debug.Log("Skiping Enemy Turn");
EndCurrentUnitTurn();
}
}
public async Task <ServiceResponse <GetCharecterDto> > getNamebyID(int id)
{
ServiceResponse <GetCharecterDto> serviceResponse = new ServiceResponse <GetCharecterDto>();
Charecter chars = await _contect.charecters.SingleOrDefaultAsync(x => x.Id == id && x.Users.Id == GetUserID());
serviceResponse.data = _mapper.Map <GetCharecterDto>(chars);
return(serviceResponse);
}
void Heal(Charecter Target)
{
Target.CurrentHealth += SpellPower + HealPower;
if (Target.MaxHP < Target.CurrentHealth)
{
Target.CurrentHealth = Target.MaxHP;
}
}
void SetCharecter()
{
charecter = GameObject.FindGameObjectWithTag("Player").GetComponent <Charecter>();
if (!charecter)
{
Debug.LogError("Cannot find charecter in scene!");
}
}
public void SetToAttack(int skill)
{
Charecter monster = currentSelectedUnit.GetComponent <Charecter> ();
monster.setToMove = false;
monster.setToAttack = true;
monster.attemptingAttack = skill;
}
public async Task <ServiceResponce <GetCharecterDTO> > GetCharecterById(int id)
{
ServiceResponce <GetCharecterDTO> serviceResponce = new ServiceResponce <GetCharecterDTO>();
Charecter dbCharecter = await _context.Charecters.FirstOrDefaultAsync(c => c.Id == id && c.User.Id == GetUserId());
serviceResponce.Data = _mapper.Map <GetCharecterDTO>(dbCharecter);
return(serviceResponce);
}
public void SetToMove()
{
Charecter monster = currentSelectedUnit.GetComponent <Charecter> ();
//Debug.Log ("987654321");
pathfinder.SetMoveBorder(monster.leftMove, monster.posX, monster.posY);
monster.setToMove = true;
monster.setToAttack = false;
monster.attemptingAttack = 0;
}
private static int DoSkillAttack(Charecter attacker, Charecter opponent, CharecterSkill charecterSkill)
{
int damage = Convert.ToInt32(charecterSkill.Skill.Damage) + (new Random().Next(attacker.Intelligence));
damage -= new Random().Next(opponent.Defence);
if (damage > 0)
{
opponent.HitPoints -= damage;
}
return(damage);
}
private static int DoWeaponAttack(Charecter attacker, Charecter opponent)
{
int damage = attacker.Weapon.Damage + (new Random().Next(attacker.Strength));
damage -= new Random().Next(opponent.Defence);
if (damage > 0)
{
opponent.HitPoints -= damage;
}
return(damage);
}
public async Task <ServiceResponce <List <GetCharecterDTO> > > AddCharecter(AddCharecterDTO newCharecter)
{
ServiceResponce <List <GetCharecterDTO> > serviceResponce = new ServiceResponce <List <GetCharecterDTO> >();
Charecter charecter = (_mapper.Map <Charecter>(newCharecter));
charecter.User = await _context.Users.FirstOrDefaultAsync(u => u.Id == GetUserId());
await _context.Charecters.AddAsync(charecter);
await _context.SaveChangesAsync();
serviceResponce.Data = (_context.Charecters.Where(c => c.User.Id == GetUserId()).Select(c => _mapper.Map <GetCharecterDTO>(c))).ToList();
return(serviceResponce);
}
public void SliceAndDice(Charecter Target)
{
int numOfRandomHits = UnityEngine.Random.Range(2, 3);
for (int i = 0; i < numOfRandomHits; i++)
{
//due to the way the BasicAttack method works this is not optimal :S
if (BasicAttack(Target))
{
Debug.Log("CD inc!!!");
SkillOneCDLeft = SkillOneCD;
}
}
Debug.Log("Slice'nDice");
}
public async Task <ServiceResponse <AttackResultDto> > SkillAttack(SkillAttackDto request)
{
ServiceResponse <AttackResultDto> response = new ServiceResponse <AttackResultDto>();
try{
Charecter attacker = await _context.charecters.Include(chars => chars.CharecterSkills).ThenInclude(cs => cs.Skills)
.FirstOrDefaultAsync(c => c.Id == request.AttackerId);
Charecter opponent = await _context.charecters.FirstOrDefaultAsync(c => c.Id == request.OpponentId);
CharecterSkill charecterSkill =
attacker.CharecterSkills.FirstOrDefault(cs => cs.Skills.Id == request.SkillId);
if (charecterSkill == null)
{
response.Message = $"{attacker.Name} does not known Skil";
response.Success = false;
return(response);
}
int damage = int.Parse(charecterSkill.Skills.Damage) + (new Random().Next(attacker.Intelligence));
damage -= new Random().Next(opponent.Defence);
if (damage > 0)
{
opponent.HitPoints -= damage;
}
if (opponent.HitPoints <= 0)
{
response.Message = $"{opponent.Name} has been defeated !";
}
_context.charecters.Update(opponent);
await _context.SaveChangesAsync();
response.data = new AttackResultDto {
Attacker = attacker.Name,
AttackerHP = attacker.HitPoints.ToString(),
Opponent = opponent.Name,
OpponentHP = opponent.HitPoints.ToString(),
Damage = damage
};
}
catch (Exception ex)
{
response.Message = ex.ToString();
response.Success = false;
}
return(response);
}
public async Task <ServiceResponse <GetCharecterDto> > AddCharecterSkill(AddCharecterSkillDto addCharecterSkill)
{
ServiceResponse <GetCharecterDto> response = new ServiceResponse <GetCharecterDto>();
try
{
Charecter chars = await _context.charecters
.Include(c => c.Weapons)
.Include(c => c.CharecterSkills)
.ThenInclude(we => we.Skills)
.FirstOrDefaultAsync(c => c.Id == addCharecterSkill.CharecterId &&
c.Users.Id == int.Parse(_httpContextAccessor.HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier)));
if (chars == null)
{
response.Success = false;
response.Message = "No Charecter Record found";
return(response);
}
Skill skill = await _context.Skills.SingleOrDefaultAsync(s => s.Id == addCharecterSkill.SkillId);
if (skill == null)
{
response.Success = false;
response.Message = "No skill Record found";
return(response);
}
CharecterSkill charecter = new CharecterSkill {
charecters = chars,
Skills = skill
};
await _context.CharecterSkills.AddAsync(charecter);
await _context.SaveChangesAsync();
response.data = _mapper.Map <GetCharecterDto>(chars);
}
catch (Exception e)
{
response.Success = false;
response.Message = e.Message;
}
return(response);
}
HexNode FindClosestTarget(Charecter closesTo)
{
Debug.Log("Start finding Target!");
GameObject[] found = GameObject.FindGameObjectsWithTag("Monster");
List <Charecter> list = new List <Charecter>();
foreach (GameObject obj in found)
{
list.Add(obj.GetComponent <Charecter> ());
}
float lowestDist = 999999f;
Charecter closest = null;
foreach (Charecter charecter in list)
{
if (!charecter.isPlayerUnit)
{
continue;
}
float x = charecter.posX - closesTo.posX;
float y = charecter.posY - closesTo.posY;
float rawDist = Mathf.Sqrt(x * x + y * y);
if (lowestDist > rawDist)
{
lowestDist = rawDist;
closest = charecter;
}
}
if (closest == null)
{
//Add AI win logic here
return(null);
}
Debug.Log("Found target: " + closest.name);
target = closest;
List <HexNode> resoults = map.GetHexNeighbours(map.hexNodeGrid [closest.posX, closest.posY]);
if (resoults.Count == 0)
{
return(null);
}
HexNode result = resoults[0];
Debug.Log(result.posX);
return(result);
}
//target is kinda useless????
public int FindPath(Charecter target = null, bool AI = false)
{
if (target) {
Debug.Log (map.hexNodeGrid);
sellectedTile = map.hexNodeGrid [target.posX, target.posY];
}
HexNode start = map.hexNodeGrid [currentX, currentY];
HashSet<HexNode> closedSet = new HashSet<HexNode>();
List<HexNode> openSet = new List<HexNode> ();
openSet.Add(start);
while (openSet.Count > 0) {
HexNode currentSearch = openSet [0];
for (int i = 1; i < openSet.Count; i++) {
if(openSet[i].fCost < currentSearch.fCost || openSet[i].fCost == currentSearch.fCost)
{
currentSearch = openSet [i];
}
}
closedSet.Add (currentSearch);
openSet.Remove (currentSearch);
if (currentSearch == sellectedTile) {
return RetracePath(start, sellectedTile, AI);
}
foreach (HexNode neighbour in map.GetHexNeighbours(currentSearch)) {
if (!neighbour.passable || closedSet.Contains (neighbour)) {
continue;
}
int newCostToNeighbour = currentSearch.gCost + GetDistance (currentSearch, neighbour);// should be set to static +10;
if (newCostToNeighbour < neighbour.gCost || !openSet.Contains (neighbour)) {
neighbour.gCost = newCostToNeighbour;
neighbour.hCost = GetDistance (neighbour, sellectedTile);
neighbour.parent = currentSearch;
if (!openSet.Contains (neighbour))
openSet.Add (neighbour);
}
}
}
return 98;
}
public async Task <ServiceResponce <GetCharecterDTO> > AddCharecterSkill(AddCharecterSkillDTO newCharecterSkill)
{
ServiceResponce <GetCharecterDTO> responce = new ServiceResponce <GetCharecterDTO>();
try{
Charecter charecter = await _context.Charecters
.Include(c => c.Weapon)
.Include(c => c.CharecterSkills).ThenInclude(cs => cs.Skill)
.FirstOrDefaultAsync(c => c.Id == newCharecterSkill.CharecterId &&
c.User.Id == int.Parse(_httpContextAccessor.HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier)));
if (charecter == null)
{
responce.Success = false;
responce.Message = "Charecter not found.";
return(responce);
}
Skill skill = await _context.Skills.FirstOrDefaultAsync(s => s.Id == newCharecterSkill.SkillId);
if (skill == null)
{
responce.Success = false;
responce.Message = "Skill not found.";
return(responce);
}
CharecterSkill characterSkill = new CharecterSkill()
{
Charecter = charecter,
Skill = skill
};
await _context.CharecterSkills.AddAsync(characterSkill);
await _context.SaveChangesAsync();
responce.Data = _mapper.Map <GetCharecterDTO>(charecter);
}
catch (Exception ex)
{
responce.Success = false;
responce.Message = ex.Message;
}
return(responce);
}
public async Task <ServiceResponce <AttackResultDTO> > SkillAttack(SKillAttackDTO request)
{
ServiceResponce <AttackResultDTO> responce = new ServiceResponce <AttackResultDTO>();
try
{
Charecter attacker = await _context.Charecters
.Include(c => c.CharecterSkills).ThenInclude(cs => cs.Skill)
.FirstOrDefaultAsync(c => c.Id == request.AttackerId);
Charecter opponent = await _context.Charecters.FirstOrDefaultAsync(c => c.Id == request.OpponentId);
CharecterSkill charecterSkill = attacker.CharecterSkills.FirstOrDefault(cs => cs.Skill.Id == request.SkillId);
if (charecterSkill == null)
{
responce.Success = false;
responce.Message = $"{attacker.Name} doesnt know that skill!";
return(responce);
}
int damage = DoSkillAttack(attacker, opponent, charecterSkill);
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);
}
// getting userid from header directly
public async Task <ServiceResponse <List <GetCharecterDto> > > addNewCharecter(AddCharecterDto objOfClass)
{
ServiceResponse <List <GetCharecterDto> > serviceResponse = new ServiceResponse <List <GetCharecterDto> >();
Charecter chars = _mapper.Map <Charecter>(objOfClass);
// chars.Id = knights.Max(ob => ob.Id) + 1; // getting max id and incrementing it using LINQ
// knights.Add(chars);
chars.Users = await _contect.Users.FirstOrDefaultAsync(x => x.Id == GetUserID());
await _contect.charecters.AddAsync(chars);
await _contect.SaveChangesAsync();
serviceResponse.data = (_contect.charecters.Where(u => u.Users.Id == GetUserID()).Select(ob => _mapper.Map <GetCharecterDto>(ob))).ToList(); // this select all data and convert to dto object and make it List
// // this where for getting records based on reference key and Select for mapping records to list
return(serviceResponse);
}
public override void DoAttacksCheck()
{
if (attemptingAttack > 0 && !hasAttackedForTurn)
{
pathfinder.ClearLines();
switch (attemptingAttack)
{
case 1:
pathfinder.SetMoveBorder(1, posX, posY, Color.red);
Charecter BasicAttackTarget = FindTargetForAttack();
if (BasicAttackTarget)
{
BasicAttack(BasicAttackTarget);
}
break;
case 2:
Debug.Log(SkillOneCDLeft);
if (SkillOneCDLeft > 0)
{
break;
}
//maybe bad name :S
pathfinder.SetMoveBorder(1, posX, posY, Color.red);
Charecter S2target = FindTargetForAttack();
if (S2target)
{
SkillOne(S2target);
}
break;
case 3:
if (SkillTwoCDLeft > 0)
{
break;
}
SkillTwo(null);
break;
}
}
}
