// File: /workspace/github_cpp_makefile_star2_O2/giovifazi[P]knossos-bloodbath/ClassPlayer.cpp
// Function: Player::engage_battle(Player**, Map&, int, int, Node&, int&)
int Player::engage_battle(Player* p[], Map& map, int np, int p1_index, Node& node, int& alive_players)
{
   int x1 = pos->get_x(), y1 = pos->get_y();    // Coordinate di dove avviene lo scontro
   
   int atk2, p2_index;
   std::string shield2;

    
   // Cerco il giocatore nelle stesse coordinate con cui combattere
   for (int i=0; i < np; i++)
      if (i != p1_index && p[i] != NULL)                             // Escludo il giocatore attaccante e i morti dal controllo
         if (p[i]->pos->get_x() == x1 and p[i]->pos->get_y() == y1)
         {
            // salvo le variabili del giocatore che viene attaccato ed esco dal ciclo
            atk2 = p[i]->getAtk();
            shield2 = p[i]->getShield();
            p2_index = i;
            break;
         }

   // prendo i nomi dei giocatori per la stampa dell HUD
   std::string name_p1=getName();
   std::string name_p2=p[p2_index]->getName();		


   // Calcolo la formula per il combattimento (atk1-scudo2 e atk2-scudo1)
   // Sottraggo all attacco di un giocatore i valori dello scudo dell altro
   if (atk2 > 3)
   {
      if (getShield() == "bronze")
         atk2 -= 1;
      else
      if (getShield() == "silver")
         atk2 -= 2;
      else
      if (getShield() == "gold")
         atk2 -= 3;
   }
   else
      atk2 = 0;

   if (atk > 3)
   {
      if (shield2 == "bronze")
         atk -= 1;
      else
      if (shield == "silver")
         atk -= 2;
      else
      if (shield == "gold")
         atk -= 3;
   }
   else
      atk = 0;


   // Tiro il dado per randomizzare lo scontro, aumentanto a caso atk e atk2
   srand(time(0));
   int roll = (rand()%10) +1;
   
   switch (roll)
   {
      case 1:
         atk += 4;
         break;

      case 2:
         atk += 3;
         break;

      case 3:
         atk += 2;
         break;

      case 4:
         atk2 += 4;
         break;

      case 5:
         atk2 += 3;
         break;

      case 6:
         atk2 += 2;
         break;
   }
   

   // Infliggo i rispettivi danni
   p[p2_index]->set_hp(p[p2_index]->getHp() - atk);

   set_hp(hp - atk2);

   // Stampo su schermo i danni inflitti
   for(int j=0; j<40; j++)
      std::cout << "\n";

   // Variabile per stampare nell hud la morte di entrambi i giocatori
   int j=-1;	

   // nel caso muoiano entrambi i giocatori ritorna 1 se il p1 resuscita, 
   // 2 se resuscita p2
   int morte=0;

   // Controlla giocatori uccisi, impedisce la morte di entrambi
   if (!p[p2_index]->is_alive() and !p[p1_index]->is_alive())
   {
      // In caso siano entrambi morti, sceglie a caso chi riportare in vita
      // (con hp = 1)
      roll = (rand()%2) +1;

      if (roll == 1)
      {
         set_hp(1);
         j=1;

         p[p2_index]->remove_from_map(map);
         p[p2_index]->pos = NULL;
         p[p2_index] = NULL;
         alive_players--;  
 
      }
      else
      {
         p[p2_index]->set_hp(1);
         j=2;
         morte=2;
        
      }
   }
   else {
   // Visto che se muore il giocatore due, (cioe` il giocatore che viene
   // attaccato) non essendo il suo turno, non viene effettuato il controllo 
   // sulla sua morte nel main (essendo il turno del giocatore 1),
   // e se non viene rimosso, rimane sulla mappa con gli hp negativi

                if (!p[p1_index]->is_alive()){ j= 0; morte=1;}  //controllo se e' morto il giocatore che attacca e stampa

                if (!p[p2_index]->is_alive())
                {
                        j=3;

                        p[p2_index]->remove_from_map(map);
                        p[p2_index]->pos = NULL;
                        p[p2_index] = NULL;
                        alive_players--;    
                }
        }

   // Stampa grafica
  hud_battle(name_p1, name_p2, atk, atk2, j);
  
  return morte;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl %r8d, %r13d
movl %ecx, %ebx
movq %rdx, -0x50(%rbp)
movq %rsi, %r12
movq %rdi, %r14
movq 0x50(%rdi), %rdi
callq 0x2c02
movl %eax, %r15d
movq %r14, -0x30(%rbp)
movq 0x50(%r14), %rdi
callq 0x2c0c
leaq -0xa8(%rbp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movl %eax, -0x38(%rbp)
movb $0x0, (%rcx)
movl %r13d, -0x3c(%rbp)
movl %r13d, %r14d
xorl %r13d, %r13d
testl %ebx, %ebx
cmovlel %r13d, %ebx
cmpq %r13, %rbx
je 0x655e
cmpq %r13, %r14
je 0x6559
movq (%r12,%r13,8), %rax
testq %rax, %rax
je 0x6559
movq 0x50(%rax), %rdi
callq 0x2c02
cmpl %r15d, %eax
jne 0x6559
movq (%r12,%r13,8), %rax
movq 0x50(%rax), %rdi
callq 0x2c0c
cmpl -0x38(%rbp), %eax
je 0x6619
incq %r13
jmp 0x6522
movq %rax, -0x58(%rbp)
movq %r12, %r14
movq -0x30(%rbp), %rax
leaq 0x8(%rax), %rsi
leaq -0x98(%rbp), %rdi
callq 0x21d0
movl %ebx, %eax
movq %rax, -0x38(%rbp)
movq (%r14,%rax,8), %rsi
addq $0x8, %rsi
leaq -0x118(%rbp), %rdi
callq 0x21d0
xorl %r15d, %r15d
movl $0x0, %r13d
movq -0x58(%rbp), %rbx
cmpl $0x4, %ebx
jl 0x6693
movq -0x30(%rbp), %rax
leaq 0x30(%rax), %rsi
leaq -0x78(%rbp), %rdi
movq %rsi, -0x48(%rbp)
callq 0x21d0
leaq 0x634b(%rip), %rsi      # 0xc910
leaq -0x78(%rbp), %r12
movq %r12, %rdi
callq 0x69fa
movl %eax, %r13d
movq %r12, %rdi
callq 0x2080
testb %r13b, %r13b
je 0x65e5
decl %ebx
jmp 0x6614
leaq -0x78(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x21d0
leaq 0x631e(%rip), %rsi      # 0xc917
movq %r12, %rdi
callq 0x69fa
movl %eax, %r13d
movq %r12, %rdi
callq 0x2080
testb %r13b, %r13b
je 0x665d
addl $-0x2, %ebx
movl %ebx, %r13d
jmp 0x6693
movq %r12, %r14
movq (%r12,%r13,8), %rsi
movl 0x4(%rsi), %eax
movq %rax, -0x58(%rbp)
addq $0x30, %rsi
leaq -0x98(%rbp), %rdi
callq 0x21d0
leaq -0xb8(%rbp), %rdi
leaq -0x98(%rbp), %r15
movq %r15, %rsi
callq 0x2180
movq %r15, %rdi
callq 0x2080
movl %r13d, %ebx
jmp 0x6565
leaq -0x78(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x21d0
leaq 0x62ad(%rip), %rsi      # 0xc91e
leaq -0x78(%rbp), %r13
movq %r13, %rdi
callq 0x69fa
movl %eax, %r12d
movq %r13, %rdi
callq 0x2080
leal -0x3(%rbx), %r13d
testb %r12b, %r12b
cmovel %ebx, %r13d
movq -0x30(%rbp), %rbx
cmpl $0x4, 0x4(%rbx)
jl 0x6705
leaq 0x626c(%rip), %rsi      # 0xc910
leaq -0xb8(%rbp), %rdi
callq 0x69fa
testb %al, %al
je 0x66c1
movq -0x30(%rbp), %rbx
movl 0x4(%rbx), %r15d
decl %r15d
jmp 0x6705
movq -0x30(%rbp), %rbx
leaq 0x30(%rbx), %r15
leaq 0x6247(%rip), %rsi      # 0xc917
movq %r15, %rdi
callq 0x69fa
testb %al, %al
je 0x66e6
movl 0x4(%rbx), %r15d
addl $-0x2, %r15d
jmp 0x6705
leaq 0x6231(%rip), %rsi      # 0xc91e
movq %r15, %rdi
callq 0x69fa
testb %al, %al
je 0x6709
movq -0x30(%rbp), %rbx
movl 0x4(%rbx), %r15d
addl $-0x3, %r15d
movl %r15d, 0x4(%rbx)
xorl %edi, %edi
callq 0x2100
movl %eax, %edi
callq 0x2110
callq 0x2050
pushq $0xa
popq %rcx
cltd
idivl %ecx
cmpl $0x5, %edx
ja 0x6765
leaq 0x617a(%rip), %rax      # 0xc8a8
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq -0x30(%rbp), %rdx
addl $0x4, 0x4(%rdx)
jmp 0x6769
addl $0x3, %r13d
jmp 0x6765
movq -0x30(%rbp), %rdx
addl $0x2, 0x4(%rdx)
jmp 0x6769
addl $0x4, %r13d
jmp 0x6765
movq -0x30(%rbp), %rdx
addl $0x3, 0x4(%rdx)
jmp 0x6769
addl $0x2, %r13d
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rax
movq (%r14,%rax,8), %rax
movl 0x4(%rdx), %ecx
subl %ecx, (%rax)
subl %r13d, (%rdx)
pushq $0x28
popq %rbx
movq 0x984d(%rip), %r15      # 0xffd0
leaq 0x60cb(%rip), %r12      # 0xc855
subl $0x1, %ebx
jb 0x679c
movq %r15, %rdi
movq %r12, %rsi
callq 0x2120
jmp 0x678a
movq -0x38(%rbp), %rax
movq (%r14,%rax,8), %rdi
cmpl $0x0, (%rdi)
movslq -0x3c(%rbp), %rax
movq (%r14,%rax,8), %rax
movl (%rax), %eax
jle 0x67c8
xorl %r14d, %r14d
xorl %r15d, %r15d
testl %eax, %eax
setle %r14b
setg %r15b
negl %r15d
jmp 0x683b
testl %eax, %eax
jle 0x67f4
movq -0x50(%rbp), %rsi
callq 0x646a
movq -0x38(%rbp), %rcx
movq (%r14,%rcx,8), %rax
andq $0x0, 0x50(%rax)
andq $0x0, (%r14,%rcx,8)
movq 0x10(%rbp), %rax
decl (%rax)
xorl %r14d, %r14d
pushq $0x3
jmp 0x6839
callq 0x2050
testb $0x1, %al
jne 0x68d2
movq -0x30(%rbp), %rax
movl $0x1, (%rax)
movq -0x38(%rbp), %rax
movq (%r14,%rax,8), %rdi
movq -0x50(%rbp), %rsi
callq 0x646a
movq -0x38(%rbp), %rcx
movq (%r14,%rcx,8), %rax
andq $0x0, 0x50(%rax)
andq $0x0, (%r14,%rcx,8)
movq 0x10(%rbp), %rax
decl (%rax)
xorl %r14d, %r14d
pushq $0x1
popq %r15
leaq -0xf8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x21d0
leaq -0xd8(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x21d0
movq -0x30(%rbp), %rax
movl 0x4(%rax), %edx
leaq -0xf8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
movl %r13d, %ecx
movl %r15d, %r8d
callq 0x544c
leaq -0xd8(%rbp), %rdi
callq 0x2080
leaq -0xf8(%rbp), %rdi
callq 0x2080
leaq -0x118(%rbp), %rdi
callq 0x2080
leaq -0x98(%rbp), %rdi
callq 0x2080
leaq -0xb8(%rbp), %rdi
callq 0x2080
movl %r14d, %eax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x38(%rbp), %rax
movq (%r14,%rax,8), %rax
movl $0x1, (%rax)
pushq $0x2
popq %r15
movl %r15d, %r14d
jmp 0x683b
jmp 0x6924
jmp 0x691f
jmp 0x6924
jmp 0x6924
movq %rax, %rbx
leaq -0xd8(%rbp), %rdi
callq 0x2080
jmp 0x6908
movq %rax, %rbx
leaq -0xf8(%rbp), %rdi
callq 0x2080
jmp 0x6927
movq %rax, %rbx
jmp 0x6933
jmp 0x691f
jmp 0x6924
movq %rax, %rbx
jmp 0x693f
movq %rax, %rbx
leaq -0x118(%rbp), %rdi
callq 0x2080
leaq -0x98(%rbp), %rdi
callq 0x2080
leaq -0xb8(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2220
nop