Scripte für das neue Open EasyUO

[Bonbori]

Der Thread ist ab sofort dafür gedacht, dass man sich Anregungen holen und es gegebenenfalls etwas leichter fällt Lua (die Scriptspache für OEUO) zu erlernen. Fragen werden gerne beantwortet.

OpenEUO nutzt Lua als Scriptsprache und ist um einiges mächtiger und vor allem deutlich schneller als EasyUO. Ich habe daher mal ein Script gebastelt, das Wegpunkte abläuft und alle 25 Felder in Reichweite leergräbt. Kristalle werden ebenfalls abgebaut. Werden keine Wegpunkte angegeben, wird an der momentanen Position gebuddelt. Ein Packpferd oder -lama muss man dabei haben und Schaufeln müssen im Hauptrucksack liegen.

Eine Fütterfunktion ist für das Script in Zukunft vorgesehen, aber noch nicht implementiert.

Da dies meine ersten Gehversuche mit Lua sind, ist das Ganze noch nicht Objektorientiert aufgezogen. Die Programmierer unter euch mögen es mir nachsehen

Wenn ihr die Meldung "Für den Steinabbau benötigt ihr eine Spitzhacke" bekommt, einfach manuell einmalig irgendein Feld abgraben und das Script starten. Das scheint nur zu passieren, wenn man im Client seit dem Start noch nie einen Target Cursor hatte.

Code: Alles auswählen

--Schaufel Type = 3897
--Spitzhacke Type = 3717
--Kristall Type = 10055

startWegpunkt = 1--Diesen Wert anpassen, um bei einem anderen als den ersten Wegpunkt zu beginnen

if UO.TileInit(true) then
   print("TileInit war erfolgreich!")
   else
   print("TileInit fehlgeschlagen!")
   stop()
end
if nRef == nil then
   nRef = 0
end
nRef,nCnt = UO.ScanJournal(nRef)

tMeldungen = {
   ["success"] = "in euren Rucksack.",
   ["fail"]    = "Ihr konntet kein verwertbares Erz gewinnen",
   ["empty"]   = "Hier gibt es kein Erz mehr abzubauen",
   ["busy"]    = "I am already doing something else.",
   ["far"]     = "Das ist zu weit entfernt",
   ["crystal"] = "Ihr legt den Kristall in Euren Rucksack."
}

tPacktiere = {
   ["Packpferd"] = 291,
   ["Packlama"] =  292
}

tWegpunkte = {
   --Wegpunkte haben das Format {X,Y} und werden durch Kommata getrennt.
   --5 einzelne Wegpunkte sähen also so aus: {1,2}, {3,4}, {5,6}, {7,8}, {9,10}
   --Wenn hier keine Wegpunkte angegeben werden, buddelt das Script die 25 Felder um den Character leer.
   --Wepunkte direkt nach dieser Zeile einfügen.

}

function findDist(findX, findY)
   --Gibt die Distanz in Feldern zurück
   local dx,dy = math.abs(UO.CharPosX - findX), math.abs(UO.CharPosY - findY)
   return math.max(dx,dy)
end

function findItem(nFindType, nRange, nCont)
   --Sucht einen ItemType und gibt die Eigenschaften als Tabelle oder nil zurück
   local tResult = nil
   local nItems = UO.ScanItems(true) - 1
   for nIndex = 0,nItems do
      local nID,nType,nKind,nContID,nX,nY,nZ,nStack,nRep,nCol = UO.GetItem(nIndex)
      if ( nType == nFindType ) then
         if ( ( nCont == nil and findDist(nX,nY) <= nRange ) or (nCont ~= nil and nCont == nContID) ) then --Nur Items ins Ergebnis schreiben, die in dem Container liegen, der Angegeben wurde bzw. die in Reichweite sind
            local temp =
            {
               ["id"] = nID,
               ["type"] = nType,
               ["kind"] = nKind,
               ["contid"] = nContID,
               ["x"] = nX,
               ["y"] = nY,
               ["z"] = nZ,
               ["stack"] = nStack,
               ["col"] = nCol
            }
            if ( tResult == nil ) then
               tResult = {}
            end
            table.insert(tResult, temp)
         end
      end
   end
   return tResult
end

function setToolId()
   --Setzt die ID des zu nutzenden Werkzeugs. Nimmt als erstes kleine Stacks
   local tItemList = findItem(3897,0,UO.BackpackID)--Schaufeln im Rucksack
   local stack = 999
   for num,item in pairs(tItemList) do
      if ( item["stack"] < stack ) then
         stack = item["stack"]
         nToolId = item["id"]
      end
   end
end

function checkCrystal()
   local tItemList = findItem(10055,2)
   if ( tItemList ~= nil ) then
      UO.LObjectID = tItemList[1]["id"]
      UO.Macro(17,0)
      waitJournal()
   end
end

function digTile(x,y,z)
   --Buddelt auf einem Feld
   while true do
      setToolId()
      if ( nToolId ~= nil ) then
         --Kristall in der Nähe?
         checkCrystal()
         --Gewichtslimit fast erreicht?
         if ( ( UO.Weight + 15 ) >= UO.MaxWeight ) then
            oreToPacki()
         end   
         UO.LObjectID = nToolId
         UO.Macro(17,0)--LastObject
         UO.LTargetX = x
         UO.LTargetY = y
         UO.LTargetZ = z
         UO.LTargetKind = 3
         --Auf Target Cursor warten
         repeat
            wait(10)
         until UO.TargCurs == true
         UO.Macro(22,0)--LastTarget
         next = waitJournal()
         if next then
            print("Feld leer, nächstes")
            return
         end
         
         else
         print("Schaufeln alle")
         stop()
      end
   end
end

function waitJournal()
   while true do
      wait(10)
      nRef,nCnt = UO.ScanJournal(nRef)
      
      for i=0,nCnt - 1 do
         local sLine,nCol = UO.GetJournal(i)     
         for k,val in pairs(tMeldungen) do
            if string.find(sLine, val) ~= nil then
               if k ~= "busy" then               
                  if (k == "success") or (k == "fail") or (k == "crystal") then
                     return false
                     elseif (k == "empty") or (k=="far") then
                     return true
                  end
                  else
                  wait(10000)
               end
            end 
         end
      end
   end
end

function feedPacki()
   
end

function oreToPacki()
   feedPacki()
   UO.NextCPosX = 0
   UO.NextCPosY = 0
    if nPackiID == nil then
      findPacki()
   end
   
   
   UO.LObjectID = nPackiID
   UO.Macro(17,0)
   wait(1000)
   local con = UO.ContID
   local tItemList = findItem(6585,0,UO.BackpackID)--Erz aller Art
   for k,item in pairs(tItemList) do
      UO.Drag(item["id"],item["stack"])
      wait(500)
      UO.DropC(con)
   end
end


function findPacki()
   while nPackiID == nil do
      for k,v in pairs(tPacktiere) do
         local temp = findItem(v,2)            
         if ( temp[1]["id"] ~= nil ) then
            nPackiID = temp[1]["id"]
            return
         end
      end
      
      if nPackiID == nil then
         UO.Macro(1,0,"all follow me")
         wait(2000)
      end   
   end
end

function selectTile()
   --Wählt ein Tile zum Minern aus, wenn das TileType stimmt
   for i = -2,2 do
      local x = UO.CharPosX + i
      for j = -2,2 do
         local y = UO.CharPosY + j
         for nTileIndex = UO.TileCnt(x,y),1,-1 do
            local nTileType, z, sName, nFlags = UO.TileGet(x,y,nTileIndex)
            if sName == "Hoehlenboden" then
               digTile(x,y,z)
            end
         end
      end
   end
end

function moveTo(moveX,moveY)
   local moveZ = -1
   if (moveX == nil) or (moveY == nil) then
      return false
   end
   
   UO.Pathfind(moveX,moveY,moveZ)
   repeat
      wait(100)
   until (UO.CharPosX == moveX) and (UO.CharPosY == moveY)
   return true
end
if tWegpunkte[1] ~= nil then
   --Equivalent zu foreach in anderen Sprachen
   for key,value in pairs(tWegpunkte) do
      if key >= startWegpunkt then
         minetile = moveTo(value[1], value[2])
         if minetile then
            selectTile()
         end
      end
   end
   else
   selectTile()
end


print("Ende")


[BB28]

Gefällt mir, damit hätte ich auch Scripte gebastelt
Mit EasyUo konnte ich mich nie anfreunden.

[Bonbori]

Man hat halt so schöne Sachen wie Arrays (genauer wäre bei Lua "Tabellen"), foreach, vernünftige Strings (und nicht so ein Hick-Hack wie bei EUO), kann Klassen und (echte) Funktionen erstellen usw. Der gewaltige Performanceunterschied rührt einfach daher, dass die Scripte im Arbeitsspeicher ausgeführt werden, anstatt jedes mal Zeile für Zeile das Script neu zu interpretieren.

[Vendor Fujin]

Soltle ich mir auch mal antun, array kann EUO aber auch .
Wenn ich damit wirkliuch OOP machen kann wäre das ein Traum.

[Bonbori]

OOP kann Lua eingeschränkt. Man darf hier kein C++ oder Java erwarten
Siehe auch hier

[Vendor Fujin]

Ich habe auch mal ein wenig rumgespielt,
Ein Fisching Script was Soweit alles Automatisiert. (Theoretisch)

Dem Script bedarf es sicher noch einige Optimierungen und Tests.

Das Script tut folgendes:
- Fischbare Tiles ermitteln
- Tiles Abfischen
- Fische in Packy lagern (Packy detektieren)
- Packy min alle 1h füttern
- Nach dem Abfischen eine Neue Postion suchen (beachtet die Anleitung)
- Angel und Futter selbstständig detektieren und wenn nötig wechseln
- Bei Gefahr Positionmerken, Zum "Sicheren Punkt" entfliehen, Script Pausieren, bei erneuten Starten an die alte Poistion laufen und weiter machen

Das Script habe ich einfach so drauf los geschrieben, Anregungen von Bonboris Script geholt
und es ist für mich ein "Lern Project". Es gibt noch einiges zu Lernen.
Die Sprache Lua ist mir neu. Die bisherigen Test liefen soweit erfolgreich.
Mein Wording ist wie immer eine Katastrophe

Danke Bonbori für die Anregung, OEU hat tatsächlich einiges an Vorteilen, besonder hervorzuheben ist die Geschwindigkeit. Natürlich wird das Scripten um einiges Komplexer aber auch mächtiger.
Ich hoffe es ist okay das ich deinen Thread dafür ausnutze

Code: Alles auswählen

----------------------------------------------------------------------------------
-- Fishing-Script by Giulia Fourier ----------------------------------------------
-- for UO-Freeshard Sigena (www.uosigena.de) -------------------------------------
-- Version 1.0 Beta --------------------------------------------------------------
----------------------------------------------------------------------------------
-- Anleitung
-- Rettungpunkt einstellen
--     savePointX und savePointY sind die X/Y Koordinaten andem der Char sich bei Gefahr zurückzieht
-- Wegfindungs Routine
--     Der Charakter sucht sich seinen Weg an der Küste entlange in folgenden Formen
--     #A                                   ######################
--     #|                                   <-<-<-<-<-<-<-<-<-<-A#
--     #A                                                       |#
--     #|                                                       A#
--     #A                                                       |#
--     #|                                                       A#
--     #A <-<-<-<-<-<-<-<                                       |#
--     ###################                                      A#
--     LEGENDE: # UferTile  -> oder v Laufrichtung
--     Laufrichtung kann mit local nDirection = 1 ungedreht werden
-- Im Backpack werden folgende Item benötigt
--     die Angeln
--     Futter (momentan nur Äpfel und Zitronen)
-- Packpferd wird alle 1h gefüttert
----------------------------------------------------------------------------------
-- TODO-List
--     Configuration über ein Menu
--     Einbetten von einer Fischernetzfunktion
--     Fisch Counter
--     Testen Testen Testen
----------------------------------------------------------------------------------
----------------------------------------------------------------------------------

-- INITIALISEING -----------------------------------------------------------------
-- constants ---
local ANGEL = 3519
local nTILEEMPTY = -1
local nFishingRange = 6
local nShoreWaterDistance = 3
local nMaxStateWait = 500 -- * 10ms
local nSearchRange = 24
local nDirection = 1
local savePointX = 262
local savePointY = 381

-- variables ---
local timeToFeed = true
local tFishTiles = {}
local nPackyBagID = 0
local nTableSize = 0
local nTempAngelID
local uferTiles = {}
local nShoreCnt = 0
local nHour, nMinute = gettime ()
local  firstTimeFeed = true
local nFeedID = nil



local nNewRef = 0
nNewRef,nCnt= UO.ScanJournal(nNewRef)

tFishingStates = {
  succes1 = "praechtiger Fang",
  succes2 = "beissen sie heute nicht",
  succes3 = "merkwuerdig aussehenden Fisch",
  succes4 = "ihr fischt etwas Treibholz heraus",
  succes5 = "Ihr zieht eine kleine Truhe an Land",
  succes6 = "Ein alter Stiefel haengt am Haken",
  fail1 = "es keinen Fisch zu geben",
  fail2 = "ihr nicht sehen",
  fail3 = "ihr nicht angeln",
  fail4 = "zu weit entfernt",
  danger = "das ist kein Fisch"
}

tPackAnimals = {
     lama = 292,
     horse = 291
}

tPackyFeed = {
      apfel = 2512,
      zitrone = 5928,
      bananne = 5919,
      limette = 5930,
      birne = 5833,
      pfirsisch = 5932
}

tFishTypes = {
     schwertfisch = 506,
     barsch = 507,
     hecht =  508,
     dorsch = 509,
     lachs = 510,
     --bless = 41832,
     --dex = 41833;
     --int = 41834,
     --str = 41835,
     magic = 3542,
     --heal = 41837,
     --invis = 41838,
     --nightsight = 41839
}

tPackAnimals = {
     lama = 292,
     horse = 291
}


-- FUNCTIONS ---------------------------------------------------------------------

-- creates an table with tile parameters --
function createTileTable(type ,x ,y)
              tileTab = {}
              tileTab.type = type
              tileTab.x = x
              tileTab.y = y
              tileTab.maker = false
              return tileTab
end

-- search items by item-type in mainbackpack and returns the id of the item which will found and nil if no item found
function findItemIDMB(itemType)     
            local item = nil
            local itemCnt = UO.ScanItems(true)
            for i=0, itemCnt do
                local nID,nType,nKind,nContID,nX,nY,nZ,nStack,nRep,nCo = UO.GetItem(i)
                if ( nContID == UO.BackpackID or nContID == UO.CharID ) and nType == itemType then
                   -- print(UO.Property(nID))
                   -- print("\n")
                   item = nID
                   break
                end
            end
            if item == nil then
               item = print("no item from type "..itemType.." was found in "..cont)
               pause()
            end
            return item
end

-- search item by type and return therer id
function findItemID(itemType)
         local item = nil
         local itemCnt = UO.ScanItems(true)
         for i=0, itemCnt do
             local nID,nType,nKind,nContID,nX,nY,nZ,nStack,nRep,nCo = UO.GetItem(i)
             if nType == itemType then
                item = nID
                break
             end
         end
         return item
end

-- search items by item-type in containter and returns the id
function findItemIDStack(itemType,nContainerID)
            local item = nil
            local stack = nil
            local itemCnt = UO.ScanItems(true)
            for i=0, itemCnt do
                local nID,nType,nKind,nContID,nX,nY,nZ,nStack,nRep,nCo = UO.GetItem(i)
                if ( nContID == nContainerID) and nType == itemType then
                   -- print(UO.Property(nID))
                   -- print("\n")
                   item = nID
                   stack = nStack
                   break
                end
            end
            if item == nil then
               item = print("no item from type "..itemType.." was found in "..nContainerID)
            end
            return item, stack
end

-- checks for existing an tile on x,y in fish tile table
function alreadyExistInTable(x, y)
         for i = 0, nTableSize - 1 do
             if tFishTiles[i].x == x and tFishTiles[i].y == y then
                return true
             end
         end
         return false
end

-- searching of new water tiles for fishing in nRange, new tiles will added to nFishTiles table
function findFishingTiles(nRange)
   for i = -nRange, nRange do
       for k = -nRange, nRange do
           local tile =UO.TileCnt(UO.CharPosX + i, UO.CharPosY + k)
           local nType,nZ,sName,nFlags = UO.TileGet(UO.CharPosX + i, UO.CharPosY + k, tile)
           --print(nType.."  "..nZ.."  "..sName.."  "..nFlags)
           if  sName == "water" or sName == "Wasser"  and  false == alreadyExistInTable(UO.CharPosX + i, UO.CharPosY + k) then
              tFishTiles[nTableSize] = createTileTable(nType, UO.CharPosX + i, UO.CharPosY + k)
              nTableSize = nTableSize + 1
           end
       end
   end
end

-- return an status code for systemmessages
function analyseJournal()
   nReturn = 0
   nNewRef,nCnt= UO.ScanJournal(nNewRef)
   for i = 0, nCnt - 1 do
         local sLine = UO.GetJournal(i)
         if string.find(sLine, tFishingStates.succes1 ) ~= nil or
            string.find(sLine,tFishingStates.succes2) ~= nil or
            string.find(sLine,tFishingStates.succes3) ~= nil or
            string.find(sLine,tFishingStates.succes4) ~= nil or
            string.find(sLine,tFishingStates.succes5) ~= nil or 
            string.find(sLine,tFishingStates.succes6) ~= nil then
               nReturn = 1
               break               
         elseif string.find(sLine,tFishingStates.fail1) ~= nil or
                string.find(sLine,tFishingStates.fail2) ~= nil or
                string.find(sLine,tFishingStates.fail3) ~= nil or
                string.find(sLine, tFishingStates.fail4) ~= nil then
                nReturn = -1
                break             
         elseif string.find(sLine, tFishingStates.danger) ~= nil then
                local tempX = UO.CharPosX
                local tempY = UO.CharPosY
                print("Danger")
                UO.Move(savePointX, savePointY)
                pause()
                UO.Move(tempX, tempY)
                nReturn = 1
         end
   end
   --print(nReturn)
   return nReturn
                   
end

-- TODO
function checkFeedTime()
         nHour2, nMinute2 = gettime ()
         if firstTimeFeed or ( nHour2 > nHour and nMinute2 > nMinute ) or nHour2 > (nHour + 2) or nHour == 0 then
            feedPackanimal()
            nHour = nHour2
            nMinute = nMinute2
            --nHour = nHour - 1
            --nMinute = nMinute + 2
            firstTimeFeed = false
         end
end

-- table iteration function which fishs an tile while no fish can found at this tile
function fisching(_index)
         if tFishTiles[_index].maker == false then
              local loopCnt
              local state 

              while(state ~= nTILEEMPTY) do
                  checkFeedTime()
                  nTempAngelID = findItemIDStack(ANGEL, UO.CharID)
                   if nTempAngleID == nil then
                      nTempAngelID = findItemID(ANGEL)
                   end
                   if UO.Weight > UO.MaxWeight then
                      fishInToPacky()
                   end
                   state = 0
                   UO.LTargetX = tFishTiles[_index].x
                   UO.LTargetY = tFishTiles[_index].y
                   UO.LTargetKind = 2
                   UO.LObjectID = nTempAngelID
                   UO.Macro(17,0)
                   loopCnt = 0
                   repeat
                         loopCnt = loopCnt + 1
                         wait(10)
                   until UO.TargCurs == true or loopCnt >= 20
                   UO.Macro(22,0)
                   loopCnt = 0
                   repeat                         
                         wait(10)
                         state = analyseJournal()
                         if state ~= 0 or loopCnt >= nMaxStateWait then
                            break
                         end
                         loopCnt = loopCnt + 1
                   until false
              end
              state = 0
              tFishTiles[_index].maker = true
         end
end

-- returns the absolut distance between the char and x,y
function getDis(x, y)
   x = x - UO.CharPosX
   y = y - UO.CharPosY
   return math.abs((x)^2 + (y)^2);
end

-- searching watertiles along the abscissa (x) and an fixed point on the ordinate (y) which abut on grasstiles
function shoreSearchAlongAbscissa(absissaPos)
         for i = -nSearchRange, nSearchRange do
             local tile =UO.TileCnt(UO.CharPosX + i, UO.CharPosY + absissaPos)
             local nType,nZ,sName,nFlags = UO.TileGet(UO.CharPosX + i, UO.CharPosY + absissaPos, tile)
             if  sName == "water" or sName == "Wasser"  then
                 for j = -1, 1 do
                    local tile =UO.TileCnt(UO.CharPosX + i + j * nShoreWaterDistance, UO.CharPosY + absissaPos)
                    local nType,nZ,sName,nFlags = UO.TileGet(UO.CharPosX + i + j * nShoreWaterDistance, UO.CharPosY + absissaPos, tile)
                    if sName == "grass" then
                       print("1 shoretile found "..nShoreCnt)
                       uferTiles[nShoreCnt] = {x = UO.CharPosX + i + j * nShoreWaterDistance,y = UO.CharPosY + absissaPos}
                       nShoreCnt = nShoreCnt + 1
                    end
                 end
             end
         end
end

-- searching watertiles along the ordinate (y) and an fixed point on the abscissa (x) which abut on grasstiles
function shoreSearchAlongOrdinate(odinatePos)
         for k = -nSearchRange, nSearchRange do
             local tile =UO.TileCnt(UO.CharPosX + odinatePos, UO.CharPosY + k)
             local nType,nZ,sName,nFlags = UO.TileGet(UO.CharPosX + odinatePos, UO.CharPosY + k, tile)
             if sName == "grass" then
                 for j = -1, 1 do
                     local tile =UO.TileCnt(UO.CharPosX + odinatePos, UO.CharPosY + k + j * nShoreWaterDistance)
                     local nType,nZ,sName,nFlags = UO.TileGet(UO.CharPosX + odinatePos, UO.CharPosY + k + j * nShoreWaterDistance, tile)
                     if sName == "water" or sName == "Wasser"  then
                        print("2 shoretile found "..nShoreCnt)
                        uferTiles[nShoreCnt] = {x = UO.CharPosX + odinatePos,y = UO.CharPosY + k + j * nShoreWaterDistance}
                        print(uferTiles[nShoreCnt].x)
                        nShoreCnt = nShoreCnt + 1
                     end
                 end
             end
         end
end

-- searching the next position to move
-- Reouten Muster (with nDirection == 1)
-- # v
-- # |
-- # v
-- # |
-- # v > - > - >
-- #################
function findNextPosition()
         local nextX
         local nextY
         shoreSearchAlongOrdinate(-nFishingRange * 2 * nDirection)
         shoreSearchAlongOrdinate(-nFishingRange * nDirection)
         if uferTiles[0] == nil then
             print("1 no shoretile found")
             shoreSearchAlongOrdinate(nFishingRange * 2 * nDirection)
             shoreSearchAlongOrdinate(nFishingRange * nDirection)
             if uferTiles[0] == nil then
                 print("2 no shoretile found")
                 shoreSearchAlongAbscissa(nFishingRange * 2 * nDirection)
                 shoreSearchAlongAbscissa(nFishingRange * nDirection)
                 if uferTiles[0] == nil then
                     print("3 no shoretile found")
                     shoreSearchAlongAbscissa(-nFishingRange * 2 * nDirection)
                     shoreSearchAlongAbscissa(-nFishingRange * nDirection)
                 end
             end
         end
         if uferTiles[0] ~= nil then
             print("shorefiles found "..uferTiles[0].x)   
             nextX = uferTiles[0].x
             nextY = uferTiles[0].y
             
             local maxDistance = getDis(uferTiles[0].x, uferTiles[0].y)

             for i = 0, nShoreCnt - 1 do
                 tempDistance = getDis(uferTiles[i].x, uferTiles[i].y)
                 if tempDistance > maxDistance then
                    local nextX = uferTiles[i].x
                    local nextY = uferTiles[i].y
                    maxDistance = tempDistance
                 end
             end
         end
         if nextX ~= nil or nextY ~= nil then 
            print("x"..nextX.." y"..nextY)
            return nextX, nextY
         else
             return nil, nil
         end
end

-- itteration function to transfer alle item from type which tFishTypes includes from mainbagpack to packanimal
function transferItemTable(_index)
     repeat
          local tempItem, tempStack = findItemIDStack(tFishTypes[_index], UO.BackpackID)
          if tempItem ~= nil then
             print(tempItem.." "..tempStack)
             UO.Drag(tempItem, tempStack)
             wait(10)
             --print(nPackyBagID)
             UO.DropC(nPackyBagID)
             UO.LObjectID = UO.BackpackID
             UO.Macro(17,0) -- BackpackRefresh
          else
               break
          end
     until false
end

-- function to transfer all fishitems to packanimal
function fishInToPacky()
         
         nPackyID = findItemID(tPackAnimals.horse)
         if nPackyID == nil then
            nPackyID = findItemID(tPackAnimals.lama)
         end
         if nPackyID == nil then
            print("couln'd found an pack animal, "..nPackyID)
            pause()
         else
             UO.LObjectID = nPackyID
             UO.Macro(17,0)
             wait(500)
             nPackyBagID = UO.ContID
             print(nPackyBagID)
             table.foreach(tFishTypes,transferItemTable)
         end
         
end

-- search an packyfeed item
function findOneFromTable(_index)
 print(tPackyFeed[_index])
 if nFeedID ~= nil then
    local test = UO.Property(nFeedID)
    if test == nil then
       nFeedID = nil
    end
 end
 if nFeedID == nil then
    nFeedID = nil
    local nItemCnt = UO.ScanItems(true)
    for i = 0, nItemCnt do
        local nItemID,nType = UO.GetItem(i)
        --print(nType)
        if nType == tPackyFeed[_index] then
           print(nType.."  "..nItemID)
           nFeedID = nItemID
           break
        end
    end
 end
end

-- feed packanimal
function feedPackanimal()
    table.foreach(tPackyFeed, findOneFromTable)
    local nPacky = findItemID(tPackAnimals.lama)
    if nFeedID ~= nil and nPacky ~= nil then
       UO.Drag(nFeedID, 1)
       UO.DropC(nPacky)
    else
        print("did not found a packanimal or feed")
    end
end

-- MAIN --------------------------------------------------------------------------
if UO.TileInit(true) then
   nTempAngelID = findItemID(ANGEL)   
   repeat
         findFishingTiles(nFishingRange)
         print(nTableSize)
         uferTiles = {}
         uferTiles[0] = nil
         nShoreCnt = 0
         table.foreach(tFishTiles, fisching)
         local x,y = findNextPosition()
         if x == nil or y == nil then
            x = UO.CharPosX
            y = UO.CharPosY
            print("unexpected error, no new position found. Paused")
            pause()
         end
         UO.Move(x,y,nShoreWaterDistance, 5000)
   until false
else
    print("Init Fail")
end


[Bonbori]

Das Script habe ich einfach so drauf los geschrieben, Anregungen von Bonboris Script geholt
und es ist für mich ein "Lern Project". Es gibt noch einiges zu Lernen.
Die Sprache Lua ist mir neu. Die bisherigen Test liefen soweit erfolgreich.
Mein Wording ist wie immer eine Katastrophe

Danke Bonbori für die Anregung, OEU hat tatsächlich einiges an Vorteilen, besonder hervorzuheben ist die Geschwindigkeit. Natürlich wird das Scripten um einiges Komplexer aber auch mächtiger.
Ich hoffe es ist okay das ich deinen Thread dafür ausnutze

Klar, ist kein Ding. Ich benenn den Thread mal um, dann können wir das erstmal als "Sammelbecken" nutzen. Ich habe auch schon den ein oder anderen Bug in meinem Script gefunden, die ich auch überwiegend schon gefixt habe. Nach ein paar Tests werd ich mal den Code oben aktualisieren und ein paar mehr Kommentare spendieren (damit bin ich immer viel zu sparsam ).

[Vendor Fujin]

Sehr cool!

Das ganze Objektorientiert auszuziehen find ich garnicht so Trivial, deshlab hab ich nur mit Tabellen gearbeitet.
Wie ich ne Klasse/Objekt erstelle muss ich mir nochmal zugemüte führen.
Außerdem würde ich gerne Biblioteken erstellen, um das erstellen von Scripten zu beschleunigen.

Die ganze Entwicklungsumgebung macht das Debugen soviel angenehmer als im EUO
*Werbetrommel rührt*

Habe mal nen paar nützliches Links hinzugefügt:

Open EasyUO Dokumentation
LUA für Anfänger
LUA-Docu
LUA-Users
Open EasyUO Download -> Registration
EasyUO Forum

[Bonbori]

Das ganze Objektorientiert auszuziehen find ich garnicht so Trivial, deshlab hab ich nur mit Tabellen gearbeitet.
Wie ich ne Klasse/Objekt erstelle muss ich mir nochmal zugemüte führen.
Außerdem würde ich gerne Biblioteken erstellen, um das erstellen von Scripten zu beschleunigen.

Irgendwo im OpenEasyUO-Forum gibt es bereits eine Bibliothek für FindItem, die meines Wissens ähnlich wie bei EasyUO funktioniert. Ich wollte aber zu Lernzwecken am Anfang keinen Fremdcode nutzen.

[Vendor Fujin]

(Falscher) Programmierer Stolz (ich bin mal so frei mich so zu nennen) , ich will meine Eigenen Biblioteken schreiben *g*

[Bonbori]

(Falscher) Programmierer Stolz (ich bin mal so frei mich so zu nennen) , ich will meine Eigenen Biblioteken schreiben *g*

Hihi, ja das Gefühl kenne ich. Man sucht sich dann noch bei Bedarf allerhand Gründe, warum man seine eigene Klasse schreiben sollte, wie zum Beispiel: "Das ist aber nicht elegant gelöst" oder "Ich kann die Klasse so schreiben, dass sie 10% schneller läuft!" (was bei einer Klasse, die eine Laufzeit von <10ms aufweist und alle paar Sekunden ein mal ausgeführt wird effektiv ziemlich genau gar keine Auswirkungen hat )

[Vendor Fujin]

"Das ist aber nicht elegant gelöst" oder "Ich kann die Klasse so schreiben, dass sie 10% schneller läuft!" (was bei einer Klasse, die eine Laufzeit von <10ms aufweist und alle paar Sekunden ein mal ausgeführt wird effektiv ziemlich genau gar keine Auswirkungen hat )

Erwischt!

[Vendor Fujin]

Sigena Farmer
Funktion:
- Erntet die in tPlantTypes definierten Pflanzen ab
- Packt die Ernte die in tItemTypes definiert wurde ins Packpferd

Code: Alles auswählen

----------------------------------------------------------------------------------
-- Sigena Farmer by Giulia Fourier ----------------------------------------------
-- for UO-Freeshard Sigena (www.uosigena.de) -------------------------------------
-- Version 1.0 Beta --------------------------------------------------------------
----------------------------------------------------------------------------------
-- Anleitung
-- Positions Koordinaten configurieren
-- ######################
-- # X <pos2            #
-- #                    #
-- #                    #
-- #            pos1> X #
-- ######################
-- Planzenarten werden folgender maßen hinzugefügt:
--    mit ".type" die Grafic-ID der Pflanze ermitteln und in tPlantTypes eintragen
--    nach jedem außer dem letzen eintrag muss ein Komma folgen.
--    ACHTUNG: Ausgewachsene (Voll/Maximaler Abbau möglich) Pflanzen haben möglciherweise
--    einen andere Grafic-ID
--
--    mit ".type" die Grafic-ID des geernteten Items ermitteln und zu tItemTypes hinzufügen
--    Alle IDs die in tItemTypes eingetragen sind werden bei "Übergewicht und am Ende in Packy gelagert".
-- PackyFunktion Ein-/Ausschalten
--    in der Configuration "usePacky = true" setzen für Packy Unterstüzung
--    in der Configuration "usePacky = false" setzen für KEINE Packy Unterstüzung
----------------------------------------------------------------------------------
-- TODO-List
--     Pfanzen Tabelle erweitern
--     Configuration über ein Menü
----------------------------------------------------------------------------------
----------------------------------------------------------------------------------

-- INITIALISEING -----------------------------------------------------------------
-- constants ---

local pos1X  = 222
local pos1Y  = 399
local pos2X  = 213
local pos2Y  = 390
local usePacky = false

-- constant tables --

local tSysMessages = {
 succes = "Ihr legt die Ernte in euren Rucksack",
 fail = "Hier gibt es nichts zu ernten."
}

local tPlantTypes = {
 weizen = 3159,
 weizenFull = 3160
}

local tItemTypes = {
   weizen = 7869
}

tPackAnimals = {
     lama = 292,
     horse = 291
}

-- variables ---
local nPackyID
local tPlantList = {}
local plantCnt = 0
local nRef = UO.ScanJournal(0)


-- analysiert das Jorunal und gibt den status zurück
--  1 = pflanze noch nicht abgeerntet
-- -1 = pflanze abgeerntet
--  0 = sonstiges
function analyseJournal()
   local nReturn = 0
   nRef, nCnt =UO.ScanJournal(nRef)
   for i = 0, nCnt - 1 do
      local sLine = UO.GetJournal(i)
      print(sLine)
      if string.find(sLine,tSysMessages.succes) ~= nil then
         nReturn = 1
         print("return 1")
      elseif string.find(sLine,tSysMessages.fail) ~= nil then
         nReturn = -1
         print("return -1")
      end
   end
   return nReturn
end

-- gibt ein true zurück wenn sich die Koordianten (nX, nY) im Rechteck pos1 -> pos2 befindet
-- sieht configuration (oben)
function checkFieldPosition(nX, nY)
   if nX > pos1X or nX < pos2X or nY > pos1Y or nY < pos2Y then
      return false
   else
       return true
   end
end

-- erstellt eine Liste (tPlantList) in der alle Erntbaren Pflanzen enthalten sind
function findPlants(_index)
   print("Search for Plant "..tPlantTypes[_index])
   local items = UO.ScanItems(true)
   for i=0, items do
   --local nID,nType,nKind,nContID,nX,nY,nZ,nStack,nRep,nCo
      local nItemID, nItemType, nItemKind, nContID, nX, nY = UO.GetItem(i)
      --print(nItemType.."  "..UO.Property(nItemID))
      if nItemType == tPlantTypes[_index] and checkFieldPosition(nX, nY) then
         tPlantList[plantCnt] = { id = nItemID, x = nX, y = nY}
         plantCnt = plantCnt + 1
         print(plantCnt.."  "..nItemID)
      end
   end
end

-- search item by type and return therer id
function findItemID(itemType)
         local item = nil
         local itemCnt = UO.ScanItems(true)
         for i=0, itemCnt do
             local nID,nType,nKind,nContID,nX,nY,nZ,nStack,nRep,nCo = UO.GetItem(i)
             if nType == itemType then
                item = nID
                break
             end
         end
         return item
end

-- search items by item-type in containter and returns the id
function findItemIDStack(itemType,nContainerID)
            local item = nil
            local stack = nil
            local itemCnt = UO.ScanItems(true)
            for i=0, itemCnt do
                local nID,nType,nKind,nContID,nX,nY,nZ,nStack,nRep,nCo = UO.GetItem(i)
                if ( nContID == nContainerID) and nType == itemType then
                   -- print(UO.Property(nID))
                   -- print("\n")
                   item = nID
                   stack = nStack
                   break
                end
            end
            if item == nil then
               item = print("no item from type "..itemType.." was found in "..nContainerID)
            end
            return item, stack
end

--itterations Funktion, transferiert die Items aus tItemTypes ins Packy
function transferToPacky(_index)
   local nID,nStack = findItemIDStack(tItemTypes[_index], UO.BackpackID)
   UO.Drag(nID, nStack)
   UO.DropC(nPackyBagID)   
end

--findet das Packpferd, ermittelt die Packpferd Tasche und itteriert über tItemType die Funktion tranfserToPacky
function toPacky()
         if usePacky == false then
            return
         end
         nPackyID = findItemID(tPackAnimals.horse)
         if nPackyID == nil then
            nPackyID = findItemID(tPackAnimals.lama)
         end
         if nPackyID == nil then
            print("couln'd found an pack animal, "..nPackyID)
            pause()
         else
             UO.LObjectID = nPackyID
             UO.Macro(17,0)
             wait(500)
             nPackyBagID = UO.ContID
             print(nPackyBagID)
             table.foreach(tItemTypes,transferToPacky)
         end     
end

--Erntet die Pflanze bis nichts mehr zuholen ist
function liftPlant(itemID)
   local loopCnt = 0
   local jCode = 0
   UO.LObjectID = itemID
   while true do
      UO.Macro(17,0)
      jCode = 0
      loopCnt = 0
      while true do
         wait(10)
         jCode = analyseJournal()
         loopCnt = loopCnt + 1
         if jCode ~= 0 or loopCnt > 500 then
            break
         end
      end
      if jCode == -1 then
         break
      end
   end
end

table.foreach(tPlantTypes, findPlants)
if usePacky then
   UO.Macro(1,0, "all follow me")
end

for i = 0, plantCnt - 1 do
    print("Plant "..i + 1)
    UO.Move(tPlantList[i].x, tPlantList[i].y)
    liftPlant(tPlantList[i].id)
    if UO.Weight > UO.MaxWeight then
       toPacky()
    end
end
toPacky()
print("Ende")
UO.SysMessage("Fertig")
exit()






[Bonbori]

Kleines Healscript für OEUO. Nutzt .healme

Code: Alles auswählen

-- =======================
-- == Author:  Bonbori  ==
-- == Version: 1.0      ==
-- == Shard:   Sigena   ==
-- == Name:    Autoheal ==
-- =======================

-- ANFANG:EINSTELLUNGEN --
margin = 10 -- Legt fest, ab wie viel Schaden geheilt werden soll
curePoison = true -- true = Script entgiftet (mit Bandagen), false = Script entgiftet nicht.
-- ENDE:  EINSTELLUNGEN --

nRef,nCnt = UO.ScanJournal(0)

tMeldungen =
{
   "Patienten vollstaendig geheilt.",
   "bester Gesundheit",
   "nur Teile",
   "hat seine Wirkung",
   "hat euch geheilt.",
   "wenig ausrichten",
   "nicht helfen",
   "unterbrecht ",
   "Dafuer muesst",
   "bricht eure Behandlung ab."
}

function checkHealth()
   local badHealth, state = false, UO.CharStatus
   if  ( ( ( UO.MaxHits - margin) >= UO.Hits ) or ( (curePoison) and ( string.find(state, "C") ) ) ) then
      badHealth = true;
   end
   return badHealth
end

function waitJournal()
   while true do
      nRef,nCnt = UO.ScanJournal(nRef)
      wait(100)
      for i=0,nCnt - 1 do
         local sLine = UO.GetJournal(i)
         for k,meldung in pairs(tMeldungen) do
            if string.find(sLine, meldung) ~= nil then
               return true
            end
         end
      end
   end
end

function heal()
   local healagain = true;
   repeat
      UO.Macro(1,0,".healme")
      waitJournal()
      wait(750)
      healagain = checkHealth()
   until healagain == false
end

function main()
   local check = false
   while true do
      repeat
         wait(100)
         check = checkHealth()
      until check == true
      heal()
   end
end

main()

[Peter Lustig]

Kennt ihr das HIER?

Spoiler: Zeigen

Spoiler

Grüße Stone