mob
   var
      hp = 4

mob
   verb
      Attack(mob/M in oview(1))
         M.hp-=1
         M.Check()

mob
   proc
      Check(mob/M)
         if(!M.hp)
            [src] has killed [M]!

mob
   var
      hp = 4
      MHp = 4 //You'll see why I added this very soon

mob
   verb
      Straight_Punch()  //This will show you how to attack in one direction without having a mob list show up.
         var/mob/M = locate(/mob) in get_step(src,src.dir) //Tries to locate ONE mob in the step ahead of the usr (hence the dir)
         if(!M) return  //If a mob is NOT found (M=null), we stop the program from continuing onwards.. ! is a boolean checker
         M.thp(1,src)  //I _HIGHLY_ recommend the use of 'general' procedures for things like taking health.. \
reason: Less screwups, less space being used, less time being wasted [imagine copying MANY things over instead of where you could make a few lines and than make one line to refer it all], and if you want to update, you need to update one spot instead of dangload of lines

mob
   proc
      thp(dmg=0,mob/M)  //thp = take HP
         src.hp=min(max(0,src.hp-max(0,dmg)),src.Mhp)
/*Let's break the above down:
min() picks the lowest value from the list.. eg: min(25,12,21) would return 12..

max() returns the highest value from the list.. eg: max(0,-21,11) would return 11..

max(0,dmg) => Makes the highest damage possible 0.. why? Think about it:
dmg=21 ==> max(0,21) = 21
dmg=0 ==> max(0,0) = 0
dmg=-12 ==> max(0,-12) = 0 <-- remember, 0 > -12 and max() picks the highest number.

max(0,src.hp-max(0,dmg) => Makes the lowest possible amount of health lost equal to 0.. we don't want them to gain health in a take HP proc, don't we? ;)

min(..,src.Mhp) => Always makes the HIGHEST possible health value equal to the Max HP.. just in case.. you should know how by now why.. (if you don't: if(hp < M) than hp = hp.. but if hp > Mhp than hp = Mhp due to the min() picking the lowest value*/

         if(src.hp<=0)  //Even though we made the lowest possible health = 0, it's very wise to cover all possible extents we can
            src.Death(M)
      Death(mob/M) // M = killer
         if(M.hp>0)return //no need to kill a person who has life still.. safety checks = always a goodthing to have
         world<<"\red[src.name] has killed [M==src?"\himself" : M.name]!"
/*I really don't know why people don't get the compact if statement (the ? and : part)

X?Y : Z
is the samething as
if(X)
   Y
else
   Z

..so:
dmg*= hp>100 ? 2 : 1

the above is saying like:
if(hp>100) dmg*=2
else dmg*=1

Got it?

The \himself is a text macro reference.. a very useful one I find too... it refers to the atom's gender variable (built-in but you CAN change the default variable) which returns either "himself", "herself", "themselves" or "itself", depending on the gender..

\red if also another text macro, basically like a <font color="red">

The reason for adding .name to [src]/[M] is I think it makes the name proper (no 'the _').. that and why should you refer to the whole mob when you just need it's name? :/*/
         src.loc = locate(1,1,1) //Respawn point
         src.died++ //adds 1 to src's death count
         if(M!=src)  //if M is not src
             M.gainEXP(round(src.level/M.level)*rand()) //some random formula giving M exp for src's death.. this is a reference to another 'general' proc which you have to make in order to use
             M.kill++ //Killers count goes up >_>

if(hp>=1) return //Everything below will NOT happen because the return stopped it
world<<"I rule you"

if(hp > 0) return