###############################################################
### Переменные ###############################################
###############################################################
var myx, myy, body, enemy, idenemy, xe, ye, pack, dagger, nfd
enemy='0x0003' ; Тип моба которого будем убивать
body='0x2006'  ; Тип трупа
dagger='0x13F6'; Тип ножа которым будем резать труп
var tweapon=uo.getserial(uo.objatlayer('Rhand'))
var tshield=uo.getserial(uo.objatlayer('Lhand'))

###############################################################
### Начальная функция ########################################
###############################################################


sub main()
var de, m

   Dim loot[50]
   loot[0]=2 # count
   loot[1]='0x0EED' ;ТУТ ОБА И ПЕРВАЯ И ВТОРАЯ ЭТО ТИП ТОГО ЧТО ЛУТИМ
   loot[2]='0x1BD1'
   loot[3]=''
   
uo.ignorereset()
while uo.weight<uo.str
nfd=1
myx=uo.getx()
myy=uo.gety()
ignorbody()   ; Игнорируем уже имеющиеся трупы
wait(1000)
repeat
 uo.set('finddistance',nfd)   ; Дистанция поиска равна nfd(шагов или клеток)
  uo.findtype(enemy,-1,'ground') ; ищем тип( жертвы,любого цвета,на земле)
if nfd<4 then
 nfd=nfd+1
 checklag()
 else
   uo.exec("warmode 0")
   uo.useskill("Stealth")
 checklag()
 wait(2000)
 checklag() 
 nfd=1
endif
wait(200)
until uo.findcount()>0
if uo.getserial('finditem')<>'0x00000000' || uo.findcount()>0  then
 uo.print('Нашли жертву')
    idenemy=uo.getserial('finditem')   ; Задаём переменной idenemy значение ID найденого типа
    xe=uo.getx(idenemy)
      ye=uo.gety(idenemy)
    uo.print('ID жертвы: '+idenemy)
     uo.print('Координаты(x,y) :' +str(xe)+','+str(ye))
      uo.attack(idenemy)
      ws()
       Walker(xe,ye,1)
        CheckLag()
  repeat
   if uo.getdistance(idenemy)>1 then
   xe=uo.getx(idenemy)
    ye=uo.gety(idenemy)
      uo.print('Идём к координатам(x,y) :'+str(xe)+','+str(ye))
       Walker(xe,ye,1)
   endif
until uo.gethp(idenemy)==0
 wait(2000)
 checklag()
           uo.useobject('lastcorpse')
            checklag()
            wait(1000)
            for m=1 to loot[0]
               while uo.getquantity('<'+loot[m])
                  uo.moveitem('<'+loot[m])
                  wait(700)
               wend
            next
            Walker(5332,1374,0)
            while uo.life<uo.str-20 and uo.count('0x0E21')
               uo.bandageself()
               wait(3500)
            wend
            if uo.count('0x0E20') then
               uo.waittargettype('0x1008')
               uo.usetype('0x0E20')
               wait(1000)
            endif
uo.useobject(tweapon)
uo.useobject(tshield)
else
    uo.ignore('finditem')
    wait(200)
  endif
 checklag()
wend
#bank()
end sub

sub bank()
uo.exec("warmode 0")
wait(200)
uo.exec("warmode 0")
Walker(1893,2745,0)
Walker(1894,2728,0)
Walker(1902,2719,0)
Walker(1910,2718,0)
Walker(1913,2715,0)
Walker(1913,2691,0)
Walker(1904,2687,0)
uo.useobject('0x40008707')
Walker(1899,2687,1)
uo.sayu('bank')
repeat
uo.findtype('0x1BD1','-1','backpack')
uo.moveitem('finditem','all','0x402BEF47')
wait(1000)
until uo.count('0x1BD1')==0
Walker(1904,2687,0)
Walker(1913,2691,0)
Walker(1913,2715,0)
Walker(1910,2718,0)
Walker(1902,2719,0)
Walker(1894,2728,0)
Walker(1893,2745,0)
 Walker(1897,2745,0)
main()
end sub


###############################################################
### Функция игнорирования трупов ####################################
###############################################################
Sub ignorbody()
 uo.set('finddistance',15)
uo.findtype(body,-1,'ground')
 while uo.findcount()>0
  uo.ignore('finditem')
   wait(200)
    uo.findtype(body,-1,'ground')
 wend
end sub


###############################################################
### Функция мародёрства ####################################
###############################################################
sub loot()
uo.set('finddistance',2)
 uo.print('Ищем труп')
  uo.findtype(body,-1,'ground')
   pack=uo.getserial('finditem')
 if uo.findcount()>0 then
  uo.print('Нашли труп')
   uo.print('ID трупака : ' +pack)
    uo.waittargetground(body)
     uo.usetype(dagger)
      CheckLag()
       wait(1000)
        uo.usefromground(body)
         CheckLag()
          wait(1000)
  repeat
   ws()
    uo.findtype(-1,-1,pack)
    if uo.getgraphic('finditem')<>'0x09F1' then
     uo.moveitem('finditem','all','backpack')
      CheckLag()
       wait(450)
     else
uo.ignore('finditem')
wait(200)
endif
wait(200)
  until uo.findcount()<1
 endif
 Walker(myx,myy,0)
end sub

###############################################################
### Функция изучения трупа ####################################
###############################################################
sub forensic()
var n, p
 uo.warmode(0)
  uo.disarm('arm')
   p=0
 for n=0 to 5
  uo.deletejournal()
   ws()
    uo.waittargetground(body)
     uo.useskill('Forensic Evaluation')
  while not uo.injournal('stop|This is the|You can tell')
   wait(200)
   if p<15 then
    p=p+1
   else
    uo.sayu('stop')
    uo.waittargetground(body)
     uo.useskill('Forensic Evaluation')
     p=0
   endif
  wend
   p=0
    wait(1500)
 next
  ir()
  uo.arm('arm')
end sub

###############################################################
### Функция готовки рёбрышек #################################
###############################################################
sub cooking()
var food, fire
 food='0x09F1'
  fire='0x40024CDE'
   uo.ignorereset()
    UO.Print('Жарим бекон на углях')
 While uo.count(food) > 0
  uo.print(uo.count(food))
   ws()
   uo.waittargetobject(fire)
    uo.usetype(food)
     uo.deletejournal()
  while not uo.injournal("You put the") and not uo.injournal("You burn the")
   wait(100)
  wend
 wend
end sub

sub ir()
 uo.ignorereset()
end sub

Sub ws()
var p, t
t=0
p=1
 if uo.injournal("world is saving now...") then
 uo.print('Saving time')
   while not uo.injournal("world data saving")
   if t==0 then
   uo.print(p)
   endif
    wait(100)
     if t<=9 then
      t=t+1
      else
      t=0
      p=p+1
     endif      
       if uo.injournal("You are starving") then
         main()
       endif
   wend
 endif
CheckLag()
end sub

sub autohide()
 ws()
  if not uo.hidden() then
   uo.exec("warmode 0")
   uo.useskill("Hiding")
  endif
      while not uo.injournal("You have been revealed|You can't seem")
         wait(100)
      wend
  uo.deletejournal()
end sub

########################################## ХОДИЛКА 3 ##########################
#var Prec=3 # Как близко следует подойти к цели (Precision)
#var MaxTraceDistance=15 # Максимальная длина обхода. Желательно ставить с расчета возможных препятсвий. Если ставить очень #большие числа, кодилка может пойти в обход пол мира чтобы дойти к соседнему дереву.
#var Speed=2 # Длина шага. Сколько шагов делать за раз. Выше 3 ставить смысла нет. Тоесть тупое умножение шагов. Для ламбера #идеально 3, для майнинга - 1.
#var StepTimeOut=400 # Если уперлись в неопознанный обьект, сколько мсек ждать сдвига с места. Если по простому - таймаут #шага. Если поставить сильно маленькие, ходилка начнет трассировать пустые места.
#UO.SetGlobal("Logging","1")  # - показывать отладочные сообщения.
#UO.SetGlobal("BlindWalk","0") # - не использовать проверку тайлов, а использовать ходьбу наощупь. Для майнинга ОБЯЗАТЕЛЬНО #ВКЛЮЧИТЬ.
#В функции IsPass, содержиться список проходимых тайлов.

#Walker(X,Y,Prec) - идем к цели с координатами X,Y. Возвращает 1 в случае успешного достижения цели, и 0 - при невозможном обходе (путь не найден)
#Tracer(StartDir,Direction) - трассировка 1 шага. Возвращает направление по которому получилось сдвинуться с места. StartDir #- направление последнего движения, Direction (-1 или +1) направление обхода. -1 - по часовой стрелке, +1 против часовой #стрелки. Направления скрипт использует личного формата:
#1 - влево вниз
#2 - вниз
#3 - вправо вниз
#4 - вправо
#5 - вправо вверх
#6 - вверх
#7 - влево вверх
#8 - влево
#Tracer(StartDir,Direction) - идеально подходит для рыбалки вдоль берега так как она будет обходить берег бесконечно (1 #запуск функции = 1 шаг обхода).
#####################################################
# WW  W  WW   AA    LL     Kk KK  EE  EE  RRR       #
# WW  W  WW  AA A   LL     Kk K   EEE     R  R      #
# WW  W  WW  AA A   LL     KKK    EEEEE   R R       #
# WW WW  WW  AAAA   LL     KKK    EEE     RRR       #
#  WWW WWW  AA   A   LLLL  KK Kk  EE  EE  R  RR     #
####################################################
var MaxTraceDistance=10
var TraceLoopIncrease=5 #Увеличение MaxTraceDistance при исчерпании количества ходов
var LimitTrace=20 #Сколько шагов в ОБЕ стороны от начальной точки обхода прекращают ходилку (выхода нет).
var Speed=1
var StepTimeOut=500 #Таймаут шага. Устанавливать не в размер пинга, а в размер шага + размер пинга.
# Для ходьбы - 500+Ping
# Для бега/ходьбы на лошади - 300+Ping
# Бег на лошади - 150 + Ping

var CheckCnt=2 #Количество слепых проверок. УВЕЛИЧИВАЕТ В СТОЛЬКО РАЗ ТАЙМАУТ. Использовать только на БЫСТРОМ но НЕСТАБИЛЬНОМ коннекте. При большом пинге будет УЖАС.
var DynamicPause=30 #Минимальные паузы в циклах. Чем меньше число - тем меньше рывков и тем больше нагрузка процессора.

sub ttt()
walker(5332,1374,0)
end sub

Sub Walker(GoX,GoY,Prec)
  UO.SetGlobal("Logging","0")
  UO.SetGlobal("BlindWalk","0")
  var LastDir
  var MoveRes
  var TracerCnt
  UO.SetGlobal("GlobalGoX",str(GoX))
  UO.SetGlobal("GlobalGoY",str(GoY))
  while not IsEnd(GoX,GoY,Prec)
    TracerCnt = MaxTraceDistance
    repeat
      LogInfo('Just walking')
      LastDir=GoUntilHit(GoX,GoY,Prec)

      if IsEnd(GoX,GoY,Prec) then
        return 1
      end if

      LogInfo('Tracing')
      MoveRes = FullAroundTrace(LastDir,GoX,GoY,Prec,TracerCnt)
      if TracerCnt > LimitTrace then
        return 0
      endif
      TracerCnt = TracerCnt + TraceLoopIncrease
    until MoveRes == 1
  wend
  return 1
end sub

Sub FullAroundTrace(StartDir,GoX,GoY,Prec,MaxTrace)
  var LineX=UO.GetX()
  var LineY=UO.GetY()
  var CurDir=StartDir
  var Direction=CountDirection(GoX,GoY,CurDir,Prec)
  var StartX,StartY
  var MovesDone=0
  repeat
    StartX=UO.GetX()
    StartY=UO.GetY()
    CurDir=Tracer(CurDir,Direction,Prec)
    if (CurDir==GetDir(GoX,GoY,Prec)) then
      return 1
    endif
    if MovesDone>0 and PrevMoveCross(GetDirToDir(UO.GetDir(),Prec),LineX,LineY,GoX,GoY,StartX,StartY,Prec) then
      return 1
    end if
    MovesDone=MovesDone+1
    CurDir=AddToDir(CurDir,-Direction,Prec)
  until MovesDone>MaxTrace
  return 0
end sub

Sub CountDirection(GoX,GoY,StartDir,Prec)
  var GoDir=GetDir(GoX,GoY,Prec)
  var MyX=UO.GetX()
  var MyY=UO.GetY()
  if GoDir<StartDir then
    return -1
  end if
  if GoDir>StartDir then
    return 1
  end if
  if Abs(MyX-GoX)>Abs(MyY-GoY) then
    if (GoDir==3 and GoY>MyY) OR (GoDir==7 and GoY<MyY) then
      return -1
    else
      return 1
    end if
  else
    if (GoDir==1 and GoX<MyX) or (GoDir==5 and GoX>MyX) then
      return -1
    else
      return 1
    end if
  end if
end sub

Sub PrevMoveCross(Dir,x1,y1,x2,y2,StartX,StartY,Prec)
  var x3,y3,x4,y4
  x3=StartX
  y3=StartY
  x4=StartX+(XFromDir(Dir)-StartX)*Speed
  y4=StartY+(YFromDir(Dir)-StartY)*Speed
  return LinesCrossing(x1,y1,x2,y2,x3,y3,x4,y4,Prec)
end sub

Sub LinesCrossing(x1,y1,x2,y2,x3,y3,x4,y4,Prec)
  if x1==x3 and y1==y3 then
    return false
  end if
  var z1=(x3-x1)*(y2-y1)-(y3-y1)*(x2-x1)
  var z2=(x4-x1)*(y2-y1)-(y4-y1)*(x2-x1)
  if z1*z2>0 then
    return false
  else
    LogInfo('Vector info:')
    LogInfo('x1= '+str(x1))
    LogInfo('y1= '+str(y1))
    LogInfo('x2= '+str(x2))
    LogInfo('y2= '+str(y2))
    LogInfo('x3= '+str(x3))
    LogInfo('y3= '+str(y3))
    LogInfo('x4= '+str(x4))
    LogInfo('y4= '+str(y4))
    return true
  end if
end sub

Sub IsDiap(X,X0,X1,Prec)
  if X<=X0+Prec and X>=X1-Prec OR X>=X0-Prec and X<=X1+Prec then
    return true
  end if
  return false
end sub

Sub GoUntilHit(GoX,GoY,Prec)
  var LastDir
  LastDir=GetDir(GoX,GoY,Prec)
  var CouldMove
  repeat
    LastDir=GetDir(GoX,GoY,Prec)
    if LastDir<>0 and not IsEnd(GoX,GoY,Prec) then
      CouldMove=TryDir(LastDir,Prec)
    end if
  until LastDir==0 or IsEnd(GoX,GoY,Prec) or not CouldMove
  return LastDir
end sub

Sub IsEnd(GoX,GoY,Prec)
  if Abs(UO.GetX()-GoX)<=Prec and Abs(UO.GetY()-GoY)<=Prec then
    LogInfo('END FOUND')
    return true
  else
    return false
  end if
end sub

Sub GetDir(GoX,GoY,Prec)
  var MyX=UO.GetX()
  var MyY=UO.GetY()
  var DiffX=Abs(UO.GetX()-GoX)
  var DiffY=Abs(UO.GetY()-GoY)
  var GoDir=0
  if (DiffX/(DiffY+0.1))>=2 then
    if (MyX>GoX) then
      GoDir=7
    else
      GoDir=3
    end if
  else

  if (DiffY/(DiffX+0.1))>=2 then
    if (MyY>GoY) then
      GoDir=5
    else
      GoDir=1
    end if
  else

  if (MyX>GoX) and (MyY>GoY) then
    GoDir=6
  else
  if (MyX>GoX) and (MyY<GoY) then
    GoDir=8
  else
  if (MyX<GoX) and (MyY>GoY) then
    GoDir=4
  else
  if (MyX<GoX) and (MyY<GoY) then
    GoDir=2
  end if
  end if
  end if
  end if
  end if
  end if
  return GoDir
end sub

Sub Tracer(StartDir,Direction,Prec)
  var CurDir=StartDir
  var Result
  repeat
    Result=TryDir(CurDir,Prec)
    if not Result then
      CurDir=AddToDir(CurDir,Direction,Prec)
    end if
  until Result
  return Result
end sub

Sub AddToDir(Dir,Cnt,Prec)
  var NewDir=Dir
  NewDir=NewDir+Cnt
  while NewDir>8
    NewDir=NewDir-8
  wend
  while NewDir<1
    NewDir=NewDir+8
  wend
  return NewDir
end sub

Sub TryDir(Dir,Prec)
  var BegX=UO.GetX() # Ia?aeuiia O
  var BegY=UO.GetY() # Ia?aeuiia Y
  var Counter=0
  var GoX=BegX
  var GoY=BegY
  GoX=XFromDir(Dir)
  GoY=YFromDir(Dir)
  if not IsPass(GoX,GoY) then
    LogInfo(str(GoX)+':'+str(GoY)+' is not passable')
    return false
  end if
  return TurnAndGoDir(Dir,Prec)
end sub

Sub XFromDir(Dir)
  if Dir==2 OR Dir==3 Or Dir==4 then
    return (UO.GetX()+1)
  end if
  if Dir==6 OR Dir==7 Or Dir==8 then
    return (UO.GetX()-1)
  end if
  return (UO.GetX())
end sub

Sub YFromDir(Dir)
  if Dir==8 OR Dir==1 Or Dir==2 then
    return (UO.GetY()+1)
  end if
  if Dir==4 OR Dir==5 Or Dir==6 then
    return (UO.GetY()-1)
  end if
  return (UO.GetY())
end sub

Sub TurnAndGoDir(Dir,Prec)
  var StartDir=GetDirToDir(UO.GetDir(),Prec)
  var StartX=UO.GetX()
  var StartY=UO.GetY()
  var EndDir
  var Counter=0
  var TestCounter=CheckCnt

 #Direction Test
  repeat
    Counter = 0
    LogInfo('Dir: '+str(StartDir)+' Counter: '+str(Counter))
    PressDir(Dir)
    repeat
      EndDir=GetDirToDir(UO.GetDir(),Prec)
      wait(DynamicPause)
      Counter=Counter+1
    until StartDir<>EndDir or StartY<>UO.GetY() or StartX<>UO.GetX() or Counter>=StepTimeOut/DynamicPause
    TestCounter = TestCounter - 1
    LogInfo('Dir: '+str(EndDir)+' Counter: '+str(Counter))
  until TestCounter <= 0 or Counter < StepTimeOut/DynamicPause

  if Counter>=StepTimeOut/DynamicPause  then
     LogInfo('Direction timeout reached')
     return 0
  end if
  #End direction Test

  if StartY<>UO.GetY() or StartX<>UO.GetX() then
    return Dir
  end if

  #Start Primary test
  TestCounter=CheckCnt
  repeat
    GoDir(Dir,Prec)
    Counter=0
    repeat
      wait(DynamicPause)
      Counter=Counter+1
    until StartY<>UO.GetY() or StartX<>UO.GetX() or Counter>=StepTimeOut/DynamicPause
    TestCounter = TestCounter - 1
  until TestCounter <= 0 or Counter < StepTimeOut/DynamicPause
  #End primary test

  if Counter>=StepTimeOut/DynamicPause then
    LogInfo('Step timeout reached')
    return 0
  else
    return Dir
  end if
end sub

Sub GetDirToDir(GotDir,Prec)
   var ChangedDir=-GotDir
   ChangedDir=AddToDir(ChangedDir,5,Prec)
   return ChangedDir
end sub

Sub DirToInj(Dir)
   dim Dirs[9]
   Dirs[1]=1
   Dirs[2]=2
   Dirs[3]=3
   Dirs[4]=6
   Dirs[5]=9
   Dirs[6]=8
   Dirs[7]=7
   Dirs[8]=4

   return (Dirs[Dir])
end sub

Sub PressDir(Dir)
   dim Dirs[9]
   Dirs[1]=35
   Dirs[2]=40
   Dirs[3]=34
   Dirs[4]=39
   Dirs[5]=33
   Dirs[6]=38
   Dirs[7]=36
   Dirs[8]=37

   UO.Press(Dirs[Dir],1)
end sub

Sub GoDir(Dir,Prec)
   dim Dirs[9]
   Dirs[1]=35
   Dirs[2]=40
   Dirs[3]=34
   Dirs[4]=39
   Dirs[5]=33
   Dirs[6]=38
   Dirs[7]=36
   Dirs[8]=37

   var DistanceX=Abs(UO.GetX()-val(UO.GetGlobal("GlobalGoX")))
   var DistanceY=Abs(UO.GetY()-val(UO.GetGlobal("GlobalGoY")))
   var GoDistance
   if (DistanceX-Prec)<Speed then
      GoDistance=DistanceX-Prec
   else
      if (DistanceY-Prec)<Speed then
         GoDistance=DistanceY-Prec
      else
         GoDistance=Speed
      endif
   endif

   UO.Press(Dirs[Dir],GoDistance)
end sub

Sub IsPass(X,Y)
  if UO.GetGlobal("BlindWalk") then
    return true
  endif

   dim Types[60]
   Types[1]=3
   Types[2]=25
   Types[3]=51
   Types[4]=63
   Types[5]=113
   Types[6]=140
   Types[7]=172
   Types[8]=219
   Types[9]=232
   Types[10]=235
   Types[11]=239
   Types[12]=243
   Types[13]=248
   Types[14]=251
   Types[15]=264
   Types[16]=267
   Types[17]=282
   Types[18]=289
   Types[19]=321
   Types[20]=379
   Types[21]=420
   Types[22]=440
   Types[23]=476
   Types[24]=499
   Types[25]=513
   Types[26]=542
   Types[27]=578
   Types[28]=586
   Types[29]=622
   Types[30]=700
   Types[31]=804
   Types[32]=1740
   Types[33]=1758
   Types[34]=1770
   Types[35]=1779
   Types[36]=1779
   Types[37]=1881
   Types[38]=1886
   Types[39]=1801
   Types[40]=1805
   Types[41]=1813
   Types[42]=1820
   Types[43]=1831
   Types[44]=1833
   Types[45]=1843
   Types[46]=1850
   Types[47]=1873
   Types[48]=1876
   Types[49]=1885
   Types[50]=1888
   Types[51]=1946
   Types[52]=1969
   Types[53]=2500
   Types[54]=2539

  for var i=1 TO 53 STEP 2
    if UO.PrivateGetTile(X,Y,-1,Types[i],Types[i+1]) then
      return true
    end if
  next
  return false
end sub

Sub LogInfo(Line)
  if not UO.GetGlobal("Logging")=="0" then
    UO.TextOpen()
    UO.TextPrint(str(UO.GetX())+":"+str(UO.GetY())+" - "+Line);
  end if
end sub

Sub Abs(X)
  if X>0 then
    return X
  else
    return (-X)
  end if
end sub
########################################## КОНЕЦ ХОДИЛКИ 3 ##########################

sub CheckLag()
   UO.DeleteJournal() ; вытрем все сообщения в журнале (Inj, но не клиента)
   UO.Click('backpack') ; одиночный клик по вашему backpack
;       ждем сообщения в журнале
   repeat
      wait(100)
   until UO.InJournal("backpack")
;       этот цикл завершится, если это сообщение появится.... замечу "Backpack" и "backpack"
;       регистр важен Пишите точно что ждете
end sub