[Question]
  [
* Alice (A) and Bob (B) decided to have a battle.
* Each combatant has 10 health.
* They take turns to roll a 6 sided die for damage.
* That damage is removed from their opponent's health.
* In the end either Alice or Bob, will vanquish their foe.
---
Show me how the battle went. Outputting these codes for the actions which have taken place. 
Attack
```
B a A    
^ Combatant
  ^ Action (attack)
    ^ Target
```
Roll
```
B r 4
^ Combatant
  ^ Action (roll)
    ^ Value
```
Health change
```
A h 6
^ Combatant
  ^ Attribute (health)
    ^ Value   
```
Win
```
A w 
^ Combatant
  ^ Action (win)
```
---
Example output: 
```
A a B
A r 4
B h 6
B a A
B r 6
A h 4
A a B
A r 6
B h 0        
A w
```
---
Here are the rules:
* Write in any language.
* A single roll of the die should have an equal chance of resulting in any one of the numbers 1, 2, 3, 4, 5, or 6.
* Alice always starts (Bob is chivalrous, in an old-fashioned way).
* Output an action for each turn.
* You must report the attack, roll, damage and win actions.
* Combatants are upper case, actions are lower case.
* It must not consistently produce the same result.
* There must be at least one whitespace character between an output combatant, action and value.
* The win action takes place when the opponent has zero or less health.
* All parts of an action must be on the same line.
* There should be one action per line.
* Fewest bytes wins.
Have at it!
  
[Answer]
# [Python 3](https://docs.python.org/3/), 131 bytes
```
x,y="AB"
from random import*
X=Y=10
p=print
while X>0:p(x,"a",y);d=randint(1,6);p(x,"r",d);Y-=d;p(y,"h",Y);x,y,X,Y=y,x,Y,X
p(y,"w")
```
[Try it online!](https://tio.run/##Hc1BCsMgFATQvacIfxXLFBIKXVR@oD2FLgO2KDRGRIie3tqshuExTKzZ7eHWWkFler5IfNK@DWkNtoff4p7yRWg2PE8ickw@ZHE4/30PepkecSyglVClsvwfdR5n3KU6JRGsVObKtvcKcgQjVb@ChuGKAgMtTjpItvYD "Python 3 – Try It Online")
-8 bytes thanks to officialaimm  
-2 bytes thanks to ChooJeremy
[Answer]
# [Python 3](https://docs.python.org/3/), 127 bytes
*This is an improvement on [@HyperNeutrino answer](https://codegolf.stackexchange.com/a/159903/20064) that wouldn't fit in a comment. See the explanation below.*
```
x,y="AB"
s=id(0)
X=Y=10
p=print
while X>0:p(x,"a",y);s=s**7%~-2**67;d=s%6+1;p(x,"r",d);Y-=d;p(y,"h",Y);x,y,X,Y=y,x,Y,X
p(y,"w")
```
[Try it online!](https://tio.run/##HY1BCsIwFAX3OYV8KDTxFVKFFgxf0FMkSyFCClJDU2iy8eqxdDnMwMSyhu98rTWjMD2eJBJPvtVSWHbcaxE5LtO8ii1Mn/fJ3vUtthn0IhRpEielxubXXZQaRuM5NcO5N0exELw0rmO/cwEFgpNm38DCcUGGgxWH2kjW@gc "Python 3 – Try It Online")
---
## An epic quest for a shorter python dice roll
**TL;DR: It's possible to shave 4 bytes off the standard python dice roll by using RSA encryption.**
I wanted to see if the standard python dice roll (**32 bytes**) could be shortened a bit:
```
from random import*;randint(1,6)
```
In particular, `id(x)` is quite convenient to bring some non-deterministic value into the program. My idea then was to somehow hash this value to create some actual randomness. I tried a few approaches, and one of them paid off: [RSA encryption](https://en.wikipedia.org/wiki/RSA_(cryptosystem)#Encryption).
RSA encryption, due to its simplicity, only requires a few bytes: `m**e%n`. The next random value can then be created by encrypting the previous one. Assuming the `(e,n)` key is available, the dice roll can be written with **22 bytes**:
```
s=id(0);s=s**e%n;s%6+1
```
That means we have about 10 bytes to define a valid RSA key. Here I got lucky. During my experiments, I started to use the [Mersenne prime](https://en.wikipedia.org/wiki/Mersenne_prime) **M67** only to realize later on that [Mersenne made a mistake](https://en.wikipedia.org/wiki/Mersenne_prime#History) including **M67** in his list. It turns out to be the product of `p=193707721` and `q=761838257287`. I had found my modulus:
```
n=~-2**67
```
Now, the exponent and the [Charmichael totient](https://en.wikipedia.org/wiki/Carmichael_function) `lcm(p-1,q-1)` need to be coprime. Luckily again, the first prime number that do not divide the totient of n is only one digit long: 7. The dice roll can then be written using **28 bytes** (4 bytes less than the standard approach):
```
s=id(0);s=s**7%~-2**67;s%6+1
```
One good thing with **M67** is that the random value generated has 66 bits, which is more than the usual 64 bits RNG. Also, the use of RSA makes it possible to go back in time by decrypting the current value multiple times. Here are the encrypting and decrypting keys:
```
Encryption: (7,                    147573952589676412927)
Decryption: (42163986236469842263, 147573952589676412927)
```
I'm definitely not an expert in statistics or cryptography, so I can't really tell whether or not this RNG checks the criteria for "good randomness". I did write [a small benchmark](https://gist.github.com/vxgmichel/2f7cb31f32c5d92810d44ccca36c99b7) that compares the standard deviation of the occurrences of the 1 to 6 dice rolls using different RNGs. It seems like the proposed solution works just like other ones.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~146~~ 141 bytes
```
f(A,B,r,t,a,b){for(A=B=10;r=1+clock()%6,A*B>0;t=!t)printf("%c a %c\n%c r %u\n%c h %i\n",a=65+t,b=66-t,a,r,b,t?A-=r:(B-=r));printf("%c w",a);}
```
[Try it online!](https://tio.run/##TYyxDsIgFAB3vwKbkPDsI2kHGSRo4CdculASaiNSgxiHpr8uVieXyy13jg/OleKZRoMJM1rsYfZTYloZ1TYyqbZ2YXJXBlSg3pljI7PaZrinMWbPKuqIJdR1cZVE6PMnF0LHLlZoldjXGXslBP@@E/aYT5qrdGBmJYD8@7zWAORSbnaMDOaNZyA3S3k7H@zwKPxsQ/gA "C (gcc) – Try It Online")
De-golf:
```
f(A,B,r,t,a,b){
    for(A=B=10; //Initialize HP
        r=1+clock()%6, // Get the number of processor cycles the program has consumed. This is relatively random, so I call it good enough.
        A*B>0;t=!t) // Flip t for change of turns
        printf("%c a %c\n%c r %u\n%c h %i\n", // Print the turn
            a=65+t,b=65+!t,a,r,b, // 65 is ASCII for 'A', 66 for 'B'
            t?A-=r:(B-=r)); // Deduct the damage.
    printf("%c w",a); // Print the winner
}
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 49 bytes
```
"BaABr0Aha"S3ô»D„ABÂ‡[6LΩ©Tǝ¤H®-©16ǝ=®0‹#s]н…ÿ w?
```
[Try it online!](https://tio.run/##AVAAr/8wNWFiMWX//yJCYUFCcjBBaGEiUzPDtMK7ROKAnkFCw4LigKFbNkzOqcKpVMedwqRIwq4twqkxNsedPcKuMOKAuSNzXdC94oCmw78gdz///w "05AB1E – Try It Online")
**Explanation**
```
"BaABr0Aha"                                        # push the initial state of B
           S                                       # split to list of characters
            3ô                                     # divide into 3 parts
              »                                    # join each part on space and all on nl
               D„ABÂ‡                              # make a copy with A and B inverted
                     [                             # start a loop
                      6LΩ©                         # pick a random number in [1 ... 6]
                          Tǝ                       # insert at position 10 of the string
                            ¤H                     # get the last char of the string and
                                                   # convert from hex
                              ®-©                  # subtract the random number
                                 16ǝ=              # insert at position 16 and print
                                     ®0‹#          # if the hp is less than 0, break
                                         s         # swap the other string to the stack top
                                          ]        # end loop
                                           н…ÿ w?  # print the winner
```
[Answer]
# [Perl 5](https://www.perl.org/), ~~93~~ ~~88~~ 87 bytes
```
$A=$B=10;$_=B;${$_^=v3}-=$%=1+rand 6,say"$_ a $'
$_ r $%
$' h $$_"until//>$$_;say"$_ w"
```
[Try it online!](https://tio.run/##K0gtyjH9/1/F0VbFydbQwFol3tbJWqVaJT7Otsy4VtdWRdXWULsoMS9FwUynOLFSSSVeIVFBRZ0LSBcpqKhyqagrZCioqMQrleaVZObo69sB2dZQheVK////yy8oyczPK/6v62uqZ2igZwAA "Perl 5 – Try It Online")
[Answer]
# JavaScript (ES6), 122 bytes
```
f=(h=[10,10,p=0])=>`${x='AB'[p]} a ${y='BA'[p]}
${x} r ${d=Math.random()*6+1|0}
${y} h ${H=h[p^=1]-=d}
${H<1?x+' w':f(h)}`
```
[Try it online!](https://tio.run/##HcmxDoIwFIXh3afoQNJWhNDFwXg1MLH4BARDQynVIG2AKAT77LWYnOX835O/@VgPDzNFvRaNcxKIgoIlBz8DSUnhUgXrDDjNcGFKizgK1gVwlv7vzptFg28CbnxS8cB7oV@E7o8h@yabLxYp7zmowtyBlRGILedndp1DjD74JImitnK17kfdNXGnWyIJpe4H "JavaScript (Node.js) – Try It Online")
[Answer]
# [Java (JDK 10)](http://jdk.java.net/), 180 bytes
```
v->{var r="";int p=0,H[]={10,10},h=0;for(;H[0]*H[1]>0;)r+=r.format("%3$c a %4$c%n%3$c r %d%n%4$c h %d%n",h+=Math.random()*6-h+1,H[p]-=h,p+65,(p^=1)+65);return r+(char)(66-p)+" w";}
```
[Try it online!](https://tio.run/##LY8xb4MwEIX3/IoTCpIdjAVqy@I6Y5UlU6QuiEouhNjUGMsYqijit1OXdrrv3r270@vELNKu@VprLcYRzkIZeOwA7PSpVQ2jFz6UeVAN9GGGLt4pcysrEO424s0K0IUjdPJK03YytVeDoW//8PoeVsnf1hFavs7p8TELB45HEVPGg@UZOZUVf@QZybOFSJ6xdnCIncqsOpzKvDpmDLuEOxrkXngUxU/7GgTEz/s6NlvjIG4CBgHkhhGRCT8LL6kTphl6hA9FKpM8vLJVyiWxSfFCkP3gOQ6Embv6yRlwCaqlcBgVRWpxEsF3xJaVbTEv99FfezpMntqQx2uDWiqs1XdkJq0x/rUtu2X9AQ "Java (JDK 10) – Try It Online")
## Credits
* -8 bytes thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen)
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~122 120 96 92~~ 91 bytes
```
f=->x=?A,y=?B,m=10,n=m{p [x,?a,y],[x,?r,r=1+rand(6)],[y,?h,t=n-r]
t<1?p([x,?w]):f[y,x,t,m]}
```
Saved 1 byte thanks to [Asone Tuhid](https://codegolf.stackexchange.com/users/77598/asone-tuhid).
[Try it online!](https://tio.run/##KypNqvz/P81W167C1t5Rp9LW3kkn19bQQCfPNre6QCG6Qsc@UacyVgfEKNIpsjXULkrMS9Ew0wQKVerYZ@iU2ObpFsVyldgY2hdogFSVx2papQHlKnRKdHJja/@nRcf@BwA "Ruby – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 142 bytes
```
#define R(c,t)r=rand()%6+1,c&&printf(#c" a "#t"\n"#c" r %d\n"#t" h %d\n",r,t-=t<r?t:r),t||puts(#c" w")
f(A,B,r){for(A=B=10;A*B;R(B,A))R(A,B);}
```
[Try it online!](https://tio.run/##RY7BasMwEETP8VcsMgnaVgLn0kMVE@xP8KWXUnBlKxW1ZbNe00OSX68apYVehplZlnlWn6yNMe9650MPjbSKkUpqQydx@/S4V3a3m8kHdjK3AloQOYvXIFIg2HbJsoCPX6tIsS75QEd@JlR8ucwrL/fPL4GZk5WqFeHZTSSrsi73hakeatPIWlWITTqjucbbHIytDxLhnG2WOw37sZcFwhvYYbKfEtFkGyeT/vElrP@Sel4pQGGya/y2bmhPS9QvYdJ@nAdvPUftbul99QP78AM "C (gcc) – Try It Online")
[Answer]
# Java 8, ~~230~~ ~~229~~ 228 bytes
```
v->{for(int h=104,a=h,x=0,y=1,A=10,B=A,r=0,t=0,T;a<119;System.out.printf("%c %3$c %c%n",x+65,y=(a<98?t=r+=Math.random()*6-r+1:a>h?(T=x<1?A-=t:(B-=t))<0?0:T:A*B<1?-16:(x^1)+17)+48,a=a<98?114:a>h?h:A*B<1?119:97))x^=a>h|A*B<1?1:0;}
```
-2 bytes thanks to *@ceilingcat*.
Note: there is already [a much shorter Java answer, so make sure to upvote his](https://codegolf.stackexchange.com/a/159906/52210)! I use a completely different approach however, so figured it was worth posting as well.
**Explanation:**
[Try it online.](https://tio.run/##LVDfb4IwEH7fX9GYmbRSCM2cPwqV4Lu@SPayzKQrMHBYTKkE4/zb2akkd9f0u/su930H2Uq3PmX6kP72qpJNgzay1NcXhEptM5NLlaHt/YtQW5cpUvjj/rQkAOwGCdFYaUuFtkgjgfrWXV3z2mDgo0Iwf0qlKGgnfHoRjMaA0LWIqQHAQiaBDBlbBrtLY7OjV5@tdzLAzfForND47RWKGusR7ZzZO6zAMlwuIiuMIzbSFp6ROq2PmExmrnEYl6siwonoQhbFrrAcr6ESEvqRzxMeT9bQcNmM427PiMPmxJku4MDHUsamD34xzMFZfDknpNsLgP8GkPvBrQ@eyk/n7wqUDwY8DDqCfXhnQcLP55ckT@u0p7A@V9Xg2q3/Bw)
```
v->{                     // Method with empty unused parameter and no return-type
  for(int h=104,         //  Temp integer with unicode for 'h' to save bytes
          a=h,           //  Second part (Action)
          x=0,           //  First part
          y=1,           //  Third part
          A=10,          //  Score player A, starting at 10
          B=A,           //  Score player B, starting at 10
          r=0,           //  Random dice-roll
          t=0,           //  Previous dice-roll
          T;             //  Temp integer
      a<119              //  Loop until there is a winner:
      ;                  //    After every iteration:
       System.out.printf(//     Print:
        "%c %3$c %c,%n", //      The three parts with spaces, and a new-line
                         //      First part:
        x+65,            //       Add 65 to `x` to convert 0/1 to 65/66 
                         //       (unicode values of A/B)
        (y=              //      Third part (after set-up):
           (a<98?        //       If the previous action was 'a'
             t=r+=Math.random()*6-r+1
                         //        Roll the dice, and save it in `t`
            :a>h?        //       Else-if the previous action was 'r':
             (T=x<1?     //        If the first part changed to player A:
              A-=t       //         Subtract the previous dice-roll from A
             :           //        Else:
              (B-=t))    //         Subtract the previous dice-roll from B
             <0?         //        If this score is below 0:
              0          //         Use 0
             :           //        Else:
              T          //         Use this score
           :             //       Else (the previous action was 'h'):
            A*B<1?       //        Is there a winner:
             -16         //         Change the third part to a space
            :            //        Else:
             (x^1)+17)   //         Change the third part to the other player
         +48,            //       Add 48 to convert it to unicode
         a=              //      Second part:
           a<98?         //       If the previous action was 'a': 
            114          //        Change it to 'r'
           :a>h?         //       Else-if the previous action was 'r':
            h            //        Change it to 'h'
           :             //       Else (the previous action was 'h'):
            A*B<1?       //        If either score is 0:
             119         //         Use 'w'
            :            //        Else:
             97))        //         Use 'a'
    x^=                  //   First part set-up:
       a>h               //    If the previous action is 'r',
       |A*B<1?           //    or there is a winner:
         1               //     Change A→B or B→A
       :                 //    Else:
         0;}             //     A/B remains unchanged
```
[Answer]
## Batch, 174 bytes
```
@set/aA=B=10
@set c=A
@set d=B
:g
@set/ar=%random%%%6+1,h=%d%-=r
@echo %c% a %d%
@echo %c% r %r%
@echo %d% h %h%
@if %h% gtr 0 set c=%d%&set d=%c%&goto g
@echo %c% w
```
Explanation: `%` variable references are substituted at parse time. This has two useful benefits:
* `%d%-=r` subtracts `r` from the variable named by `d` (i.e. indirect reference)
* `set c=%d%&set d=%c%` is simply a straight swap.
[Answer]
# PHP 7.1: 159 bytes
```
<?php $A=$B=10;$t='AB';while($A>0&&$B>0){$a=$t[0];$b=$t[1];$d=rand(1,6);$$b-=$d;echo"$a a $b\n$a r $d\n$b h {$$b}\n";$t=strrev($t);}echo($A>0?'A':'B')." w\n";
```
[Run it in the browser here!](http://sandbox.onlinephpfunctions.com/code/79a833581d55a878c3e79a8da8cfb5a8a5cc1303)
# PHP 5.6: 156 bytes
```
<?php $A=$B=10;$t='AB';while($A>0&&$B>0){list($a,$b)=$t;$d=rand(1,6);$$b-=$d;echo"$a a $b\n$a r $d\n$b h {$$b}\n";$t=strrev($t);}echo($A>0?'A':'B')." w\n";
```
[Run it in the browser here!](http://sandbox.onlinephpfunctions.com/code/ad3752f87c8167f19b29920b4309d5728f413706)
Here's what the PHP 5.6 solution looks like with formatting and comments:
```
<?php
// Initialize both HP counters
$A = $B = 10;
// Set the turn order as a string (which 5.6 allows to be unpacked into a list)
$t = 'AB';
// Run this loop as long as both players have HP
while ($A > 0 && $B > 0) {
    // Unpack the turn string into $a and $b variables; on the first run, $a = 'A'
    // and $b = 'B'. This is no longer possible in PHP 7.0, so the PHP 7.0
    // solution needed to use an array instead.
    list($a, $b) = $t;
    // Set damage to a random number between 1 and 6
    $d = rand(1, 6);
    // Subtract the damage from the referenced value $b. On the first turn, this
    // is 'B', so this ends up subtracting $d from $B. Next turn, $b will be 'A',
    // so it'll subtract $d from $A
    $$b -= $d;
    // Echo the string (interpolated values)
    echo "$a a $b\n$a r $d\n$b h {$$b}\n";
    // Reverse the turn order string ('AB' becomes 'BA', which will affect the
    // call to list in the first line of the while-loop)
    $t = strrev($t);
}
// Someone's run out of HP; figure out whom by figuring out who still has HP
echo ($A > 0 ? 'A' : 'B') . " w\n";
```
[Answer]
# F#, 238 235 bytes
I thought I was doing well, but you've all far outclassed me!
```
let p=printfn
let mutable A=10
let mutable B=A
let x h a d=
 p"%s a %s"a d
 let i=(new System.Random()).Next(1,7)
 let j=h-i
 p"%s r %i"a i
 p"%s h %i"d j
 if j<=0 then p"%s w"a
 j
while A*B>0 do
 B<-x B"A""B"
 if B>0 then A<-x A"B""A"
```
[Try it online!](https://tio.run/##VY9RS8MwFIXf@ysOkbFVXNs9CbIMWtAnEXG@iQ/Zmi4pbRLSzG2/vt6sKviW833nXm6aYbm3Xo55jmcpvEFPCWJnjwFPNxABKgT3kOfNoIR3mfWHhLpbKRGUxJw678dgvRbdHM7bVu4DGuunPUp2LkuSj/WjCf7yarUJm8@kkwG90AbCH77AMSISx50n35jkGvtjELtOouSr4j@peDmBMxQEap4Ajs0Ges8GRoBy1JovjDxhexmC7LM3YWrbL9I0e5HnsFjd3ac/vZarpf7d4THTtOMvq5hrtJR1g3bNi/hvM8kTE8TJnZSOp95WmwK1JVatl2dUrGSsYtNoVNfJMqqSONkRxfgN)
Thanks to Rogem for the brilliant advice to use A\*B>0 instead of A>0&&B>0 (takes off 3 bytes).
Thank you also to officialaimm, whose hint about predefining printf in the Python answer helped me shave a few bytes off too.
[Answer]
# [Haskell](https://www.haskell.org/), 204 bytes
My attempt with Haskell, I wasn't able to get it more competitive unfortunately 
```
import System.Random
main=getStdGen>>= \g->putStr$q(randomRs(1,6)g)10(10::Int)"A ""B "
(!)=(++)
l="\n"
q(x:z)a b p o=p!"a "!o!l!p!"r "!show x!l!o!"h "!show n!l!if n<1then p!"w"else q z n a o p where n=b-x
```
[Try it online!](https://tio.run/##NYw9y8IwFEb3/oqbi0OCH9jFoZiCLuKqq0vEa1NMb9ok0uqfr@GFdzvn4fBYE1/k3Dy3Xe9DgusnJuo2F8MP3xWdaVk3lK7pcSKuaw23Zl337zyExSDDX3WJslztVKPKrSy3VXXmpPAAiEfAQgql5XKpCqfxxlgMcqq@ysAdevC6F2gAhRdOZAwZo/UjTNm9QPvvnL19Au/LZIkhpyOSiwQDfIHBgM9vo6VAwPq@nub5Bw "Haskell – Try It Online")
Explanations:
```
import System.Random  --import random module
main=                        --main function, program entry point
 getStdGen                   -- get the global random number generator
   >>= \g->                  --using the random generator g
       putStr $ q            --print the result of function q, passing in ..
          (randomRs (1,6) g) --an infinite list of random numbers, 1 to 6 generated by g
           10 (10::Int)      --the starting health of both players, 
                             --type annotation sadly seems to be required
           "A " "B "         --The names of the players,
                             --with an extra space for formatting
(!)=(++) --define the operator ! for list (String) concatenation, 
         -- we do this a lot so we save a bit by having a one byte operator
l="\n"   -- define l as the newline character
q      --define function q                         
 (x:z) --our list of random numbers, split into the next number (x) and the rest (z)
 a     -- the health of the active player
 b     -- the health of the player getting attacked
 p     -- the name of the active player
 o     -- the name of the player getting attacked
=
  p!"a "!o!l --create the attack action string with a newline
 !p!"r "!show x!l -- append the roll action
 !o!"h "!show n!l -- append the health remaining
 !           -- append the result of the following if
  if n<1     -- if the player being attacked has been defeated
  then p!"w" -- append the win string for the active player
  else q z n a o p  --otherwise append the result of calling q again with 
                    --rest of the random numbers, and the active players swapped
  where n=b-x -- define the attacked player's new health n
              -- their current health b - the random roll x
```
[Answer]
# [Julia 0.6](http://julialang.org/), 175 bytes
```
p=println()
f(l="AB",h=[10,10],a=1)=(while min(h...)>0;d=3-a;p(l[a]," a ",l[d]);r=rand(1:6);h[d]-=r;p(l[a]," r ",r);p(l[d]," h ",max(h[d],0));a=d;end;p(l[findmax(h)[2]]," w"))
```
[Try it online!](https://tio.run/##RcpBCsIwEIXhvacoWc1AWhKFLgwj6DVCFgPTkkgMJSj19rHtxuX/3vf85MRjawstNZV3LoCnGTKp@0PpSN4abU3QTBYJ1pjy1L1SgTgMA96ME7r07BbInoNWHXdKZy8BXaXKRcBeR3RxW3qqf1Y3VvFo2Ttu/eIv7FAbRMckbipyiDkVOU7057DrVSG29gM "Julia 0.6 – Try It Online")
Long, ungolfed version:
```
function status(player, health)
    println("$player h $(max(0,health))")
end
function roll(player)
    x = rand(1:6)
    println("$player r $x")
    x
end
function play()
    players = ["A","B"]
    healths = [10, 10]
    attacker = 1
    while min(healths...) > 0
        println("$(players[attacker]) a $(players[3-attacker])")
        healths[3-attacker]-=roll(players[attacker])
        status(players[3-attacker], healths[3-attacker])
        attacker = 3 - attacker
    end
    winner = findmax(healths)[2]
    println("$(players[winner]) w")
end
```
[Answer]
## VBA, ~~222~~ ~~185~~ 179 Bytes
This recursive solution involves 3 subs
1. g is the *game start* that kicks off the first turn
2. t is called for each *turn*. It uses recursion.
3. ~~p is shorter than Debug.Print when used more than 3 times (only 4 in this solution)~~ *Edit:* Now that I learned that `Debug.?` is an acceptable alternative to `Debug.Print`, `Debug.?x` is shorter than calling a Sub to print.
```
Sub g()
t "A",10,"B",10
End Sub
Sub t(i,j,x,h)
d=Int(Rnd()*6)+1
Debug.?i &" a "&x
Debug.?i &" r "&d
h=h-d
If h<1Then
Debug.?i &" w"
Else
Debug.?x &" h "&h
t x,h,i,j
End If
End Sub
```
This was a fun challenge. If you know of an online interpreter like TIO for VB6/VBScript/VBA please leave a comment. Then I can post a link to a working solution.
If you want to test this code and have Microsoft Excel, Word, Access, or Outlook installed (Windows only), press Alt+F11 to open the VBA IDE. Insert a new code module (Alt+I,M) and clear out Option Explicit. Then paste in the code and press F5 to run it. The results should appear in the Immediate Window (press Ctrl+G if you don't see it).
*Edit 1:* Removed whitespace that the VBA editor will automatically add back in. Reduced by 37 bytes  
*Edit 2:* Removed Sub p()\* to save 6 bytes after learning `Debug.?` is an acceptable alternative to `Debug.Print`. Calling a [Sub](https://codegolf.stackexchange.com/a/166127/69061) to handle `Debug.?` only saves bytes after more than six calls.
]