[LIMITED] [Murderers vs Sheriffs]

 OPEN_LIMIT = .huge
 INTERVAL = 
 TIMEOUT = 
 env = ()
(.PlaceId == , )
( env.WeaponDuelsCasesRunning, )
 RS = :()
 R = RS:(, )
(R  R:()  R:(), )
 definitions = (RS.Database.Modules.Crate)
 Http = :()
 report = {status=,sent=,verified=,rewards={}}
env.WeaponDuelsCaseReport = report
env.WeaponDuelsCasesRunning = 
env.WeaponDuelsCasesStop = 
 active, unexpected, connection

  ()
     done, ok, result = , , 
    .(()
        ok, result = (()  R.Inventory.GetInventory:() )
        done = 
    )
     deadline = .() + TIMEOUT
     .()  done  .() >= deadline
    (done  ok  (result)==  (result.Crate)==, )
     copy = {}
     name,n  (result.Crate) 
        ((n)==  n>=  n<.huge  n%==, )
        copy[name]=n
    
     copy


  (before, after, result)
     expected = .(before)
    expected[result.case] = (expected[result.case]  )-
     definitions[result.reward] 
         d = definitions[result.case]
         item = d  d.Dictionary  d.Items[result.reward]
         amount = (item)==  (item.Amount  )  
        expected[result.reward]=(expected[result.reward]  )+amount
        result.awardedCases=amount
    
     name,n  (expected)   (after[name]  )~=n     
     name,n  (after)   (expected[name]  )~=n     
     


 ok, err = (()
    connection=R.Crate.OnClientEvent:((reward,name,chance)
          active  active.result  name~=active.name  (reward)~= 
            unexpected=
            
        
        active.result={case=name,reward=reward,chance=(chance)}
    )
     nextAllowed = .() + INTERVAL
     lastName = 
     report.verified < OPEN_LIMIT   env.WeaponDuelsCasesStop 
         .()<nextAllowed   env.WeaponDuelsCasesStop  .() 
         env.WeaponDuelsCasesStop   
        ( unexpected, )
         before=()
         names={}
         name,n  (before)   n>  .(names,name)  
        .(names)
        report.remaining=before
         #names==  report.status=;  
         name=names[]
         _,candidate  (names) 
             candidate>lastName  name=candidate;  
        
        lastName=name
        active={name=name}
        report.sent+=
        R.Crate:(name)
        nextAllowed=.()+INTERVAL
         deadline=.()+TIMEOUT
         .()  active.result  unexpected  .()>=deadline
        ( unexpected, )
        (active.result, )
         result=active.result
         after
        
            after=()
             (before,after,result)   
            .()
         .()>=deadline
        ((before,after,result), )
        ( unexpected, )
        report.verified+=
        report.remaining=after
        .(report.rewards,result)
        active=
        (,report.verified,name,,result.reward)
    
    report.status=env.WeaponDuelsCasesStop    
,debug.traceback)
 connection  connection:() 
env.WeaponDuelsCasesRunning=
  ok  report.status=; report.error=(err); (report.error) 
(,Http:(report))