diff --git a/lib/Gdip_All.ahk b/lib/Gdip_All.ahk index cca4049..b53bd29 100644 --- a/lib/Gdip_All.ahk +++ b/lib/Gdip_All.ahk @@ -2864,7 +2864,7 @@ Gdip_ResetClip(pGraphics) Gdip_GetClipRegion(pGraphics) { Region := Gdip_CreateRegion() - DllCall("gdiplus\GdipGetClip", "UPtr", pGraphics, "UInt", Region) + DllCall("gdiplus\GdipGetClip", "UPtr", pGraphics, "UPtr", Region) return Region } @@ -2875,7 +2875,7 @@ Gdip_SetClipRegion(pGraphics, Region, CombineMode:=0) Gdip_CreateRegion() { - DllCall("gdiplus\GdipCreateRegion", "UInt*", &Region:=0) + DllCall("gdiplus\GdipCreateRegion", "UPtr*", &Region:=0) return Region } @@ -3704,20 +3704,20 @@ StrGetB(Address, Length:=-1, Encoding:=0) if !Encoding { ; "" or 0 ; No conversion necessary, but we might not want the whole string. if (Length == -1) - Length := DllCall("lstrlen", "UInt", Address) + Length := DllCall("lstrlen", "Ptr", Address) VarSetStrCapacity(myString, Length) - DllCall("lstrcpyn", "str", myString, "UInt", Address, "Int", Length + 1) + DllCall("lstrcpyn", "str", myString, "Ptr", Address, "Int", Length + 1) } else if (Encoding = 1200) { ; UTF-16 - char_count := DllCall("WideCharToMultiByte", "UInt", 0, "UInt", 0x400, "UInt", Address, "Int", Length, "UInt", 0, "UInt", 0, "UInt", 0, "UInt", 0) + char_count := DllCall("WideCharToMultiByte", "UInt", 0, "UInt", 0x400, "Ptr", Address, "Int", Length, "UInt", 0, "UInt", 0, "UInt", 0, "UInt", 0) VarSetStrCapacity(myString, char_count) - DllCall("WideCharToMultiByte", "UInt", 0, "UInt", 0x400, "UInt", Address, "Int", Length, "str", myString, "Int", char_count, "UInt", 0, "UInt", 0) + DllCall("WideCharToMultiByte", "UInt", 0, "UInt", 0x400, "Ptr", Address, "Int", Length, "str", myString, "Int", char_count, "UInt", 0, "UInt", 0) } else if IsInteger(Encoding) { ; Convert from target encoding to UTF-16 then to the active code page. - char_count := DllCall("MultiByteToWideChar", "UInt", Encoding, "UInt", 0, "UInt", Address, "Int", Length, "UInt", 0, "Int", 0) + char_count := DllCall("MultiByteToWideChar", "UInt", Encoding, "UInt", 0, "Ptr", Address, "Int", Length, "Ptr", 0, "Int", 0) VarSetStrCapacity(myString, char_count * 2) - char_count := DllCall("MultiByteToWideChar", "UInt", Encoding, "UInt", 0, "UInt", Address, "Int", Length, "UInt", myString.Ptr, "Int", char_count * 2) + char_count := DllCall("MultiByteToWideChar", "UInt", Encoding, "UInt", 0, "Ptr", Address, "Int", Length, "Ptr", myString.Ptr, "Int", char_count * 2) myString := StrGetB(myString.Ptr, char_count, 1200) } diff --git a/lib/OCR.ahk b/lib/OCR.ahk new file mode 100644 index 0000000..6c455db --- /dev/null +++ b/lib/OCR.ahk @@ -0,0 +1,1890 @@ +#Requires AutoHotkey v2 + +ProcessImage(fileName, whiteThreshold := 200, delta := 30) { + if SubStr(fileName, -4) == ".png" { + fileName := SubStr(fileName, -4) + } + imgPath := fileName . ".png" + hBitmap := Gdip_CreateBitmapFromFile(imgPath) + if !hBitmap { + return + } + + width := Gdip_GetImageWidth(hBitmap) + height := Gdip_GetImageHeight(hBitmap) + + Loop height { + y := A_Index - 1 + Loop width { + x := A_Index - 1 + + color := Gdip_GetPixel(hBitmap, x, y) + + r := (color >> 16) & 0xFF + g := (color >> 8) & 0xFF + b := color & 0xFF + a := (color >> 24) & 0xFF + + if ((b - r) >= delta && (b - g) >= delta) { + Gdip_SetPixel(hBitmap, x, y, 0x00000000) + } + else if (r >= whiteThreshold && g >= whiteThreshold && b >= whiteThreshold) { + Gdip_SetPixel(hBitmap, x, y, 0x00000000) + } + } + } + + Gdip_SaveBitmapToFile(hBitmap, fileName . "_processed.png") + + Gdip_DisposeImage(hBitmap) + + return fileName . "_processed.png" +} + +LevenshteinDistance(s1, s2) { + len1 := StrLen(s1), len2 := StrLen(s2) + s1 := StrSplit(s1), s2 := StrSplit(s2) + d := {}, d.0 := { 0: 0 } + Loop len1 + d.%A_Index% := { 0: A_Index } + Loop len2 + d.0.%A_Index% := A_Index + Loop len1 { + i := A_Index + Loop len2 { + j := A_Index ; only for simplicity + cost := s1[i] != s2[j] + d.%i%.%j% := Min(d.%i - 1%.%j% + 1, d.%i%.%j - 1% + 1, d.%i - 1%.%j - 1% + cost) + } + } + return d.%len1%.%len2% +} + +isCorrectWord(items, wordsList, idx) { + word := wordsList.Words.Get(idx) + itemName := StrLower(items[1]) + if wordsList.Words.Length > idx { + nextWord := wordsList.Words.Get(idx + 1) + if (items.Length <= 1 ? nextWord.BoundingRect.y == word.BoundingRect.y : StrLower(nextWord.Text) != StrLower(items[2])) { + return + } + } else { + return StrLower(itemName) == StrLower(word.Text) + } + return True +} + +isUnspacedWord(items, wordsList, idx, max:=4) { + if items.Length <= 1 { + ; I cbf trying to replace everything with spacing ngl + word := wordsList.Words.Get(idx) + itemName := StrLower(items[1]) + text := StrLower(word.Text) + Loop max { + curIdx := idx + A_Index + if wordsList.Words.length >= curIdx { + nextWord := wordsList.Words.Get(curIdx) + text .= StrLower(nextWord.Text) + if text == itemName { + return True + } + } else { + break + } + } + } + return +} + +findTextInRegion(item, img:="", x:=0, y:=0, w:=0, h:=0, absolute:=False) { + wordsList := {} + if img != "" { + wordsList := OCR.FromFile(img) + } else { + wordsList := OCR.FromRect(x, y, w, h) + } + + exactMatch := False + items := StrSplit(item, " ") + itemName := StrLower(items[1]) + region := "" + bestDist := [9999999999] + TextRegion := Map() + TextRegion["Words"] := wordsList.Words + if absolute { + for idx, word in wordsList.Words { + if itemName == StrLower(word.Text) and isCorrectWord(items, wordsList, idx) { + TextRegion["Word"] := word + return TextRegion + } else if isUnspacedWord(items, wordsList, idx) { + TextRegion["Word"] := word + return TextRegion + } + } + return TextRegion + } else { + for idx, word in wordsList.Words { + text := StrLower(word.Text) + rect := word.BoundingRect + if itemName == text and isCorrectWord(items, wordsList, idx) { + TextRegion["Word"] := word + return TextRegion + } else if StrLen(text) >= 1 { + if isUnspacedWord(items, wordsList, idx) { + TextRegion["Word"] := word + return TextRegion + } + foundPos := InStr(StrLower(itemName), StrLower(text)) + dist := 0 + if foundPos { + dist := (StrLen(text) - foundPos) / StrLen(itemName) + } else { + dist := LevenshteinDistance(itemName, text) + } + if bestDist[1] > dist { + bestDist := [dist, word] + } + } + } + } + + word := bestDist[2] + text := word.Text + rect := word.BoundingRect + if bestDist[1] > .15 || bestDist[1] < 0 { + return TextRegion + } + + TextRegion["Word"] := word + return TextRegion +} + +getAvailableLang() { + GlobalizationPreferencesStatics := OCR.CreateClass("Windows.System.UserProfile.GlobalizationPreferences", IGlobalizationPreferencesStatics := "{01BF4326-ED37-4E96-B0E9-C1340D1EA158}") + LanguageFactory := OCR.CreateClass("Windows.Globalization.Language", ILanguageFactory := "{9B0252AC-0C27-44F8-B792-9793FB66C63E}") + ComCall(9, GlobalizationPreferencesStatics, "ptr*", &LanguageList:=0) ; get_Languages + ComCall(7, LanguageList, "int*", &count:=0) ; count + loop count + { + ComCall(6, LanguageList, "int", A_Index-1, "ptr*", &hString:=0) ; get_Item + ComCall(6, LanguageFactory, "ptr", hString, "ptr*", &LanguageTest:=0) ; CreateLanguage + ComCall(8, OCR.OcrEngineStatics, "ptr", LanguageTest, "int*", &bool:=0) ; IsLanguageSupported + if (bool = 1) + { + ComCall(6, LanguageTest, "ptr*", &hText:=0) + b := DllCall("Combase.dll\WindowsGetStringRawBuffer", "ptr", hText, "uint*", &length:=0, "ptr") + text .= StrGet(b, "UTF-16") "`n" + } + ObjRelease(LanguageTest) + } + ObjRelease(LanguageList) + return text +} + +/** + * OCR library: a wrapper for the the UWP Windows.Media.Ocr library. + * Based on the UWP OCR function for AHK v1 by malcev. + * + * Ways of initiating OCR: + * OCR(RandomAccessStreamOrSoftwareBitmap, Options?) + * OCR.FromDesktop(Options?) + * OCR.FromMonitor(Monitor?, Options?) + * OCR.FromRect(X, Y, W, H, Options?) + * OCR.FromWindow(WinTitle:="", Options?, WinText:="", ExcludeTitle:="", ExcludeText:="") + * Note: the result object coordinates will be in CoordMode "Pixel" + * OCR.FromFile(FileName, Options?) + * OCR.FromBitmap(bitmap, Options?, hDC?) + * OCR.FromPDF(FileName, Options?, Start:=1, End?, Password:="") => returns an array of results for each PDF page + * OCR.FromPDFPage(FileName, page, Options?) + * Helper functions for PDF OCR: + * OCR.GetPdfPageCount(FileName, Password:="") + * OCR.GetPdfPageProperties(FileName, Page, Password:="") + * + * Options can be an object containing none or all of these elements: + * { + * lang: OCR language. Default is first from available languages. This can also be a function which evaluates to a language string. + * scale: a Float scale factor to zoom the image in or out, which might improve detection. + * The resulting coordinates will be adjusted to scale. Default is 1. + * grayscale: Boolean 0 | 1 whether to convert the image to black-and-white. Default is 0. + * monochrome: 0-255, converts all pixels with luminosity less than the threshold to black, otherwise to white. Default is 0 (no conversion). + * invertcolors: Boolean 0 | 1, whether to invert the colors of the image. Default is 0. + * rotate: 0 | 90 | 180 | 270, can be used to rotate the image clock-wise by degrees. Default is 0. + * flip: 0 | "x" | "y", can be used to flip the image on the x- or y-axis. Default is 0. + * x, y, w, h: can be used to crop the image. This is applied before scaling. Default is no cropping. + * decoder: gif | ico | jpeg | jpegxr | png | tiff | bmp. Optional bitmap codec name to decode RandomAccessStream. Default is automatic detection. + * } + * + * Note: Options also accepts any optional parameters after it like named parameters. + * Eg. OCR.FromMonitor({lang:"en-us", monitor:2}) + * + * Additional methods: + * OCR.GetAvailableLanguages() + * OCR.LoadLanguage(lang:="FirstFromAvailableLanguages") + * OCR.WaitText(needle, timeout:=-1, func?, casesense:=False, comparefunc?) + * Calls a func (the provided OCR method) until a string is found + * OCR.WordsBoundingRect(words*) + * Returns the bounding rectangle for multiple words + * OCR.ClearAllHighlights() + * Removes all highlights created by Result.Highlight + * OCR.Cluster(objs, eps_x:=-1, eps_y:=-1, minPts:=1, compareFunc?, &noise?) + * Clusters objects (by default based on distance from eachother). Can be used to create more + * accurate "Line" results. + * OCR.SortArray(arr, optionsOrCallback:="N", key?) + * Sorts an array in-place, optionally by object keys or using a callback function. + * OCR.ReverseArray(arr) + * Reverses an array in-place. + * OCR.UniqueArray(arr) + * Returns an array with unique values. + * OCR.FlattenArray(arr) + * Returns a one-dimensional array from a multi-dimensional array + * + * Properties: + * OCR.MaxImageDimension + * MinImageDimension is not documented, but appears to be 40 pixels (source: user FanaticGuru in AutoHotkey forums) + * OCR.PerformanceMode + * Increases speed of OCR acquisition by about 20-50ms if set to 1, but also increases CPU usage. Default is 0. + * OCR.DisplayImage + * If set to True then the captured image is displayed on the screen before proceeding to OCR-ing the image. + * + * OCR returns an OCR.Result object: + * Result.Text => All recognized text + * Result.TextAngle => Clockwise rotation of the recognized text + * Result.Lines => Array of all OCR.Line objects + * Result.Words => Array of all OCR.Word objects + * Result.ImageWidth => Used image width + * Result.ImageHeight => Used image height + * + * Result.FindString(Needle, Options?) + * Finds a string in the result. Possible options (see descriptions at the function definition): + * {CaseSense: False, IgnoreLinebreaks: False, AllowOverlap: false, i: 1, x, y, w, h, SearchFunc} + * Result.FindStrings(Needle, Options?) + * Finds all strings in the result. + * Result.Filter(callback) + * Returns a filtered result object that contains only words that satisfy the callback function + * Result.Crop(x1, y1, x2, y2) + * Crops the result object to contain only results from an area defined by points (x1,y1) and (x2,y2). + * + * OCR.Line object: + * Line.Text => Recognized text of the line + * Line.Words => Array of Word objects for the Line + * Line.x,y,w,h => Size and location of the Line. + * + * OCR.Word object: + * Word.Text => Recognized text of the word + * Word.x,y,w,h => Size and location of the Word. + * Word.BoundingRect => Bounding rectangle of the Word in format {x,y,w,h}. + * + * OCR.Result, OCR.Line, and OCR.Word also all have some common methods: + * + * Result.Click(WhichButton?, ClickCount?, DownOrUp?) + * Clicks an object (Word, FindString result etc) + * Result.ControlClick(WinTitle?, WinText?, WhichButton?, ClickCount?, Options?, ExcludeTitle?, ExcludeText?) + * ControlClicks an object (Word, FindString result etc) + * Result.Highlight(showTime?, color:="Red", d:=2) + * Highlights a Word, Line, or object with {x,y,w,h} properties on the screen (default: 2 seconds), or removes the highlighting + * + * Additional notes: + * Languages are recognized in BCP-47 language tags. Eg. OCR.FromFile("myfile.bmp", {lang: "en-AU"}) + * Languages can be installed for example with PowerShell (run as admin): Install-Language + * or from Language settings in Settings. + * Not all language packs support OCR though. A list of supported language can be gotten from + * Powershell (run as admin) with the following command: Get-WindowsCapability -Online | Where-Object { $_.Name -Like 'Language.OCR*' } + */ +class OCR { + static Version => "2.0.0" + static IID_IRandomAccessStream := "{905A0FE1-BC53-11DF-8C49-001E4FC686DA}" + , IID_IPicture := "{7BF80980-BF32-101A-8BBB-00AA00300CAB}" + , IID_IAsyncInfo := "{00000036-0000-0000-C000-000000000046}" + , IID_IAsyncOperation_OcrResult := "{c7d7118e-ae36-59c0-ac76-7badee711c8b}" + , IID_IAsyncOperation_SoftwareBitmap := "{c4a10980-714b-5501-8da2-dbdacce70f73}" + , IID_IAsyncOperation_BitmapDecoder := "{aa94d8e9-caef-53f6-823d-91b6e8340510}" + , IID_IAsyncOperationCompletedHandler_OcrResult := "{989c1371-444a-5e7e-b197-9eaaf9d2829a}" + , IID_IAsyncOperationCompletedHandler_SoftwareBitmap := "{b699b653-33ed-5e2d-a75f-02bf90e32619}" + , IID_IAsyncOperationCompletedHandler_BitmapDecoder := "{bb6514f2-3cfb-566f-82bc-60aabd302d53}" + , IID_IPdfDocumentStatics := "{433A0B5F-C007-4788-90F2-08143D922599}" + , Vtbl_GetDecoder := {bmp:6, jpg:7, jpeg:7, png:8, tiff:9, gif:10, jpegxr:11, ico:12} + , PerformanceMode := 0 + , DisplayImage := 0 + + class IBase { + __OCR := OCR + __New(ptr?) { + if IsSet(ptr) { + if !ptr + throw ValueError('Invalid IUnknown interface pointer', -2, this.__Class) + else if IsObject(ptr) { + if ptr.HasProp("Relative") + this.DefineProp("Relative", {value: ptr.Relative}) + ptr := 0 + } + } + this.DefineProp("ptr", {Value:ptr ?? 0}) + } + __Delete() => this.ptr ? ObjRelease(this.ptr) : 0 + } + + static __New() { + this.LanguageFactory := this.CreateClass("Windows.Globalization.Language", ILanguageFactory := "{9B0252AC-0C27-44F8-B792-9793FB66C63E}") + this.SoftwareBitmapFactory := this.CreateClass("Windows.Graphics.Imaging.SoftwareBitmap", "{c99feb69-2d62-4d47-a6b3-4fdb6a07fdf8}") + this.BitmapTransform := this.CreateClass("Windows.Graphics.Imaging.BitmapTransform") + this.BitmapDecoderStatics := this.CreateClass("Windows.Graphics.Imaging.BitmapDecoder", IBitmapDecoderStatics := "{438CCB26-BCEF-4E95-BAD6-23A822E58D01}") + this.BitmapEncoderStatics := this.CreateClass("Windows.Graphics.Imaging.BitmapEncoder", IBitmapDecoderStatics := "{a74356a7-a4e4-4eb9-8e40-564de7e1ccb2}") + this.SoftwareBitmapStatics := this.CreateClass("Windows.Graphics.Imaging.SoftwareBitmap", ISoftwareBitmapStatics := "{df0385db-672f-4a9d-806e-c2442f343e86}") + this.OcrEngineStatics := this.CreateClass("Windows.Media.Ocr.OcrEngine", IOcrEngineStatics := "{5BFFA85A-3384-3540-9940-699120D428A8}") + ComCall(6, this.OcrEngineStatics, "uint*", &MaxImageDimension:=0) ; MaxImageDimension + this.MaxImageDimension := MaxImageDimension + DllCall("Dwmapi\DwmIsCompositionEnabled", "Int*", &compositionEnabled:=0) + this.CAPTUREBLT := compositionEnabled ? 0 : 0x40000000 + /* // Based on code by AHK forums user Xtra + unsigned int Convert_GrayScale(unsigned int bitmap[], unsigned int w, unsigned int h, unsigned int Stride) + { + unsigned int a, r, g, b, gray, ARGB; + unsigned int x, y, offset = Stride/4; + for (y = 0; y < h * offset; y += offset) { + for (x = 0; x < w; ++x) { + ARGB = bitmap[x+y]; + a = ARGB & 0xFF000000; + r = (ARGB & 0x00FF0000) >> 16; + g = (ARGB & 0x0000FF00) >> 8; + b = (ARGB & 0x000000FF); + gray = ((300 * r) + (590 * g) + (110 * b)) >> 10; + bitmap[x+y] = (gray << 16) | (gray << 8) | gray | a; + } + } + return 0; + } + */ + this.GrayScaleMCode := this.MCode((A_PtrSize = 4) + ? "2,x86:VVdWU4PsCIt8JCiLdCQki0QkIMHvAg+v94k0JIX2dH+FwHR7jTS9AAAAAIl0JASLdCQcjRyGMfaNtCYAAAAAkItEJByNDLCNtCYAAAAAZpCLEYPBBInQD7buwegQae1OAgAAD7bAacAsAQAAAegPtuqB4gAAAP9r7W4B6MHoConFCcLB4AjB5RAJ6gnQiUH8Odl1vAH+A1wkBDs0JHKhg8QIMcBbXl9dww==" + : "2,x64:V1ZTQcHpAkSJxkiJy0GJ00EPr/GF9nRnRTHAhdJ0YJBEicEPH0QAAInIg8EBTI0Ug0GLEonQD7b+wegQaf9OAgAAD7bAacAsAQAAAfgPtvqB4gAAAP9r/24B+MHoConHCcLB4AjB5xAJ+gnCQYkSRDnZdbRFAchFActBOfByoTHAW15fww==") + /* + unsigned int Invert_Colors(unsigned int bitmap[], unsigned int w, unsigned int h, unsigned int Stride) + { + unsigned int a, r, g, b, gray, ARGB; + unsigned int x, y, offset = Stride/4; + for (y = 0; y < h * offset; y += offset) { + for (x = 0; x < w; ++x) { + ARGB = bitmap[x+y]; + a = ARGB & 0xFF000000; + r = (ARGB & 0x00FF0000) >> 16; + g = (ARGB & 0x0000FF00) >> 8; + b = (ARGB & 0x000000FF); + bitmap[x+y] = ((255-r) << 16) | ((255-g) << 8) | (255-b) | a; + } + } + return 0; + } + */ + this.InvertColorsMCode := this.MCode((A_PtrSize = 4) + ? "2,x86:VVdWU4PsCItsJCiLfCQki0QkIMHtAg+v/Yk8JIX/dGeFwHRjjTytAAAAAIl8JASLfCQcjTSHMf+NtCYAAAAAkItEJByNDLiNtCYAAAAAZpCLEYPBBInQidOB4v8AAP/30PfTgPL/JQAA/wCB4wD/AAAJ2AnQiUH8OfF11AHvA3QkBDs8JHK5g8QIMcBbXl9dww==" + : "2,x64:V1ZTQcHpAkSJx0iJzonTQQ+v+YX/dFNFMcCF0nRMZpBEicEPH0QAAInIg8EBTI0chkGLE4nQQYnSgeL/AAD/99BB99KA8v8lAAD/AEGB4gD/AABECdAJ0EGJAznLdclFAchEActBOfhytjHAW15fww==") + /* + unsigned int Convert_Monochrome(unsigned int bitmap[], unsigned int w, unsigned int h, unsigned int Stride, unsigned int threshold) + { + unsigned int a, r, g, b, ARGB; + unsigned int x, y, offset = Stride / 4; + for (y = 0; y < h * offset; y += offset) { + for (x = 0; x < w; ++x) { + ARGB = bitmap[x + y]; + a = ARGB & 0xFF000000; + r = (ARGB & 0x00FF0000) >> 16; + g = (ARGB & 0x0000FF00) >> 8; + b = (ARGB & 0x000000FF); + unsigned int luminance = (77 * r + 150 * g + 29 * b) >> 8; + bitmap[x + y] = (luminance > threshold) ? 0xFFFFFFFF : 0xFF000000; + } + } + return 0; + } + */ + this.MonochromeMCode := this.MCode((A_PtrSize = 4) + ? "2,x86:VVdWU4PsDIt0JCyLTCQoi0QkJIt8JDDB7gIPr86JNCSJTCQEhcl0aYXAdGXB5gIx7Yl0JAiLdCQgjTSGjXQmAItEJCCNDKiNtCYAAAAAZpCLEYnTD7bGD7bSwesQacCWAAAAD7bba9Ida9tNAdgB0MHoCDn4dinHAf////+DwQQ58XXMAywkA3QkCDlsJAR3r4PEDDHAW15fXcONdCYAkMcBAAAA/4PBBDnxdaMDLCQDdCQIOWwkBHeG69U=" + : "2,x64:VVdWU4t0JEhBwekCRInHSInLQYnTQQ+v+YX/dFyF0nRYRTHADx9AAESJwQ8fRAAAichMjRSDQYsSidUPtsYPttLB7RBpwJYAAABAD7bta9Ida+1NAegB0MHoCDnwdiGDwQFBxwL/////QTnLdcJFAchFActEOcd3rzHAW15fXcODwQFBxwIAAAD/RDnZdaFFAchFActEOcd3juvd") + } + + /** + * Returns an OCR results object for an IRandomAccessStream. + * Images of other types should be first converted to this format (eg from file, from bitmap). + * @param RandomAccessStreamOrSoftwareBitmap Pointer or an object containing a ptr to a RandomAccessStream or SoftwareBitmap + * @param {String} lang OCR language. Default is first from available languages. + * @param {Integer|Object} transform Either a scale factor number, or an object {scale:Float, grayscale:Boolean, invertcolors:Boolean, monochrome:0-255, rotate: 0 | 90 | 180 | 270, flip: 0 | "x" | "y"} + * @param {String} decoder Optional bitmap codec name to decode RandomAccessStream. Default is automatic detection. + * Possible values are gif, ico, jpeg, jpegxr, png, tiff, bmp. + * @returns {OCR.Result} + */ + static Call(RandomAccessStreamOrSoftwareBitmap, Options:=0) { + local SoftwareBitmap := 0, RandomAccessStream := 0, lang:="FirstFromAvailableLanguages", width, height, x := 0, y := 0, w := 0, h := 0, scale, grayscale, invertcolors, monochrome, OcrResult := this.Result(), Result, transform := 0, decoder := 0 + this.__ExtractTransformParameters(Options, &transform) + scale := transform.scale, grayscale := transform.grayscale, invertcolors := transform.invertcolors, monochrome := transform.monochrome, rotate := transform.rotate, flip := transform.flip + this.__ExtractNamedParameters(Options, "x", &x, "y", &y, "w", &w, "h", &h, "language", &lang, "lang", &lang, "decoder", &decoder) + this.LoadLanguage(lang) + local customRegion := x || y || w || h + + try SoftwareBitmap := ComObjQuery(RandomAccessStreamOrSoftwareBitmap, "{689e0708-7eef-483f-963f-da938818e073}") ; ISoftwareBitmap + if SoftwareBitmap { + ComCall(8, SoftwareBitmap, "uint*", &width:=0) ; get_PixelWidth + ComCall(9, SoftwareBitmap, "uint*", &height:=0) ; get_PixelHeight + this.ImageWidth := width, this.ImageHeight := height + if (Floor(width*scale) > this.MaxImageDimension) or (Floor(height*scale) > this.MaxImageDimension) + throw ValueError("Image is too big - " width "x" height ".`nIt should be maximum - " this.MaxImageDimension " pixels (with scale applied)") + if scale != 1 || customRegion || rotate || flip + SoftwareBitmap := this.TransformSoftwareBitmap(SoftwareBitmap, &width, &height, scale, rotate, flip, x?, y?, w?, h?) + goto SoftwareBitmapCommon + } + RandomAccessStream := RandomAccessStreamOrSoftwareBitmap + + if decoder { + ComCall(this.Vtbl_GetDecoder.%decoder%, this.BitmapDecoderStatics, "ptr", DecoderGUID:=Buffer(16)) + ComCall(15, this.BitmapDecoderStatics, "ptr", DecoderGUID, "ptr", RandomAccessStream, "ptr*", BitmapDecoder:=ComValue(13,0)) ; CreateAsync + } else + ComCall(14, this.BitmapDecoderStatics, "ptr", RandomAccessStream, "ptr*", BitmapDecoder:=ComValue(13,0)) ; CreateAsync + this.WaitForAsync(&BitmapDecoder) + + BitmapFrame := ComObjQuery(BitmapDecoder, IBitmapFrame := "{72A49A1C-8081-438D-91BC-94ECFC8185C6}") + ComCall(12, BitmapFrame, "uint*", &width:=0) ; get_PixelWidth + ComCall(13, BitmapFrame, "uint*", &height:=0) ; get_PixelHeight + if (width > this.MaxImageDimension) or (height > this.MaxImageDimension) + throw ValueError("Image is too big - " width "x" height ".`nIt should be maximum - " this.MaxImageDimension " pixels") + + BitmapFrameWithSoftwareBitmap := ComObjQuery(BitmapDecoder, IBitmapFrameWithSoftwareBitmap := "{FE287C9A-420C-4963-87AD-691436E08383}") + OcrResult.ImageWidth := width, OcrResult.ImageHeight := height + if !(customRegion || rotate || flip) && (width < 40 || height < 40 || scale != 1) { + scale := scale = 1 ? 40.0 / Min(width, height) : scale + ComCall(7, this.BitmapTransform, "int", width := Floor(width*scale)) ; put_ScaledWidth + ComCall(9, this.BitmapTransform, "int", height := Floor(height*scale)) ; put_ScaledHeight + ComCall(8, BitmapFrame, "uint*", &BitmapPixelFormat:=0) ; get_BitmapPixelFormat + ComCall(9, BitmapFrame, "uint*", &BitmapAlphaMode:=0) ; get_BitmapAlphaMode + ComCall(8, BitmapFrameWithSoftwareBitmap, "uint", BitmapPixelFormat, "uint", BitmapAlphaMode, "ptr", this.BitmapTransform, "uint", IgnoreExifOrientation := 0, "uint", DoNotColorManage := 0, "ptr*", SoftwareBitmap:=this.IBase()) ; GetSoftwareBitmapAsync + } else { + ComCall(6, BitmapFrameWithSoftwareBitmap, "ptr*", SoftwareBitmap:=this.IBase()) ; GetSoftwareBitmapAsync + } + this.WaitForAsync(&SoftwareBitmap) + if customRegion || rotate || flip || scale != 1 + SoftwareBitmap := this.TransformSoftwareBitmap(SoftwareBitmap, &width, &height, scale, rotate, flip, x?, y?, w?, h?) + + SoftwareBitmapCommon: + + if (grayscale || invertcolors || monochrome || this.DisplayImage) { + ComCall(15, SoftwareBitmap, "int", 2, "ptr*", &BitmapBuffer := 0) ; LockBuffer + MemoryBuffer := ComObjQuery(BitmapBuffer, "{fbc4dd2a-245b-11e4-af98-689423260cf8}") + ComCall(6, MemoryBuffer, "ptr*", &MemoryBufferReference := 0) ; CreateReference + BufferByteAccess := ComObjQuery(MemoryBufferReference, "{5b0d3235-4dba-4d44-865e-8f1d0e4fd04d}") + ComCall(3, BufferByteAccess, "ptr*", &SoftwareBitmapByteBuffer:=0, "uint*", &BufferSize:=0) ; GetBuffer + + ;if grayscale + ; DllCall(this.GrayScaleMCode, "ptr", SoftwareBitmapByteBuffer, "uint", width, "uint", height, "uint", (width*4+3) // 4 * 4, "cdecl uint") + + ;if monochrome + ; DllCall(this.MonochromeMCode, "ptr", SoftwareBitmapByteBuffer, "uint", width, "uint", height, "uint", (width*4+3) // 4 * 4, "uint", monochrome, "cdecl uint") + ; + ;if invertcolors + ; DllCall(this.InvertColorsMCode, "ptr", SoftwareBitmapByteBuffer, "uint", width, "uint", height, "uint", (width*4+3) // 4 * 4, "cdecl uint") + + if this.DisplayImage { + local hdc := DllCall("GetDC", "ptr", 0, "ptr"), bi := Buffer(40, 0), hbm + NumPut("uint", 40, "int", width, "int", -height, "ushort", 1, "ushort", 32, bi) + hbm := DllCall("CreateDIBSection", "ptr", hdc, "ptr", bi, "uint", 0, "ptr*", &ppvBits:=0, "ptr", 0, "uint", 0, "ptr") + DllCall("ntdll\memcpy", "ptr", ppvBits, "ptr", SoftwareBitmapByteBuffer, "uint", BufferSize, "cdecl") + DllCall("ReleaseDC", "Ptr", 0, "Ptr", hdc, "Int") + this.DisplayHBitmap(hbm) + } + + BufferByteAccess := "", ObjRelease(MemoryBufferReference), MemoryBuffer := "", ObjRelease(BitmapBuffer) ; Release in correct order + } + + ComCall(6, this.OcrEngine, "ptr", SoftwareBitmap, "ptr*", Result:=ComValue(13,0)) ; RecognizeAsync + this.WaitForAsync(&Result) + OcrResult.Ptr := Result.Ptr, ObjAddRef(OcrResult.ptr) + + ; Cleanup + if RandomAccessStream is this.IBase + this.CloseIClosable(RandomAccessStream) + if SoftwareBitmap is this.IBase + this.CloseIClosable(SoftwareBitmap) + + if scale != 1 || x != 0 || y != 0 + this.NormalizeCoordinates(OcrResult, scale, x, y) + + return OcrResult + } + + static ClearAllHighlights() => this.Result.Prototype.Highlight("clearall") + + class Result extends OCR.Common { + ; Gets the recognized text. + Text { + get { + ComCall(8, this, "ptr*", &hAllText:=0) ; get_Text + buf := DllCall("Combase.dll\WindowsGetStringRawBuffer", "ptr", hAllText, "uint*", &length:=0, "ptr") + this.DefineProp("Text", {Value:StrGet(buf, "UTF-16")}) + this.__OCR.DeleteHString(hAllText) + return this.Text + } + } + + ; Gets the clockwise rotation of the recognized text, in degrees, around the center of the image. + TextAngle { + get => (ComCall(7, this, "double*", &value:=0), value) + } + + ; Returns all Line objects for the result. + Lines { + get { + ComCall(6, this, "ptr*", LinesList:=ComValue(13, 0)) ; get_Lines + ComCall(7, LinesList, "int*", &count:=0) ; count + lines := [] + loop count { + ComCall(6, LinesList, "int", A_Index-1, "ptr*", Line:=this.__OCR.Line(this)) + lines.Push(Line) + } + this.DefineProp("Lines", {Value:lines}) + return lines + } + } + + ; Returns all Word objects for the result. Equivalent to looping over all the Lines and getting the Words. + Words { + get { + local words := [], line, word + for line in this.Lines + for word in line.Words + words.Push(word) + this.DefineProp("Words", {Value:words}) + return words + } + } + + BoundingRect { + get => this.DefineProp("BoundingRect", {Value:this.__OCR.WordsBoundingRect(this.Words*)}).BoundingRect + } + + /** + * Finds a string in the search results, and returns a new Result object. + * If the match is partial then the result will contain the whole word: in "hello world" searching "wo" will return "world". + * To force a full word search instead of a partial search, use IgnoreLinebreaks:True + * and add a space to the beginning and end: " hello " + * To search multi-line matches, set IgnoreLinebreaks:True and use a linebreak in the needle: "hello`nworld" + * @param Needle The string to find. + * @param Options Extra search options object, which can contain the following properties: + * CaseSense: False (this is ignored if a custom SearchFunc is used) + * IgnoreLinebreaks: False (if this is True, then linebreaks are converted to whitespaces, otherwise remain `n) + * AllowOverlap: False (if True then the needle can overlap itself) + * i: 1 (which occurrence of the needle to find) + * x, y, w, h: defines the search area inside the result object + * SearchFunc: default is InStr, but if a custom function is provided then it needs to return + * the needle location in the haystack, and accept arguments (Haystack, Needle, &FoundMatch) + * This can used for example to perform a RegEx search by providing RegExMatch + * @returns {Object} + */ + FindString(Needle, Options := "") => this.__FindString(Needle, Options, 0) + + /** + * Finds all strings matching the needle in the search results. Returns an array of Result objects. + * @param Needle The string to find. + * @param Options See Result.FindString. {CaseSense: False, IgnoreLinebreaks: False, AllowOverlap: false, i: 1, x, y, w, h, SearchFunc} + * If i is specified then the result object will contains matches starting from i. + * @returns {Array} + */ + FindStrings(Needle, Options := "") => this.__FindString(Needle, Options, true) + + __FindString(Needle, Options, All) { + local CaseSense := false, IgnoreLinebreaks := false, AllowOverlap := false, i := 1, SearchFunc, x, y, w, h + local currentHaystack, fullHaystackLinebreaks := "`n", offset := 0, line, counter := 0, x1, y1, x2, y2, result, results := [], word + + if !(Needle is String) + throw TypeError("Needle is required to be a string, not type " Type(Needle), -1) + if Trim(Needle, " `t`n`r") == "" + throw ValueError("Needle cannot be an empty string", -1) + + this.__OCR.__ExtractNamedParameters(Options, "CaseSense", &CaseSense, "IgnoreLinebreaks", &IgnoreLinebreaks, "AllowOverlap", &AllowOverlap, "i", &i, "SearchFunc", &SearchFunc, "x", &x, "y", &y, "w", &w, "h", &h) + + if !IsSet(SearchFunc) + SearchFunc := (haystack, needle, &foundstr) => (pos := InStr(haystack, needle, casesense), foundstr := SubStr(haystack, pos, StrLen(needle)), pos) + + if (IsSet(x) || IsSet(y) || IsSet(w) || IsSet(h)) { + x1 := x ?? -100000, y1 := y ?? -100000, x2 := IsSet(w) ? x + w : 100000, y2 := IsSet(h) ? y + h : 100000 + } + + tokenizedHaystack := [IgnoreLinebreaks ? " " : "`n"] + for Line in this.Lines { + fullHaystackLinebreaks .= line.Text "`n" + for Word in Line.Words + tokenizedHaystack.Push(Word, " ") + tokenizedHaystack.Pop() + tokenizedHaystack.Push(IgnoreLinebreaks ? " " : "`n") + } + + fullHaystackNoLinebreaks := StrReplace(fullHaystackLinebreaks, "`n", " ") ; Make sure the words are in the same order as the tokenized version + fullHaystack := IgnoreLinebreaks ? fullHaystackNoLinebreaks : fullHaystackLinebreaks + + Needle := RegExReplace(StrReplace(Needle, "`t", " "), " +", " ") + + fullFirst := SubStr(Needle, 1, 1) ~= "[ \n]", fullLast := SubStr(Needle, -1, 1) ~= "[ \n]" + + currentHaystack := fullHaystack + Loop { + if !(loc := SearchFunc(currentHaystack, Needle, &foundNeedle)) + break + + if IsObject(foundNeedle) + foundNeedle := foundNeedle[] + + foundLen := AllowOverlap ? 1 : StrLen(foundNeedle) + currentHaystack := SubStr(currentHaystack, loc + foundLen) ; Remove the match from the haystack, allowing overlap + offset += loc + foundLen - 1 + + if ++counter < i + continue + + tokenizedNeedle := [] + ; Tokenize the needle + for wsNeedle in wsSplit := StrSplit(foundNeedle, " ") { + for lbNeedle in lbSplit := StrSplit(wsNeedle, "`n") { + tokenizedNeedle.Push(lbNeedle, "`n") + } + if lbSplit.Length + tokenizedNeedle.Pop() + tokenizedNeedle.Push(" ") + } + tokenizedNeedle.Pop() + + preceding := SubStr(fullHaystackNoLinebreaks, 1, offset - foundLen) + ; Find first Word location + StrReplace(preceding, " ",,, &startingWord:=0) + startingWord := startingWord*2 + fullFirst - 1 ; Substracted 1 to allow subsequent loop to just add A_Index + + foundNeedle := "", foundWords := [], foundLines := [], line := this.__OCR.Line(this), line.DefineProp("Words", {value:[]}), line.DefineProp("Text", {value:""}) + Loop tokenizedNeedle.Length { + word := tokenizedHaystack[startingWord + A_Index] + if (word == "`n") { + foundNeedle .= line.Text + line.Text := RTrim(line.Text), foundLines.Push(line) + line := this.__OCR.Line(this), line.DefineProp("Words", {value:[]}), line.DefineProp("Text", {value:""}) + } + if !IsObject(word) + continue + If IsSet(x1) && (word.x < x1 || word.y < y1 || word.x+word.w > x2 || word.y+word.h > y2) { + counter-- + continue 2 + } + line.Words.Push(word), line.Text .= word.Text " " + foundWords.Push(word) + } + if line.Text { + foundNeedle .= line.Text + line.Text := RTrim(line.Text), foundLines.Push(line) + } + + result := this.Clone(), ObjAddRef(this.ptr) + result.DefineProp("BoundingRect", {value: this.__OCR.WordsBoundingRect(foundWords*)}) + result.DefineProp("Lines", {value: foundLines}) + result.DefineProp("Words", {value: foundWords}) + result.DefineProp("Text", {value: foundNeedle}) + if All { + results.Push(result) + } else + return result + } + if All + return results + + throw TargetError('The target string "' Needle '" was not found', -1) + } + + /** + * Filters out all the words that do not satisfy the callback function and returns a new OCR.Result object + * @param {Object} callback The callback function that accepts a OCR.Word object. + * If the callback returns 0 then the word is filtered out (rejected), otherwise is kept. + * @returns {OCR.Result} + */ + Filter(callback) { + if !HasMethod(callback) + throw ValueError("Filter callback must be a function", -1) + local result := this.Clone(), line, croppedLines := [], croppedText := "", croppedWords := [], lineText := "", word + ObjAddRef(result.ptr) + for line in result.Lines { + croppedWords := [], lineText := "" + for word in line.Words { + if callback(word) + croppedWords.Push(word), lineText .= word.Text " " + } + if croppedWords.Length { + line := this.__OCR.Line() + line.DefineProp("Text", {value:Trim(lineText)}) + line.DefineProp("Words", {value:croppedWords}) + croppedLines.Push(line) + croppedText .= lineText + } + } + result.DefineProp("Lines", {Value:croppedLines}) + result.DefineProp("Text", {Value:Trim(croppedText)}) + result.DefineProp("Words", this.__OCR.Result.Prototype.GetOwnPropDesc("Words")) + return result + } + + /** + * Crops the result object to contain only results from an area defined by points (x1,y1) and (x2,y2). + * Note that these coordinates are relative to the result object, not to the screen. + * @param {Integer} x1 x coordinate of the top left corner of the search area + * @param {Integer} y1 y coordinate of the top left corner of the search area + * @param {Integer} x2 x coordinate of the bottom right corner of the search area + * @param {Integer} y2 y coordinate of the bottom right corner of the search area + * @returns {OCR.Result} + */ + Crop(x1:=-100000, y1:=-100000, x2:=100000, y2:=100000) => this.Filter((word) => word.x >= x1 && word.y >= y1 && (word.x+word.w) <= x2 && (word.y+word.h) <= y2) + } + class Line extends OCR.Common { + ; Gets the recognized text for the line. + Text { + get { + ComCall(7, this, "ptr*", &hText:=0) ; get_Text + buf := DllCall("Combase.dll\WindowsGetStringRawBuffer", "ptr", hText, "uint*", &length:=0, "ptr") + text := StrGet(buf, "UTF-16") + this.__OCR.DeleteHString(hText) + this.DefineProp("Text", {Value:text}) + return text + } + } + + ; Gets the Word objects for the line + Words { + get { + ComCall(6, this, "ptr*", WordsList:=ComValue(13, 0)) ; get_Words + ComCall(7, WordsList, "int*", &WordsCount:=0) ; Words count + words := [] + loop WordsCount { + ComCall(6, WordsList, "int", A_Index-1, "ptr*", Word:=this.__OCR.Word(this)) + words.Push(Word) + } + this.DefineProp("Words", {Value:words}) + return words + } + } + + BoundingRect { + get => this.DefineProp("BoundingRect", {Value:this.__OCR.WordsBoundingRect(this.Words*)}).BoundingRect + } + } + + class Word extends OCR.Common { + ; Gets the recognized text for the word + Text { + get { + ComCall(7, this, "ptr*", &hText:=0) ; get_Text + buf := DllCall("Combase.dll\WindowsGetStringRawBuffer", "ptr", hText, "uint*", &length:=0, "ptr") + text := StrGet(buf, "UTF-16") + this.__OCR.DeleteHString(hText) + this.DefineProp("Text", {Value:text}) + return text + } + } + + /** + * Gets the bounding rectangle of the text in {x,y,w,h} format. + * The bounding rectangles coordinate system will be dependant on the image capture method. + * For example, if the image was captured as a rectangle from the screen, then the coordinates + * will be relative to the left top corner of the screen. + */ + BoundingRect { + get { + ComCall(6, this, "ptr", RECT := Buffer(16, 0)) ; get_BoundingRect + this.DefineProp("x", {Value:Integer(NumGet(RECT, 0, "float"))}) + , this.DefineProp("y", {Value:Integer(NumGet(RECT, 4, "float"))}) + , this.DefineProp("w", {Value:Integer(NumGet(RECT, 8, "float"))}) + , this.DefineProp("h", {Value:Integer(NumGet(RECT, 12, "float"))}) + return this.DefineProp("BoundingRect", {Value:{x:this.x, y:this.y, w:this.w, h:this.h}}).BoundingRect + } + } + } + + class Common extends OCR.IBase { + x { + get => this.BoundingRect.x + } + y { + get => this.BoundingRect.y + } + w { + get => this.BoundingRect.w + } + h { + get => this.BoundingRect.h + } + + /** + * Highlights the object on the screen with a red box + * @param {number} showTime Default is 2 seconds. + * * Unset - if highlighting exists then removes the highlighting, otherwise pauses for 2 seconds + * * 0 - Indefinite highlighting + * * Positive integer (eg 2000) - will highlight and pause for the specified amount of time in ms + * * Negative integer - will highlight for the specified amount of time in ms, but script execution will continue + * * "clear" - removes the highlighting unconditionally + * * "clearall" - remove highlightings from all OCR objects + * @param {string} color The color of the highlighting. Default is red. + * @param {number} d The border thickness of the highlighting in pixels. Default is 2. + * @returns {OCR.Result} + */ + Highlight(showTime?, color:="Red", d:=2) { + static Guis := Map() + local x, y, w, h, key, oObj, GuiObj, iw, ih + ; showTime unset => either highlights for 2s, or removes highlight + ; showTime clear => removes highlight + if IsSet(showTime) { + if showTime = "clearall" { + for key, oObj in Guis { ; enum all OCR result objects + try oObj.GuiObj.Destroy() + SetTimer(oObj.TimerObj, 0) + } + Guis := Map() + return this + } else if showTime = "clear" { + if Guis.Has(this) { + try Guis[this].GuiObj.Destroy() + SetTimer(Guis[this].TimerObj, 0) + Guis.Delete(this) + } + return this + } + } + + if !IsSet(showTime) { + if Guis.Has(this) { + try Guis[this].GuiObj.Destroy() + SetTimer(Guis[this].TimerObj, 0) + Guis.Delete(this) + return this + } else + showTime := 2000 + } + + x := this.x, y := this.y, w := this.w, h := this.h + if this.HasProp("Relative") { + if this.Relative.HasProp("CoordMode") { + if this.Relative.CoordMode = "Client" + WinGetClientPos(&rX, &rY,,, this.Relative.hWnd), x += rX, y += rY + else if this.Relative.CoordMode = "Window" + WinGetPos(&rX, &rY,,, this.Relative.hWnd), x += rX, y += rY + } + x += this.Relative.HasProp("x") ? this.Relative.x : 0 + y += this.Relative.HasProp("y") ? this.Relative.y : 0 + } + + if !Guis.Has(this) { + Guis[this] := {} + Guis[this].GuiObj := Gui("+AlwaysOnTop -Caption +ToolWindow -DPIScale +E0x08000000") + Guis[this].TimerObj := ObjBindMethod(this, "Highlight", "clear") + } + GuiObj := Guis[this].GuiObj + GuiObj.BackColor := color + iw:= w+d, ih:= h+d, w:=w+d*2, h:=h+d*2, x:=x-d, y:=y-d + WinSetRegion("0-0 " w "-0 " w "-" h " 0-" h " 0-0 " d "-" d " " iw "-" d " " iw "-" ih " " d "-" ih " " d "-" d, GuiObj.Hwnd) + GuiObj.Show("NA x" . x . " y" . y . " w" . w . " h" . h) + + if showTime > 0 { + Sleep(showTime) + this.Highlight() + } else if showTime < 0 + SetTimer(Guis[this].TimerObj, -Abs(showTime)) + return this + } + ClearHighlight() => this.Highlight("clear") + + /** + * Clicks an object + * If this object (the one Click is called from) contains a "Relative" property (this is + * added by default with OCR.FromWindow) containing a hWnd property, then that window will be activated, + * otherwise the Relative objects x/y properties values will be added to the x and y coordinates as offsets. + */ + Click(WhichButton?, ClickCount?, DownOrUp?) { + local x := this.x, y := this.y, w := this.w, h := this.h, mode := "Screen", hwnd + if this.HasProp("Relative") { + if this.Relative.HasProp("CoordMode") { + if this.Relative.CoordMode = "Window" + mode := "Window", hwnd := this.Relative.Hwnd + else if this.Relative.CoordMode = "Client" + mode := "Client", hwnd := this.Relative.Hwnd + if IsSet(hwnd) && !WinActive(hwnd) { + WinActivate(hwnd) + WinWaitActive(hwnd,,1) + } + } + x += this.Relative.HasProp("x") ? this.Relative.x : 0 + y += this.Relative.HasProp("y") ? this.Relative.y : 0 + } + oldCoordMode := A_CoordModeMouse + CoordMode "Mouse", mode + Click(x+w//2, y+h//2, WhichButton?, ClickCount?, DownOrUp?) + CoordMode "Mouse", oldCoordMode + } + + /** + * ControlClicks an object. + * If the result object originates from OCR.FromWindow which captured only the client area, + * then the result object will contain correct coordinates for the ControlClick. + * Coordinates will be adjusted to Client area from the CoordMode that the OCR happened in. + * Otherwise, if additionally a WinTitle is provided then the coordinates are treated as Screen + * coordinates and converted to Client coordinates. + * @param WinTitle If WinTitle is set, then the coordinates stored in Obj will be converted to + * client coordinates and ControlClicked. + */ + ControlClick(WinTitle?, WinText?, WhichButton?, ClickCount?, Options?, ExcludeTitle?, ExcludeText?) { + local x := this.x, y := this.y, w := this.w, h := this.h, hWnd + if this.HasProp("Relative") { + x += this.Relative.HasProp("x") ? this.Relative.x : 0 + y += this.Relative.HasProp("y") ? this.Relative.y : 0 + } + if this.HasProp("Relative") && this.Relative.HasProp("CoordMode") && (this.Relative.CoordMode = "Client" || this.Relative.CoordMode = "Window") { + mode := this.Relative.CoordMode, hWnd := this.Relative.hWnd + if mode = "Window" { + ; Window -> Client + RECT := Buffer(16, 0), pt := Buffer(8, 0) + DllCall("user32\GetWindowRect", "Ptr", hWnd, "Ptr", RECT) + winX := NumGet(RECT, 0, "Int"), winY := NumGet(RECT, 4, "Int") + NumPut("int", winX+x, "int", winY+y, pt) + DllCall("user32\ScreenToClient", "Ptr", hWnd, "Ptr", pt) + x := NumGet(pt,0,"int"), y := NumGet(pt,4,"int") + } + } else if IsSet(WinTitle) { + hWnd := WinExist(WinTitle, WinText?, ExcludeTitle?, ExcludeText?) + pt := Buffer(8), NumPut("int",x,pt), NumPut("int", y,pt,4) + DllCall("ScreenToClient", "Int", Hwnd, "Ptr", pt) + x := NumGet(pt,0,"int"), y := NumGet(pt,4,"int") + } else + throw TargetError("ControlClick needs to be called either after a OCR.FromWindow result or with a WinTitle argument") + + ControlClick("X" (x+w//2) " Y" (y+h//2), hWnd,, WhichButton?, ClickCount?, Options?) + } + + OffsetCoordinates(offsetX?, offsetY?) { + if !IsSet(offsetX) || !IsSet(offsetY) { + if this.HasOwnProp("Relative") { + offsetX := this.Relative.HasProp("x") ? this.Relative.X : 0 + offsetY := this.Relative.HasProp("y") ? this.Relative.Y : 0 + } else + throw Error("No Relative property found",, -1) + } + if offsetX = 0 && offsetY = 0 + return this + local word + for word in this.Words + word.x += offsetX, word.y += offsetY, word.BoundingRect := {X:word.x, Y:word.y, W:word.w, H:word.h} + return this + } + } + + /** + * Returns an OCR results object for an image file. Locations of the words will be relative to + * the top left corner of the image. + * @param FileName Either full or relative (to A_WorkingDir) path to the file. + * @param lang OCR language. Default is first from available languages. + * @param transform Either a scale factor number, or an object {scale:Float, grayscale:Boolean, invertcolors:Boolean, monochrome:0-255, rotate: 0 | 90 | 180 | 270, flip: 0 | "x" | "y"} + * @returns {OCR.Result} + */ + static FromFile(FileName, Options:=0) { + FileName := ProcessImage(FileName) + + if !(fe := FileExist(FileName)) or InStr(fe, "D") + throw TargetError("File `"" FileName "`" doesn't exist", -1) + GUID := this.CLSIDFromString(this.IID_IRandomAccessStream) + + pBM := Gdip_CreateBitmapFromFile(FileName) + hBM := Gdip_CreateHBITMAPFromBitmap(pBM) + IRandomAccessStream := this.HBitmapToRandomAccessStream(hBM) + Gdip_DisposeImage(pBM) + FileDelete(FileName) + if IsObject(Options) && !Options.HasProp("Decoder") + Options.Decoder := this.Vtbl_GetDecoder.HasOwnProp(ext := StrSplit(FileName, ".")[-1]) ? ext : "" + return this(IRandomAccessStream, Options) + } + + /** + * Returns an OCR results object for a given window. Locations of the words will be relative + * using the CoordMode from A_CoordModePixel (default is Client). + * The window from where the image was captured is stored in Result.Relative.hWnd + * Additionally, Result.Relative.CoordMode is stored (the A_CoordModePixel at the time of OCR). + * @param WinTitle A window title or other criteria identifying the target window. + * @param Options Optional: OCR options {lang, scale, grayscale, invertcolors, rotate, flip, x, y, w, h, decoder}. + * Additionally for FromWindow the options may include: + * mode: Different methods of capturing the window. + * 0 = uses GetDC with BitBlt + * 1 = same as 0 but window transparency is turned off beforehand with WinSetTransparent + * 2 = uses PrintWindow. + * 3 = same as 1 but window transparency is turned off beforehand with WinSetTransparent + * 4 = uses PrintWindow with undocumented PW_RENDERFULLCONTENT flag, allowing capture of hardware-accelerated windows + * 5 = uses Direct3D11 from UWP Windows.Graphics.Capture (slowest option, but may work with games) + * This may draw a yellow border around the target window in older Windows versions. + * @param WinText Additional window criteria. + * @param ExcludeTitle Additional window criteria. + * @param ExcludeText Additional window criteria. + * @returns {OCR.Result} + */ + static FromWindow(WinTitle:="", Options:=0, WinText:="", ExcludeTitle:="", ExcludeText:="") { + local result, coordsmode := A_CoordModePixel, onlyClientArea := coordsMode = "Client", mode := 4, X := 0, Y := 0, W := 0, H := 0, sX, sY, hBitMap, hwnd, customRect := 0, transform := 0 + if !Options && Type(WinTitle) = "Object" + Options := WinTitle, WinTitle := "" + if IsObject(Options) + Options := Options.Clone() + this.__ExtractTransformParameters(Options, &transform) + this.__ExtractNamedParameters(Options, "x", &x, "y", &y, "w", &w, "width", &w, "h", &h, "height", &h, "mode", &mode, "WinTitle", &WinTitle, "WinText", &WinText, "ExcludeTitle", &ExcludeTitle, "ExcludeText", &ExcludeText) + this.__DeleteProps(Options, "x", "y", "w", "width", "h", "height", "scale", "mode") + if (x !=0 || y != 0 || w != 0 || h != 0) + customRect := 1 + if !(hWnd := WinExist(WinTitle, WinText, ExcludeTitle, ExcludeText)) + throw TargetError("Target window not found", -1) + if DllCall("IsIconic", "uptr", hwnd) + DllCall("ShowWindow", "uptr", hwnd, "int", 4) + if mode < 4 && mode&1 { + oldStyle := WinGetExStyle(hwnd), i := 0 + WinSetTransparent(255, hwnd) + While (WinGetTransparent(hwnd) != 255 && ++i < 30) + Sleep 100 + } + + WinGetPos(&wX, &wY, &wW, &wH, hWnd) + If onlyClientArea { + WinGetClientPos(&cX, &cY, &cW, &cH, hWnd) + W := W || cW, H := H || cH, sX := X + cX, sY := Y + cY ; Calculate final X and Y screen coordinates + } else { + W := W || wW, H := H || wH, sX := X + wX, sY := Y + wY + } + + if mode = 5 { + /* + If we are capturing the whole window, then WinGetPos/MouseGetPos might include hidden borders. + Eg (0,0) might be (-11, -11) for Direct3D, meaning (11,11) by WinGetPos is (0,0) for Direct3D. + These offsets are calculated and stored in offsetX, offsetY, and if only the window + area is captured then the result object coordinates are adjusted accordingly. + + If the SoftwareBitmap needs to be transformed in any way (eg scale or custom rect is + provided) then we need to offset coordinates and possibly width/height as well. + + */ + SoftwareBitmap := this.CreateDirect3DSoftwareBitmapFromWindow(hWnd) + + local sbW := SoftwareBitmap.W, sbH := SoftwareBitmap.H, sbX := SoftwareBitmap.X, sbY := SoftwareBitmap.Y + local offsetX := 0, offsetY := 0 + + if transform.scale != 1 || transform.rotate || transform.flip || customRect || onlyClientArea { + ; The bounds need to fit inside the SoftwareBitmap bounds, so possibly X,Y need to be adjusted along with W,H + local tX := X, tY := Y, tW := W, tH := H + if onlyClientArea + tX -= SoftwareBitmap.X-cX, tY -= SoftwareBitmap.Y-cY + else + tX -= SoftwareBitmap.X-wX, tY -= SoftwareBitmap.Y-wY + if tX < 0 ; If resulting coordinates are negative then adjust width and height accordingly + tW += tX, offsetX := -tX, tX := 0 + if tY < 0 + tH += tY, offsetY := -tY, tY := 0 + tW := Min(sbW-tX, tW), tH := Min(sbH-tY, tH) + + SoftwareBitmap := this.TransformSoftwareBitmap(SoftwareBitmap, &sbW, &sbH, transform.scale, transform.rotate, transform.flip, tX, tY, tW, tH) + this.__DeleteProps(Options, "scale", "rotate", "flip") + } else + offsetX := sbX-wX, offsetY := sbY-wY + result := this(SoftwareBitmap, Options) + } else { + hBitMap := this.CreateHBitmap(X, Y, W, H, {hWnd:hWnd, onlyClientArea:onlyClientArea, mode:(mode//2)}, transform.scale) + if mode&1 + WinSetExStyle(oldStyle, hwnd) + SoftwareBitmap := this.HBitmapToSoftwareBitmap(hBitMap,, transform) + this.__DeleteProps(Options, "invertcolors", "grayscale", "monochrome") + result := this(SoftwareBitmap, Options) + } + + result.Relative := {CoordMode:coordsmode, hWnd:hWnd} + if coordsmode = "Screen" + x += sX, y += sY + this.NormalizeCoordinates(result, transform.scale, x, y) + if mode = 5 && !onlyClientArea + result.OffsetCoordinates(offsetX, offsetY) + return result + } + + /** + * Returns an OCR results object for the specified monitor. Locations of the words will be relative to + * the primary screen (CoordMode "Screen"), even if a secondary monitor is being captured. + * @param Monitor Optional: The monitor from which to get the desktop area. Default is primary monitor. + * If screen scaling between monitors differs, then use DllCall("SetThreadDpiAwarenessContext", "ptr", -3) + * @param Options Optional: OCR options {lang, scale, grayscale, invertcolors, rotate, flip, x, y, w, h, decoder}. + * @returns {OCR.Result} + */ + static FromMonitor(Monitor?, Options:=0) { + if !Options && IsSet(Monitor) && IsObject(Monitor) + Options := Monitor, Monitor := unset + this.__ExtractNamedParameters(Options, "Monitor", &Monitor) + MonitorGet(monitor?, &Left, &Top, &Right, &Bottom) + return this.FromRect(Left, Top, Right-Left, Bottom-Top, Options) + } + + /** + * Returns an OCR results object for the whole virtual screen. Locations of the words will be relative to + * the primary screen (CoordMode "Screen"). + * @param Options Optional: OCR options {lang, scale, grayscale, invertcolors, rotate, flip, x, y, w, h, decoder}. + * If screen scaling between monitors differs, then use DllCall("SetThreadDpiAwarenessContext", "ptr", -3) + * @returns {OCR.Result} + */ + static FromDesktop(Options:=0) => this.FromRect(SysGet(76), SysGet(77), SysGet(78), SysGet(79), Options) + + /** + * Returns an OCR results object for a region of the screen. Locations of the words will be relative + * to the screen. + * @param x Screen x coordinate + * @param y Screen y coordinate + * @param w Region width. Maximum is OCR.MaxImageDimension; minimum is 40 pixels (source: user FanaticGuru in AutoHotkey forums), smaller images will be scaled to at least 40 pixels. + * @param h Region height. Maximum is OCR.MaxImageDimension; minimum is 40 pixels, smaller images will be scaled accordingly. + * @param Options OCR options {lang, scale, grayscale, invertcolors, rotate, flip, x, y, w, h, decoder}. + * @returns {OCR.Result} + */ + static FromRect(x, y, w, h, Options:=0) { + local transform := 0, result + if IsObject(Options) + Options := Options.Clone() + this.__ExtractTransformParameters(Options, &transform) + this.__DeleteProps(Options, "scale", "invertcolors", "grayscale") + local scale := transform.scale + , hBitmap := this.CreateHBitmap(X, Y, W, H,, scale) + , SoftwareBitmap := this.HBitmapToSoftwareBitmap(hBitmap,, transform) + , result := this(SoftwareBitmap, Options) + return this.NormalizeCoordinates(result, scale, x, y) + } + + /** + * Returns an OCR results object from a bitmap. Locations of the words will be relative + * to the top left corner of the bitmap. + * @param Bitmap A pointer to a GDIP Bitmap object, or HBITMAP, or an object with a ptr property + * set to one of the two. + * @param Options OCR options {lang, scale, grayscale, invertcolors, rotate, flip, x, y, w, h, decoder}. + * @param hDC Optional: a device context for the bitmap. If omitted then the screen DC is used. + * @returns {OCR.Result} + */ + static FromBitmap(Bitmap, Options:=0, hDC?) { + local result, pDC, hBitmap, hBM2, oBM, oBM2, pBitmapInfo := Buffer(32, 0), W, H, scale, transform := 0 + if IsObject(Options) + Options := Options.Clone() + this.__ExtractTransformParameters(Options, &transform) + scale := transform.scale + this.__ExtractNamedParameters(Options, "hDC", &hDC) + this.__DeleteProps(Options, "scale", "invertcolors", "grayscale") + if !DllCall("GetObject", "ptr", Bitmap, "int", pBitmapInfo.Size, "ptr", pBitmapInfo) { + DllCall("gdiplus\GdipCreateHBITMAPFromBitmap", "UPtr", Bitmap, "UPtr*", &hBitmap:=0, "Int", 0xffffffff) + DllCall("GetObject", "ptr", hBitmap, "int", pBitmapInfo.Size, "ptr", pBitmapInfo) + Bitmap := 0 ; Marks hBitmap to be deleted afterwards + } else + hBitmap := Bitmap + + W := NumGet(pBitmapInfo, 4, "int"), H := NumGet(pBitmapInfo, 8, "int") + + if scale != 1 || (W && H && (W < 40 || H < 40)) { + sW := Ceil(W * scale), sH := Ceil(H * scale) + + hDC := DllCall("CreateCompatibleDC", "Ptr", 0, "Ptr") + , oBM := DllCall("SelectObject", "Ptr", hDC, "Ptr", hBitmap, "Ptr") + , pDC := DllCall("CreateCompatibleDC", "Ptr", hDC, "Ptr") + , hBM2 := DllCall("CreateCompatibleBitmap", "Ptr", hDC, "Int", Max(40, sW), "Int", Max(40, sH), "Ptr") + , oBM2 := DllCall("SelectObject", "Ptr", pDC, "Ptr", hBM2, "Ptr") + if sW < 40 || sH < 40 ; Fills the bitmap so it's at least 40x40, which seems to improve recognition + DllCall("StretchBlt", "Ptr", pDC, "Int", 0, "Int", 0, "Int", Max(40,sW), "Int", Max(40,sH), "Ptr", hDC, "Int", 0, "Int", 0, "Int", 1, "Int", 1, "UInt", 0x00CC0020 | this.CAPTUREBLT) ; SRCCOPY. + PrevStretchBltMode := DllCall("SetStretchBltMode", "Ptr", PDC, "Int", 3, "Int") ; COLORONCOLOR + , DllCall("StretchBlt", "Ptr", pDC, "Int", 0, "Int", 0, "Int", sW, "Int", sH, "Ptr", hDC, "Int", 0, "Int", 0, "Int", W, "Int", H, "UInt", 0x00CC0020 | this.CAPTUREBLT) ; SRCCOPY + , DllCall("SetStretchBltMode", "Ptr", PDC, "Int", PrevStretchBltMode) + , DllCall("SelectObject", "Ptr", pDC, "Ptr", oBM2) + , DllCall("SelectObject", "Ptr", hDC, "Ptr", oBM) + , DllCall("DeleteDC", "Ptr", hDC) + SoftwareBitmap := this.HBitmapToSoftwareBitmap(hBM2, pDC, transform) + result := this(SoftwareBitmap, Options) + this.NormalizeCoordinates(result, scale) + DllCall("DeleteDC", "Ptr", pDC) + , DllCall("DeleteObject", "UPtr", hBM2) + goto End + } + result := this(this.HBitmapToSoftwareBitmap(hBitmap, hDC?, transform), Options) + End: + if !Bitmap + DllCall("DeleteObject", "UPtr", hBitmap) + return result + } + + /** + * Returns all available languages as a string, where the languages are separated by newlines. + * @returns {String} + */ + static GetAvailableLanguages() { + ComCall(7, this.OcrEngineStatics, "ptr*", &LanguageList := 0) ; AvailableRecognizerLanguages + ComCall(7, LanguageList, "int*", &count := 0) ; count + Loop count { + ComCall(6, LanguageList, "int", A_Index - 1, "ptr*", &Language := 0) ; get_Item + ComCall(6, Language, "ptr*", &hText := 0) + buf := DllCall("Combase.dll\WindowsGetStringRawBuffer", "ptr", hText, "uint*", &length := 0, "ptr") + text .= StrGet(buf, "UTF-16") "`n" + this.DeleteHString(hText) + ObjRelease(Language) + } + ObjRelease(LanguageList) + return text + } + + /** + * Loads a new language which will be used with subsequent OCR calls. + * @param {string} lang OCR language. Default is first from available languages. + * @returns {void} + */ + static LoadLanguage(lang:="FirstFromAvailableLanguages") { + local hString, Language:=ComValue(13, 0), OcrEngine:=ComValue(13, 0) + if this.HasOwnProp("CurrentLanguage") && this.HasOwnProp("OcrEngine") && this.CurrentLanguage = lang + return + if HasMethod(lang) + lang := lang() + if (lang = "FirstFromAvailableLanguages") + ComCall(10, this.OcrEngineStatics, "ptr*", OcrEngine) ; TryCreateFromUserProfileLanguages + else { + hString := this.CreateHString(lang) + , ComCall(6, this.LanguageFactory, "ptr", hString, "ptr*", Language) ; CreateLanguage + , this.DeleteHString(hString) + , ComCall(9, this.OcrEngineStatics, "ptr", Language, "ptr*", OcrEngine) ; TryCreateFromLanguage + } + if (OcrEngine.ptr = 0) + Throw Error(lang = "FirstFromAvailableLanguages" ? "No OCR supporting languages are installed on your system! Please follow the Knowledge Base guide to install a supported language as a secondary language on Windows." : "Can not use language `"" lang "`" for OCR, please install language pack.") + this.OcrEngine := OcrEngine, this.CurrentLanguage := lang + } + + /** + * Returns a bounding rectangle {x,y,w,h} for the provided Word objects + * @param words Word object arguments (at least 1) + * @returns {Object} + */ + static WordsBoundingRect(words*) { + if !words.Length + throw ValueError("This function requires at least one argument", -1) + local X1 := 100000000, Y1 := 100000000, X2 := -100000000, Y2 := -100000000, word + for word in words { + X1 := Min(word.x, X1), Y1 := Min(word.y, Y1), X2 := Max(word.x+word.w, X2), Y2 := Max(word.y+word.h, Y2) + } + return {X:X1, Y:Y1, W:X2-X1, H:Y2-Y1, X2:X2, Y2:Y2} + } + + /** + * Waits text to appear on screen. If the method is successful, then Func's return value is returned. + * Otherwise nothing is returned. + * @param needle The searched text + * @param {number} timeout Timeout in milliseconds. Less than 0 is indefinite wait (default) + * @param func The function to be called for the OCR. Default is OCR.FromDesktop + * @param casesense Text comparison case-sensitivity + * @param comparefunc A custom string compare/search function, that accepts two arguments: haystack and needle. + * Default is InStr. If a custom function is used, then casesense is ignored. + * @returns {OCR.Result} + */ + static WaitText(needle, timeout:=-1, func?, casesense:=False, comparefunc?) { + local endTime := A_TickCount+timeout, result, line, total + if !IsSet(func) + func := this.FromDesktop + if !IsSet(comparefunc) + comparefunc := InStr.Bind(,,casesense) + While timeout > 0 ? (A_TickCount < endTime) : 1 { + result := func(), total := "" + for line in result.Lines + total .= line.Text "`n" + if comparefunc(Trim(total, "`n"), needle) + return result + } + return + } + + /** + * Returns word clusters using a two-dimensional DBSCAN algorithm + * @param objs An array of objects (Words, Lines etc) to cluster. Must have x, y, w, h and Text properties. + * @param eps_x Optional epsilon value for x-axis. Default is infinite. + * This is unused if compareFunc is provided. + * @param eps_y Optional epsilon value for y-axis. Default is median height of objects divided by two. + * This is unused if compareFunc is provided. + * @param minPts Optional minimum cluster size. + * @param compareFunc Optional comparison function to judge the minimum distance between objects + * to consider it a cluster. Must accept two objects to compare. + * Default comparison function determines whether the difference of middle y-coordinates of + * the objects are less than epsilon-y, and whether objects are less than eps_x apart on the x-axis. + * + * Eg `(p1, p2) => ((Abs(p1.y+p1.h-p2.y) < 5 || Abs(p2.y+p2.h-p1.y) < 5) && ((p1.x >= p2.x && p1.x <= (p2.x+p2.w)) || ((p1.x+p1.w) >= p2.x && (p1.x+p1.w) <= (p2.x+p2.w))))` + * will cluster objects if they are located on top of eachother on the x-axis, and less than 5 pixels + * apart in the y-axis. + * @param noise If provided, then will be set to an array of clusters that didn't satisfy minPts + * @returns {Array} Array of objects with {x,y,w,h,Text,Words} properties + */ + static Cluster(objs, eps_x:=-1, eps_y:=-1, minPts:=1, compareFunc?, &noise?) { + local clusters := [], start := 0, cluster, word + visited := Map(), clustered := Map(), C := [], c_n := 0, sum := 0, noise := IsSet(noise) && (noise is Array) ? noise : [] + if !IsObject(objs) || !(objs is Array) + throw ValueError("objs argument must be an Array", -1) + if !objs.Length + return [] + if IsSet(compareFunc) && !HasMethod(compareFunc) + throw ValueError("compareFunc must be a valid function", -1) + + if !IsSet(compareFunc) { + if (eps_y < 0) { + for point in objs + sum += point.h + eps_y := (sum // objs.Length) // 2 + } + compareFunc := (p1, p2) => Abs(p1.y+p1.h//2-p2.y-p2.h//2) array is considered to consist of only numeric values. This is the default option. + * C, C1 or COn => case-sensitive sort of strings + * C0 or COff => case-insensitive sort of strings + * + * The callback function should accept two parameters elem1 and elem2 and return an integer: + * Return integer < 0 if elem1 less than elem2 + * Return 0 is elem1 is equal to elem2 + * Return > 0 if elem1 greater than elem2 + * @param Key Optional: Omit it if you want to sort a array of primitive values (strings, numbers etc). + * If you have an array of objects, specify here the key by which contents the object will be sorted. + * @returns {Array} + */ + static SortArray(arr, optionsOrCallback:="N", key?) { + static sizeofFieldType := 16 ; Same on both 32-bit and 64-bit + if HasMethod(optionsOrCallback) + pCallback := CallbackCreate(CustomCompare.Bind(optionsOrCallback), "F Cdecl", 2), optionsOrCallback := "" + else { + if InStr(optionsOrCallback, "N") + pCallback := CallbackCreate(IsSet(key) ? NumericCompareKey.Bind(key) : NumericCompare, "F CDecl", 2) + if RegExMatch(optionsOrCallback, "i)C(?!0)|C1|COn") + pCallback := CallbackCreate(IsSet(key) ? StringCompareKey.Bind(key,,True) : StringCompare.Bind(,,True), "F CDecl", 2) + if RegExMatch(optionsOrCallback, "i)C0|COff") + pCallback := CallbackCreate(IsSet(key) ? StringCompareKey.Bind(key) : StringCompare, "F CDecl", 2) + if InStr(optionsOrCallback, "Random") + pCallback := CallbackCreate(RandomCompare, "F CDecl", 2) + if !IsSet(pCallback) + throw ValueError("No valid options provided!", -1) + } + mFields := NumGet(ObjPtr(arr) + (8 + (VerCompare(A_AhkVersion, "<2.1-") > 0 ? 3 : 5)*A_PtrSize), "Ptr") ; in v2.0: 0 is VTable. 2 is mBase, 3 is mFields, 4 is FlatVector, 5 is mLength and 6 is mCapacity + DllCall("msvcrt.dll\qsort", "Ptr", mFields, "UInt", arr.Length, "UInt", sizeofFieldType, "Ptr", pCallback, "Cdecl") + CallbackFree(pCallback) + if RegExMatch(optionsOrCallback, "i)R(?!a)") + this.ReverseArray(arr) + if InStr(optionsOrCallback, "U") + arr := this.Unique(arr) + return arr + + CustomCompare(compareFunc, pFieldType1, pFieldType2) => (ValueFromFieldType(pFieldType1, &fieldValue1), ValueFromFieldType(pFieldType2, &fieldValue2), compareFunc(fieldValue1, fieldValue2)) + NumericCompare(pFieldType1, pFieldType2) => (ValueFromFieldType(pFieldType1, &fieldValue1), ValueFromFieldType(pFieldType2, &fieldValue2), fieldValue1 - fieldValue2) + NumericCompareKey(key, pFieldType1, pFieldType2) => (ValueFromFieldType(pFieldType1, &fieldValue1), ValueFromFieldType(pFieldType2, &fieldValue2), fieldValue1.%key% - fieldValue2.%key%) + StringCompare(pFieldType1, pFieldType2, casesense := False) => (ValueFromFieldType(pFieldType1, &fieldValue1), ValueFromFieldType(pFieldType2, &fieldValue2), StrCompare(fieldValue1 "", fieldValue2 "", casesense)) + StringCompareKey(key, pFieldType1, pFieldType2, casesense := False) => (ValueFromFieldType(pFieldType1, &fieldValue1), ValueFromFieldType(pFieldType2, &fieldValue2), StrCompare(fieldValue1.%key% "", fieldValue2.%key% "", casesense)) + RandomCompare(pFieldType1, pFieldType2) => (Random(0, 1) ? 1 : -1) + + ValueFromFieldType(pFieldType, &fieldValue?) { + static SYM_STRING := 0, PURE_INTEGER := 1, PURE_FLOAT := 2, SYM_MISSING := 3, SYM_OBJECT := 5 + switch SymbolType := NumGet(pFieldType + 8, "Int") { + case PURE_INTEGER: fieldValue := NumGet(pFieldType, "Int64") + case PURE_FLOAT: fieldValue := NumGet(pFieldType, "Double") + case SYM_STRING: fieldValue := StrGet(NumGet(pFieldType, "Ptr")+2*A_PtrSize) + case SYM_OBJECT: fieldValue := ObjFromPtrAddRef(NumGet(pFieldType, "Ptr")) + case SYM_MISSING: return + } + } + } + ; Reverses the array in-place + static ReverseArray(arr) { + local len := arr.Length + 1, max := (len // 2), i := 0 + while ++i <= max + temp := arr[len - i], arr[len - i] := arr[i], arr[i] := temp + return arr + } + ; Returns a new array with only unique values + static UniqueArray(arr) { + local unique := Map() + for v in arr + unique[v] := 1 + return [unique*] + } + + ; Returns a one-dimensional array from a multi-dimensional array + static FlattenArray(arr) { + local r := [] + for v in arr { + if v is Array + r.Push(this.FlattenArray(v)*) + else + r.Push(v) + } + return r + } + + ;; Only internal methods ahead + + ; Scales and optionally crops a SoftwareBitmap. Crop parameters need to not be scale-adjusted. + ; Rotation can be clockwise 0, 90, 180, or 270 degrees + ; Flip: 0 = no flip, 1 = around y-axis, 2 = around x-axis + static TransformSoftwareBitmap(SoftwareBitmap, &sbW, &sbH, scale:=1, rotate:=0, flip:=0, X?, Y?, W?, H?) { + InMemoryRandomAccessStream := this.SoftwareBitmapToRandomAccessStream(SoftwareBitmap) + + ComCall(this.Vtbl_GetDecoder.png, this.BitmapDecoderStatics, "ptr", DecoderGUID:=Buffer(16)) + ComCall(15, this.BitmapDecoderStatics, "ptr", DecoderGUID, "ptr", InMemoryRandomAccessStream, "ptr*", BitmapDecoder:=ComValue(13,0)) ; CreateAsync + this.WaitForAsync(&BitmapDecoder) + + BitmapFrameWithSoftwareBitmap := ComObjQuery(BitmapDecoder, IBitmapFrameWithSoftwareBitmap := "{FE287C9A-420C-4963-87AD-691436E08383}") + BitmapFrame := ComObjQuery(BitmapDecoder, IBitmapFrame := "{72A49A1C-8081-438D-91BC-94ECFC8185C6}") + + BitmapTransform := this.CreateClass("Windows.Graphics.Imaging.BitmapTransform") + + if IsSet(W) && W + sbW := Min(sbW, W) + if IsSet(H) && H + sbH := Min(sbH, H) + local sW := Floor(sbW*scale), sH := Floor(sbH*scale), intermediate + if scale != 1 { + ; First the bitmap is scaled, then cropped + ComCall(7, BitmapTransform, "uint", sW) ; put_ScaledWidth + ComCall(9, BitmapTransform, "uint", sH) ; put_ScaledHeight + } + if rotate { + ComCall(15, BitmapTransform, "uint", rotate//90) ; put_Rotation + if rotate = 90 || rotate = 270 + intermediate := sW, sW := sH, sH := intermediate + } + if flip + ComCall(13, BitmapTransform, "uint", flip) ; put_Flip + + if (IsSet(X) && X != 0) || (IsSet(Y) && Y != 0) || IsSet(W) || IsSet(H) { + bounds := Buffer(16,0), NumPut("int", Floor(X*scale), "int", Floor(Y*scale), "int", Floor(sbW*scale), "int", Floor(sbH*scale), bounds) + ComCall(17, BitmapTransform, "ptr", bounds) ; put_Bounds + } + ComCall(8, BitmapFrame, "uint*", &BitmapPixelFormat:=0) ; get_BitmapPixelFormat + ComCall(9, BitmapFrame, "uint*", &BitmapAlphaMode:=0) ; get_BitmapAlphaMode + ComCall(8, BitmapFrameWithSoftwareBitmap, "uint", BitmapPixelFormat, "uint", BitmapAlphaMode, "ptr", BitmapTransform, "uint", IgnoreExifOrientation := 0, "uint", DoNotColorManage := 0, "ptr*", SoftwareBitmap:=ComValue(13,0)) ; GetSoftwareBitmapTransformedAsync + + this.WaitForAsync(&SoftwareBitmap) + ; this.CloseIClosable(BitmapFrameWithSoftwareBitmap) ; Implemented, but is it necessary? + this.CloseIClosable(InMemoryRandomAccessStream) + sbW := sW, sbH := sH + return SoftwareBitmap + } + + static CreateDIBSection(w, h, hdc?, bpp:=32, &ppvBits:=0) { + local hdc2 := IsSet(hdc) ? hdc : DllCall("GetDC", "Ptr", 0, "UPtr") + , bi := Buffer(40, 0), hbm + NumPut("int", 40, "int", w, "int", h, "ushort", 1, "ushort", bpp, "int", 0, bi) + hbm := DllCall("CreateDIBSection", "uint", hdc2, "ptr" , bi, "uint" , 0, "uint*", &ppvBits:=0, "uint" , 0, "uint" , 0) + if !IsSet(hdc) + DllCall("ReleaseDC", "Ptr", 0, "Ptr", hdc2) + return hbm + } + + /** + * Creates an hBitmap of a region of the screen or a specific window + * @param X Captured rectangle X coordinate. This is relative to the screen unless hWnd is specified, + * in which case it may be relative to the window/client + * @param Y Captured rectangle Y coordinate. + * @param W Captured rectangle width. + * @param H Captured rectangle height. + * @param {Integer|Object} hWnd Window handle which to capture. Coordinates will be relative to the window. + * hWnd may also be an object {hWnd, onlyClientArea, mode} where onlyClientArea:1 means the client area will be captured instead of the whole window (and X, Y will also be relative to client) + * mode 0 uses GetDC + StretchBlt, mode 1 uses PrintWindow, mode 2 uses PrintWindow with undocumented PW_RENDERFULLCONTENT flag. + * Default is mode 2. + * @param {Integer} scale + * @returns {OCR.IBase} + */ + static CreateHBitmap(X, Y, W, H, hWnd:=0, scale:=1) { + local sW := Ceil(W*scale), sH := Ceil(H*scale), onlyClientArea := 0, mode := 2, HDC, obm, hbm, pdc, hbm2 + if hWnd { + if IsObject(hWnd) + onlyClientArea := hWnd.HasOwnProp("onlyClientArea") ? hWnd.onlyClientArea : onlyClientArea, mode := hWnd.HasOwnProp("mode") ? hWnd.mode : mode, hWnd := hWnd.hWnd + HDC := DllCall("GetDCEx", "Ptr", hWnd, "Ptr", 0, "Int", 2|!onlyClientArea, "Ptr") + if mode > 0 { + PDC := DllCall("CreateCompatibleDC", "Ptr", 0, "Ptr") + HBM := DllCall("CreateCompatibleBitmap", "Ptr", HDC, "Int", Max(40,X+W), "Int", Max(40,Y+H), "Ptr") + , OBM := DllCall("SelectObject", "Ptr", PDC, "Ptr", HBM, "Ptr") + , DllCall("PrintWindow", "Ptr", hWnd, "Ptr", PDC, "UInt", (mode=2?2:0)|!!onlyClientArea) + if scale != 1 || X != 0 || Y != 0 { + PDC2 := DllCall("CreateCompatibleDC", "Ptr", PDC, "Ptr") + , HBM2 := DllCall("CreateCompatibleBitmap", "Ptr", PDC, "Int", Max(40,sW), "Int", Max(40,sH), "Ptr") + , OBM2 := DllCall("SelectObject", "Ptr", PDC2, "Ptr", HBM2, "Ptr") + , PrevStretchBltMode := DllCall("SetStretchBltMode", "Ptr", PDC, "Int", 3, "Int") ; COLORONCOLOR + , DllCall("StretchBlt", "Ptr", PDC2, "Int", 0, "Int", 0, "Int", sW, "Int", sH, "Ptr", PDC, "Int", X, "Int", Y, "Int", W, "Int", H, "UInt", 0x00CC0020 | this.CAPTUREBLT) ; SRCCOPY + , DllCall("SetStretchBltMode", "Ptr", PDC, "Int", PrevStretchBltMode) + , DllCall("SelectObject", "Ptr", PDC2, "Ptr", obm2) + , DllCall("DeleteDC", "Ptr", PDC) + , DllCall("DeleteObject", "UPtr", HBM) + , hbm := hbm2, pdc := pdc2 + } + DllCall("SelectObject", "Ptr", PDC, "Ptr", OBM) + , DllCall("DeleteDC", "Ptr", HDC) + , oHBM := this.IBase(HBM), oHBM.DC := PDC + return oHBM.DefineProp("__Delete", {call:(this, *)=>(DllCall("DeleteObject", "Ptr", this), DllCall("DeleteDC", "Ptr", this.DC))}) + } + } else { + HDC := DllCall("GetDC", "Ptr", 0, "Ptr") + } + PDC := DllCall("CreateCompatibleDC", "Ptr", HDC, "Ptr") + , HBM := DllCall("CreateCompatibleBitmap", "Ptr", HDC, "Int", Max(40,sW), "Int", Max(40,sH), "Ptr") + , OBM := DllCall("SelectObject", "Ptr", PDC, "Ptr", HBM, "Ptr") + if sW < 40 || sH < 40 ; Fills the bitmap so it's at least 40x40, which seems to improve recognition + DllCall("StretchBlt", "Ptr", PDC, "Int", 0, "Int", 0, "Int", Max(40,sW), "Int", Max(40,sH), "Ptr", HDC, "Int", X, "Int", Y, "Int", 1, "Int", 1, "UInt", 0x00CC0020 | this.CAPTUREBLT) ; SRCCOPY. + PrevStretchBltMode := DllCall("SetStretchBltMode", "Ptr", PDC, "Int", 3, "Int") ; COLORONCOLOR + , DllCall("StretchBlt", "Ptr", PDC, "Int", 0, "Int", 0, "Int", sW, "Int", sH, "Ptr", HDC, "Int", X, "Int", Y, "Int", W, "Int", H, "UInt", 0x00CC0020 | this.CAPTUREBLT) ; SRCCOPY + , DllCall("SetStretchBltMode", "Ptr", PDC, "Int", PrevStretchBltMode) + , DllCall("SelectObject", "Ptr", PDC, "Ptr", OBM) + , DllCall("DeleteDC", "Ptr", HDC) + , oHBM := this.IBase(HBM), oHBM.DC := PDC + return oHBM.DefineProp("__Delete", {call:(this, *)=>(DllCall("DeleteObject", "Ptr", this), DllCall("DeleteDC", "Ptr", this.DC))}) + } + + static CreateDirect3DSoftwareBitmapFromWindow(hWnd) { + static init := 0, DXGIDevice, Direct3DDevice, Direct3D11CaptureFramePoolStatics, GraphicsCaptureItemInterop, GraphicsCaptureItemGUID, D3D_Device, D3D_Context + local x, y, w, h, rect + if !init { + DllCall("LoadLibrary","str","DXGI") + DllCall("LoadLibrary","str","D3D11") + DllCall("LoadLibrary","str","Dwmapi") + DllCall("D3D11\D3D11CreateDevice", "ptr", 0, "int", D3D_DRIVER_TYPE_HARDWARE := 1, "ptr", 0, "uint", D3D11_CREATE_DEVICE_BGRA_SUPPORT := 0x20, "ptr", 0, "uint", 0, "uint", D3D11_SDK_VERSION := 7, "ptr*", D3D_Device:=ComValue(13, 0), "ptr*", 0, "ptr*", D3D_Context:=ComValue(13, 0)) + DXGIDevice := ComObjQuery(D3D_Device, IID_IDXGIDevice := "{54ec77fa-1377-44e6-8c32-88fd5f44c84c}") + DllCall("D3D11\CreateDirect3D11DeviceFromDXGIDevice", "ptr", DXGIDevice, "ptr*", GraphicsDevice:=ComValue(13, 0)) + Direct3DDevice := ComObjQuery(GraphicsDevice, IDirect3DDevice := "{A37624AB-8D5F-4650-9D3E-9EAE3D9BC670}") + Direct3D11CaptureFramePoolStatics := this.CreateClass("Windows.Graphics.Capture.Direct3D11CaptureFramePool", IDirect3D11CaptureFramePoolStatics := "{7784056a-67aa-4d53-ae54-1088d5a8ca21}") + GraphicsCaptureItemStatics := this.CreateClass("Windows.Graphics.Capture.GraphicsCaptureItem", IGraphicsCaptureItemStatics := "{A87EBEA5-457C-5788-AB47-0CF1D3637E74}") + GraphicsCaptureItemInterop := ComObjQuery(GraphicsCaptureItemStatics, IGraphicsCaptureItemInterop := "{3628E81B-3CAC-4C60-B7F4-23CE0E0C3356}") + GraphicsCaptureItemGUID := Buffer(16,0) + DllCall("ole32\CLSIDFromString", "wstr", IGraphicsCaptureItem := "{79c3f95b-31f7-4ec2-a464-632ef5d30760}", "ptr", GraphicsCaptureItemGUID) + init := 1 + } + ; INIT done + + DllCall("Dwmapi.dll\DwmGetWindowAttribute", "ptr", hWnd, "uint", DWMWA_EXTENDED_FRAME_BOUNDS := 9, "ptr", rect := Buffer(16,0), "uint", 16) + x := NumGet(rect, 0, "int"), y := NumGet(rect, 4, "int"), w := NumGet(rect, 8, "int") - x, h := NumGet(rect, 12, "int") - y + ComCall(6, Direct3D11CaptureFramePoolStatics, "ptr", Direct3DDevice, "int", B8G8R8A8UIntNormalized := 87, "int", numberOfBuffers := 2, "int64", (h << 32) | w, "ptr*", Direct3D11CaptureFramePool:=ComValue(13, 0)) ; Direct3D11CaptureFramePool.Create + if ComCall(3, GraphicsCaptureItemInterop, "ptr", hWnd, "ptr", GraphicsCaptureItemGUID, "ptr*", GraphicsCaptureItem:=ComValue(13, 0), "uint") { ; IGraphicsCaptureItemInterop::CreateForWindow + this.CloseIClosable(Direct3D11CaptureFramePool) + throw Error("Failed to capture GraphicsItem of window",, -1) + } + ComCall(10, Direct3D11CaptureFramePool, "ptr", GraphicsCaptureItem, "ptr*", GraphicsCaptureSession:=ComValue(13, 0)) ; Direct3D11CaptureFramePool.CreateCaptureSession + + GraphicsCaptureSession2 := ComObjQuery(GraphicsCaptureSession, IGraphicsCaptureSession2 := "{2c39ae40-7d2e-5044-804e-8b6799d4cf9e}") + ComCall(7, GraphicsCaptureSession2, "int", 0) ; GraphicsCaptureSession.IsCursorCaptureEnabled put + + if (Integer(StrSplit(A_OSVersion, ".")[3]) >= 20348) { ; hide border + GraphicsCaptureSession3 := ComObjQuery(GraphicsCaptureSession, IGraphicsCaptureSession3 := "{f2cdd966-22ae-5ea1-9596-3a289344c3be}") + ComCall(7, GraphicsCaptureSession3, "int", 0) ; GraphicsCaptureSession.IsBorderRequired put + } + ComCall(6, GraphicsCaptureSession) ; GraphicsCaptureSession.StartCapture + Loop { + ComCall(7, Direct3D11CaptureFramePool, "ptr*", Direct3D11CaptureFrame:=ComValue(13, 0)) ; Direct3D11CaptureFramePool.TryGetNextFrame + if (Direct3D11CaptureFrame.ptr != 0) + break + } + ComCall(6, Direct3D11CaptureFrame, "ptr*", Direct3DSurface:=ComValue(13, 0)) ; Direct3D11CaptureFrame.Surface + + ComCall(11, this.SoftwareBitmapStatics, "ptr", Direct3DSurface, "ptr*", SoftwareBitmap:=ComValue(13, 0)) ; SoftwareBitmap::CreateCopyFromSurfaceAsync + this.WaitForAsync(&SoftwareBitmap) + + this.CloseIClosable(Direct3D11CaptureFramePool) + this.CloseIClosable(GraphicsCaptureSession) + if GraphicsCaptureSession2 { + this.CloseIClosable(GraphicsCaptureSession2) + } + if IsSet(GraphicsCaptureSession3) { + this.CloseIClosable(GraphicsCaptureSession3) + } + this.CloseIClosable(Direct3D11CaptureFrame) + this.CloseIClosable(Direct3DSurface) + + SoftwareBitmap.x := x, SoftwareBitmap.y := y, SoftwareBitmap.w := w, SoftwareBitmap.h := h + return SoftwareBitmap + } + + static HBitmapToRandomAccessStream(hBitmap) { + static PICTYPE_BITMAP := 1 + , BSOS_DEFAULT := 0 + , sz := 8 + A_PtrSize*2 + local PICTDESC, riid, size, pIRandomAccessStream + + DllCall("Ole32\CreateStreamOnHGlobal", "Ptr", 0, "UInt", true, "Ptr*", pIStream:=ComValue(13,0), "UInt") + , PICTDESC := Buffer(sz, 0) + , NumPut("uint", sz, "uint", PICTYPE_BITMAP, "ptr", IsInteger(hBitmap) ? hBitmap : hBitmap.ptr, PICTDESC) + , riid := this.CLSIDFromString(this.IID_IPicture) + , DllCall("OleAut32\OleCreatePictureIndirect", "Ptr", PICTDESC, "Ptr", riid, "UInt", 0, "Ptr*", pIPicture:=ComValue(13,0), "UInt") + , ComCall(15, pIPicture, "Ptr", pIStream, "UInt", true, "uint*", &size:=0, "UInt") ; IPicture::SaveAsFile + , riid := this.CLSIDFromString(this.IID_IRandomAccessStream) + , DllCall("ShCore\CreateRandomAccessStreamOverStream", "Ptr", pIStream, "UInt", BSOS_DEFAULT, "Ptr", riid, "Ptr*", pIRandomAccessStream:=ComValue(13, 0), "UInt") + Return pIRandomAccessStream + } + + ; Converts HBITMAP to SoftwareBitmap. NOTE: SetStretchBltMode HALFTONE breaks this + ; The optional transform parameter may contain {grayscale, invertcolors} + static HBitmapToSoftwareBitmap(hBitmap, hDC?, transform?) { + local bi := Buffer(40, 0), W, H, BitmapBuffer, MemoryBuffer, MemoryBufferReference, BufferByteAccess, BufferSize + hDC := (hBitmap is OCR.IBase ? hBitmap.DC : (hDC ?? dhDC := DllCall("GetDC", "Ptr", 0, "UPtr"))) + + NumPut("uint", 40, bi, 0) + DllCall("GetDIBits", "ptr", hDC, "ptr", hBitmap, "uint", 0, "uint", 0, "ptr", 0, "ptr", bi, "uint", 0) + W := NumGet(bi, 4, "int"), H := NumGet(bi, 8, "int") + + ComCall(7, this.SoftwareBitmapFactory, "int", 87, "int", W, "int", H, "int", 0, "ptr*", SoftwareBitmap := ComValue(13,0)) ; CreateWithAlpha: Bgra8 & Premultiplied + ComCall(15, SoftwareBitmap, "int", 2, "ptr*", &BitmapBuffer := 0) ; LockBuffer + MemoryBuffer := ComObjQuery(BitmapBuffer, "{fbc4dd2a-245b-11e4-af98-689423260cf8}") + ComCall(6, MemoryBuffer, "ptr*", &MemoryBufferReference := 0) ; CreateReference + BufferByteAccess := ComObjQuery(MemoryBufferReference, "{5b0d3235-4dba-4d44-865e-8f1d0e4fd04d}") + ComCall(3, BufferByteAccess, "ptr*", &SoftwareBitmapByteBuffer:=0, "uint*", &BufferSize:=0) ; GetBuffer + + NumPut("short", 32, "short", 0, bi, 14), NumPut("int", -H, bi, 8) ; Negative height to get correctly oriented image + DllCall("GetDIBits", "ptr", hDC, "ptr", hBitmap, "uint", 0, "uint", H, "ptr", SoftwareBitmapByteBuffer, "ptr", bi, "uint", 0) + if IsSet(transform) { + ;if (transform.HasProp("grayscale") && transform.grayscale) + ; DllCall(this.GrayScaleMCode, "ptr", SoftwareBitmapByteBuffer, "uint", w, "uint", h, "uint", (w*4+3) // 4 * 4, "cdecl uint") + ;if (transform.HasProp("monochrome") && transform.monochrome) + ; DllCall(this.MonochromeMCode, "ptr", SoftwareBitmapByteBuffer, "uint", w, "uint", h, "uint", (w*4+3) // 4 * 4, "uint", transform.monochrome, "cdecl uint") + ;if (transform.HasProp("invertcolors") && transform.invertcolors) + ; DllCall(this.InvertColorsMCode, "ptr", SoftwareBitmapByteBuffer, "uint", w, "uint", h, "uint", (w*4+3) // 4 * 4, "cdecl uint") + } + + if IsSet(dhDC) + DllCall("DeleteDC", "ptr", dhDC) + if BufferByteAccess.HasMethod("Dispose") + BufferByteAccess.Dispose() + if MemoryBuffer.HasMethod("Dispose") + MemoryBuffer.Dispose() + BufferByteAccess := "", ObjRelease(MemoryBufferReference), MemoryBuffer := "", ObjRelease(BitmapBuffer) ; Release in correct order + + return SoftwareBitmap + } + + static MCode(mcode) { + static e := Map('1', 4, '2', 1), c := (A_PtrSize=8) ? "x64" : "x86" + if (!regexmatch(mcode, "^([0-9]+),(" c ":|.*?," c ":)([^,]+)", &m)) + return + if (!DllCall("crypt32\CryptStringToBinary", "str", m.3, "uint", 0, "uint", e[m.1], "ptr", 0, "uint*", &s := 0, "ptr", 0, "ptr", 0)) + return + p := DllCall("GlobalAlloc", "uint", 0, "ptr", s, "ptr") + if (c="x64") + DllCall("VirtualProtect", "ptr", p, "ptr", s, "uint", 0x40, "uint*", &op := 0) + if (DllCall("crypt32\CryptStringToBinary", "str", m.3, "uint", 0, "uint", e[m.1], "ptr", p, "uint*", &s, "ptr", 0, "ptr", 0)) + return p + DllCall("GlobalFree", "ptr", p) + } + + static DisplayHBitmap(hBitmap) { + local gImage := Gui("-DPIScale"), W, H + , hPic := gImage.Add("Text", "0xE w640 h640") + SendMessage(0x172, 0, hBitmap,, hPic.hWnd) + hPic.GetPos(,,&W, &H) + gImage.Show("w" (W+20) " H" (H+20)) + WinWaitClose gImage + } + + static SoftwareBitmapToRandomAccessStream(SoftwareBitmap) { + InMemoryRandomAccessStream := this.CreateClass("Windows.Storage.Streams.InMemoryRandomAccessStream") + ComCall(8, this.BitmapEncoderStatics, "ptr", encoderId := Buffer(16, 0)) ; IBitmapEncoderStatics::PngEncoderId + ComCall(13, this.BitmapEncoderStatics, "ptr", encoderId, "ptr", InMemoryRandomAccessStream, "ptr*", BitmapEncoder:=ComValue(13,0)) ; IBitmapEncoderStatics::CreateAsync + this.WaitForAsync(&BitmapEncoder) + BitmapEncoderWithSoftwareBitmap := ComObjQuery(BitmapEncoder, "{686cd241-4330-4c77-ace4-0334968b1768}") + ComCall(6, BitmapEncoderWithSoftwareBitmap, "ptr", SoftwareBitmap) ; SetSoftwareBitmap + ComCall(19, BitmapEncoder, "ptr*", asyncAction:=ComValue(13,0)) ; FlushAsync + this.WaitForAsync(&asyncAction) + ComCall(11, InMemoryRandomAccessStream, "int64", 0) ; Seek to beginning + return InMemoryRandomAccessStream + } + + static CreateClass(str, interface?) { + local hString := this.CreateHString(str), result + if !IsSet(interface) { + result := DllCall("Combase.dll\RoActivateInstance", "ptr", hString, "ptr*", cls:=ComValue(13, 0), "uint") + } else { + GUID := this.CLSIDFromString(interface) + result := DllCall("Combase.dll\RoGetActivationFactory", "ptr", hString, "ptr", GUID, "ptr*", cls:=ComValue(13, 0), "uint") + } + if (result != 0) { + if (result = 0x80004002) + throw Error("No such interface supported", -1, interface) + else if (result = 0x80040154) + throw Error("Class not registered", -1) + else + throw Error(result) + } + this.DeleteHString(hString) + return cls + } + + static CreateHString(str) => (DllCall("Combase.dll\WindowsCreateString", "wstr", str, "uint", StrLen(str), "ptr*", &hString:=0), hString) + + static DeleteHString(hString) => DllCall("Combase.dll\WindowsDeleteString", "ptr", hString) + + static WaitForAsync(&obj) { + local AsyncInfo := ComObjQuery(obj, this.IID_IAsyncInfo), status, ErrorCode + Loop { + ComCall(7, AsyncInfo, "uint*", &status:=0) ; IAsyncInfo.Status + if (status != 0) { + if (status != 1) { + ComCall(8, ASyncInfo, "uint*", &ErrorCode:=0) ; IAsyncInfo.ErrorCode + throw Error("AsyncInfo failed with status error " ErrorCode, -1) + } + break + } + Sleep this.PerformanceMode ? -1 : 0 + } + ComCall(8, obj, "ptr*", ObjectResult:=this.IBase()) ; GetResults + obj := ObjectResult + } + + static CloseIClosable(pClosable) { + static IClosable := "{30D5A829-7FA4-4026-83BB-D75BAE4EA99E}" + local Close := ComObjQuery(pClosable, IClosable) + ComCall(6, Close) ; Close + } + + static CLSIDFromString(IID) { + local CLSID := Buffer(16), res + if res := DllCall("ole32\CLSIDFromString", "WStr", IID, "Ptr", CLSID, "UInt") + throw Error("CLSIDFromString failed. Error: " . Format("{:#x}", res)) + Return CLSID + } + + static NormalizeCoordinates(result, scale, x:=0, y:=0) { + local word + if (scale == 1 && x == 0 && y == 0) + return result + for word in result.Words + word.x := Integer(word.x / scale)+x, word.y := Integer(word.y / scale)+y, word.w := Integer(word.w / scale), word.h := Integer(word.h / scale), word.BoundingRect := {X:word.x, Y:word.y, W:word.w, H:word.h} + return result + } + + static __OpenPdfDocument(IRandomAccessStream, Password:="") { + PdfDocumentStatics := this.CreateClass("Windows.Data.Pdf.PdfDocument", this.IID_IPdfDocumentStatics) + ComCall(8, PdfDocumentStatics, "ptr", IRandomAccessStream, "ptr*", PdfDocument:=ComValue(13, 0)) ; LoadFromStreamAsync + this.WaitForAsync(&PdfDocument) + return PdfDocument + } + + static __ExtractNamedParameters(obj, params*) { + local i := 0 + if !IsObject(obj) || Type(obj) != "Object" + return 0 + Loop params.Length // 2 { + name := params[++i], value := params[++i] + if obj.HasProp(name) + %value% := obj.%name% + } + return 1 + } + + static __ExtractTransformParameters(obj, &transform) { + local scale := 1, grayscale := 0, invertcolors := 0, monochrome := 0, rotate := 0, flip := 0 + if IsObject(obj) + this.__ExtractNamedParameters(obj, "scale", &scale, "grayscale", &grayscale, "invertcolors", &invertcolors, "monochrome", &monochrome, "rotate", &rotate, "flip", &flip, "transform", &transform) + + if IsSet(transform) && IsObject(transform) { + for prop in ["scale", "grayscale", "invertcolors", "monochrome", "rotate", "flip"] + if !transform.HasProp(prop) + transform.%prop% := %prop% + } else + transform := {scale:scale, grayscale:grayscale, invertcolors:invertcolors, monochrome:monochrome, rotate:rotate, flip:flip} + + transform.flip := transform.flip = "y" ? 1 : transform.flip = "x" ? 2 : transform.flip + } + + static __DeleteProps(obj, props*) { + if IsObject(obj) + for prop in props + obj.DeleteProp(prop) + } + + /** + * Converts coordinates between screen, window and client. + * @param X X-coordinate to convert + * @param Y Y-coordinate to convert + * @param outX Variable where to store the converted X-coordinate + * @param outY Variable where to store the converted Y-coordinate + * @param relativeFrom CoordMode where to convert from. Default is A_CoordModeMouse. + * @param relativeTo CoordMode where to convert to. Default is Screen. + * @param winTitle A window title or other criteria identifying the target window. + * @param winText If present, this parameter must be a substring from a single text element of the target window. + * @param excludeTitle Windows whose titles include this value will not be considered. + * @param excludeText Windows whose text include this value will not be considered. + */ + static ConvertWinPos(X, Y, &outX, &outY, relativeFrom:="", relativeTo:="screen", winTitle?, winText?, excludeTitle?, excludeText?) { + relativeFrom := relativeFrom || A_CoordModeMouse + if relativeFrom = relativeTo { + outX := X, outY := Y + return + } + local hWnd := WinExist(winTitle?, winText?, excludeTitle?, excludeText?) + + switch relativeFrom, 0 { + case "screen", "s": + if relativeTo = "window" || relativeTo = "w" { + DllCall("user32\GetWindowRect", "Int", hWnd, "Ptr", RECT := Buffer(16)) + outX := X-NumGet(RECT, 0, "Int"), outY := Y-NumGet(RECT, 4, "Int") + } else { + ; screen to client + pt := Buffer(8), NumPut("int",X,pt), NumPut("int",Y,pt,4) + DllCall("ScreenToClient", "Int", hWnd, "Ptr", pt) + outX := NumGet(pt,0,"int"), outY := NumGet(pt,4,"int") + } + case "window", "w": + ; window to screen + WinGetPos(&outX, &outY,,,hWnd) + outX += X, outY += Y + if relativeTo = "client" || relativeTo = "c" { + ; screen to client + pt := Buffer(8), NumPut("int",outX,pt), NumPut("int",outY,pt,4) + DllCall("ScreenToClient", "Int", hWnd, "Ptr", pt) + outX := NumGet(pt,0,"int"), outY := NumGet(pt,4,"int") + } + case "client", "c": + ; client to screen + pt := Buffer(8), NumPut("int",X,pt), NumPut("int",Y,pt,4) + DllCall("ClientToScreen", "Int", hWnd, "Ptr", pt) + outX := NumGet(pt,0,"int"), outY := NumGet(pt,4,"int") + if relativeTo = "window" || relativeTo = "w" { ; screen to window + DllCall("user32\GetWindowRect", "Int", hWnd, "Ptr", RECT := Buffer(16)) + outX -= NumGet(RECT, 0, "Int"), outY -= NumGet(RECT, 4, "Int") + } + } + } +} diff --git a/lib/Roblox.ahk b/lib/Roblox.ahk index 4495283..39bf681 100644 --- a/lib/Roblox.ahk +++ b/lib/Roblox.ahk @@ -1,8 +1,10 @@ -/*********************************************************** +/*********************************************************** * @description: Functions for automating the Roblox window * @author SP ***********************************************************/ +#Include OCR.ahk + ; Updates global variables windowX, windowY, windowWidth, windowHeight ; Optionally takes a known window handle to skip GetRobloxHWND call ; Returns: 1 = successful; 0 = TargetError @@ -56,29 +58,24 @@ GetYOffset(hwnd?, &fail?) { try WinActivate "Roblox" GetRobloxClientPos(hwnd) - pBMScreen := Gdip_BitmapFromScreen(windowX+windowWidth//2 "|" windowY "|60|100") + + if true { + fail := 0 + return 22 + } Loop 20 ; for red vignette effect - { - if ((Gdip_ImageSearch(pBMScreen, bitmaps["toppollen"], &pos, , , , , 20) = 1) - && (Gdip_ImageSearch(pBMScreen, bitmaps["toppollenfill"], , x := SubStr(pos, 1, (comma := InStr(pos, ",")) - 1), y := SubStr(pos, comma + 1), x + 41, y + 10, 20) = 0)) - { - Gdip_DisposeImage(pBMScreen) + { + TextRegion := findTextInRegion("Pollen",, windowX, windowY, windowWidth, 100, True) + if TextRegion.Has("Word") { hRoblox := hwnd, fail := 0 - return offset := y - 14 - } - else - { - if (A_Index = 20) - { - Gdip_DisposeImage(pBMScreen), fail := 1 + return offset := TextRegion["Word"].BoundingRect.y - windowY - 14 + } else { + if (A_Index = 20) { + fail := 1 return 0 ; default offset, change this if needed - } - else - { + } else { Sleep 50 - Gdip_DisposeImage(pBMScreen) - pBMScreen := Gdip_BitmapFromScreen(windowX+windowWidth//2 "|" windowY "|60|100") } } } diff --git a/lib/nm_InventorySearch.ahk b/lib/nm_InventorySearch.ahk index 1f25198..b78918d 100644 --- a/lib/nm_InventorySearch.ahk +++ b/lib/nm_InventorySearch.ahk @@ -1,43 +1,32 @@ -nm_InventorySearch(item, direction:="down", prescroll:=0, prescrolldir:="", scrolltoend:=1, max:=70){ ;~ item: string of item; direction: down or up; prescroll: number of scrolls before direction switch; prescrolldir: direction to prescroll, set blank for same as direction; scrolltoend: set 0 to omit scrolling to top/bottom after prescrolls; max: number of scrolls in total - global bitmaps - static hRoblox:=0, l:=0 +Scroll(direction:="Down", repeat:=1) { + Loop repeat + { + SendInput "{Wheel" direction "}" + } +} +; item: string of item +; direction: down or up +; prescroll: number of scrolls before direction switch +; prescrolldir: direction to prescroll, set blank for same as direction +; scrolltoend: set 0 to omit scrolling to top/bottom after prescrolls +; max: number of scrolls in total +nm_InventorySearch(item, direction:="down", prescroll:=0, prescrolldir:="", scrolltoend:=1, max:=70){ + global bitmaps + static hRoblox:=0 + pos := 0 + scrollDir := ((A_Index <= prescroll && prescrolldir) ? ((prescrolldir = "Down") ? "Down" : "Up") : ((direction = "down") ? "Down" : "Up")) + nm_OpenMenu("itemmenu") - ; detect inventory end for current hwnd + ; Activate roblox window and get it's current position and height if (hwnd := GetRobloxHWND()) { if (hwnd != hRoblox) { ActivateRoblox() - offsetY := GetYOffset(hwnd) GetRobloxClientPos(hwnd) - pBMScreen := Gdip_BitmapFromScreen(windowX "|" windowY+offsetY+150 "|306|" windowHeight-offsetY-150) - - Loop 40 - { - if (Gdip_ImageSearch(pBMScreen, bitmaps["item"], &lpos, , , 6, , 2, , 2) = 1) - { - Gdip_DisposeImage(pBMScreen) - l := SubStr(lpos, InStr(lpos, ",")+1)-60 ; image 20px, item 80px => y+20-80 = y-60 - hRoblox := hwnd - break - } - else - { - if (A_Index = 40) - { - Gdip_DisposeImage(pBMScreen) - return 0 - } - else - { - Sleep 50 - Gdip_DisposeImage(pBMScreen) - pBMScreen := Gdip_BitmapFromScreen(windowX "|" windowY+offsetY+150 "|306|" windowHeight-offsetY-150) - } - } - } + hRoblox := hwnd } } else @@ -45,57 +34,57 @@ offsetY := GetYOffset(hwnd) ; search inventory + TopText := "" + idx := 0 Loop max { + idx += 1 ActivateRoblox() GetRobloxClientPos(hwnd) - pBMScreen := Gdip_BitmapFromScreen(windowX "|" windowY+offsetY+150 "|306|" l) - - ; wait for red vignette effect to disappear - Loop 40 - { - if (Gdip_ImageSearch(pBMScreen, bitmaps["item"], , , , 6, , 2) = 1) - break - else - { - if (A_Index = 40) - { - Gdip_DisposeImage(pBMScreen) - return 0 - } - else - { - Sleep 50 - Gdip_DisposeImage(pBMScreen) - pBMScreen := Gdip_BitmapFromScreen(windowX "|" windowY+offsetY+150 "|306|" l) + + TextInRegion := findTextInRegion(item,, windowX, windowY, 360, windowHeight, true) + + TopEntry := "" + if idx > 10 { + for _, word in TextInRegion["Words"] { + if word.BoundingRect.h > 15 { + TopEntry := word + break } } } - if (Gdip_ImageSearch(pBMScreen, bitmaps[item], &pos, , , , , 10, , 5) = 1) { - Gdip_DisposeImage(pBMScreen) + if TextInRegion.Has("Word") { + word := TextInRegion["Word"] + pos := [30, word.BoundingRect.y + word.BoundingRect.h] break ; item found + } else if TopEntry && TopEntry.Text == TopText && TopText != "" { + break ; at the top of inventory } - Gdip_DisposeImage(pBMScreen) - + if TopEntry { + TopText := TopEntry.Text + } + switch A_Index { case (prescroll+1): ; scroll entire inventory on (prescroll+1)th search if (scrolltoend = 1) { - Loop 100 + Loop 10 { SendEvent "{Click " windowX+30 " " windowY+offsetY+200 " 0}" - SendInput "{Wheel" ((direction = "down") ? "Up" : "Down") "}" + Scroll(((direction = "down") ? "Up" : "Down"), 100) Sleep 50 } } default: ; scroll once SendEvent "{Click " windowX+30 " " windowY+offsetY+200 " 0}" - SendInput "{Wheel" ((A_Index <= prescroll) ? (prescrolldir ? ((prescrolldir = "Down") ? "Down" : "Up") : ((direction = "down") ? "Down" : "Up")) : ((direction = "down") ? "Down" : "Up")) "}" + Scroll(scrollDir, 3) Sleep 50 } Sleep 500 ; wait for scroll to finish + } - return (pos ? [30, SubStr(pos, InStr(pos, ",")+1)+190] : 0) ; return list of coordinates for dragging + + return pos ; return list of coordinates for dragging } diff --git a/nm_image_assets/inventory/BlueClayPlanter.png b/nm_image_assets/inventory/BlueClayPlanter.png deleted file mode 100644 index aac5ef9..0000000 Binary files a/nm_image_assets/inventory/BlueClayPlanter.png and /dev/null differ diff --git a/nm_image_assets/inventory/CandyPlanter.png b/nm_image_assets/inventory/CandyPlanter.png deleted file mode 100644 index dbd982e..0000000 Binary files a/nm_image_assets/inventory/CandyPlanter.png and /dev/null differ diff --git a/nm_image_assets/inventory/FestivePlanter.png b/nm_image_assets/inventory/FestivePlanter.png deleted file mode 100644 index 12d5723..0000000 Binary files a/nm_image_assets/inventory/FestivePlanter.png and /dev/null differ diff --git a/nm_image_assets/inventory/HeatTreatedPlanter.png b/nm_image_assets/inventory/HeatTreatedPlanter.png deleted file mode 100644 index 1e9f2e9..0000000 Binary files a/nm_image_assets/inventory/HeatTreatedPlanter.png and /dev/null differ diff --git a/nm_image_assets/inventory/HydroponicPlanter.png b/nm_image_assets/inventory/HydroponicPlanter.png deleted file mode 100644 index bb074fd..0000000 Binary files a/nm_image_assets/inventory/HydroponicPlanter.png and /dev/null differ diff --git a/nm_image_assets/inventory/PaperPlanter.png b/nm_image_assets/inventory/PaperPlanter.png deleted file mode 100644 index a46e854..0000000 Binary files a/nm_image_assets/inventory/PaperPlanter.png and /dev/null differ diff --git a/nm_image_assets/inventory/PesticidePlanter.png b/nm_image_assets/inventory/PesticidePlanter.png deleted file mode 100644 index 5256b21..0000000 Binary files a/nm_image_assets/inventory/PesticidePlanter.png and /dev/null differ diff --git a/nm_image_assets/inventory/PetalPlanter.png b/nm_image_assets/inventory/PetalPlanter.png deleted file mode 100644 index 0fd6ff1..0000000 Binary files a/nm_image_assets/inventory/PetalPlanter.png and /dev/null differ diff --git a/nm_image_assets/inventory/PlanterOfPlenty.png b/nm_image_assets/inventory/PlanterOfPlenty.png deleted file mode 100644 index c3b1408..0000000 Binary files a/nm_image_assets/inventory/PlanterOfPlenty.png and /dev/null differ diff --git a/nm_image_assets/inventory/PlasticPlanter.png b/nm_image_assets/inventory/PlasticPlanter.png deleted file mode 100644 index 7bd3ef3..0000000 Binary files a/nm_image_assets/inventory/PlasticPlanter.png and /dev/null differ diff --git a/nm_image_assets/inventory/RedClayPlanter.png b/nm_image_assets/inventory/RedClayPlanter.png deleted file mode 100644 index 8b8908e..0000000 Binary files a/nm_image_assets/inventory/RedClayPlanter.png and /dev/null differ diff --git a/nm_image_assets/inventory/TackyPlanter.png b/nm_image_assets/inventory/TackyPlanter.png deleted file mode 100644 index dee3e59..0000000 Binary files a/nm_image_assets/inventory/TackyPlanter.png and /dev/null differ diff --git a/nm_image_assets/inventory/TicketPlanter.png b/nm_image_assets/inventory/TicketPlanter.png deleted file mode 100644 index f956e90..0000000 Binary files a/nm_image_assets/inventory/TicketPlanter.png and /dev/null differ diff --git a/nm_image_assets/inventory/basicegg.png b/nm_image_assets/inventory/basicegg.png deleted file mode 100644 index 70d0ab2..0000000 Binary files a/nm_image_assets/inventory/basicegg.png and /dev/null differ diff --git a/nm_image_assets/inventory/bitmaps.ahk b/nm_image_assets/inventory/bitmaps.ahk deleted file mode 100644 index 2a374b4..0000000 --- a/nm_image_assets/inventory/bitmaps.ahk +++ /dev/null @@ -1,114 +0,0 @@ -bitmaps["item"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAAMAAAAUAQMAAAByNRXfAAAAA1BMVEXU3dp/aiCuAAAAC0lEQVR42mMgEgAAACgAAU1752oAAAAASUVORK5CYII=") -bitmaps["blueberry"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAFkAAAASBAMAAADCum8zAAAAD1BMVEUAAAAbKjUcKzYdLDceLDe8hzzeAAAAAXRSTlMAQObYZgAAAJlJREFUeNq10oEJAjEMheEXXSD/TaCb6P5LSfo42sAhRTAkIYGvB1cqSO0Hg0c7Et80+zqL/lsz1arznVVhV11TB4yWkkaHUfc0AhadlaGZyJXeIK+0e20unO3bN+DUT2BqH+x/GRSxrjGnfslai6711DVOnbHqGGrR0bQyPMWij6Gdj6ahvRMPuB2+76kHEaTHy+h6M37Qkj4y8wuCNNqdxAAAAABJRU5ErkJggg==") -bitmaps["strawberry"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAGUAAAARBAMAAAA24X8rAAAAD1BMVEUAAAAbKjUcKzYdLDceLDe8hzzeAAAAAXRSTlMAQObYZgAAALlJREFUeNqd0tFNQzEUg+HftAPYwADtBowA+y+FsJKGqO3DrZUTXTn3e4gUaMR9xLMouRw1VzhsDLxklKBzOCdGdG3GP/4bGWRyMylPSxOUNt2Tzqlm/Kp+lw9jxFqBjkHAKR4nw2A8zZSGTiiFLJMELHIz1yTLDA76ombSTyFNkyRe5nsa7yZBYRqAZazHRv+NNoO1LrMZ87bqy2aSbgkoNSSpoV3eW5llZHqyPZ/Rf7BlM0fysgF+AYk1CtE5QOD0AAAAAElFTkSuQmCC") -bitmaps["glitter"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAADcAAAAPAQMAAAB6PMXFAAAABlBMVEUAAAAbKjWMzP1VAAAAAXRSTlMAQObYZgAAAFFJREFUeNotyLEJgEAQRcEXyNZw4Y+MDQ1EPWzIEoy0Le3I8AQRWfaigQFDMzBVc/WsbpaemzYsg6vcdBy7q/ANl09sLuLyR2QLR0v9WgSWAP1wyRghiUY/cgAAAABJRU5ErkJggg==") -bitmaps["gumdrops"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAFwAAAAUAQMAAAA6KsgaAAAABlBMVEUAAAAbKjWMzP1VAAAAAXRSTlMAQObYZgAAAHpJREFUeNqdzrENgCAQheGnXtTCwg1kBCZQ2cRJDAkmNg6FsIgjMICFECJS+zeXr7jkITbHMyGkI0QOnUN2/e1gFswRth3s6dbqClDEbdkKAvbDgxmPLaHuhMohNeQHhnN7fySHIA8eAIaxcooGU7i1ueBThDIMT/3GA3+GKqkj9c29AAAAAElFTkSuQmCC") -bitmaps["blueclayplanter"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAJ8AAAAWAQMAAADkatyzAAAABlBMVEUAAAAbKjWMzP1VAAAAAXRSTlMAQObYZgAAAdlJREFUeAEBzgEx/gD4AAAAAAAAAAAAAAAAAAAAAAAAAAD+BgAAAAAADAAAAAHgDAAAAEAAAAD/BgAAAAB+DAAAAAH+DAAAAEAAAACBhgAAAACCDAAAAAECDAAAAEAAAACBhgAAAAGADAAAAAEDDAAAAEAAAACBhjBAAAGADB8MDAEDDB8MAfAAJgCBBjBB8AEADAGEDAEDDAGP4fD4PAD/BjBCCAEADACECAH+DACMEEEEMAD+BjBCCAEADACGGAHgDACMEEEEIAD/BjBD+AEADB+CEAEADB+MEEH8IACBhjBH/AEADCCCEAEADCCMEEP+IACAhjBGAAGADCCDMAEADCCMEEMAIACAhhBCAAGADCCBIAEADCCMEEEAIACBhhBCAACCDCCB4AEADCCMEEEAIAD/Bg/B8AB+DB+AwAEADB+MEHD4IAD4BgAAAAAADAAAwAEADAAMEAAAIAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAFzEPdK0OEUMAAAAAElFTkSuQmCC") -bitmaps["candyplanter"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAIEAAAAVAQMAAABbmR9GAAAABlBMVEUAAAAbKjWMzP1VAAAAAXRSTlMAQObYZgAAAYVJREFUeAEBegGF/gAAAAAAACAAAHgDAAAAEAAAAAA/AAAAAGAAAH+DAAAAEAAAAABBAAAAAGAAAECDAAAAEAAAAADAAAAAAGAAAEDDAAAAEAAAAADAA+GAAGMDAEDDB8MAfAAJgACAADH8D+EDAEDDAGP4fD4PAACAABGCGGECAH+DACMEEEEMAACAABGCEGGGAHgDACMEEEEIAACAA/GCEGCEAEADB+MEEH8IAACABBGCEGCEAEADCCMEEP+IAADABBGCEGDMAEADCCMEEMAIAADABBGCEGBIAEADCCMEEEAIAABBBBGCGGB4AEADCCMEEEAIAAA/A/GCD+AwAEADB+MEHD4IAAAAAAGCAAAwAEADAAMEAAAIAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAIA3MKqb/Uz+AAAAAElFTkSuQmCC") -bitmaps["festiveplanter"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAIsAAAAPAQMAAADu9q5yAAAABlBMVEUAAAAbKjWMzP1VAAAAAXRSTlMAQObYZgAAAShJREFUeAEBHQHi/gD/AAAAIAAAAAAeAMAAAAQAAAAA/wAAACAAAAAAH+DAAAAEAAAAAIAAAAAgAAAAABAgwAAABAAAAACAAAAAIAAAAAAQMMAAAAQAAAAAgAAAAPjGBAAAEDDB8MAfAAJgAIAHwPj4wgQfABAwwBj+Hw+DwAD8CCEAIMIMIIAf4MAIwQQQQwAA/AghACDDCCCAHgDACMEEEEIAAIAP4MAgwRg/gBAAwfjBBB/CAACAH/AwIMEQf8AQAMIIwQQ/4gAAgBgACCDAkGAAEADCCMEEMAIAAIAIAAwgwLAgABAAwgjBBBACAACACAAIIMDgIAAQAMIIwQQQAgAAgAfB+DjAYB8AEADB+MEHD4IAAIAAAAAAwEAAABAAwADBAAACAD/FQ7p8ZfErAAAAAElFTkSuQmCC") -bitmaps["heattreatedplanter"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAL8AAAAPAQMAAACP7owwAAAABlBMVEUAAAAbKjWMzP1VAAAAAXRSTlMAQObYZgAAAYJJREFUeAEBdwGI/gCAgAAACAB/gAAAAAgAAAgB4AwAAABAAAAAgIAAAAgAf4AAAAAIAAAYAf4MAAAAQAAAAICAAAAIAAwAAAAACAAAGAECDAAAAEAAAACAgAAACAAMAAAAAAgAABgBAwwAAABAAAAAgIAAfD4ADATAAHw+AAAYAQMMHwwB8AAmAICD4AY+AAwHg+AGPh8D+AEDDAGP4fD4PAD/hBACCHgMBgQQAggghhgB/gwAjBBBBDAA/4QQAgh4DAQEEAIIIIQYAeAMAIwQQQQgAICH8H4IAAwEB/B+CD+EGAEADB+MEEH8IACAj/iCCAAMBA/4ggh/xBgBAAwgjBBD/iAAgIwAgggADAQMAIIIYAQYAQAMIIwQQwAgAICEAIIIAAwEBACCCCAEGAEADCCMEEEAIACAhACCCAAMBAQAggggBhgBAAwgjBBBACAAgIPgfg4ADAQD4H4OHwP4AQAMH4wQcPggAICAAAAAAAwEAAAAAAAAAAEADAAMEAAAIFF2Q5RnzOirAAAAAElFTkSuQmCC") -bitmaps["hydroponicplanter"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAALEAAAAVAQMAAAAzap1+AAAABlBMVEUAAAAbKjWMzP1VAAAAAXRSTlMAQObYZgAAAgNJREFUeAEB+AEH/gCAgAAAgAAAAAAAAAAAAHgDAAAAEAAAAACAgAABgAAAAAAAAAAAAH+DAAAAEAAAAACAgAABgAAAAAAAAAAAAECDAAAAEAAAAACAgAABgAAAAAAAAAAAAEDDAAAAEAAAAACAjAwBhMAAgAADADAAAEDDB8MAfAAJgACAhAw/h4Pg/AfD+DB8AEDDAGP4fD4PAAD/hAhhhgQQgggjBDCAAH+DACMEEEEMAAD/hhhBhAQQgwgjBDCAAHgDACMEEEEIAACAghBBhAwYgxgzBDGAAEADB+MEEH8IAACAghBBhAwYgxgzBDGAAEADCCMEEP+IAACAgzBBhAwYgxgzBDGAAEADCCMEEMAIAACAgSBBhAQQgwgjBDCAAEADCCMEEEAIAACAgeBhhAQQgggjBDCAAEADCCMEEEAIAACAgMA/hAPg/AfDBDB8AEADB+MEHD4IAACAgMAABAAAgAADBDAAAEADAAMEAAAIAAAAAMAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAMerStYWLR4mAAAAAElFTkSuQmCC") -bitmaps["paperplanter"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAH0AAAAUAQMAAACataD0AAAABlBMVEUAAAAbKjWMzP1VAAAAAXRSTlMAQObYZgAAAV9JREFUeAEBVAGr/gDwAAAAAAAAB4AwAAABAAAAAP8AAAAAAAAH+DAAAAEAAAAAgQAAAAAAAAQIMAAAAQAAAACBgAAAAAAABAwwAAABAAAAAIGD4IAAATAEDDB8MAfAAJgAgYAw/AfB4AQMMAY/h8Pg8AD/ABCCCCGAB/gwAjBBBBDAAPAAEIMIIQAHgDACMEEEEIAAgAPwgw/hAAQAMH4wQQfwgACABBCDH/EABAAwgjBBD/iAAIAEEIMYAQAEADCCMEEMAIAAgAQQgwgBAAQAMIIwQQQAgACABBCCCAEABAAwgjBBBACAAIAD8PwHwQAEADB+MEHD4IAAgAAAgAABAAQAMAAwQAAAgAAAAACAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAADLtjg13P4DpwAAAABJRU5ErkJggg==") -bitmaps["pesticideplanter"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAJ0AAAAPAQMAAADERl/dAAAABlBMVEUAAAAbKjWMzP1VAAAAAXRSTlMAQObYZgAAAUZJREFUeAEBOwHE/gDwAAAAEAAAAAEAAAeAMAAAAQAAAAD/AAAAEAAAAAMAAAf4MAAAAQAAAACBAAAAEAAAAAMAAAQIMAAAAQAAAACBgAAAEAAAAAMAAAQMMAAAAQAAAACBgAAAfGAAMAMAAAQMMHwwB8AAmACBg+B8fGD4MH8HwAQMMAY/h8Pg8AD/BBCAEGEAMMMIIAf4MAIwQQQQwADwBBCAEGEAMIMIIAeAMAIwQQQQgACAB/BgEGMAMIMP4AQAMH4wQQfwgACAD/gYEGMAMIMf8AQAMIIwQQ/4gACADAAEEGMAMIMYAAQAMIIwQQwAgACABAAGEGEAMIMIAAQAMIIwQQQAgACABAAEEGEAMMMIAAQAMIIwQQQAgACAA+D8HGD4MH8HwAQAMH4wQcPggACAAAAAAGAAMAAAAAQAMAAwQAAAgP5rQDXjJsGFAAAAAElFTkSuQmCC") -bitmaps["petalplanter"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAHYAAAAPAQMAAAALRKlbAAAABlBMVEUAAAAbKjWMzP1VAAAAAXRSTlMAQObYZgAAAPtJREFUeAEB8AAP/wDwAABAADADwBgAAACAAAAA/wAAQAAwA/wYAAAAgAAAAIEAAEAAMAIEGAAAAIAAAACBgABAADACBhgAAACAAAAAgYAB8PgwAgYYPhgD4ABMAIGD4fAMMAIGGAMfw+HweAD/BBBABDAD/BgBGCCCCGAA8AQQQAQwA8AYARgggghAAIAH8ED8MAIAGD8YIIP4QACAD/hBBDACABhBGCCH/EAAgAwAQQQwAgAYQRgghgBAAIAEAEEEMAIAGEEYIIIAQACABABBBDACABhBGCCCAEAAgAPgcPwwAgAYPxgg4fBAAIAAAAAAMAIAGAAYIAAAQPxqMvFduh0GAAAAAElFTkSuQmCC") -bitmaps["planterofplenty"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAJkAAAAMAQMAAABLOY0JAAAABlBMVEUAAAAbKjWMzP1VAAAAAXRSTlMAQObYZgAAAQdJREFUeAEB/AAD/wD+AAAAcAAAAAAAAAAAA4AAAAAAAAD+QAAAfhAAAEAAAB4IA/CAAAIAAAAQQAAAAhAAAEAAACEIABCAAAIAAAAQQAAAABABAPAAAACcAACACAegAAAQfh4AAhEh+PPBwECcABCPD8eggAAQQgEAfhARCEAhAECIA/CAiEIQgAAQQiEAcBARCEQgAECIA4CQiEIRAAAQQj8AABHxCEfgAECIAACfiEIBAAAQQj8AABARCEfgAACIAACfiEIIAAAQQgAAABARCEAAACEIAACACEIKAAAQQh4AABHxCEPAAB4IAACPCEIGAAAQQgAAABABCAAAAAAIAACACEAEACcfKiwo59aBAAAAAElFTkSuQmCC") -bitmaps["plasticplanter"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAIYAAAAPAQMAAAAbCCXCAAAABlBMVEUAAAAbKjWMzP1VAAAAAXRSTlMAQObYZgAAARlJREFUeAEBDgHx/gDwBgAAAEAAAAPAGAAAAIAAAAD/BgAAAEAAAAP8GAAAAIAAAACBBgAAAEAAAAIEGAAAAIAAAACBhgAAAEAAAAIGGAAAAIAAAACBhg+AAfGAAAIGGD4YA+AATACBhgDB8fGD4AIGGAMfw+HweAD/BgBCAEGEAAP8GAEYIIIIYADwBgBCAEGEAAPAGAEYIIIIQACABg/BgEGMAAIAGD8YIIP4QACABhBAYEGMAAIAGEEYIIf8QACABhBAEEGMAAIAGEEYIIYAQACABhBAGEGEAAIAGEEYIIIAQACABhBAEEGEAAIAGEEYIIIAQACABg/D8HGD4AIAGD8YIOHwQACABgAAAAGAAAIAGAAYIAAAQMPiOJbfYHAOAAAAAElFTkSuQmCC") -bitmaps["redclayplanter"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAJoAAAAWAQMAAAACQxf3AAAABlBMVEUAAAAbKjWMzP1VAAAAAXRSTlMAQObYZgAAAdlJREFUeAEBzgEx/gD4AAAAAAAAAAAAAAAAAAAAAAAAAAD+AAABAAABgAAAADwBgAAACAAAAAD/AAADAA/BgAAAAD/BgAAACAAAAACBgAADABBBgAAAACBBgAAACAAAAACBgAADADABgAAAACBhgAAACAAAAACBgAADADABg+GBgCBhg+GAPgAEwACBA+B/ACABgDCBgCBhgDH8Ph8HgAD+BBDDACABgBCBAD/BgBGCCCCGAAD8BBCDACABgBDDADwBgBGCCCCEAACGB/CDACABg/BCACABg/GCCD+EAACCD/iDACABhBBCACABhBGCCH/EAACCDACDADABhBBmACABhBGCCGAEAACDBACDADABhBAkACABhBGCCCAEAACBBADDABBBhBA8ACABhBGCCCAEAACBA+B/AA/Bg/AYACABg/GCDh8EAACBgAAAAAABgAAYACABgAGCAAAEAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAFMRqnrn9fvAAAAAElFTkSuQmCC") -bitmaps["tackyplanter"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAIAAAAAVAQMAAAC0W3R4AAAABlBMVEUAAAAbKjWMzP1VAAAAAXRSTlMAQObYZgAAAXBJREFUeAEBZQGa/gD/AAAAIAAAAPAGAAAAIAAAAP8AAABgAAAA/wYAAAAgAAAAGAAAAGAAAACBBgAAACAAAAAYAAAAYAAAAIGGAAAAIAAAABgHwABjBgYAgYYPhgD4ABMAGABg+GICBgCBhgDH8Ph8HgAYACEAZAIEAP8GAEYIIIIYABgAIQB8AwwA8AYARgggghAAGAfjAHYBCACABg/GCCD+EAAYCCMAYgEIAIAGEEYIIf8QABgIIwBhAZgAgAYQRgghgBAAGAghAGEAkACABhBGCCCAEAAYCCEAYIDwAIAGEEYIIIAQABgH4PhggGAAgAYPxgg4fBAAGAAAAGBAYACABgAGCAAAEAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAHKgMQ3R/o1WAAAAAElFTkSuQmCC") -bitmaps["ticketplanter"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAIEAAAAPAQMAAAD51D67AAAABlBMVEUAAAAbKjWMzP1VAAAAAXRSTlMAQObYZgAAARlJREFUeAEBDgHx/gD/AAAEAAAEAHgDAAAAEAAAAAD/AAAMAAAEAH+DAAAAEAAAAAAYAAAMAAAEAECDAAAAEAAAAAAYAAAMAAAEAEDDAAAAEAAAAAAYDAAMYAAfAEDDB8MAfAAJgAAYDB8MQD4fAEDDAGP4fD4PAAAYDCAMgEEEAH+DACMEEEEMAAAYDCAPgEEEAHgDACMEEEEIAAAYDGAOwH8EAEADB+MEEH8IAAAYDGAMQP+EAEADCCMEEP+IAAAYDGAMIMAEAEADCCMEEMAIAAAYDCAMIEAEAEADCCMEEEAIAAAYDCAMEEAEAEADCCMEEEAIAAAYDB8MED4HAEADB+MEHD4IAAAYDAAMCAAAAEADAAMEAAAIAI1KIpDOlz4qAAAAAElFTkSuQmCC") -bitmaps["Cog"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAM4AAAAcCAYAAAAp6YDgAAABgWlDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhT83Bg8iFqYQsdhCrbRREUuJoggGJEbwKtzdHArZNewm2FgKtoKFR+NV2Fhra2ErCIIHiK2NlaKNyPrPRkgQIjgwzMebeY+ZN6Ad5Czbqx0C2ym4ibGYPjM7p9c9E6EWjTANhuXl41OjSaqOj1tq1HrTo7L432hKpT0LanThISvvFoQXhQdWC3nFO8JRa8lICZ8Kd7tyQeF7pZslflGcDVhTmVE3mRgWjgrr2Qo2K9hacm3hfuGOlO1IvjZT4pTiNcV2rmj93FO9MJJ2pqeULrOdMcaJM4mOSZFlchTokdURxSMh+7Eq/rbAPykuU1zLWOIYYQUbI/Cj/uB3t16mr7eUFIlB+Mn33zqhbgu+Nn3/89D3v44g9AgXTtm/cgCD76JvlrWOfWheh7PLsmZuw/kGtD7kDdcIpJBMLZOB1xP5pllouYbG+VJvP/sc30FSupq4gt096MpK9kKVd9dX9vbnmaA/Yt8LX3J9Lfn1awAAAAlwSFlzAAALEgAACxIB0t1+/AAAAAd0SU1FB+cMBAIFH3781hIAAAOVSURBVHhe7ZvZS5VBFMD7P3ooihYsssIraqaSS5mKSalYmVkZalFmpanlEi6lZYraYmhkqCRIRaQYVmJCmSJWarlUbsl13+3x5Bn4Rj8b424wwj0Pv4fvnDP3vpwfc78zc1fN/JkDgiD0g8QhCAMgcQjCAEgcgjAAEocgDIDEIQgDIHEkMjw2BmlZeeDo6Qvrd9jDVjsXOHD0FBSWlMHU7IxwDbEyIHEk8XtQC05efrDaQiPE/0Q4TExPCdcS8iFxJBESEc0EWbPNFgqKn8LQ6Ch0dnfDuZgEFt+kcYLq2jrhWkI+JI4E2jq7+M6ScDNTlZuem4UHj4thYHBQFSdWFiSOBLLzC7k4TV9bhDUiegcGICoxFTTOnrBu+y6wcfWGuJQMoWST8+9IdwuLwMUngL0/We7eC+djE/n3Piot+2cNoTskjgRCI2NY826xdRbmRXT394Nmjydv/MXY7fOBfq1WVX826pqwVoHEMQ4SRwI+gSGseXE4IMqLiE5KY2s2WztBVU0tjE5OwIvK12w3wfj1jGxeW/uxnguCAv3s7WWEX47jcRLHOEgcCbj7HmPN6xkQLMwvBUfTG60c2Zr0nHuq3NXUDBa3tHfjsdjkdBbD8fb41CSP466FcYTEMQ4SRwL67jg/enp5w7+vb1DlKqrf8Zx2ZJjFcJSNz4FhEapaEsd0kDgS0Pcdp6H5C2/41vYOVe5DY9NCrqOTxfb7BbFnHG0vriVxTAeJIwF9p2q/+vp4fd2nRlWu8k0Nz+FZEMaUHe34mUhVLYljOkgcCeDOoDRwUnqWKofnOPlFJaoRM8Zwd8L65d5xcOKmxJSx804nd9XVHRLHdJA4klBuDqy1tGNNjPfWurp7eNMvvTmAgmF8g5UDvKp+y6Zqzyur2HkOxm/l5fNajGMMiU+7zSTEzz594QqPkzjGQeJIAs9d/ndXzS84TDURGxgaAgePQ8JaV5/DTDylFncoXC+qVSBxjIPEkQg2e+qdXCYE7hwWNs7gfeTksrejcWqWcCMTbN28Wb29+0FIycyB4fEFaRRGJsbnc7nscBR3NRxXh16MJXFMBIljRnxu+8bFeVZRJawhdIPEMSOy7hdwcZpb24Q1hG6QOGZCy/d29lMQpbF28WKXQEV1hG6QOGZA+csKPs5GHj4pFdYRukPimAH4RzlFmkvxycIaQj9IHDMAz3w8/IOgpPw5G1WLagj9IHEIQm/m4C/EYHc2YcPsTQAAAABJRU5ErkJggg==") -bitmaps["Ticket"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAM4AAAAcCAYAAAAp6YDgAAABgmlDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhb9sFEUiFqYQsdhCrQxIFLGUKIqgIDGCV+HuxkQhu4bdiI2lYCtYeDRehY21tha2giB4gNjaWCnaSFj/2QgJQgQHhvl4M+8x8wa0w5xlezUDYDsFNzmS0KdnZvW6FyKE0YjTbVhefnxyOEXV8XlHSK23MZXF/0ZjetGzIKQLD1h5tyC8INy3Vsgr3hWOWktGWvhMuMuVCwo/KN0s8avibMCayoy6qeSgcFRYz1awWcHWkmsL9wq3p21H8rXpEqcVryu2c6vWzz3VCyOLztSk0mW2McIo40ygY7LKMjkKxGR1RPFIyn6iir818E+IyxTXMpY4hljBxgj8qD/43a2X6YmXkiIJqH32/fcOqNuG4pbvfx35fvEYwk9w6ZT9K4fQ/yH6VllrP4CmDTi/KmvmDlxsQstj3nCNQArL1DIZeDuVb5qB5htomCv19rPPyT2kpKuxa9jbh86sZM9XeXd9ZW9/ngn6I/EN2jpy0BRbFzEAAAAJcEhZcwAACxIAAAsSAdLdfvwAAAAHdElNRQfnDAMCNRylZIniAAAD3klEQVR4Xu2a6UtUURTA+z9aoYVQWyw1bbHFrMzApCTKslQq22wnWtCUbNGy1TaLtAVbkCIhCKKk3KoxzWhlTCuX0XHf+njiXHm3e9+8mfQ9XxFzPvzAe865Z0aYH+e9+96grp89QBBE/yBxCEIHJA5B6IDEIQgdkDgEoQMS5z+mxmaDpNRTcP1urmbeKO1dnXAp+xacybymmXdnSJwBYnrIEhjs4euSmC27eH2x5Q2MmxYMEdFx0NnTLfXqC43NzTDGZybrezHrpmaNUcJXrWX9D6ae1My7MyTOANFfcYospeA1dS6ERcbqEqeusZH3NUsc5X8icRwhcUwgN+8R/1Fbq79p1hiFxPm3kDgm0BdxMP60oIjR1tmhWeMKZ+LceZAHqWcvMl6WlUt7+guJ4xwSxwT6Ik7G1Wxe86O+XsrhendiCvjOWQQjJkwF75khEBu/WxJBS5wrN2/z2KoN29jNvVKv0NzeBodPngP/4DDW22d2KOxPSYN6u53XpF/I5H1EUEaxlztD4piAEXFqG2wQMC+M50RGek+HFyWvWJ1aHJw0Q72msPXSNXHQ0t7Oeyp0dHfBspiNfJ9IcPgKJhXWkTh/hsQxASPiJKedZjGUIOf+Q/Zjzi8qYQcJOCGOnj7P6kRxVq7fCsPHB7C/UTp7SwvvJ5J5I4fVeAYEweP856zuyfMC8PAPYnH1sTNdqjmHxDEBI+JMDFzAYtGbd0r1JaVl8L2ujq9FcURQri9VVdJehaDFy1nNifOXpTheumE8dNlqKU7iOIfEMQG94uAEUGL44FG9R0QtjvIjR3YcSHaob2prhSGeftIeNaN9AqU9JI5zSBwT0CvOJ2slj92+n+ewR0QUJzB0KesRtXE7W+Nl2+fKr1J9dU0Nr3eFeMJH4jiHxDGBvz1xlFO11+UVfKps25ck1dtbf/c+niFfqjmDxHEOiWMCZtzjFL62QHVtLV9riYOs2bSDxXDq4ART4ohyWhe5Ll6Kt3Y4nsAhijiJx9I18+4MiWMCRsRxdaqGMmidqoniWN7+njrxexN5HDlyKoPFMZ+Vc4/d9zwrLGayokwFryxSfUhEFKvHQwX8LviakJh3Z0gcEzAiDj7HwYeTSk7E1XMcZT+C0wrjw8b5w0erlcfxcm1ueO/JmpqxfrOg/P0HqQ9OGrFGfd/kzpA4JmBEHATXuxIOweTZC9nx8oQZ89kLon96c0ChtOIdnzpb9iRIOVuTHRKOnADfoN63EvAzsEYUTKGhuYl97qhJM9hDVXXenSFxCEIHJA5B6IDEIQgdkDgEoQMShyB0QOIQhA5IHILoNz3wCy9BbMGE4c7EAAAAAElFTkSuQmCC") -bitmaps["SprinklerBuilder"] := Gdip_BitmapFromBase64("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") -bitmaps["BeequipCase"] := Gdip_BitmapFromBase64("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") -bitmaps["Gumdrops"] := Gdip_BitmapFromBase64("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") -bitmaps["Coconut"] := Gdip_BitmapFromBase64("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") -bitmaps["Stinger"] := Gdip_BitmapFromBase64("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") -bitmaps["Snowflake"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAM4AAAAcCAYAAAAp6YDgAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsIAAA7CARUoSoAAAAjPSURBVHhe7ZwJUFVHFoZ/d9wwbqNRozHuBpVAQBEVENRREQVBwEEwiETUxCUVZsaMJu7GCC4jYAQZEWUbFsUVl4mWCyqiiMGgxhiTuCDggihu6NxzXl94EgnDo6ZKef1VverTfbt4977q0+c/p6/WKCx6+AISiaRS1BStRCKpBNJxJBIdkI4jkeiAdByJRAek41QDrt/IgYvnFBhbDoOb9zQ8efJUXAEys37ApOmfo6jokRipHHfvFSDgn+uRuH23GJEQ0nEUtu3cCycPX/S2GAILu9H4eMbfcOLUGXH19efLpQHsIEWPHuHM2e/x7NkzHt+6I4Ud6kjqSbx4Ufni6cOHRRhs74r1G7ewLSlF7x1ndUg4/OctRtYPF/D4yRPcvnMXB4+kwmvKLGyOTRSzXl+Knz/HsRPpbA+y7IuVS79E3bp1uH+voIBbXXlWXIwHDx+KnkQbvXac8xcuIWTDJrZnTvXBqUO7cCA5BsNsrXjsTOb3vDBfZygSqBHGyrIfRgwdjNq1a3Nf8v9Drx1nZ8oBljA9unWG36QJaNyoIdq1fRsrFs3F9th/IWDxPNSq+Xr/RLpIMCLj3Hl8PncxbEaOw/t9bWE1whmLvlmNgoL7Ykb50O8WHLaJP1nZF8WofqHXjnNHkWUEybPCBw/YJkjqdOnUUfQ0kIzrZmrFnzkLvobH5E9hZmPPCbnnxzNxLitbzCyF/u6Cr1fBxn4c5092Du5YGhj00uJcviqE/+YIZ08xAhTcL+TFTOPDnDzEqOYeelnY8Xhc0g6sCg6DmfVIcRVYuHw1X6soH/nt2g2M956G5F17cf1mDkesmzm5iIxJhMtEP/7+8ohJSMbsOQsUibsB585no3uXTuJKKXSfa9aF8/Ma9bOD9QgXfu77haW/8ZuOXjuOUc/u3ObcysNIFy98s2Yd5zcV6fqEbbuQdvosOwAl5FRI8JwyEzdybokZQF7+bYz18MWWuCSuetFi+vXadWzcEgdnrylcrSJMjI24vXzlKu7cvcf2vu8Ol8ivn6/+ios//sR2RmZWScXM1LgXt7pAUdXNeTS3U328MH/OZxhsZcnX6PsiYxLYLgtFmvnLVrJtYW6K1cvmo1atWtxXea5I26mz5iAoNIKf9+nTp/y70HN7+s7g36E6oNeOM87RHv37mrJNO25YRDRX1PrbjcFXSwPLTa5bNGuKmPAgZBxNQVDAItSrW5d3+W/DN4sZUHKnSN7NSf6FBwcgM3UfggMWw6BePVz95TeER8byvA96axyHOHUmk9vd+/7Drcqe/Qe5PZ6mqfS91cQQ773bnvOytIM7eYyY6z8DF9IPoUGD+mKkfPxn+iElcTNm+HnDbawDglYswjtt2/C1dHEf2hxJTYP/vCXsGO3btUFI4JKSIoQ2sYnbceR4Gt8jPXfGkRRErFuJJoaGnFPSRlId0GvHoSQ6bO0KfPX32Ur06YaaIp959PgxouO3wcXLD/m37/CYNuOcHPBBHyPUNzCAnfVAuDqN4vH0jHPc0uJK2r6Hbe8JrrDs+yE7l631ALi7jObxhG2aBd9cccIO77RlmxyHoljqydPcb9G8GbcpBw5xe+KUZtxEiTY1atRgW1du5eZj9hcLWW72NB8M65EuJRHvVRH3u8PHSqLgDWWTuXNPM7csJOUI9bnr1zdAPzMTeLg68niK2ATedPTacQhK/t0V2ZIQuR6nD+/GhqAVGDnMlq9RZKC8oSx/atlcWBpI8hA3b+Vym5t3u2TxWZh/yK1Kf9HPUxxSzavICQmSf6pMq1OnDmZP9+XxH3/6mZPwTJFHVUWmERRd3T6ayouYHLW4uJjlqno/5dUbOnZozy3Jr3VKRC0LbTgXLl1mO3BtKOdb6oekG3Hx8hVu33T03nG0oQgyoJ8ZApfMw6QJbjxGu726E1fEC1G6pqKASrO3mghLQ1Otfv5tzTyTPhpHyFakTLySPxF9TY0x3M66RA4tU5JrWrCEqXFvbnUlNCKKIylJruSYcJxL3Y+9SVvQoX07MeP3dOrYAdHhazlqEgnJu3Ht+k22VQqV5L+iKp92+fxNRu8dh5JV2inLYjOoP7cku65c/YXt/5UWzZsKC4qkeTlPUosCREshxUxExKEzo9NnNXKPvp9yFQszTQ52Mj2DW5J8Rj26sq0r9HYBMcnTHd26dGLnJKdp1LAhj7+K8S5j2Ok/8f2IZSItfsrjtGnYsIGwgFnTJnO+9apPdThn0lvHod2b3gygkim9i1UW7VduDJRIVBkoN6HkmDh2Io1blaOi36Z1q5IkvvN778KwcSO2VWwGahxX3eFVehv1YBlXJUR+dP8Pys7lQWdeduKeknbs4dK2CkVsimKE6pwqarSsLuit4zxXJMWGyBglSc7Dpuh4LkVTCZkqaXSeoe6mhoaN0bXMmU5F0I48zlFTMAiNiMaho8c5su0/eBhRcVt53HWsA7cEze/Tq6fogc+Q2rZpzbatlSVfV6lqfkP0UZyPCN8cqylIKA4U9e+tuHRZU/auiOm+E0uiTrB480LFYcRQbumZ47fu5GhOuZuNvStXLOngtTqgt45Dksd/hp/ogUvRlkMdYW4zik/QVR0+xdtDJ2kxeeJ4zgtI0/t++lc+AJ322T/YgXp26wIvd2cxU4Oa5xCDB2nOVAiKXupCJ6qa3xB0b1TNo1zsLz6f8CEqnc9ov1X9R3Tv2hlDbAayTS+S0nmNio+XO0clynW+WLgcffoP5cPi3Lx8pGdkKnKwVM69yeh1jjN8iA2fhZQH7Z7eHq6iVzlIesVFhMBHySNIvpCjUlVqqo8nopQkm8q02mhHEpuBFsLSoMo1KperFbiqQDIxPvJbOI0azo5J90Z/12WMPQZYmMO49/tiZvmoUYcqcsGhpVGH5Nrm0DVcXGnzdiuWla1bteTvSooKY1laHZD/WYcC5TPrN0bhfPZF/ncrJJXovMXR/s8vySSJREU6jkSiA3pfjpZIdEE6jkSiA9JxJBIdkI4jkeiAdByJpNIA/wVhPqLq2w3KtAAAAABJRU5ErkJggg==") -bitmaps["MicroConverter"] := Gdip_BitmapFromBase64("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") -bitmaps["Honeysuckle"] := Gdip_BitmapFromBase64("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") -bitmaps["Whirligig"] := Gdip_BitmapFromBase64("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") -bitmaps["FieldDice"] := Gdip_BitmapFromBase64("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") -bitmaps["SmoothDice"] := Gdip_BitmapFromBase64("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") -bitmaps["LoadedDice"] := Gdip_BitmapFromBase64("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") -bitmaps["JellyBeans"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAM4AAAAcCAYAAAAp6YDgAAABgmlDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhb9sFEUiFqYQsdhCrQxIFLGUKIqgIDGCV+HuxkQhu4bdiI2lYCtYeDRehY21tha2giB4gNjaWCnaSFj/2QgJQgQHhvl4M+8x8wa0w5xlezUDYDsFNzmS0KdnZvW6FyKE0YjTbVhefnxyOEXV8XlHSK23MZXF/0ZjetGzIKQLD1h5tyC8INy3Vsgr3hWOWktGWvhMuMuVCwo/KN0s8avibMCayoy6qeSgcFRYz1awWcHWkmsL9wq3p21H8rXpEqcVryu2c6vWzz3VCyOLztSk0mW2McIo40ygY7LKMjkKxGR1RPFIyn6iir818E+IyxTXMpY4hljBxgj8qD/43a2X6YmXkiIJqH32/fcOqNuG4pbvfx35fvEYwk9w6ZT9K4fQ/yH6VllrP4CmDTi/KmvmDlxsQstj3nCNQArL1DIZeDuVb5qB5htomCv19rPPyT2kpKuxa9jbh86sZM9XeXd9ZW9/ngn6I/EN2jpy0BRbFzEAAAAJcEhZcwAACxIAAAsSAdLdfvwAAAAHdElNRQfnDAMCNRiiCU37AAAGR0lEQVR4Xu2b+1MWVRjH+z8qu9mUV0hFuQdyCQQvaMIYoHkPLEBTUBhBTIU0r4Eaolk66gxjODlhFCmjhMSA17goqEQKcQdR+vHJ77FzZvd9d+Hdl3eGxff88Jlhv+c5+77n3fPd8zxnl5ee/DtAEonEGNI4EokdSONIJHYgjSOR2IE0jkRiB9I4DqC8qpqilq+hju5um3RH4Dc7kl4e72bF29N82WdWVF/X7CdxDE5vnLPni8Sku1VXrxkzGCcLCkX/9q6uIXVHoWcczhuunnTp96uafSXDRxpnmMbJPfqd6K80iJ7uKIYyDkCMVl/J8JHGGeXGSUzdotJb2ttpRWKy+Oz6xnuqdoljkMZ5wYwDbtbWic8uLa+wareVssoqilufRm4zw+m1yR401X8WbdyaRS1tbZrxzoQ0jo5xuvp6acfeHHIPmkuvu3jSNP8wStu+i1o7OlT9jRhn59eHhYbJzWM51/+sEe0bMrZbtSsZzDjVt26L8/xxTb1JYOu4sFKNmThDnEeJV+h8trLx83E9YVMGzYtZQePcZ9LYKT40f/Equlp1TXVecLGsnOZGL6d33PxYbETsSjpR8AP1PX1iFWtWpHE0jPP42QWMWhYvdCVBER+xycL7GzFOQ1MTvfr/ZEzP2i1iOdB4n8obN63alegZp7mlhSKXxrE2GEO5o2dkXCB5yw6aETSHtu/JofyTZyg2LknEf3ngEItRGkcL7PJh3PycF34rFb+BJZ8mbxZxZkcaR8M4R06cZscTPAKouPQym3wll8tovHsA0w8c+Vb0N2IcwCf1ZO9g6u1/LHTcbV19Q1hb8IIYoevBjTMYSKuUfYyMC3T29qi+I4yHlQqxGAc0pXFcno3pSkUldfR007kLxfSmqxfT16dvE+dYHL+WabMil7CUr+ZuAzOhd+iCUVWPSeNoGCdg3iJ2vPtgnioWKQ70sKglQjNqnDOF54VeWFQs9KKSS0LHBOe6HkMZB6mSZc1mZFygtqGRliVsYOnUmEnuNMUvlKVXylilcbAyKftv2prNdP85UULDCgkNKeJPJReZGaH3DzwVMaMBaRwL4+Au+8qE6ULTAukH72/UOJho42b4Mz1mdaLQVyalMA0T/p9Odb2hhS0rjovPB/R3ayuLNzquxqa/2KqoFQewYiBOaRxLw/PfAMbj2u36enp3+nPzARgoe/9B1W80GpDGURgHF7Xp4UNxPBg8hTFqHIDUBTqK7/vNzazQ5mnNZynpqlg9uHE+3/yFSsdnpW7bKT4b3wO60XGlZGaxY4/guWyzobuvj2ru3CXPkAimGzEOjKLU79y7T6vXbWQ1GO87PXA23aipVcWZGacxDiYn7qKWOnZz+MXDJEZ+zo+/ylWnNFrYYxy8isPbkDah8ObHqBGUsXroGQdg8r/1njdrR4EPzei4gudHs1h8N5X+rP6CPhzjcJoePWLpHd5yQJxlqmhmXnjjoOhem5bJUiBsgVpueSalZrKLNtEzUOTZuMtCi16VoIrtedynOgb2GAe8H76QteEOjgmDv33DPrSK02Mw42B14CuYsu4wMi5ukL2H8jX14Rin70m/6hj9+DlgcGWbWXGKFYcXqeDjNetYSoYVCBcMRS/0jOw9Ij5rXy7TUBMcP13A6gO894VdL0w6PBjksfYaZ3/eMdHOyck/bhWnh55xUB9B4+fE6sbbjIwLz5EQO8kriD1Exe+V9/0psTrYa5xTZ8+xugYrfVtXJ6vB4jeksTiskpamMitOYRxcXOwO8QtsScjCWNWdDn8HRjzfgbIEk0CZi9trHKQp3LQA+T4v5G3Bls0BPJBU9jEyrrsPHjhsc4AbB+PDljWPtwS7e8r+ZsZpahykYdgIwPMH3GFx58SzA+zoaKUHuHPjgaRbQDib1HjdBIV7XWOjKs5e44DYTxJFDHbVtGL00DMOXo3BuPYdPqr5JN7WcQGYB23YnUPqF75oKUtt8W8L2IBAjNEVB+ZB+ojvj3NiRcPbBrg2yr5mx2mMY0Ywufmk+6X0imaMxJxI44wgeM0FpsFrLaPtAaCzI40zQuDlR77a7Mr5RjNGYl6kcUYIvg3OH4JqxUjMizTOCIBt2LFTfZhxsEGgFSMxN9I4I4Dygd+PP/+qGSMxN9I4EolhBug/IbOh2XrFBxwAAAAASUVORK5CYII=") -bitmaps["RedExtract"] := Gdip_BitmapFromBase64("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") -bitmaps["BlueExtract"] := Gdip_BitmapFromBase64("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") -bitmaps["Glitter"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAM4AAAAcCAYAAAAp6YDgAAABgmlDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhb9sFEUiFqYQsdhCrQxIFLGUKIqgIDGCV+HuxkQhu4bdiI2lYCtYeDRehY21tha2giB4gNjaWCnaSFj/2QgJQgQHhvl4M+8x8wa0w5xlezUDYDsFNzmS0KdnZvW6FyKE0YjTbVhefnxyOEXV8XlHSK23MZXF/0ZjetGzIKQLD1h5tyC8INy3Vsgr3hWOWktGWvhMuMuVCwo/KN0s8avibMCayoy6qeSgcFRYz1awWcHWkmsL9wq3p21H8rXpEqcVryu2c6vWzz3VCyOLztSk0mW2McIo40ygY7LKMjkKxGR1RPFIyn6iir818E+IyxTXMpY4hljBxgj8qD/43a2X6YmXkiIJqH32/fcOqNuG4pbvfx35fvEYwk9w6ZT9K4fQ/yH6VllrP4CmDTi/KmvmDlxsQstj3nCNQArL1DIZeDuVb5qB5htomCv19rPPyT2kpKuxa9jbh86sZM9XeXd9ZW9/ngn6I/EN2jpy0BRbFzEAAAAJcEhZcwAACxIAAAsSAdLdfvwAAAAHdElNRQfnDAMCNRcytlBqAAAD3ElEQVR4Xu2a+W9MURTH/R/EkiBoaUPpQlFt7VRjqRJFLZGWJqIllJJYGqUIamssVRS1BQlCEGpJ1RZaFUPsxXRv1Y+Hc+Ve7828TqfPzZD0+8Pnh55z3u38cD5z7z3z2jX+aCIAQOuAOADYAOIAYAOIA4ANIA4ANoA4/5i7JQ8pbk4yOaurLfOu1DU20N68o7Q992CrckAvEEczHyoqaMW6LAodHkNdAsMoIHwETZ2bTKcvXnKrPVJ4ltr36i/4VlWl4vdKHlHvgdE0efYCamj6bnomdsY8Ub8ma6sp3lIO6AXiaKTslYMCB49UMriSsny1qT5nf57KGcXhXcg/LIpips9xE2fQqImi3koOTzmgF4ijCW7wUZMTROP2DI6gc5euUGVtDT0rL6f4eQtFPGDQcHr8vFQ905w4noA4/wcQRxOXr99UEhw4dtKUc9ZU077Dx4RIxnhz4jjevqPrRXcFtQ31pmd8Kc62vfupe9AQGj1lJhUVl1jWtFUgjiaWrFormrZTn1CqcDota1xpThxjnO9MHNuyO1fFjGTt2OMxJ9esqqulDVt3Ukh0DHUOCKOgiDGUvn6T22flQQU/y3Ud/YPVWvmFZ0x1bR2Iowl5TONvZ6u8Fb4Sp/57I8UlJlnWRMdOE1LJ/y3FMcJDDm+/DNoKEEcT/SJGiyZLSFpsmbeiNeJI7BzVcvMLRNwvNJKu3LwlRt/XbhVRr5BIETeOr43i5B0/JY6X7z9/Nq0HII42uCm52ZKXrlQxvhfIJpTw4EDmfSVO5IR4Ec/etc8U56Mbx8fE/dkljUc1Yy0wA3E0wXcGbjjjjmMlDu9MMu8LcXjH6OA3QK1nRbegwapeijMuPlHFgDsQRxN8t+GGM95xrMThO4XM+0Kctx8/qrU8Iad3EMc7II4mUjPWiYazmqrV/bqc81iX80lp6SruC3F4FC7X2pxjPqpZAXG8A+Jogi/dskEPFRQ2mztx7oKK/404qzduMcU95fj1H45Pn59iitfU15n+ZiCOd0AcTfCbA/K41jNkGJ2/fFXcL+48KFGNGxw93jT6tSOOHHvzhb/g7Hnxek5LucxtOSLOdx2Wmj/XjTv3xOtBLJPxx02I4x0QRyPljtdqLO1K177hdPt+sanejji8m8gc8/L1mxZzfFyLiv09WXOlx4Ch9KS0TK0BcbwD4mjm09cvlJGZTWEjY8UPhzymTkxJo6dlL9xq7YjztaqSEhelChEnzVrgde5LpVN8rv6RY8WbAyz4omUZ9MLhMNVBHO+AOADYAOIAYAOIA4ANIA4ANoA4ANgA4gBgA4gDQKtpop8mKiYdmraDDQAAAABJRU5ErkJggg==") -bitmaps["Glue"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAM4AAAAcCAYAAAAp6YDgAAABgmlDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhb9sFEUiFqYQsdhCrQxIFLGUKIqgIDGCV+HuxkQhu4bdiI2lYCtYeDRehY21tha2giB4gNjaWCnaSFj/2QgJQgQHhvl4M+8x8wa0w5xlezUDYDsFNzmS0KdnZvW6FyKE0YjTbVhefnxyOEXV8XlHSK23MZXF/0ZjetGzIKQLD1h5tyC8INy3Vsgr3hWOWktGWvhMuMuVCwo/KN0s8avibMCayoy6qeSgcFRYz1awWcHWkmsL9wq3p21H8rXpEqcVryu2c6vWzz3VCyOLztSk0mW2McIo40ygY7LKMjkKxGR1RPFIyn6iir818E+IyxTXMpY4hljBxgj8qD/43a2X6YmXkiIJqH32/fcOqNuG4pbvfx35fvEYwk9w6ZT9K4fQ/yH6VllrP4CmDTi/KmvmDlxsQstj3nCNQArL1DIZeDuVb5qB5htomCv19rPPyT2kpKuxa9jbh86sZM9XeXd9ZW9/ngn6I/EN2jpy0BRbFzEAAAAJcEhZcwAACxIAAAsSAdLdfvwAAAAHdElNRQfnDAMCNRZFsWD8AAADaElEQVR4Xu2a2UtVURSH+z+KJipSM6UcrpqmXa+ZWuZDDgUWTQ9aUpRFWkqkCZU0kD0o2YhSIklGKoaZU6FGNjhANwgytK7z1OOqteUcztFzvdejHA1+D9+Dv7XO1of9cfbaniVjfyYIADA7IA4AOoA4AOgA4gCgA4gDgA4gzn9AU+t7ijuUTLaBAc06MB6IswD86OmhtKwr5BcWTas8/ckjcDvFH06m0hcV03oflzyjpa7egt/9/dPqYGGAOAbT8dVKnkHhsgxTSTmXqerPu/tArkGcxQPEMZDRiXHasSdRSODiG0JlFVXUNzRIn7u6KOHIMZF7bAmjD1/a5WcgzuIE4hhIZU2tLEFh0VNVzTY4QPkPi4RIyhziLE4gjoGcunBJCLBiox/12GyaPVPREqd/eEjOSstfqvpzbuSJfL1PsCrnZy5fv00mSzSt9PAnr5BISs++6vTfAdRAHAORjmkRsfs161rMhzgj42MUdzBJfkaJJWavWE+5BnAMxDGQzSERYrMmJp3UrGsxH+IUPCoWmZufmapq68S19qu6BnI1mUV+q+Ceag3gGIhjILxxeaMmnzkvZw3NrSJTwhcHUn0+xDHvThBZ7p18VS8f3TiPjHP+DQgmgTgGwnMFb1TlG0dLHH4zSfW5isOXDcvcfOR+LdZ6BanWAI6BOAbCsw1vVOWMoyUOzx1Sfa7ifO/ulntnYmh0RLUOmBmIYyCnM7LEJtW6VRv+N8Cv89oq6kmp6XKuJc7gyLCcORKHr7ml3mt56qMa0A/EMRAezKVNfL+4xG7tSVm5nGuJw2zwDxXZzfxCOWNOpF0UuXLG4U97ONt3NEXVywIqfwbOA3EMhL8ckI5rLqZt9LyyWswgjS2t8ub2texSXQ/bE4fnJM7cAyxU09Ak1ql+Uy/mFc6V4khvIZ51WFjufd34Vnz6wzLxcVHqBc4BcQymy/pNvpaeyppNgVT/rlnVb0+clrZPtNzdpHpeiVIcPq6FxkzerGn1tbV3yL3AOSDOAvDzVy9l5OSSf3iM+Dqar6kPpqTSx47Oab32xGH4eMf/VF3tGSDW4H9ypmZmU/DOWIqKP6Dq7e2zid/pbY4SXw6wvMfPZlCn1arqA84BcQDQAcQBQAcQBwAdQBwAdABxANABxAFABxAHgFkzQX8BGIwcIpXSsMkAAAAASUVORK5CYII=") -bitmaps["Oil"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAM4AAAAcCAYAAAAp6YDgAAABgmlDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhb9sFEUiFqYQsdhCrQxIFLGUKIqgIDGCV+HuxkQhu4bdiI2lYCtYeDRehY21tha2giB4gNjaWCnaSFj/2QgJQgQHhvl4M+8x8wa0w5xlezUDYDsFNzmS0KdnZvW6FyKE0YjTbVhefnxyOEXV8XlHSK23MZXF/0ZjetGzIKQLD1h5tyC8INy3Vsgr3hWOWktGWvhMuMuVCwo/KN0s8avibMCayoy6qeSgcFRYz1awWcHWkmsL9wq3p21H8rXpEqcVryu2c6vWzz3VCyOLztSk0mW2McIo40ygY7LKMjkKxGR1RPFIyn6iir818E+IyxTXMpY4hljBxgj8qD/43a2X6YmXkiIJqH32/fcOqNuG4pbvfx35fvEYwk9w6ZT9K4fQ/yH6VllrP4CmDTi/KmvmDlxsQstj3nCNQArL1DIZeDuVb5qB5htomCv19rPPyT2kpKuxa9jbh86sZM9XeXd9ZW9/ngn6I/EN2jpy0BRbFzEAAAAJcEhZcwAACxIAAAsSAdLdfvwAAAAHdElNRQfnDAMCNRZFsWD8AAACfklEQVR4Xu3b3UtUQRjH8f6PIAzCQIxMW4UV08SNsheVJVZrQ8rESLE7ybCCqIgCCbIIVFIUDLzoH4guTMwl14XK3jz2wl4I2b5prpdPzMSZ5rBz46TNIL+Lz83MnLvny+7Zc3bbr7UsAcD6IBwADQgHQAPCAdCAcAA0IJwtbGomSqGWdlpKJpX7oA/hWOijs0Cdl69RcdURytvrp5KDtdTZfZ0+LXzJOftqZpb2lAfo5NkLtJJdFeuj489oe4GP+5FIeK6Bf4dwLMNCyN9fKYZetttXRZHZmOc8+1Qp9NdQ3ekWTzgPB4fFdQhn4yEciyQyafJVH+PDXlEb5FEspZL0fGKSSmuO8/WywAlKLWeU18sQzuZCOBbpHxkTwx5989azNx2Nib2hsXGx7nz7Ti8mp7j0yrJYRzibC+FYJNjcxge9uq5RuX8oGOb7Ta0dYk0OJL64qFxHOBsP4ViE3cOwQb9y865yv/vGHb7Pfgxw1xCOGQjHEmzo3UG//3hQeeZB/1BODAjHDIRjiQ+OIwZdvoeRDYw+FWe+xuN8DeGYgXAsIYfDfiRQnekb+PuJg3DMQjiWkL+q3ertU57puX0vJwaEYwbCsYj74DPcdkm5Xx8+z/fZA093DeGYgXAs0nCmlQ/6ziK/+CrmYq/h7Cgs4/uhcxfFOsIxA+FY5NGTETHsR0PNFHs3R8lMhj/8DDScEnvyPRDCMQPhWIS9xVx04LAYeBX2wufPdEpcg3DMQDiWmZiO0K6SCjH0Mrb+MvLacx7hmIFwLDT3eZ7au3poX+WfvxWwvxd0dF2l9/OO8jz8fwgHQAPCAdCAcAA0IBwADQgHQAPCAVi3LP0GbRDPQNCd7ZIAAAAASUVORK5CYII=") -bitmaps["Enzymes"] := Gdip_BitmapFromBase64("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") -bitmaps["TropicalDrink"] := Gdip_BitmapFromBase64("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") -bitmaps["PurplePotion"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAM4AAAAcCAYAAAAp6YDgAAABgmlDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhb9sFEUiFqYQsdhCrQxIFLGUKIqgIDGCV+HuxkQhu4bdiI2lYCtYeDRehY21tha2giB4gNjaWCnaSFj/2QgJQgQHhvl4M+8x8wa0w5xlezUDYDsFNzmS0KdnZvW6FyKE0YjTbVhefnxyOEXV8XlHSK23MZXF/0ZjetGzIKQLD1h5tyC8INy3Vsgr3hWOWktGWvhMuMuVCwo/KN0s8avibMCayoy6qeSgcFRYz1awWcHWkmsL9wq3p21H8rXpEqcVryu2c6vWzz3VCyOLztSk0mW2McIo40ygY7LKMjkKxGR1RPFIyn6iir818E+IyxTXMpY4hljBxgj8qD/43a2X6YmXkiIJqH32/fcOqNuG4pbvfx35fvEYwk9w6ZT9K4fQ/yH6VllrP4CmDTi/KmvmDlxsQstj3nCNQArL1DIZeDuVb5qB5htomCv19rPPyT2kpKuxa9jbh86sZM9XeXd9ZW9/ngn6I/EN2jpy0BRbFzEAAAAJcEhZcwAACxIAAAsSAdLdfvwAAAAHdElNRQfnDAMCNRXcuDFGAAAF30lEQVR4Xu2a61NVVRjG+z9qnC7WlJeRFAwRiIuQXAxJFE1Cw3IYG5maLNMaECfAIBFDMmWsGEua8IalaBEXIQklpSY0FQqFuIMgSB9XPa+zVmtv9saz99Fz8pz14ffhPO/a79pn7fXsddsPjP09zhQKhTWUcRQKGyjjKBQ2UMZRKGygjKNQ2EAZxw2cafqZJa55jfUPDRnG/8+MjI2yPSVfso+KPzOMewv3vXGS173BHpzmp2HKjGfYzPkRLDFlHSuv+M7wOnfxRdkRcZ99g4OGZeziiraIf+lVyrsld4dGb2g6T/UsfTmVjY7f0sQ8EY80jp783cWG17qDon0l4r5cYRw9zrZFYNQSyqM3DkbRGQELWNzKNco49wO8s6xcm6bRu3p7Weqbmyk2ZaY/+721TRN3F64wzr1sCzPjeBseaxzwV28PxUDx/tIJcasU7NnHnvB9lkUvW8XqzzYZlrkT7jAOuFttYWac1vZrrKr+DDE8elMT80Q82jhdfX2is2BBC21wZFhoh745oSmfU1BE+pNzQ4SGRTw0/4g4Wi/wa/eXHaZ45JIk+v1cQhJNU6bOCaIpC+6r8fwFkYczmXFwb9k7dlFdD88KYL6hMezdrDzW3d+vKWeG1bbgXO/qYm9vyWZ+4bHsUZ/5VD/qxUjFy2CKx6+XyS38hOLy/+ro7hbXAUfyy88lbVMGW5z0CnvKP4xNnR3EXkheS2soOae78Vjj9N8YYm9lZImH8cvFS6TbNY7MIz4BojNz4xiBctU/NohcwMw4N2+N0QJevp4TEf8i3becxwirbQHaOzuZX1isiMkELIxnnT09VM6ucRzNLz8XIx73DWZX29tFXnfjFZsD8rTCGeOUfHWQDQzfoDcoj3PjPPZ0ICs7dpw6aW1DI5sTGk16WNxyURaYGQfTJ2jT54WzUzWnaau68nQ9m+YfTroj279W2wJszMwhHf8Z9aJ9sPuG/wN9a95OTXmzqZqZcRzNLz+XWYGRrO6ns9SWRytO0SgFfUP6+yKvu/FI4zw0fS4N89g6/br8W015u8bB9EIuy+HGwX3IeunhclFPy+UrQjczTvjiFaRt/3iv0ACmbtBjEldpdCOstgVGOazZUC63cLcm9l52HunoxLJuxThW8svPJSt/l6bspq3bSA99PlGjuxOPMQ46hlFcj13jLFqRoinLMTPOnx0doh68NbluZByMYujgXDcCUxWewwyrbdF27brIX9d4ThM7UVktYj0D/62xrBjHSn75ueg3L3huvABk3Z0o40ixu2mcGzdHRD18IwEYGQfrAK5Nxp12q6y2xbnmX0VueVQEWIyL2JWrQrdiHCv5HTGO/FzcjdcZR+7Q99I4shmw9uG6kXEwl+fah0XaqZoVrLaFPCrqt9crfqgRMXlKacU4VvIr47gYq50FYLsY1+zc+6lGf31z5oQHZNc4mJ5BB40XmoVuZBwwLzKONP2OGIwu/54Mq22BE35sRuAaszUIdsRknRsn44N8jW5kHCv5lXFcjB3j8GvwbRUO7LDG+L62jtYR+gfkqHGwS3Tg0FHKdeG3FhYUfbuDzQ6JYiP/LpJ5eTPj8NEOa53PS8soD7ayfYIXkpkcOXC10xaZuQV0Df778coq6sDyTpZ+BIxamkw6NjNKjxyjT22gGxkHOJpfGcfF2OksmHvj0xP+oPTYMY4RMMFB3XTQzDiYri2Iv72zpgf309xyUZPHCDttgYPR4JiECXUCnB/pv+DGSCOXudz2B+lmxnE0vzKOi7HTWQDOFPD2xJsP0wkcPuKQMGTRMha7fLUo56hx0On5lwPYgsVp98nq2gnlzYwDsLuUnrOdTtjx5QDOgtZvTGeXWls15cyw2xaoN2NbPk0X0R6YjmXlF5KZ9WV7BwdYyvoNdKKfsDpV6GbGAY7kV8bxMrhx8BGlUVzhmSjjOIkyjneijOMkyjjeiTKOkyjjeCfKOE7CjaP/GFLh2SjjOEnaO+nsZFWNYUzhuSjjKBSWGWf/AOPOGM+OJURaAAAAAElFTkSuQmCC") -bitmaps["SuperSmoothie"] := Gdip_BitmapFromBase64("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") -bitmaps["MarshmallowBee"] := Gdip_BitmapFromBase64("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") -bitmaps["Sprout"] := bitmaps["MagicBean"] := Gdip_BitmapFromBase64("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") -bitmaps["FestiveBean"] := Gdip_BitmapFromBase64("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") -bitmaps["CloudVial"] := Gdip_BitmapFromBase64("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") -bitmaps["NightBell"] := Gdip_BitmapFromBase64("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") -bitmaps["BoxOFrogs"] := Gdip_BitmapFromBase64("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") -bitmaps["AntPass"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAM4AAAAcCAYAAAAp6YDgAAABgmlDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhb9sFEUiFqYQsdhCrQxIFLGUKIqgIDGCV+HuxkQhu4bdiI2lYCtYeDRehY21tha2giB4gNjaWCnaSFj/2QgJQgQHhvl4M+8x8wa0w5xlezUDYDsFNzmS0KdnZvW6FyKE0YjTbVhefnxyOEXV8XlHSK23MZXF/0ZjetGzIKQLD1h5tyC8INy3Vsgr3hWOWktGWvhMuMuVCwo/KN0s8avibMCayoy6qeSgcFRYz1awWcHWkmsL9wq3p21H8rXpEqcVryu2c6vWzz3VCyOLztSk0mW2McIo40ygY7LKMjkKxGR1RPFIyn6iir818E+IyxTXMpY4hljBxgj8qD/43a2X6YmXkiIJqH32/fcOqNuG4pbvfx35fvEYwk9w6ZT9K4fQ/yH6VllrP4CmDTi/KmvmDlxsQstj3nCNQArL1DIZeDuVb5qB5htomCv19rPPyT2kpKuxa9jbh86sZM9XeXd9ZW9/ngn6I/EN2jpy0BRbFzEAAAAJcEhZcwAACxIAAAsSAdLdfvwAAAAHdElNRQfnDAMCNRM125RzAAAE8klEQVR4Xu2a7VNVVRTG+z8qe5+yUszkRUEFEgpBUVTAQVGBTDDxJUAFlZdBRCwoNMHQMcPUsaHUTErTcUYjU1TCARFQqAYMEuEC0scVa9HZnXPc93ru9lbOmfXhN8NZ69l7zmXWc/c6657HBv8cAoZh3IONwzAKsHEYRgE2DsMowMZhGAXYOP8zjsEB2LXvcyit2CvNM48mbByL7NxbCY+/7E0cqDoi1agwe+HbtGdOUYk0byY+ZbW4D41Rr/rCGP8QiElIgaPVJ6XrGM/CxrHI9OhFolBjk5ZLNSoEhM2hPR/GOGaKyyqkaxnPwcaxQGNLq6EwR43xg187O6Vad1E1TtzSVEO8s6sLlr2XKe6vqfWmIc94FjaOBYq2l1FBPjV2IrVF+Hf5p/ulWnfxlHGQjq7fKYdUVB405M5frIXktCzwDo6gz/F60HRYl7eFDKfXMdZg41hgSvhcKkYs2uglyfR3ROzi+3Q9jj5RuKnrs2HWgiQY7RcMz4+fDFHxS+HH2itCi+2UptVTtL3csKcZV8bp7O4W++DAQYvj6aMZ3ox/WBSt0+9z5nwNRMYlwovegXT/+BxW+cWX4Lg3qKSzI2ycB/DT1TpRZFXHq6kwtGtzO6Q3jowXJkyBlvZ20nraOH/03oX07M1in58brxvyGTkF4BsyEzYX74Dd+w/BwuRVQru1tEzoqk+fhSedmOzdjI1u6+wKG+cBbCx4n4phtG8Q3HU4oKvnDjz3WgDFtu3YZdDqjeMVEArnLlykgj5S/R08O86f4mmb8g1r/o3hgGyvO3290DfQL677h08Fv5BI0uMpqsW1/XEYgm1cQ3MLGQvvU/9FYVVnV9g4LsDiwmcBLJDVWbkinrQyg2JTI+YZ9Hrj4De7Prc+r5DiQTNjDHFPGOeJV3xEq3T46HHpOhxwJKSmkw6HB+MDw6jFwvXhMYuEbmVmDsUmBIXDN9+fof8BxgeG7gmNOzq7wsZxwelzP4jidMalunqh1xvH/HD+8Z59FMfC1cdVjYMmkeVltLb/AmOHT0Dt3szgqaFprzU1wUs+I4ZC0BiFH+2E7p4ew55WdXaFjeOCVZm5ojCckV1YLPRWjIPFpo//F8ZZm7uF1kwMjYTL9deo5Wy40QyT3ppNcb1xkBs3b8E7a9bB016TKI/4TJsBdQ2NSjo7wsZxQm+/g04HLAbZ6PnD8j2Uw29arT15VI0TGhVHa3AoYIjPWUBxs3E02js6qOV8ZtyIMfQtnYrOTrBxnIAP9FgESPOttvvy9debRB7Hshh7GONkb/3n5HKFknH+NkhJ2W5p3GwcfH9Of42fBXUIDjvc1dkRNo4TEocfpLEAgiNjpXlEa3XWbMijaxXjhM2Lp/gbs+bDwa+OQU3tZUPejIpxtDE1vs92tuYC/W7zyWcHxAmhNw6+h4enKI7dcYL42+3bkJKeRTqcJmpmsaqzK2wcCfqRc/4HpVINsqFgG2mwpcPWTsU4eNJoaxB8btDnzagYp7mtzdJwAIsfx+gyDVJQMjIptKqzM2wcCfofOV2dANiiabpj355SMg6aNGFFGr1dMHfxMkNOhopxEDTPirWbwGvym/SbUsT8JTT8iElcDpn5RUKHpsDnlcAZ0aTDUwrfgKj6+oRhP6s6u8LGYRgF2DgMowAbh2EUYOMwjAJsHIZRgI3DMAqwcRjGbYbgL/EfYygvX7MtAAAAAElFTkSuQmCC") -bitmaps["BrokenDrive"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAM4AAAAcCAYAAAAp6YDgAAABgWlDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhT83Bg8iFqYQsdhCrbRREUuJoggGJEbwKtzdHArZNewm2FgKtoKFR+NV2Fhra2ErCIIHiK2NlaKNyPrPRkgQIjgwzMebeY+ZN6Ad5Czbqx0C2ym4ibGYPjM7p9c9E6EWjTANhuXl41OjSaqOj1tq1HrTo7L432hKpT0LanThISvvFoQXhQdWC3nFO8JRa8lICZ8Kd7tyQeF7pZslflGcDVhTmVE3mRgWjgrr2Qo2K9hacm3hfuGOlO1IvjZT4pTiNcV2rmj93FO9MJJ2pqeULrOdMcaJM4mOSZFlchTokdURxSMh+7Eq/rbAPykuU1zLWOIYYQUbI/Cj/uB3t16mr7eUFIlB+Mn33zqhbgu+Nn3/89D3v44g9AgXTtm/cgCD76JvlrWOfWheh7PLsmZuw/kGtD7kDdcIpJBMLZOB1xP5pllouYbG+VJvP/sc30FSupq4gt096MpK9kKVd9dX9vbnmaA/Yt8LX3J9Lfn1awAAAAlwSFlzAAALEgAACxIB0t1+/AAAAAd0SU1FB+cMBAIFJM/3PzYAAAZ7SURBVHhe7Zr5V5VFGMf7PyrbN5dQA0NUBFEUyRAzOeaKmiEamiQGKpsLComU+5YLnqNFdcwyMtejuKCgSEdRBEEwFhGQRftxOt+pGWfeO++9lwvi9b3zw+ec+z7PM3Pvnff5zvK873Pt/zwiGo2mY2jhaDQuoIWj0biAFo5G4wJaOBqNC1hGOAFjJpDne/rY8Ia3P4mYOZdcKLyibNdV3K2rIynpWWTvDz8p/RprYXnhMF7p60dOnj2vbNtZ7jU2kje9h9Lv2bJ7nzLmaeMT9IHNmLzlE0DCp3xKcg4dVrZxxPmCy6TPoBHk48go0vbooTLGqniMcABiVG07S829e/w7niXhiHy+OJG0PmxXtjXjXEEh6e03nIRNmqmF86zChDM/IVmyI6lnzY/jCXKjrFzydwXPknDil6/htttVVfSa/fasrTulNhpzLC8ccPV6CU+OU+cu2PgBkgbbrdETppG8iwXKGDPMhPP9wV9J+votlPwrRVKb7kYlHAabWN7xHUYaWx7Y+IFqfMoq75ATeecoD9pabdpYGY8QTmHxXzyx8y8/LhKgaACb74gw0qP3+zwmO+dnHlNVU0PiklfRxHu17yAau2RlBqmpr+cxKuHs2HeA26bMWUBa2tt4PANJumrdBtrny15+xDswlPZd29AgxbB+YuKTyNjJs2iCv95/CBk3dTY9Z4h9mmFPOBgT9h2Hj53gdkfjs3HnHm6rrq2ltk27srmtuOQG74sx+bP51Iffb/yfjsbCnbC8cJD4EyLnUB9uSENTE/exxBBBEYHdrMq7d4nPMPXZwG9UOK2kIc4oHKw0L/6faOOnR5Gmlhb+nQycJyJmRPN2IiPCP+EzvygcFaga3qqstOnfiD3h4HzCihsZG7Zyu6PxUQkHEwomGNiS09fxvgDuRY8+vtSHMxWzOzsW7oRHFQe+Sk2T2oiJsefAj+T+g2Z6c5l/cUoa9b09IIAcOXWa3sBfcv8kr/UbTO2pGd/QOFE4mFFfencg/TwwOEwSqsj27P00ptfAINo34o6dziM9fYOo/dvtu2icKByvwcHkzIWLpKG5iRzMPcIT9MvEFTb9G7EnHMDGD6srszkaH5VwQNTCeGrrNzSEtAgFh03f7eXx+B/M7uxYuBMeIxxsDYxbB3ErItoBZkE2C6ev3yz5lq7KoHYkMq5F4YhghSutqJDaMoLGTqQxazdtk+zYrsAeGjGNXovCWZm5QYqNT11N7YEfRkh2FY6EEzxuEvXPi1vGbfbGB5gJ5/iZs9wubv3Yd+BeMRtwdizcCY9acbyGjJRuMEuMMRNnSH2B8jtVvN2Z/EuS7/djJ7mv7n6DjXAGh3zEPy9cmiq1BZi5X+g1QGpjBFswxIrCwcws9sMSF2ce0a7CkXDeCxxN/aoVRzU+wEw42Pr5jRxL7TNjFlFb0bXrPBYrD4vtyFi4E5YTTuyy5ZIdDycTVqTzm4CbzXz2EuNSUTFvc+1mqeTDgZz7Sm9JwvEPHU+TaGr0F/Qa27ab5bel9jg7sXh7oFLljHCwlRTtKuwJB4ULdvZABZDZXRUOyNy8ndpxJvq7vo4krcmk19he4prFdWQsxP6fNpYXDsCgs3OJszNqRXU1v2nG8nTu8VPcB2EaiwOIgfDYTLogIUVqjzMKi/96o7w9MdIdwjn0x1H+HaqqmivCgSCYGFFp6x8QQj9HxSZIcR0ZC3fCI4SDqhY7SIvnBHuJge0GDqvwm51xUHHDtUo4YPrchdSGVcf44BWFA/gmzY6R7M2tcgWuO4SDV2bgw5YPWydm74xwAFt18ftYnOq1J2fHwp2wvHBwBoGN3Ti8JsJ8jhIDL23Cjz02ZmIksVjNYjOkmXAKrj5edfAMhtlBWtZGaod/9/4cmrBIqr7+o2gCsVXuSQoHbw6IY7Nu8w6pTWeF89vR49wPcPYzxgBnx8Kd8KjigDF5HSUGBIEzi7EfgOcLrNRsJhwQOS+W2rFtKSkr43ZsUYaH/1dNMgIh4DCNuK4WjhnRi5bYvKvWWeGgFM2KDsCsrOzsWLgTlhcOtkmY6bK27JSeKQBHiQGwYiWtzqTbCaw06Gtl5np6s1mMPeHgrQW26ogP/QD6TkxbS5MapWskGWJEgT1J4WAlxQuaeGCratNZ4QBsjeHH/xOfARlxZizcCcsIR6PpTrRwNBoX0MLRaFxAC0ejcQEtHI3GBbRwNBoX0MLRaDrMI/IvlBkSdgsBZeYAAAAASUVORK5CYII=") -bitmaps["7ProngedCog"] := Gdip_BitmapFromBase64("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") -bitmaps["RoboPass"] := Gdip_BitmapFromBase64("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") -bitmaps["Translator"] := Gdip_BitmapFromBase64("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") -bitmaps["SpiritPetal"] := Gdip_BitmapFromBase64("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") -bitmaps["Present"] := Gdip_BitmapFromBase64("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") -bitmaps["Treat"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAM4AAAAcCAYAAAAp6YDgAAABgmlDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhb9sFEUiFqYQsdhCrQxIFLGUKIqgIDGCV+HuxkQhu4bdiI2lYCtYeDRehY21tha2giB4gNjaWCnaSFj/2QgJQgQHhvl4M+8x8wa0w5xlezUDYDsFNzmS0KdnZvW6FyKE0YjTbVhefnxyOEXV8XlHSK23MZXF/0ZjetGzIKQLD1h5tyC8INy3Vsgr3hWOWktGWvhMuMuVCwo/KN0s8avibMCayoy6qeSgcFRYz1awWcHWkmsL9wq3p21H8rXpEqcVryu2c6vWzz3VCyOLztSk0mW2McIo40ygY7LKMjkKxGR1RPFIyn6iir818E+IyxTXMpY4hljBxgj8qD/43a2X6YmXkiIJqH32/fcOqNuG4pbvfx35fvEYwk9w6ZT9K4fQ/yH6VllrP4CmDTi/KmvmDlxsQstj3nCNQArL1DIZeDuVb5qB5htomCv19rPPyT2kpKuxa9jbh86sZM9XeXd9ZW9/ngn6I/EN2jpy0BRbFzEAAAAJcEhZcwAACxIAAAsSAdLdfvwAAAAHdElNRQfnDAMCNRJC3KTlAAADW0lEQVR4Xu3a2UtUYRjH8f6PwhZaNRfMfculMbcytRQzM40iC8ULzVBwiXTQcsE0c4kyKwVboCAIgkTMIhSi0NLGtBBLx23U7PKJ9w0P8zon85zRE8Hv4nMx7/ucM3Pz5Zw5M+vmfy4QACiDcABUQDgAKiAcABUQDoAKCAc40/wc1TXdpaqGm7L7IEI4a8gnNIbW27ouKyUtU/ZYrUUlnuKfp6C0QnYfRAhnDf1P4Sx+VoSzMghHIw+ePJViMQx/kZ35lxCOMghHI0rDqay7Qdtd9lJYbBJ1vumWnfkbdlxqZi65BkbQRgdP2hMQRhcu6ml0bMxiFuEog3A0spJw4k6e4/seukiy2e0uzTe3PZRmJk0zVFxRzWc2OXqRS0A45RZdpm9Go3Cuj4ZB4RzmvEOjaXR8nM+V1zbIzpRevS6cD0QIRyNKwjG32clLimL2xzzFpZy1mGF0UUd5VObnO19QTO66g1RUXk2Nd1opMTVDmi+pquUzCEcdhKMRpeE0td6niZlp+jo6Ku03NLfwPTvPIHrW3kHGqSl63tFJth5BfH3po2R2/MzcrPSahceuVGw2NjlVmMWtmjIIRyNKb9Xk9oMOxfP9smv1wjq7dWPr4XFJwnrfJwOlpGfRLo9AsrH3IGf/UNrh6i87i3CUQTgaURLOgfgUiz129dhg5yadQ842Fz9pnr2Hg0+w7BzDHjqYnx/hKINwNGJtOMMjI9Lxy1m8Ncsu1PPXnsGR1PPuPU2ZTNTbP0BeIVF8HeFYB+FoxNpwjNNT0vFXasRbNTnB0Ql8lj0UENZjjvF1hGMdhKMRa8Nh2NWD7SecThfWp2dNwmtmMZCK2kbZ9T+Fk19SLqyDPISjkdUIR19Zw/fZd51bLW38e8+Ll6/IyS+Ex2T+Q2lWfhGftffWUXvXa/67Tf3te/zxNltfGk7okeN8nT2AaHn0mLq6e4R9ECEcjaxGOOx2bV/U7ydrS+1086e3vX3S7MDQkKKHA+xKY77fP/hZ2AcRwtHIaoTDfJ8wUp6+jFyDIvg/B9jfaNKy8+iDwWAxy+Jhe46++2mLkzdFxCdTRk4hf5+cS6XC7NjkBP/D6VZnXzp84oywB5YQDoAKCAdABYQDoALCAVAB4QCogHAAVEA4AIot0C8wO+BC12kKUAAAAABJRU5ErkJggg==") -bitmaps["StarTreat"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAM4AAAAcCAYAAAAp6YDgAAABgmlDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhb9sFEUiFqYQsdhCrQxIFLGUKIqgIDGCV+HuxkQhu4bdiI2lYCtYeDRehY21tha2giB4gNjaWCnaSFj/2QgJQgQHhvl4M+8x8wa0w5xlezUDYDsFNzmS0KdnZvW6FyKE0YjTbVhefnxyOEXV8XlHSK23MZXF/0ZjetGzIKQLD1h5tyC8INy3Vsgr3hWOWktGWvhMuMuVCwo/KN0s8avibMCayoy6qeSgcFRYz1awWcHWkmsL9wq3p21H8rXpEqcVryu2c6vWzz3VCyOLztSk0mW2McIo40ygY7LKMjkKxGR1RPFIyn6iir818E+IyxTXMpY4hljBxgj8qD/43a2X6YmXkiIJqH32/fcOqNuG4pbvfx35fvEYwk9w6ZT9K4fQ/yH6VllrP4CmDTi/KmvmDlxsQstj3nCNQArL1DIZeDuVb5qB5htomCv19rPPyT2kpKuxa9jbh86sZM9XeXd9ZW9/ngn6I/EN2jpy0BRbFzEAAAAJcEhZcwAACxIAAAsSAdLdfvwAAAAHdElNRQfnDAMCNRJC3KTlAAAE7UlEQVR4Xu2b+1NVVRTH+z8qe780FQ2Ul4oS6FXKEJUhMYPKpEayBpV0BrVEAhPUUATMJ4YTWo09pqYcjdTM0ckeWNo1tQTEi8AFpB9XfFeeM/vcc+71njND3HtZP3x+uGuvfTZ77/U9e+19Nnf0/tNHgiDYQ4QjCA4Q4QiCA0Q4guAAEY4gOECE4xBvbw9V795Hm2t3WpYL/xGp4yTCUdh34BNKzcim+6MSaGRCCs1bmE+Hvztu6Zs+/yW6c3gMrS6rsCwfSBJdGdx2IHIXF1jW/b8ZzHEaSEQ4tygurzQFH7hrxDjatqvO5K8FrwgnMIM5TgOJCKefU2d/YoFggtdXVlOrx0O/uy9y8MH+8huF5L3Za6gTKgFx8NMvdLG4L1+x9BlMRDgRzKrScp7cJ9OzDPYOr5d+/LXJYNMIFBDHTp2mvIKVFDMlje4ZFUdPTJ5OhW+VUEtbm8lXY2P1+/Rw9CSaPncB17fyscKucJy2o2KnfyKcCCa/sIgnd2ySi661eyx9NMqravVAVSl7bxuXY6Ua9vh4S58E1yxquX5df1bmC6+yPTZlpqHO3oaPdJ/bEYxwgmnnhreL1lVUss+9o+MpevIMWlm8nldf9VnB9u924xTuiHD6qdnzgT6xeHtiBfrs68PUdqPd5BtMQCxbvY7GpzzN+6btdftpft4S3a90c5XupwW0yn1R8aZgDYQd4aio7XT3p6GZua+YfEBK+rMsKvV5wfRPhDME6Orppjk5i0yT/MCYRCooWkvNbddMdQKlIO1dnfxM7TcCE29y+M/NydPtakDv3n+A6/3V0qKXB4Nd4Vi1U7u3nstGxCXTV0cbydPRQd80HqPhscls9z1KDrZ/QFK1CAebfwTQ1NnZdLdPKhI/LZ2uNDcb/AMFxLk/3JSbv5Qei51Cw0bGcgr4SEwS+8/IXKD7qSmUWt8OdlM1q/LkZ7K4fMPWGoMdqRvs6t8Mgu0fEOEMITydHfTlkW9p4euFPOngxdeWGXz8BQSCd1Riql7PF2zKNV8toJ/KyjU8ww52hGPVDlYP7UTRHw9FT9T97fQPiHCGKEUlG3jisQr93dqq2/0FxPI1JWyPS51JZ37+hU/mms5f4FXLN7BCQTiXr17V6wdCS83s9A+IcCIcbIDx9vW1Hzn+vR48jSd/0O3+AiJ11jy2Y9NssGdksz3UhIPVVav/7hZjqmaFnf4BEU6E0tnt5ZsBYya56M23S03l72zaqgcWPpRqdi0gcAKn+msBVFG13dIeasIBWD1QjitGqh1jo/4GdvoH/I1TuDPkhYOVJiY5jSdXm2CkLzhJq9pZxx/4YMdGWD1Jcs15ju3YWNd/fIhOnD7D9qWritmOu25HT5zk7xo47sbxL+yhKJySjVu4HHudXfUNvPJipY2aOI3FpH4otdM/4G+cwh1J1fppOPQ5T24gNtXsMNTRbhtonL/4J9svXLoUVocDAOkabk1oz1F5dFwSnW06p/va6R/wN07hjgjnFrijpk6wCq6X9PTdNPjj4yjusj04dgLNfn6RoQzBtXh5EY2eMJVvWqdl5dCSFWs4gFesLdP9QkU4ADcmcBCC1Rc3B/AhGH34ze02+QbbPxBonMIZEY4C/oUAk480BBONNGPPhwdNohEEEY4gOECEIwgOEOEIggNEOILgABGOIDhAhCMItumjfwEVb7mPgdjYigAAAABJRU5ErkJggg==") -bitmaps["AtomicTreat"] := Gdip_BitmapFromBase64("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") -bitmaps["SunflowerSeed"] := Gdip_BitmapFromBase64("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") -bitmaps["Strawberry"] := Gdip_BitmapFromBase64("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") -bitmaps["Pineapple"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAM4AAAAcCAYAAAAp6YDgAAABgmlDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhb9sFEUiFqYQsdhCrQxIFLGUKIqgIDGCV+HuxkQhu4bdiI2lYCtYeDRehY21tha2giB4gNjaWCnaSFj/2QgJQgQHhvl4M+8x8wa0w5xlezUDYDsFNzmS0KdnZvW6FyKE0YjTbVhefnxyOEXV8XlHSK23MZXF/0ZjetGzIKQLD1h5tyC8INy3Vsgr3hWOWktGWvhMuMuVCwo/KN0s8avibMCayoy6qeSgcFRYz1awWcHWkmsL9wq3p21H8rXpEqcVryu2c6vWzz3VCyOLztSk0mW2McIo40ygY7LKMjkKxGR1RPFIyn6iir818E+IyxTXMpY4hljBxgj8qD/43a2X6YmXkiIJqH32/fcOqNuG4pbvfx35fvEYwk9w6ZT9K4fQ/yH6VllrP4CmDTi/KmvmDlxsQstj3nCNQArL1DIZeDuVb5qB5htomCv19rPPyT2kpKuxa9jbh86sZM9XeXd9ZW9/ngn6I/EN2jpy0BRbFzEAAAAJcEhZcwAACxIAAAsSAdLdfvwAAAAHdElNRQfnDAMCNRHb1fVfAAAE00lEQVR4Xu2a+08UVxTH+3/YaGvVtr5ABeUhloegIhHBVmpBG9QasSmx8Y0JKhGpT6yRkopNa7VixFpp66tpFC0FMSi+wFa3gQYVYeWxCPjj6Zyj92Znucsyk2w3M5wfPj/sud97s3dzPzt37sxrPS/6gGEYY7A4DGMCFodhTMDiMIwJWByGMQGLw5iiqvYGpC37FJwdHcp2u8PiaCxZ9TkMGxuqY/j4aTAhMh7Slq6C8vO/9etTXXuT2j/IXAnP+3r7tduZY2U/yd+prb1dmbE7LI6GShxP9hWX6PrgP+74iJmQnL5syIlT9M0R+buwOEMYIU76imxd/UlrK6xck0NtwyeEwV+Of3TtQxUWh8UhvImDPG59KhdJydFSWXc0/QuXKquIrufduj7+ovJ6LWSt3QyhsUkwYmI4TIlJhI15BSS4Ku8vWBwWhxhInCdtbXKRfH3kB1l3XzzNLS1Ua3d1yVr2pi0wP2M5vBsWC6MmR0HqkhV0XyT6C7DPjsKDEBafDG8ERUBIzFzYnL8bWpxOXQ6vdnjfJcZ3J3JOKn1PkU1YkEH1We9n0FZy1JQo2lbiPGtu1unGNZMfSJzBzsfqsDga3sRxdnbAui35cpHcbrgv23yJo2J0yAx42NQkx+ju7aHDB1U2PuUjGk9kkfVbd8C0+HmQv+8gHD52AhZnrZb5nQeKZU6IoOLN4Ai4/Ge1blyjeW/iGJ2PlWFxNIQ4A7F1V6Gujy9xgqYnwB/XrpN8Z85fhJHBkVRfm7tdjoFbP6yNC4+DixVX6Wj396uVMDYsjuoHSr6VWeRZV6duW4gLFf/ZMbswM0vWhQhvTZoOZT+fpe9wpbqGtnZYj03+UGbN5L2JY3Q+VobF0VCJ8/q4qbTNSln8CZws/7VfH1/i4FXBPb8p7wuqx8xLk7W4+YuotverQ7osbnWwPjftY1294aEDlmavo++FhxWTo+fA26HR/bJCBJyXe//S0+VUR+r/fmA6700co/OxMiyOhhAHJVG1q/AljvtBgnseFz1+xqsHyinyKnBrJ/rjYcRE7SqmyiGJC32L09jcLPN4FTSbV4ljdD5Wh8XR+D/FeWdqNH1uevRIZgdCbM02bCugz+EJyXDjzl3ocLnoKhAxO4XqgxGns9slxz1adtp0XiWO0flYHRZHIxDi4H2EyO4p0m9tVCSkplMWDwV09VeLfjDiuC9uvJcxm1eJY3Q+VofF0QiEOAhePbDmeZqH//TunxGxuAuLDyvrgxEHt1tYR2rqbpnOq8RBjMzH6rA4GoESp2B/EdXw3uC70jK6T8Cj3+AZs2nx4QNPkRXH4vh+XEXVNXpuc+j743RcjHWVOHhKdvzHMzRu3b16iEpcQHU8VHD19pjOexPHyHysDoujEShxcHszM+XlSZQnmLtV3yCzDxobDR8OqMBFfeqXczJrJu9NHCPzsTosjkagxEGePnNCbsFeCI1Loift+Ozksw25cN/h0OUQlAfbgqJm0XOhpEWZsDpnG73en7N9l8wJEXARizcBxoS8R28vXLh8RTemmbw3cRAj87EyLI4NESLgC6qqdk+M5hkWx5awOP6HxbEhLI7/YXFsCIvjf1gcGyJEyNv9pbLdE6N5hsWxJdkbc+HCpQplmwqjeYbFYRgT9MF/lQU4ipgvcyUAAAAASUVORK5CYII=") -bitmaps["Blueberry"] := Gdip_BitmapFromBase64("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") -bitmaps["Bitterberry"] := Gdip_BitmapFromBase64("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") -bitmaps["Neonberry"] := Gdip_BitmapFromBase64("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") -bitmaps["MoonCharm"] := Gdip_BitmapFromBase64("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") -bitmaps["GingerbreadBear"] := Gdip_BitmapFromBase64("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") -bitmaps["AgedGingerbreadBear"] := Gdip_BitmapFromBase64("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") -bitmaps["WhiteDrive"] := Gdip_BitmapFromBase64("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") -bitmaps["RedDrive"] := Gdip_BitmapFromBase64("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") -bitmaps["BlueDrive"] := Gdip_BitmapFromBase64("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") -bitmaps["GlitchedDrive"] := Gdip_BitmapFromBase64("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") -bitmaps["ComfortingVial"] := Gdip_BitmapFromBase64("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") -bitmaps["InvigoratingVial"] := Gdip_BitmapFromBase64("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") -bitmaps["MotivatingVial"] := Gdip_BitmapFromBase64("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") -bitmaps["RefreshingVial"] := Gdip_BitmapFromBase64("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") -bitmaps["SatisfyingVial"] := Gdip_BitmapFromBase64("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") -bitmaps["PinkBalloon"] := Gdip_BitmapFromBase64("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") -bitmaps["RedBalloon"] := Gdip_BitmapFromBase64("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") -bitmaps["WhiteBalloon"] := Gdip_BitmapFromBase64("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") -bitmaps["BlackBalloon"] := Gdip_BitmapFromBase64("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") -bitmaps["SoftWax"] := Gdip_BitmapFromBase64("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") -bitmaps["HardWax"] := Gdip_BitmapFromBase64("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") -bitmaps["CausticWax"] := Gdip_BitmapFromBase64("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") -bitmaps["SwirledWax"] := Gdip_BitmapFromBase64("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") -bitmaps["Turpentine"] := Gdip_BitmapFromBase64("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") -bitmaps["PaperPlanter"] := Gdip_BitmapFromBase64("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") -bitmaps["TicketPlanter"] := Gdip_BitmapFromBase64("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") -bitmaps["FestivePlanter"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAM4AAAAcCAYAAAAp6YDgAAABgmlDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhb9sFEUiFqYQsdhCrQxIFLGUKIqgIDGCV+HuxkQhu4bdiI2lYCtYeDRehY21tha2giB4gNjaWCnaSFj/2QgJQgQHhvl4M+8x8wa0w5xlezUDYDsFNzmS0KdnZvW6FyKE0YjTbVhefnxyOEXV8XlHSK23MZXF/0ZjetGzIKQLD1h5tyC8INy3Vsgr3hWOWktGWvhMuMuVCwo/KN0s8avibMCayoy6qeSgcFRYz1awWcHWkmsL9wq3p21H8rXpEqcVryu2c6vWzz3VCyOLztSk0mW2McIo40ygY7LKMjkKxGR1RPFIyn6iir818E+IyxTXMpY4hljBxgj8qD/43a2X6YmXkiIJqH32/fcOqNuG4pbvfx35fvEYwk9w6ZT9K4fQ/yH6VllrP4CmDTi/KmvmDlxsQstj3nCNQArL1DIZeDuVb5qB5htomCv19rPPyT2kpKuxa9jbh86sZM9XeXd9ZW9/ngn6I/EN2jpy0BRbFzEAAAAJcEhZcwAACxIAAAsSAdLdfvwAAAAHdElNRQfnDAMCNQpRsDyzAAAGY0lEQVR4Xu2a+3NNVxTH+3+01ffLmyYk8RYJ8YpQMsSjkpbQepTEI0YSipDWo0qUUPWomKqi1Wa0aMZ7DJ2WQRCVtoTIgxD642q+S/eefe495967T46Mm9k/fGZy117n3HXXWd+9194nz9T/+4gMBoMeRjgGgwuMcAwGFxjhGAwuMMIxGFxghBMidfUPaP2Wr2l14Wbb8XDmxJmzlJz2AVXV1tqOe01zyOVTL5yuCcPo2ZaRAcFDt7vWS5LGvM/flZu/0mI/eeY3atMljoaPT6cHjx5axpqasZM/8stNi9adOb7k1Mm0r/hnv2u279ojfe/U1PiNPwmcchlOGOGEiIjD92Fjtm4d04cSU9KeSuH4smJdoeWatZu2yLGmEo5TLsOJsBHOzPkf2443FeHwsIVwUiZMtdgrKispfWYWj7VoE0WlZdfkmBGOO4xwQsTpYZeV/0WHj51g7j24bxlrapyEA25W3uYxULitSNoDCefY6TM0KWMeRfYeSC+0jaa3e/WnOQvzWIiqny5eC2fV+k30ekQP6j9iHMds5+M1zVI4NXX3aMnKNRQVl0gvtouhiF4DaN7iT+hWVZWfLwoebdYbkT3praje3H9v2/Ud1T2s53G0NqKwVPI//4LH1cL759YtthVs3iZt5y6Vyu8SjJ44jcde7djNEpNO3HYEEk7FnTsyJmzMhd1JOFiVsD8SYypdEoby/eCHmIV96twcGjL6Pc4jftvQsRN4DyjuGSyX4n6h5ADtOa6Fnxonnp3q96RodsK531Dw2AiLRKrEJY3iByN8iw+V0PMOxfHhrPns40Y4mJFfbt+Fbb6z6t8VFdwuYWzK7Gxp14nbCSfhVN2tpcycxfJ+f1y8JMcCrTizcpdQ57jBtHjFGtq4fSeNmTRd+i5bvY59VOHY8VpEd7paXs6+wXKpkwMhHJWX2seEPMk0lrA+HBCFqoI2BGOtomPpQMkRPmI9eOQYtYyKZbt6BCoKDUs8iv3ClatcEPhOdR8AnNoLO+GA9Blz2dahR4JcvUDBl1ul/9FTp6VdJ24nxO8JRKD4fYVTfe+upf1EYWOGh++I8ZPYpgqnXdd4/k0Q6t7iA3LyyMheJO8BnHKpkwNVOFt2fsuxYlJS7/ckaXbCiR0ykseWF2yw2LH8wz4geZy0TcvKZRvagR8PHubCgN3udExXOIeOHpd23FvY44emsK3noBHSBnTidsJOOM+16iRb0G/27fe7JpBwLl4to9SpmXw9VsmOPRO4pYWviEcVDlYm9fq5C5eyvdfgZIvdKZc6OVBbNdW3qWhWrRpmHRQK/J1A6yD8z5eW0pudHhcCgICWflbgV0BAVzgQX0zfIWxPayg+2H6/cFH6YuURvrpxOyGEA5HYjdvhJBwcerRtWEHEmC9YpeGnCkc9dADi3hCearfLpW4OhHAGjUyVtqakWQmn/MYNS6KdUNuPy9f+pIkz5vBGVIx36jOIi1y9t65wgOjp0XvjVCtn2Qr+jBYGn4Wfm7jt8FI4sxfksS06PpHOnjtPtXV1dOHyFYrpl8R2HeFgclLtdrnUzYERThB0hIPeWiT407XW5T4Y5TdvcquBIsf1vq2RG+GgGMRBAE7a0Orgb7xTUf0aE7eKl8IRLSUOBVT/+GGj2e61cHRzYIQTBB3hAMyQ8Pc9Wbp7v87yWYD/m1I/iw0qwMMUdhEHVg3VP5BwgChmtSX89fhJPz/duO3wVDj/C2Tluo0Wfy+F45tLnRwY4QRBVzh5q9ayP/rlr4p2ce+MQm3fvR8/EPUF2Y7de3lfg7P/yppqLvzJmfP4+lc6dLWIKmH4WLZjA1u053v+VxvYgwln/y+H5DjA7/H1ATpxO+GlcMTxNf7PreTEKX5vs2HrDrkiN0Y4TrnUyYERThB0hYNVok/S49MZX/AAxd4FRY7jUzs/gJMc9b5ifyLA3gj2YMLBUTTeuAsfp2PlUOMOhJfCuXL9umeHA77CccqlTg6McIKgKxxwu7qKsvOWU2TsQN70o3DxsvFSWZnFD4WOfQ2OhrFhx+yKN9+7f/jJ4gewIqVOyeA34u+8my7twYQD8B0YRyyB3jWEGrcTXgoHQDz4/nbd+nJ+Bo4cT9OzFnDRZi3KZx83wnHKJQg1B0Y4BkMYYoRjMLjACMdgcIERjsHgAiMcg8EFRjgGgwuMcAwGbR7Rf6SEa29HxquJAAAAAElFTkSuQmCC") -bitmaps["PlasticPlanter"] := Gdip_BitmapFromBase64("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") -bitmaps["CandyPlanter"] := Gdip_BitmapFromBase64("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") -bitmaps["RedClayPlanter"] := Gdip_BitmapFromBase64("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") -bitmaps["BlueClayPlanter"] := Gdip_BitmapFromBase64("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") -bitmaps["TackyPlanter"] := Gdip_BitmapFromBase64("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") -bitmaps["PesticidePlanter"] := Gdip_BitmapFromBase64("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") -bitmaps["HeatTreatedPlanter"] := Gdip_BitmapFromBase64("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") -bitmaps["HydroponicPlanter"] := Gdip_BitmapFromBase64("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") -bitmaps["PetalPlanter"] := Gdip_BitmapFromBase64("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") -bitmaps["ThePlanterOfPlenty"] := Gdip_BitmapFromBase64("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") -bitmaps["BasicEgg"] := Gdip_BitmapFromBase64("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") -bitmaps["SilverEgg"] := Gdip_BitmapFromBase64("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") -bitmaps["GoldEgg"] := Gdip_BitmapFromBase64("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") -bitmaps["DiamondEgg"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAM4AAAAcCAYAAAAp6YDgAAABgmlDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhb9sFEUiFqYQsdhCrQxIFLGUKIqgIDGCV+HuxkQhu4bdiI2lYCtYeDRehY21tha2giB4gNjaWCnaSFj/2QgJQgQHhvl4M+8x8wa0w5xlezUDYDsFNzmS0KdnZvW6FyKE0YjTbVhefnxyOEXV8XlHSK23MZXF/0ZjetGzIKQLD1h5tyC8INy3Vsgr3hWOWktGWvhMuMuVCwo/KN0s8avibMCayoy6qeSgcFRYz1awWcHWkmsL9wq3p21H8rXpEqcVryu2c6vWzz3VCyOLztSk0mW2McIo40ygY7LKMjkKxGR1RPFIyn6iir818E+IyxTXMpY4hljBxgj8qD/43a2X6YmXkiIJqH32/fcOqNuG4pbvfx35fvEYwk9w6ZT9K4fQ/yH6VllrP4CmDTi/KmvmDlxsQstj3nCNQArL1DIZeDuVb5qB5htomCv19rPPyT2kpKuxa9jbh86sZM9XeXd9ZW9/ngn6I/EN2jpy0BRbFzEAAAAJcEhZcwAACxIAAAsSAdLdfvwAAAAHdElNRQfnDAMCNQcvAUAOAAAGEklEQVR4Xu2a61dVRRiH+z9a2f1m3jJRRDRUUFGUQINUNFBzgZpKKCqkgooXSCXwrujKCrWWS9OECO+agrfMkhQ1boqAgh5R+/jmb2qm2cd9WMxpn81qMx+eD+edd8/M2Wc/Z8+8ez/z8M/HpNFo1NDiaDReoMXRaLxAi6PReIEWR6PxAi1OO+Xu/XuUmbuedu3db9quaRlHiOM3MIye7ehn4HW/IIoY9xF9u++A6TGnz12gzn1C6P24eGp+/Mg0x6k0uVzUo/8wdp627fjGNEcmMHTkU+fXnWOnS02PdSqOFUfm4zkL6MGjh4ZjTp07T50Cgil87MR2J05DY6M4N1oc73CUOPMWrxCxP6qr2Wf+w2ZvzDMc057xVpyk+YtN29sjjhWHM2lGMmt7038ANbrui/j1yio6fPIU437zA8MxJ8+co4RZqeQ3IIye79Kb3uk/lOYuWka19fWGvMqbN2nluk00Kjae3dW69RtCL3XrQ4NHxdD3xYeo5vZtSkxNpy6Bg1g87INYKj52wtBHW6DF+e84XpzSCz+Li+TAwcMivjbvCxHHBc7jV67foA6deok2mT6hkVTb0CByx09JNM0Dzz3pA+KZxXfueXpDXl1bS8lpS9l3gWT+IeGUmpFlkBXi836mz1tI78VMYn8Ir3TvS5HjJ7N9m9wncD1Zoq7bup2CI0bTy28HUte+g2lGSprox1fiqI5rxTztxPHiYP/yWo93WXvWmo0i7kkcgAu4V8gIyli1hrZ8tZPGJcwUuSty1os8WZxpyfPpVn0dHfnpNNs78XjP4OF0/tKvVHXrFsVNS2KxV3v0Y6LwfnDnMpMMBAyJoJt1dSxPFscM9HutslL0CzAvs1yOr8RRHdeKedqJ48UBQcOjWDuE4LGWxEGpVl6+obCAOwByo+ISRJyLgwtWXgbmbN4m+t6a/+8PXt94l17sFvBUfE76MhZ7o2cQFR09zvr6rvBH9s+L+KKsz1meLE7XJ8u/EyVn6M69JtpbWMTuUojPWrBE9Hu8pFTk48LEvg9MmZ0q4irimOF+7oDquFbN007ahTiDIseKH4XHWhKn7Np1mjB9NlsGdejsT92DQll5G7nDoj8UeVwcXFjy8biQed+Fh44a2vhcl6zMYZ8hJb8j4rmKnPvp0iwWhyT4LIuDu6GcO2/RchbvPyJaxFKWZLIY7oD3HrhEHHc43o8vxFEd16p52km7EAebe7S35o6DogE287zNnaFR1oiTlrmafb5RVS1yT5SeNeQWHDwi2uru3jGIs/nLHYZc/n0gO49FT5jCYlhqyrneitPapZrquFbN004cL47rYTO7a6A9M3eDiHsShy+beg8KZ3sTPCy8fLWc7TUQt1qcsxcviVyMI+disy/ayq+1Shws93gMc0UMhQQ519fiqI5r1TztxPHi7PuhWJz81lTV+LIORQEeY/GRMSxutTgVNTUiF2VwORfH8jaUkFXFwZsTiMVO/cSQ62txVMe1ap524nhx8EoN2rCEwaafxz2K848gq9dvETE5brU4qPq91Xsgi3na46Dihs+q4vByLvZo8psTvhZHdVyr5mknjhUHVRn80PzEu4vgSZzZCzNYDO+xHT1Vwp7bbNqeL6phVosD0jOzWQzVOdwVIQj64JWyz9ZuYnmq4sjzWLBsJXsmhD3c5MS5Iu4LcVTHtWqeduIocTyBsqb8TwY8iVNeUWFrcQBAzn7DRoljZEIixtCdpiaWpyoO7mYon/NjzFARpyWiJ04V+arjWjVPO3GsOPj3xgucnl6b9yQOgDx4hQZPr9mrMqPjaGZKOrs4UDrleVaJA1A1W7h8FStKYEz0mbEqlz2n4Tmq4gAsT1G6RnHjha4BrLSNpRH+AAD2gHK+GariALNx45NSRL67CKr5bY0jxNH8P/il7Hchwp6CItMcGdV8O9HiaGwje0OeEOHi5TLTHBnVfDvR4mhs4bcrV6mj/9/VQ7y/h5c6zfI4qvl2o8XR+Jzd+wtEyR2478/cUc1vC7Q4Gp+T9/UuIYH8EqonVPPbAi2OxuegGoiXY/N372WlZ7McGdX8tkCLo9Eo85j+AteOnyWfWydOAAAAAElFTkSuQmCC") -bitmaps["MythicEgg"] := Gdip_BitmapFromBase64("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") -bitmaps["StarEgg"] := Gdip_BitmapFromBase64("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") -bitmaps["GiftedSilverEgg"] := Gdip_BitmapFromBase64("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") -bitmaps["GiftedGoldEgg"] := Gdip_BitmapFromBase64("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") -bitmaps["GiftedDiamondEgg"] := Gdip_BitmapFromBase64("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") -bitmaps["GiftedMythicEgg"] := Gdip_BitmapFromBase64("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") -bitmaps["RoyalJelly"] := Gdip_BitmapFromBase64("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") -bitmaps["StarJelly"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAM4AAAAcCAYAAAAp6YDgAAABgmlDQ1BJQ0MgcHJvZmlsZQAAKM+VkTlIA0EYhb9sFEUiFqYQsdhCrQxIFLGUKIqgIDGCV+HuxkQhu4bdiI2lYCtYeDRehY21tha2giB4gNjaWCnaSFj/2QgJQgQHhvl4M+8x8wa0w5xlezUDYDsFNzmS0KdnZvW6FyKE0YjTbVhefnxyOEXV8XlHSK23MZXF/0ZjetGzIKQLD1h5tyC8INy3Vsgr3hWOWktGWvhMuMuVCwo/KN0s8avibMCayoy6qeSgcFRYz1awWcHWkmsL9wq3p21H8rXpEqcVryu2c6vWzz3VCyOLztSk0mW2McIo40ygY7LKMjkKxGR1RPFIyn6iir818E+IyxTXMpY4hljBxgj8qD/43a2X6YmXkiIJqH32/fcOqNuG4pbvfx35fvEYwk9w6ZT9K4fQ/yH6VllrP4CmDTi/KmvmDlxsQstj3nCNQArL1DIZeDuVb5qB5htomCv19rPPyT2kpKuxa9jbh86sZM9XeXd9ZW9/ngn6I/EN2jpy0BRbFzEAAAAJcEhZcwAACxIAAAsSAdLdfvwAAAAHdElNRQfnDAMCNQXBDyEiAAAGHUlEQVR4Xu2b6VMURxjG838kMZc5vC9QLkFEEISEoKBFgCgYFWOJR6GiVoEYFcEIaEDAI4JipIKGlCaURi0IeBAKE49wqKhoBOSUQ83HNzxd252ZnVlglzUphv7wq2Kefnt21+ln+u2329ee//2SJBKJdUjjSCQ2II0jkdiANI5EYgPSOBKJDUjjDIHu572Uk3eC9h86qts+nLladZ0WLV1FbZ2dg9JHGtI4Zpw49SP5LAindye70gRXbwpbHkOXyq/oxgZFLKPXxzrStpQ03fb/i9Nni9n3Ardq63Rj+iO/sEj0b+3oGFAfiUjjKNiZmiEGhpI3xk2n7Nx8Tbyb3wLWbjTjZB7JE/2VBrGkj0SkcUxU3rjJDIJBsScjh5rb2qiu/j5FrY5l+or1cdT94rmqjzSOtu9IQRrHREJyKhsQc4JCVXpndzf98We1SuP0Z5zLlVW0MnYrOc4OoLcmOtM0z3kUtz2JmlpaNLGc9Jwj9IGDB81buJj114sZDNI4rx5pHBMxcfFsQEyd5UdP29t0YzipWYfEAFKS8k02a8dMNWr8DN0YV7/51NTaKu6FhTZ0J+9AVZ/jhT+IGGuxZJyO7i7alZbBPuvtSS7k4OlPW3fuYbOrsr81xsFv5trNmloRy8FLh7dvSNipaR+uSOOYOHjsO/GAMTtgBvrpwiVq6WjXxA5kHLBx2y6a4f0JWzcdzi+giJVrRVzy/iwRx42j5J3JLprBbA16xunpSzMXRX2p+hyOd9BnzFS8vzXGudfQQG+aDB+ftFfEcqDxPkiHzduHK9I4Jrp6eygkMlo8ZM57U9woNn4HNbY81fTpL1Vr73rG7smvMXDxpkf8wsiVQlcaJ6/gFOv3uKlJtNuCnnEOHT/Jrsc5e9H50jJWTr5YdpnGOnkxXVlSt8Y4AL8H2kQ3H9Vvxppwsrsva0OlkutGQBpHAR40Btjc4HDxFuW4+AbRo8ZGVXx/xqm5V09RMRtojNNsGjXBiaWAHzrOYvH+ixaLOGWqpuw/FPSM4/VpKLvee+CgKhapm/l3stY4BUVnhV5UfF7oxRdLhI5/V64bAWkcC7Q966RzJb/S8nVx4uF/sWajKsaSceobHrG3L+9nDhb/PJYb5+PQKNU9hoK5cTCL8YqhJd53cBf9rTUO0rwxMzyZHr5ijdCXrd3EtNFTZw64bhxuSOMMAp6nYxb6q7lZ6JaMsykxienOPoF0/dZtVpmrvnOXzVrQ/0vj3K6ro4YnT8R1f/A0y1rjAKSz0FHgePD4MSuAYBMZ2upN8apYIyCNowBvTrydzfWSK9fEgCmr+E3olozjMz+M6SgKqPS+PB+6vYyDwYnZzVxHRQ73BBjEmD359deZ6lRND1uMg6M4vA3pIH47vy6vqFTFGgFpnD6e9XSzkwFTPPxo81fJmvbd+w6IQaCsDHHjoAKnjOcGScs6rKsP1ThYi63bmshSoMCwpZqN2bVbEtk9x7vMod6XL5iG2Q8ajhApY/HbldfAFuMAj4AQ1oaZFWsm/O3uH6yJMwLSOH1gpnH0ChCDAkZAeoNKWtbRfLaBCR0LfWXVyC/kc6Zj4X2y6Ax760LHfgV0nHUrvVrBZgaUu1Fmhm6PGWfz9t2sH1iyaj1LyfA5WISjGAE9Yfe/hk5Kz2Qa1jq5JwvZzIqZFFUvmEm54WqrcfYd/Fa0czIO52rijIA0jonCMz9rHro5GBjKPvy0AefO/QdMv/vw4SsvDsDsqNqZ35vjGxLBUjQej79xKkIv9qPps+hGdY2ItdU4DY2NwrQAm6zKNaGRkMZRgDNq/KGbg+MzPO3hYHMUZ9mQMgUviVa1wTxYFE+aOZctkgNCI1kKBaNs2ZEi4oayxsH3QSEA+yiYOTCjIX1Eaqk0DQeVLRQ6MLtiUGOjF9+xtr5eFWercUBE9BoRg6qaXowRkMYxA/+FAIMZaRYMgXTs2PenNaaR6JOefUQY55fSct0YIyCNI7ErOL4D0+C4kZFfNtI4Ertxrep3Mdsg7dWLMQrSOBK7wcvgfBNUL8YoSONI7AIKJaOnzWTGQYFAL8ZISONI7AI/fQ3OnLugG2MkpHEkEqt5Sf8ATdfBQPJSMtUAAAAASUVORK5CYII=") -bitmaps["BumbleBeeEgg"] := Gdip_BitmapFromBase64("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") -bitmaps["BumbleBeeJelly"] := Gdip_BitmapFromBase64("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") -bitmaps["RageBeeJelly"] := Gdip_BitmapFromBase64("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") -bitmaps["ShockedBeeJelly"] := Gdip_BitmapFromBase64("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") diff --git a/nm_image_assets/inventory/bitterberry.png b/nm_image_assets/inventory/bitterberry.png deleted file mode 100644 index a365e45..0000000 Binary files a/nm_image_assets/inventory/bitterberry.png and /dev/null differ diff --git a/nm_image_assets/inventory/blueberry.png b/nm_image_assets/inventory/blueberry.png deleted file mode 100644 index 9746096..0000000 Binary files a/nm_image_assets/inventory/blueberry.png and /dev/null differ diff --git a/nm_image_assets/inventory/glitter.png b/nm_image_assets/inventory/glitter.png deleted file mode 100644 index 1ad9cfc..0000000 Binary files a/nm_image_assets/inventory/glitter.png and /dev/null differ diff --git a/nm_image_assets/inventory/gumdrops.png b/nm_image_assets/inventory/gumdrops.png deleted file mode 100644 index bf43acf..0000000 Binary files a/nm_image_assets/inventory/gumdrops.png and /dev/null differ diff --git a/nm_image_assets/inventory/item.png b/nm_image_assets/inventory/item.png deleted file mode 100644 index 9374a3b..0000000 Binary files a/nm_image_assets/inventory/item.png and /dev/null differ diff --git a/nm_image_assets/inventory/royaljelly.png b/nm_image_assets/inventory/royaljelly.png deleted file mode 100644 index 2e308f4..0000000 Binary files a/nm_image_assets/inventory/royaljelly.png and /dev/null differ diff --git a/nm_image_assets/inventory/strawberry.png b/nm_image_assets/inventory/strawberry.png deleted file mode 100644 index a1be875..0000000 Binary files a/nm_image_assets/inventory/strawberry.png and /dev/null differ diff --git a/nm_image_assets/offset/bitmaps.ahk b/nm_image_assets/offset/bitmaps.ahk deleted file mode 100644 index 1d40d89..0000000 --- a/nm_image_assets/offset/bitmaps.ahk +++ /dev/null @@ -1,2 +0,0 @@ -bitmaps["toppollen"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAACkAAAAKBAMAAADbdmpdAAAAFVBMVEUAAAASFRcTFhgUFxkUFxgWGRsXGht4cWVYAAAAAXRSTlMAQObYZgAAABd0RVh0U29mdHdhcmUAUGhvdG9EZW1vbiA5LjDNHNgxAAADWGlUWHRYTUw6Y29tLmFkb2JlLnhtcAAAAAAAPD94cGFja2V0IGJlZ2luPSfvu78nIGlkPSdXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQnPz4KPHg6eG1wbWV0YSB4bWxuczp4PSdhZG9iZTpuczptZXRhLycgeDp4bXB0az0nSW1hZ2U6OkV4aWZUb29sIDEyLjQ0Jz4KPHJkZjpSREYgeG1sbnM6cmRmPSdodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjJz4KCiA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0nJwogIHhtbG5zOmV4aWY9J2h0dHA6Ly9ucy5hZG9iZS5jb20vZXhpZi8xLjAvJz4KICA8ZXhpZjpQaXhlbFhEaW1lbnNpb24+NDE8L2V4aWY6UGl4ZWxYRGltZW5zaW9uPgogIDxleGlmOlBpeGVsWURpbWVuc2lvbj4xMDwvZXhpZjpQaXhlbFlEaW1lbnNpb24+CiA8L3JkZjpEZXNjcmlwdGlvbj4KCiA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0nJwogIHhtbG5zOnRpZmY9J2h0dHA6Ly9ucy5hZG9iZS5jb20vdGlmZi8xLjAvJz4KICA8dGlmZjpJbWFnZUxlbmd0aD4xMDwvdGlmZjpJbWFnZUxlbmd0aD4KICA8dGlmZjpJbWFnZVdpZHRoPjQxPC90aWZmOkltYWdlV2lkdGg+CiAgPHRpZmY6T3JpZW50YXRpb24+MTwvdGlmZjpPcmllbnRhdGlvbj4KICA8dGlmZjpSZXNvbHV0aW9uVW5pdD4yPC90aWZmOlJlc29sdXRpb25Vbml0PgogIDx0aWZmOlNvZnR3YXJlPlBob3RvRGVtb24gOS4wPC90aWZmOlNvZnR3YXJlPgogIDx0aWZmOlhSZXNvbHV0aW9uPjk2LzE8L3RpZmY6WFJlc29sdXRpb24+CiAgPHRpZmY6WVJlc29sdXRpb24+OTYvMTwvdGlmZjpZUmVzb2x1dGlvbj4KIDwvcmRmOkRlc2NyaXB0aW9uPgo8L3JkZjpSREY+CjwveDp4bXBtZXRhPgo8P3hwYWNrZXQgZW5kPSdyJz8+BUybogAAAEZJREFUeNqFzcEJgEAQA8A5Ud8bbMj+qxLxPHwosq8dSCIJUBqM50vXN21J14SkJNvpl85UP6LVHfrT0TBh6HNtH2oBgFIHi0UEEPtLIT4AAAAASUVORK5CYII=") -bitmaps["toppollenfill"] := Gdip_CreateBitmap(41,10), pGraphics := Gdip_GraphicsFromImage(bitmaps["toppollenfill"]), Gdip_GraphicsClear(pGraphics, 0xff121517), Gdip_DeleteGraphics(pGraphics) diff --git a/nm_image_assets/offset/toppollen.png b/nm_image_assets/offset/toppollen.png deleted file mode 100644 index c0f9dd9..0000000 Binary files a/nm_image_assets/offset/toppollen.png and /dev/null differ diff --git a/paths/gtc-stickerPrinter.ahk b/paths/gtc-stickerPrinter.ahk index 7d4e493..8928541 100644 --- a/paths/gtc-stickerPrinter.ahk +++ b/paths/gtc-stickerPrinter.ahk @@ -1,34 +1,34 @@ -if (MoveMethod = "walk") -{ - nm_gotoramp() - nm_Walk(67.5, BackKey, LeftKey) - send "{" RotRight " 4}" - nm_Walk(31, FwdKey) - nm_Walk(7.8, LeftKey) - nm_Walk(10, BackKey) - nm_Walk(5, RightKey) - nm_Walk(1.5, FwdKey) - nm_Walk(60, LeftKey) - nm_Walk(3.75, RightKey) - nm_Walk(85, FwdKey) - nm_Walk(45, RightKey) - nm_Walk(50, BackKey) - nm_Walk(60, RightKey) - nm_Walk(15.75, FwdKey, LeftKey) - nm_Walk(18, FwdKey) - send "{" RotRight " 4}" - nm_Walk(31, LeftKey) - nm_Walk(3, BackKey) -} -else -{ - nm_gotoramp() - nm_gotocannon() - send "{e down}" - HyperSleep(100) - send "{e up}" - Sleep 4000 - nm_Walk(31, LeftKey) - nm_Walk(3, BackKey) -} -;path idkwhatimdoing money_mountain +if (MoveMethod = "walk") +{ + nm_gotoramp() + nm_Walk(67.5, BackKey, LeftKey) + send "{" RotRight " 4}" + nm_Walk(31, FwdKey) + nm_Walk(7.8, LeftKey) + nm_Walk(10, BackKey) + nm_Walk(5, RightKey) + nm_Walk(1.5, FwdKey) + nm_Walk(60, LeftKey) + nm_Walk(3.75, RightKey) + nm_Walk(85, FwdKey) + nm_Walk(45, RightKey) + nm_Walk(50, BackKey) + nm_Walk(60, RightKey) + nm_Walk(15.75, FwdKey, LeftKey) + nm_Walk(18, FwdKey) + send "{" RotRight " 4}" + nm_Walk(31, LeftKey) + nm_Walk(3, BackKey) +} +else +{ + nm_gotoramp() + nm_gotocannon() + send "{e down}" + HyperSleep(100) + send "{e up}" + Sleep 4000 + nm_Walk(31, LeftKey) + nm_Walk(3, BackKey) +} +;path idkwhatimdoing money_mountain diff --git a/submacros/AutoJelly.ahk b/submacros/AutoJelly.ahk new file mode 100644 index 0000000..7eec476 --- /dev/null +++ b/submacros/AutoJelly.ahk @@ -0,0 +1,487 @@ +/************************************************************************ + * @description Auto-Jelly is a macro for the game Bee Swarm Simulator on Roblox. It automatically rolls bees for mutations and stops when a bee with the desired mutation is found. It also has the ability to stop on mythic and gifted bees. + * @file auto-jelly.ahk + * @author ninju | .ninju. + * @date 2024/07/24 + * @version 0.0.1 + ***********************************************************************/ + +#SingleInstance Force +#Requires AutoHotkey v2.0 +#Warn VarUnset, Off +;=============INCLUDES============= +#Include %A_ScriptDir%\..\lib +#Include Gdip_All.ahk +#include Roblox.ahk +#include Gdip_ImageSearch.ahk +#include OCR.ahk +;================================== +SendMode("Event") +CoordMode('Pixel', 'Screen') +CoordMode('Mouse', 'Screen') +;================================== +pToken := Gdip_Startup() +OnExit((*) => (closefunction()), -1) +OnError (e, mode) => (mode = "Return") ? -1 : 0 +stopToggle(*) { + global stopping := true +} +class __ArrEx extends Array { + static __New() { + Super.Prototype.includes := ObjBindMethod(this, 'includes') + } + static includes(arr, val) { + for i, j in arr { + if j = val + return i + } + return 0 + } +} + +if A_ScreenDPI !== 96 + throw Error("This macro requires a display-scale of 100%") +traySetIcon(".\nm_image_assets\birb.ico") +getConfig() { + global + local k, v, p, c, i, section, key, value, inipath, config, f, ini + config := { + mutations: { + Mutations: 0, + Ability: 0, + Gather: 0, + Convert: 0, + Energy: 0, + Movespeed: 0, + Crit: 0, + Instant: 0, + Attack: 0 + }, + bees: { + Bomber: 0, + Brave: 0, + Bumble: 0, + Cool: 0, + Hasty: 0, + Looker: 0, + Rad: 0, + Rascal: 0, + Stubborn: 0, + Bubble: 0, + Bucko: 0, + Commander: 0, + Demo: 0, + Exhausted: 0, + Fire: 0, + Frosty: 0, + Honey: 0, + Rage: 0, + Riley: 0, + Shocked: 0, + Baby: 0, + Carpenter: 0, + Demon: 0, + Diamond: 0, + Lion: 0, + Music: 0, + Ninja: 0, + Shy: 0, + Buoyant: 0, + Fuzzy: 0, + Precise: 0, + Spicy: 0, + Tadpole: 0, + Vector: 0, + selectAll: 0 + }, + GUI : { + xPos: A_ScreenWidth//2-w//2, + yPos: A_ScreenHeight//2-h//2 + }, + extrasettings: { + mythicStop: 0, + giftedStop: 0 + } + } + for i, section in config.OwnProps() + for key, value in section.OwnProps() + %key% := value + if !FileExist(".\settings") + DirCreate(".\settings") + inipath := ".\settings\mutations.ini" + if FileExist(inipath) { + loop parse FileRead(inipath), "`n", "`r" A_Space A_Tab { + switch (c:=SubStr(A_LoopField,1,1)) { + case "[", ";": continue + default: + if (p := InStr(A_LoopField, "=")) + try k := SubStr(A_LoopField, 1, p-1), %k% := IsInteger(v := SubStr(A_LoopField, p+1)) ? Integer(v) : v + } + } + } + ini:="" + for k, v in config.OwnProps() { + ini .= "[" k "]`r`n" + for i in v.OwnProps() + ini .= i "=" %i% "`r`n" + ini .= "`r`n" + } + (f:=FileOpen(inipath, "w")).Write(ini), f.Close() +} +;===Dimensions=== +w:=500,h:=397 +;===Bee Array=== +beeArr := ["Bomber", "Brave", "Bumble", "Cool", "Hasty", "Looker", "Rad", "Rascal", "Stubborn", "Bubble", "Bucko", "Commander", "Demo", "Exhausted", "Fire", "Frosty", "Honey", "Rage", "Riley", "Shocked", "Baby", "Carpenter", "Demon", "Diamond", "Lion", "Music", "Ninja", "Shy", "Buoyant", "Fuzzy", "Precise", "Spicy", "Tadpole", "Vector"] +mutationsArr := [ + {name:"Ability", triggers:["rate", "abil", "ity"], full:"AbilityRate"}, + {name:"Gather", triggers:["gath", "herAm"], full:"GatherAmount"}, + {name:"Convert", triggers:["convert", "vertAm"], full:"ConvertAmount"}, + {name:"Instant", triggers:["inst", "antConv"], full:"InstantConversion"}, + {name:"Crit", triggers:["crit", "chance"], full:"CriticalChance"}, + {name:"Attack", triggers:["attack", "att", "ack"], full:"Attack"}, + {name:"Energy", triggers:["energy", "rgy"], full:"Energy"}, + {name:"Movespeed", triggers:["movespeed", "speed", "move"], full:"MoveSpeed"}, +] +extrasettings:=[ + {name:"mythicStop", text: "Stop on mythics"}, + {name:"giftedStop", text: "Stop on gifteds"} +] +getConfig() +(bitmaps := Map()).CaseSense:=0 +#Include %A_ScriptDir%\..\nm_image_assets\mutator\bitmaps.ahk +#include %A_ScriptDir%\..\nm_image_assets\mutatorgui\bitmaps.ahk +startGui() { + global + local i,j,y,hBM,x + (mgui := Gui("+E" (0x00080000) " +OwnDialogs -Caption -DPIScale", "Auto-Jelly")).OnEvent("Close", ExitApp) + mgui.Show() + for i, j in [ + {name:"move", options:"x0 y0 w" w " h36"}, + {name:"selectall", options:"x" w-330 " y220 w40 h18"}, + {name:"mutations", options:"x" w-170 " y220 w40 h18"}, + {name:"close", options:"x" w-40 " y5 w28 h28"}, + {name:"roll", options:"x10 y" h-42 " w" w-56 " h30"}, + {name:"help", options:"x" w-40 " y" h-42 " w28 h28"} + ] + mgui.AddText("v" j.name " " j.options) + for i, j in beeArr { + y := (A_Index-1)//8*1 + mgui.AddText("v" j " x" 10+mod(A_Index-1,8)*60 " y" 50+y*40 " w45 h36") + } + for i, j in mutationsArr { + y := (A_Index-1)//4*1 + mgui.AddText("v" j.name " x" 10+mod(A_Index-1,4)*120 " y" 260+y*25 " w40 h18") + } + for i, j in extrasettings { + x := 10 + (w-12)/extrasettings.length * (i-1), y:=(316+h-42)//2-10 + mgui.AddText("v" j.name " x" x " y" y " w40 h18") + } + hBM := CreateDIBSection(w, h) + hDC := CreateCompatibleDC() + SelectObject(hDC, hBM) + G := Gdip_GraphicsFromHDC(hDC) + Gdip_SetSmoothingMode(G, 4) + Gdip_SetInterpolationMode(G, 7) + update := UpdateLayeredWindow.Bind(mgui.hwnd, hDC) + update(xpos < 0 ? 0 : xpos > A_ScreenWidth ? 0 : xpos, ypos < 0 ? 0 : ypos > A_ScreenHeight ? 0 : ypos, w, h) + hovercontrol := "" + DrawGUI() +} +startGUI() +OnMessage(0x201, WM_LBUTTONDOWN) +OnMessage(0x200, WM_MOUSEMOVE) +DrawGUI() { + Gdip_GraphicsClear(G) + Gdip_FillRoundedRectanglePath(G, brush := Gdip_BrushCreateSolid(0xFF131416), 2, 2, w-4, h-4, 20), Gdip_DeleteBrush(brush) + region := Gdip_GetClipRegion(G) + Gdip_SetClipRect(G, 2, 21, w-2, 30, 4) + Gdip_FillRoundedRectanglePath(G, brush := Gdip_BrushCreateSolid("0xFFFEC6DF"), 2, 2, w-4, 40, 20) + Gdip_SetClipRegion(G, region) + Gdip_FillRectangle(G, brush, 2, 20, w-4, 14) + Gdip_DeleteBrush(brush), Gdip_DeleteRegion(region) + Gdip_TextToGraphics(G, "Auto-Jelly", "s20 x20 y5 w460 Near vCenter c" (brush := Gdip_BrushCreateSolid("0xFF131416")), "Comic Sans MS", 460, 30), Gdip_DeleteBrush(brush) + Gdip_DrawImage(G, bitmaps["close"], w-40, 5, 28, 28) + for i, j in beeArr { + ;bitmaps are w45 h36 + y := (A_Index-1)//8 + bm := hovercontrol = j && (%j% || SelectAll) ? j "bghover" : %j% || SelectAll ? j "bg" : hovercontrol = j ? j "hover" : j + Gdip_DrawImage(G, bitmaps[bm], 10+mod(A_Index-1,8)*60, 50+y*40, 45, 36) + } + ;===Switches=== + Gdip_FillRoundedRectanglePath(G, brush := Gdip_BrushCreateSolid("0xFF" . 13*2 . 14*2 . 16*2), w-330, 220, 40, 18, 9), Gdip_DeleteBrush(brush) + Gdip_FillEllipse(G, brush:=Gdip_BrushCreateSolid("0xFFFEC6DF"), selectAll ? w-310 : w-332, 218, 22, 22) + Gdip_TextToGraphics(G, "Select All Bees", "s14 x" w-284 " y220 Near vCenter c" brush, "Comic Sans MS",, 20), Gdip_DeleteBrush(brush) + if !SelectAll { + Gdip_FillEllipse(G, brush:=Gdip_BrushCreateSolid("0xFF" . 13*2 . 14*2 . 16*2), w-330, 220, 18, 18), Gdip_DeleteBrush(brush) + Gdip_DrawLines(G, Pen:=Gdip_CreatePen("0xFFCC0000", 2), [[w-325, 225], [w-317, 233]]) + Gdip_DrawLines(G, Pen , [[w-325, 233], [w-317, 225]]), Gdip_DeletePen(Pen) + } + else + Gdip_DrawLines(G, Pen:=Gdip_CreatePen("0xFF006600", 2), [[w-303, 229], [w-300, 232], [w-295, 225]]), Gdip_DeletePen(Pen) + Gdip_FillRoundedRectanglePath(G, brush := Gdip_BrushCreateSolid("0xFF" . 13*2 . 14*2 . 16*2), w-170, 220, 40, 18, 9), Gdip_DeleteBrush(brush) + Gdip_FillEllipse(G, brush:=Gdip_BrushCreateSolid("0xFFFEC6DF"), mutations ? w-150 : w-172, 218, 22, 22) + Gdip_TextToGraphics(G, "Mutations", "s14 x" w-124 " y220 Near vCenter c" (brush), "Comic Sans MS",, 20), Gdip_DeleteBrush(brush) + if !mutations { + Gdip_FillEllipse(G, brush:= Gdip_BrushCreateSolid("0xFF" . 13*2 . 14*2 . 16*2), w-170, 220, 18, 18), Gdip_DeleteBrush(brush) + Gdip_DrawLines(G, Pen:=Gdip_CreatePen("0xFFCC0000", 2), [[w-165, 225], [w-157, 233]]) + Gdip_DrawLines(G, Pen , [[w-165, 233], [w-157, 225]]), Gdip_DeletePen(Pen) + } + else + Gdip_DrawLines(G, Pen:=Gdip_CreatePen("0xFF006600", 2), [[w-143, 229], [w-140, 232], [w-135, 225]]), Gdip_DeletePen(Pen) + For i, j in mutationsArr { + y := (A_Index-1)//4 + Gdip_FillRoundedRectanglePath(G, brush := Gdip_BrushCreateSolid("0xFF" . 13*2 . 14*2 . 16*2), 10+mod(A_Index-1,4)*120, 260+y*25, 40, 18, 9), Gdip_DeleteBrush(brush) + Gdip_FillEllipse(G, brush:=Gdip_BrushCreateSolid("0xFFFEC6DF"), (%j.name% ? 3.2 : 1) * 8+mod(A_Index-1,4)*120, 258+y*25, 22, 22), Gdip_DeleteBrush(brush) + Gdip_TextToGraphics(G, j.name, "s13 x" 56+mod(A_Index-1,4)*120 " y" 260+y*25 " vCenter c" (brush := Gdip_BrushCreateSolid("0xFFFEC6DF")), "Comic Sans MS", 100, 20), Gdip_DeleteBrush(brush) + if !%j.name% { + Gdip_FillEllipse(G, brush:=Gdip_BrushCreateSolid("0xFF262832"), x:=10+mod(A_Index-1,4)*120, yp:=258+y*25+2, 18, 18), Gdip_DeleteBrush(brush) + Gdip_DrawLines(G, Pen:=Gdip_CreatePen("0xFFCC0000", 2), [[x+5, yp+5 ], [x+13, yp+13]]) + Gdip_DrawLines(G, Pen , [[x+5, yp+13], [x+13, yp+5 ]]), Gdip_DeletePen(Pen) + } + else + Gdip_DrawLines(G, Pen:=Gdip_CreatePen("0xFF006600", 2), [[x:=32.6+mod(A_Index-1,4)*120, yp:=269+y*25], [x+3, yp+3], [x+8, yp-4]]), Gdip_DeletePen(Pen) + } + if !mutations + Gdip_FillRectangle(G, brush:=Gdip_BrushCreateSolid("0x70131416"), 9, 255, w-18, 52), Gdip_DeleteBrush(brush) + Gdip_DrawLine(G, Pen:=Gdip_CreatePen("0xFFFEC6DF", 2), 10, 315, w-12, 315), Gdip_DeletePen(Pen) + ;two more switches for "stop on mythic" and "stop on gifted" + for i, j in extrasettings { + x := 10 + (tw:=(w-12)/extrasettings.length) * (i-1), y:=(316+h-42)//2-10 + Gdip_FillRoundedRectanglePath(G, brush:=Gdip_BrushCreateSolid("0xFF262832"), x, y, 40, 18, 9), Gdip_DeleteBrush(brush), Gdip_DeleteBrush(brush) + Gdip_FillEllipse(G, brush:=Gdip_BrushCreateSolid("0xFFFEC6DF"), %j.name% ? x+18 : x-2, y-2, 22, 22) + Gdip_TextToGraphics(G, j.text, "s14 x" x+46 " y" y " vCenter c" brush, "Comic Sans MS", tw,20), Gdip_DeleteBrush(brush) + if !%j.name% { + Gdip_FillEllipse(G, brush:=Gdip_BrushCreateSolid("0xFF262832"), x, y, 18, 18), Gdip_deleteBrush(brush) + Gdip_DrawLines(G, Pen:=Gdip_CreatePen("0xFFCC0000", 2), [[x+5, y+5 ], [x+13, y+13]]) + Gdip_DrawLines(G, Pen , [[x+5, y+13], [x+13, y+5 ]]), Gdip_DeletePen(Pen) + } + else + Gdip_DrawLines(G, Pen:=Gdip_CreatePen("0xFF006600", 2), [[x+25, y+9], [x+28, y+12], [x+33, y+5]]), Gdip_DeletePen(Pen) + } + if hovercontrol = "roll" + Gdip_FillRoundedRectanglePath(G, brush:=Gdip_BrushCreateSolid("0x30FEC6DF"), 10, h-42, w-56, 30, 10), Gdip_DeleteBrush(brush) + if hovercontrol = "help" + Gdip_FillRoundedRectanglePath(G, brush:=Gdip_BrushCreateSolid("0x30FEC6DF"), w-40, h-42, 30, 30, 10), Gdip_DeleteBrush(brush) + Gdip_TextToGraphics(G, "Roll!", "x10 y" h-40 " Center vCenter s15 c" (brush:=Gdip_BrushCreateSolid("0xFFFEC6DF")),"Comic Sans MS",w-56, 28) + Gdip_TextToGraphics(G, "?", "x" w-39 " y" h-40 " Center vCenter s15 c" brush,"Comic Sans MS",30, 28), Gdip_DeleteBrush(brush) + Gdip_DrawRoundedRectanglePath(G, pen:=Gdip_CreatePen("0xFFFEC6DF", 4), 10, h-42, w-56, 30, 10) + Gdip_DrawRoundedRectanglePath(G, pen, w-40, h-42, 30, 30, 10), Gdip_DeletePen(pen) + update() +} +WM_LBUTTONDOWN(wParam, lParam, msg, hwnd) { + global hovercontrol, mutations, Bomber, Brave, Bumble, Cool, Hasty, Looker, Rad, Rascal + , Stubborn, Bubble, Bucko, Commander, Demo, Exhausted, Fire, Frosty, Honey, Rage + , Riley, Shocked, Baby, Carpenter, Demon, Diamond, Lion, Music, Ninja, Shy, Buoyant + , Fuzzy, Precise, Spicy, Tadpole, Vector, SelectAll, Ability, Gather, Convert, Energy + , Movespeed, Crit, Instant, Attack, mythicStop, giftedStop + MouseGetPos(,,,&ctrl,2) + if !ctrl + return + switch mgui[ctrl].name, 0 { + case "move": + PostMessage(0x00A1,2) + case "close": + while GetKeyState("LButton", "P") + sleep -1 + mousegetpos ,,, &ctrl2, 2 + if ctrl = ctrl2 + PostMessage(0x0112,0xF060) + case "roll": + ReplaceSystemCursors() + blc_start() + case "help": + ReplaceSystemCursors() + Msgbox("This feature allows you to roll royal jellies until you obtain your specified bees and/or mutations!`n`nTo use:`n- Select the bees and mutations you want`n- Make sure your in-game Auto-Jelly settings are right`n- Put a neonberry on the bee you want to change (if trying `n to obtain a mutated bee) `n- Use one royal jelly on the bee and click Yes`n- Click on Roll.`n`nTo stop: `n- Press the escape key`n`nAdditional options:`n- Stop on Gifteds stops on any gifted bee, `n ignoring the mutation and your bee selection`n- Stop on Mythics stops on any mythic bee, `n ignoring the mutation and your bee selection", "Auto-Jelly Help", "0x40040") + case "selectAll": + IniWrite(%mgui[ctrl].name% ^= 1, ".\settings\mutations.ini", "bees", mgui[ctrl].name) + case "Bomber", "Brave", "Bumble", "Cool", "Hasty", "Looker", "Rad", "Rascal", "Stubborn", "Bubble", "Bucko", "Commander", "Demo", "Exhausted", "Fire", "Frosty", "Honey", "Rage", "Riley": + if !selectAll + IniWrite(%mgui[ctrl].name% ^= 1, ".\settings\mutations.ini", "bees", mgui[ctrl].name) + case "Shocked", "Baby", "Carpenter", "Demon", "Diamond", "Lion", "Music", "Ninja", "Shy", "Buoyant", "Fuzzy", "Precise", "Spicy", "Tadpole", "Vector": + if !selectAll + IniWrite(%mgui[ctrl].name% ^= 1, ".\settings\mutations.ini", "bees", mgui[ctrl].name) + case "giftedStop", "mythicStop": + IniWrite(%mgui[ctrl].name% ^= 1, ".\settings\mutations.ini", "extrasettings", mgui[ctrl].name) + case "mutations": + IniWrite(%mgui[ctrl].name% ^= 1, ".\settings\mutations.ini", "mutations", mgui[ctrl].name) + default: + if mutations + IniWrite(%mgui[ctrl].name% ^= 1, ".\settings\mutations.ini", "mutations", mgui[ctrl].name) + } + DrawGUI() +} +WM_MOUSEMOVE(wParam, lParam, msg, hwnd) { + global + local ctrl, hover_ctrl, tt := 0 + MouseGetPos(,,,&ctrl,2) + if !ctrl || mgui["move"].hwnd = ctrl || mgui["close"].hwnd = ctrl + return + ReplaceSystemCursors("IDC_HAND") + hovercontrol := mgui[ctrl].name + hover_ctrl := mgui[ctrl].hwnd + DrawGUI() + while ctrl = hover_ctrl { + sleep(20),MouseGetPos(,,,&ctrl,2) + if A_Index > 120 && beeArr.includes(hovercontrol) && !tt + tt:=1,ToolTip(hovercontrol . " Bee") + } + hovercontrol := "" + ToolTip() + ReplaceSystemCursors() + DrawGUI() +} +ReplaceSystemCursors(IDC := "") +{ + static IMAGE_CURSOR := 2, SPI_SETCURSORS := 0x57 + , SysCursors := Map( "IDC_APPSTARTING", 32650 + , "IDC_ARROW" , 32512 + , "IDC_CROSS" , 32515 + , "IDC_HAND" , 32649 + , "IDC_HELP" , 32651 + , "IDC_IBEAM" , 32513 + , "IDC_NO" , 32648 + , "IDC_SIZEALL" , 32646 + , "IDC_SIZENESW" , 32643 + , "IDC_SIZENWSE" , 32642 + , "IDC_SIZEWE" , 32644 + , "IDC_SIZENS" , 32645 + , "IDC_UPARROW" , 32516 + , "IDC_WAIT" , 32514 ) + if !IDC + DllCall("SystemParametersInfo", "UInt", SPI_SETCURSORS, "UInt", 0, "UInt", 0, "UInt", 0) + else + { + hCursor := DllCall("LoadCursor", "Ptr", 0, "UInt", SysCursors[IDC], "Ptr") + for k, v in SysCursors + { + hCopy := DllCall("CopyImage", "Ptr", hCursor, "UInt", IMAGE_CURSOR, "Int", 0, "Int", 0, "UInt", 0, "Ptr") + DllCall("SetSystemCursor", "Ptr", hCopy, "UInt", v) + } + } +} +blc_start() { + global stopping:=false + hotkey "~*esc", stopToggle, "On" + selectedBees := [], selectedMutations := [] + for i in beeArr + if %i% || SelectAll + selectedBees.push(i) + if mutations { + selectedMutations := [] + for i in mutationsArr + if %i.name% + selectedMutations.push(i) + } + + + ocr_enabled := 1 + ocr_language := "" + for k,v in Map("Windows.Globalization.Language","{9B0252AC-0C27-44F8-B792-9793FB66C63E}", "Windows.Graphics.Imaging.BitmapDecoder","{438CCB26-BCEF-4E95-BAD6-23A822E58D01}", "Windows.Media.Ocr.OcrEngine","{5BFFA85A-3384-3540-9940-699120D428A8}") + { + hString := OCR.CreateHString(k) + GUID := Buffer(16), DllCall("ole32\CLSIDFromString", "WStr", v, "Ptr", GUID) + result := DllCall("Combase.dll\RoGetActivationFactory", "Ptr", hString, "Ptr", GUID, "PtrP", &pClass:=0) + OCR.DeleteHString(hString) + if (result != 0) + { + ocr_enabled := 0 + break + } + } + + if !(ocr_enabled) && mutations + msgbox "OCR is disabled. This means that the macro will not be able to detect mutations.",, 0x40010 + + list := getAvailableLang() + lang:="en-" + Loop Parse list, "`n", "`r" { + if (InStr(A_LoopField, lang) = 1) { + ocr_language := A_LoopField + break + } + } + + if (ocr_language = "" && ocr_enabled) + if ((ocr_language := SubStr(list, 1, InStr(list, "`n")-1)) = "") + return msgbox("No OCR supporting languages are installed on your system! Please follow the Knowledge Base guide to install a supported language as a secondary language on Windows.", "WARNING!!", 0x1030) + if !(hwndRoblox:=GetRobloxHWND()) || !(GetRobloxClientPos(), windowWidth) + return msgbox("You must have Bee Swarm Simulator open to use this!", "Auto-Jelly", 0x40030) + if !selectedBees.length + return msgbox("You must select at least one bee to run this macro!", "Auto-Jelly", 0x40030) + + yOffset := GetYOffset(hwndRoblox, &fail) + if fail + MsgBox("Unable to detect in-game GUI offset!`nThis means the macro will NOT work correctly!`n`nThere are a few reasons why this can happen:`n- Incorrect graphics settings (check Troubleshooting Guide!)`n- Your Experience Language is not set to English`n- Something is covering the top of your Roblox window`n`nJoin our Discord server for support!", "WARNING!!", 0x1030 " T60") + if mgui is Gui + mgui.hide() + While !stopping { + ActivateRoblox() + click windowX + Round(0.5 * windowWidth + 10) " " windowY + yOffset + Round(0.4 * windowHeight + 230) + sleep 800 + pBitmap := Gdip_BitmapFromScreen(windowX + 0.5*windowWidth - 155 "|" windowY + yOffset + 0.425*windowHeight - 200 "|" 320 "|" 140) + if mythicStop + for i, j in ["Buoyant", "Fuzzy", "Precise", "Spicy", "Tadpole", "Vector"] + if Gdip_ImageSearch(pBitmap, bitmaps["-" j]) || Gdip_ImageSearch(pBitmap, bitmaps["+" j]) { + Gdip_DisposeImage(pBitmap) + msgbox "Found a mythic bee!", "Auto-Jelly", 0x40040 + break 2 + } + if giftedStop + for i, j in beeArr { + if Gdip_ImageSearch(pBitmap, bitmaps["+" j]) { + Gdip_DisposeImage(pBitmap) + msgbox "Found a gifted bee!", "Auto-Jelly", 0x40040 + break 2 + } + } + found := 0 + for i, j in selectedBees { + if Gdip_ImageSearch(pBitmap, bitmaps["-" j]) || Gdip_ImageSearch(pBitmap, bitmaps["+" j]) { + if (!mutations || !ocr_enabled || !selectedMutations.length) { + Gdip_DisposeImage(pBitmap) + if msgbox("Found a match!`nDo you want to keep this?","Auto-Jelly!", 0x40044) = "Yes" + break 2 + else + continue 2 + } + found := 1 + break + } + } + Gdip_DisposeImage(pBitmap) + if !found + continue + pBitmap := Gdip_BitmapFromScreen(windowX + Round(0.5 * windowWidth - 320) "|" windowY + yOffset + Round(0.4 * windowHeight + 17) "|210|90") + pEffect := Gdip_CreateEffect(5, -60,30) + Gdip_BitmapApplyEffect(pBitmap, pEffect) + Gdip_DisposeEffect(pEffect) + hBitmap := Gdip_CreateHBITMAPFromBitmap(pBitmap) + pIRandomAccessStream := OCR.HBitmapToRandomAccessStream(hBitmap) + text:= RegExReplace(ocr(pIRandomAccessStream), "i)([\r\n\s]|mutation)*") + found := 0 + for i, j in selectedMutations + for k, trigger in j.triggers + if inStr(text, trigger) { + found := 1 + break + } + if !found + continue + if msgbox("Found a match!`nDo you want to keep this?","Auto-Jelly!", 0x40044) = "Yes" + break + } + hotkey "~*esc", stopToggle, "Off" + mgui.show() +} +closeFunction(*) { + global xPos, yPos + Gdip_Shutdown(pToken) + ReplaceSystemCursors() + try { + mgui.getPos(&xp, &yp) + if !(xp < 0) && !(xp > A_ScreenWidth) && !(yp < 0) && !(yp > A_ScreenHeight) + xPos := xp, yPos := yp + IniWrite(xpos, ".\settings\mutations.ini", "GUI", "xpos") + IniWrite(ypos, ".\settings\mutations.ini", "GUI", "ypos") + } +} \ No newline at end of file diff --git a/submacros/BasicEgg.ahk b/submacros/BasicEgg.ahk new file mode 100644 index 0000000..9cf3b8e --- /dev/null +++ b/submacros/BasicEgg.ahk @@ -0,0 +1,128 @@ +#NoTrayIcon +#SingleInstance Force + +#Include "%A_ScriptDir%\..\lib" +#Include "Gdip_All.ahk" +#Include "Gdip_ImageSearch.ahk" +#Include "Roblox.ahk" +#Include "nm_OpenMenu.ahk" +#Include "nm_InventorySearch.ahk" + +CoordMode "Mouse", "Screen" +OnExit(ExitFunc) +pToken := Gdip_Startup() + +bitmaps := Map() +Shrine := Map() + +#Include ..\nm_image_assets\general\bitmaps.ahk + +bitmaps["giftedstar"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAgMAAAC5YVYYAAAACVBMVEX9rDT+rDT/rDOj6H2ZAAAAFElEQVR42mNYtYoBgVYyrFoBYQMAf4AKnlh184sAAAAASUVORK5CYII=") + +if (MsgBox("WELCOME TO THE BASIC BEE REPLACEMENT PROGRAM!!!!!``nMade by anniespony#8135``n``nMake sure BEE SLOT TO CHANGE is always visible``nDO NOT MOVE THE SCREEN ORRESIZE WINDOW FROM NOW ON.``nMAKE SURE AUTO-JELLY IS DISABLED!!", "Basic Bee Replacement Program", 0x40001) = "Cancel") + ExitApp + +if (MsgBox("After dismissing this message,``nleft click ONLY once on BEE SLOT", "Basic Bee Replacement Program", 0x40001) = "Cancel") + ExitApp + +hwnd := GetRobloxHWND() +ActivateRoblox() +GetRobloxClientPos() +offsetY := GetYOffset(hwnd, &offsetfail) +if (offsetfail = 1) { + MsgBox "Unable to detect in-game GUI offset!``nStopping Feeder!``n``nThere are a few reasons why this can happen, including:``n - Incorrect graphics settings``n - Your `'Experience Language`' is not set to English``n - Something is covering the top of your Roblox window``n``nJoin our Discord server for support and our Knowledge Base post on this topic (Unable to detect in-game GUI offset)!", "WARNING!!", 0x40030 + ExitApp +} +StatusBar := Gui("-Caption +E0x80000 +AlwaysOnTop +ToolWindow -DPIScale") +StatusBar.Show("NA") +hbm := CreateDIBSection(windowWidth, windowHeight), hdc := CreateCompatibleDC(), obm := SelectObject(hdc, hbm) +G := Gdip_GraphicsFromHDC(hdc), Gdip_SetSmoothingMode(G, 2), Gdip_SetInterpolationMode(G, 2) +Gdip_FillRectangle(G, pBrush := Gdip_BrushCreateSolid(0x60000000), -1, -1, windowWidth+1, windowHeight+1), Gdip_DeleteBrush(pBrush) +UpdateLayeredWindow(StatusBar.Hwnd, hdc, windowX, windowY, windowWidth, windowHeight) + +KeyWait "LButton", "D" ; Wait for the left mouse button to be pressed down. +MouseGetPos &beeX, &beeY +Gdip_GraphicsClear(G), Gdip_FillRectangle(G, pBrush := Gdip_BrushCreateSolid(0xd0000000), -1, -1, windowWidth+1, 38), Gdip_DeleteBrush(pBrush) +Gdip_TextToGraphics(G, "Hatching... Right Click or Shift to Stop!", "x0 y0 cffff5f1f Bold Center vCenter s24", "Tahoma", windowWidth, 38) +UpdateLayeredWindow(StatusBar.Hwnd, hdc, windowX, windowY, windowWidth, 38) +SelectObject(hdc, obm), DeleteObject(hbm), DeleteDC(hdc), Gdip_DeleteGraphics(G) +Hotkey "Shift", ExitFunc, "On" +Hotkey "RButton", ExitFunc, "On" +Hotkey "F11", ExitFunc, "On" +Sleep 250 + +pBMC := Gdip_CreateBitmap(2,2), G := Gdip_GraphicsFromImage(pBMC), Gdip_GraphicsClear(G,0xffae792f), Gdip_DeleteGraphics(G) ; Common +pBMM := Gdip_CreateBitmap(2,2), G := Gdip_GraphicsFromImage(pBMM), Gdip_GraphicsClear(G,0xffbda4ff), Gdip_DeleteGraphics(G) ; Mythic + +rj := 0 +Loop +{ + if ((pos := (A_Index = 1) ? nm_InventorySearch("basicegg", "up", , , , 70) : (rj = 1) ? nm_InventorySearch("royaljelly", "up", , , 0, 7) : nm_InventorySearch("basicegg", "up", , , 0, 7)) = 0) + { + MsgBox "You ran out of " ((rj = 1) ? "Royal Jellies!" : "Basic Eggs!"), "Basic Bee Replacement Program", 0x40010 + break + } + GetRobloxClientPos(hwnd) + SendEvent "{Click " windowX+pos[1] " " windowY+pos[2] " 0}" + Send "{Click Down}" + Sleep 100 + SendEvent "{Click " beeX " " beeY " 0}" + Sleep 100 + Send "{Click Up}" + found := false + Loop 10 + { + Sleep 100 + TextInRegion := findTextInRegion("Yes",, windowX + windowWidth // 4, windowY + windowHeight//2, windowWidth // 4, windowHeight//2, true) + if TextInRegion.Has("Word") { + word := TextInRegion["Word"] + Click windowX + word.BoundingRect.x, windowY + word.BoundingRect.y + ; Send "{Click " windowX + word.BoundingRect.x " " windowY + word.BoundingRect.y " 0}" + found := true + } else if found { + break + } + + if (A_Index = 10) + { + rj := 1 + continue 2 + } + } + Sleep 750 + + pBMScreen := Gdip_BitmapFromScreen(windowX+windowWidth//2-155 "|" windowY+offsetY+((4*windowHeight)//10 - 135) "|310|205"), rj := 0 + + if (Gdip_ImageSearch(pBMScreen, pBMM, , 50, 165, 260, 205, 2, , , 5) = 5) { ; Mythic Hatched + if (MsgBox("MYTHIC!!!!``nKeep this?", "Basic Bee Replacement Program", 0x40024) = "Yes") + { + Gdip_DisposeImage(pBMScreen) + break + } + } + else if (Gdip_ImageSearch(pBMScreen, pBMC, , 50, 165, 260, 205, 2, , , 5) = 5) { + rj := 1 + if (Gdip_ImageSearch(pBMScreen, bitmaps["giftedstar"], , 0, 20, 130, 50, 5) = 1) { ; If gifted is hatched, stop + MsgBox "SUCCESS!!!!", "Basic Bee Replacement Program", 0x40020 + Gdip_DisposeImage(pBMScreen) + break + } + } + else if (Gdip_ImageSearch(pBMScreen, bitmaps["giftedstar"], , 0, 20, 130, 50, 5) = 1) { ; Non-Basic Gifted Hatched + if (MsgBox("GIFTED!!!!``nKeep this?", "Basic Bee Replacement Program", 0x40024) = "Yes") + { + Gdip_DisposeImage(pBMScreen) + break + } + } + Gdip_DisposeImage(pBMScreen) +} +ExitApp + +ExitFunc(*) +{ + try Gdip_DisposeImage(pBMC), Gdip_DisposeImage(pBMM) + try StatusBar.Destroy() + try Gdip_Shutdown(pToken) + ExitApp +} \ No newline at end of file diff --git a/submacros/BitterBerry.ahk b/submacros/BitterBerry.ahk new file mode 100644 index 0000000..4fd1206 --- /dev/null +++ b/submacros/BitterBerry.ahk @@ -0,0 +1,129 @@ + +#NoTrayIcon +#SingleInstance Force + +#Include "%A_ScriptDir%\..\lib" +#Include "Gdip_All.ahk" +#Include "Gdip_ImageSearch.ahk" +#Include "Roblox.ahk" +#Include "nm_OpenMenu.ahk" +#Include "nm_InventorySearch.ahk" + +CoordMode "Mouse", "Screen" +OnExit(ExitFunc) +pToken := Gdip_Startup() + +bitmaps := Map() +Shrine := Map() + +#Include ..\nm_image_assets\general\bitmaps.ahk +bitmaps["greensuccess"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAA4AAAALCAYAAABPhbxiAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAhdEVYdENyZWF0aW9uIFRpbWUAMjAyMzowMzowOCAxNToyMzo1N/c+ABwAAAAdSURBVChTY3T+H/6fgQzABKVJBqMa8YDhr5GBAQBwxAKu5PiUjAAAAA5lWElmTU0AKgAAAAgAAAAAAAAA0lOTAAAAAElFTkSuQmCC") + +if (MsgBox("BITTERBERRY AUTO FEEDER v0.2 by anniespony#8135``nMake sure BEE SLOT TO MUTATE is always visible``nDO NOT MOVE THE SCREEN OR RESIZE WINDOW FROM NOW ON.``nMAKE SURE BEE IS RADIOACTIVE AT ALL TIMES!", "Bitterberry Auto-Feeder v0.2", 0x40001) = "Cancel") + ExitApp + +loop 10 { + bitterberrynos := InputBox("Enter the amount of bitterberry used each time", "How many bitterberry?", "w320 h180 T60").Value + if IsInteger(bitterberrynos) { + if (bitterberrynos > 30) + if (MsgBox("You have entered " bitterberrynos " which is more than 30.``nAre you sure?", "Bitterberry Auto-Feeder v0.2", 0x40034) = "No") + ExitApp + break + } else { + MsgBox "You must enter a number for Bitterberries!!", "Bitterberry Auto-Feeder v0.2", 0x40010 + } +} + +if (MsgBox("After dismissing this message,``nleft click ONLY once on BEE SLOT", "Bitterberry Auto-Feeder v0.2", 0x40001) = "Cancel") + ExitApp + +hwnd := GetRobloxHWND() +ActivateRoblox() +GetRobloxClientPos(hwnd) +offsetY := GetYOffset(hwnd, &offsetfail) +if (offsetfail = 1) { + MsgBox "Unable to detect in-game GUI offset!``nStopping Feeder!``n``nThere are a few reasons why this can happen, including:``n - Incorrect graphics settings``n - Your `'Experience Language`' is not set to English``n - Something is covering the top of your Roblox window``n``nJoin our Discord server for support and our Knowledge Base post on this topic (Unable to detect in-game GUI offset)!", "WARNING!!", "0x40030" + ExitApp +} + +StatusBar := Gui("-Caption +E0x80000 +AlwaysOnTop +ToolWindow -DPIScale") +StatusBar.Show("NA") +hbm := CreateDIBSection(windowWidth, windowHeight), hdc := CreateCompatibleDC(), obm := SelectObject(hdc, hbm) +G := Gdip_GraphicsFromHDC(hdc), Gdip_SetSmoothingMode(G, 2), Gdip_SetInterpolationMode(G, 2) +Gdip_FillRectangle(G, pBrush := Gdip_BrushCreateSolid(0x60000000), -1, -1, windowWidth+1, windowHeight+1), Gdip_DeleteBrush(pBrush) +UpdateLayeredWindow(StatusBar.Hwnd, hdc, windowX, windowY, windowWidth, windowHeight) + +KeyWait "LButton", "D" ; Wait for the left mouse button to be pressed down. +MouseGetPos &beeX, &beeY +Gdip_GraphicsClear(G), Gdip_FillRectangle(G, pBrush := Gdip_BrushCreateSolid(0xd0000000), -1, -1, windowWidth+1, 38), Gdip_DeleteBrush(pBrush) +Gdip_TextToGraphics(G, "Mutating... Right Click or Shift to Stop!", "x0 y0 cffff5f1f Bold Center vCenter s24", "Tahoma", windowWidth, 38) +UpdateLayeredWindow(StatusBar.Hwnd, hdc, windowX, windowY, windowWidth, 38) +SelectObject(hdc, obm), DeleteObject(hbm), DeleteDC(hdc), Gdip_DeleteGraphics(G) +try +{ + Hotkey "Shift", ExitFunc, "On" + Hotkey "RButton", ExitFunc, "On" + Hotkey "F11", ExitFunc, "On" +} +Sleep 250 + +Loop +{ + if ((pos := nm_InventorySearch("bitterberry", "down", , , , (A_Index = 1) ? 40 : 4)) = 0) + { + MsgBox "You ran out of Bitterberries!", "Bitterberry Auto-Feeder v0.2", 0x40010 + break + } + GetRobloxClientPos(hwnd) + + SendEvent "{Click " windowX+pos[1] " " windowY+pos[2] " 0}" + Send "{Click Down}" + Sleep 100 + SendEvent "{Click " beeX " " beeY " 0}" + Sleep 100 + Send "{Click Up}" + Loop 10 + { + Sleep 100 + pBMScreen := Gdip_BitmapFromScreen(windowX+(54*windowWidth)//100-300 "|" windowY+offsetY+(46*windowHeight)//100-59 "|250|100") + if (Gdip_ImageSearch(pBMScreen, bitmaps["feed"], &pos, , , , , 2, , 2) = 1) + { + Gdip_DisposeImage(pBMScreen) + SendEvent "{Click " windowX+(54*windowWidth)//100-300+SubStr(pos, 1, InStr(pos, ",")-1)+140 " " windowY+offsetY+(46*windowHeight)//100-59+SubStr(pos, InStr(pos, ",")+1)+5 "}" ; Click Number + Sleep 100 + Loop StrLen(bitterberrynos) + { + SendEvent "{Text}" SubStr(bitterberrynos, A_Index, 1) + Sleep 100 + } + SendEvent "{Click " windowX+(54*windowWidth)//100-300+SubStr(pos, 1, InStr(pos, ",")-1) " " windowY+offsetY+(46*windowHeight)//100-59+SubStr(pos, InStr(pos, ",")+1) "}" ; Click Feed + break + } + Gdip_DisposeImage(pBMScreen) + if (A_Index = 10) + continue 2 + } + Sleep 750 + + pBMScreen := Gdip_BitmapFromScreen(windowX+windowWidth//2-295 "|" windowY+offsetY+((4*windowHeight)//10 - 15) "|150|50") + if (Gdip_ImageSearch(pBMScreen, bitmaps["greensuccess"], , , , , , 20) = 1) { + if (MsgBox("SUCCESS!!!!``nKeep this?", "Bitterberry Auto-Feeder v0.2", 0x40024) = "Yes") + { + Gdip_DisposeImage(pBMScreen) + break + } + else + { + ActivateRoblox() + SendEvent "{Click " windowX + (windowWidth//2 - 132) " " windowY + offsetY + ((4*windowHeight)//10 - 150) "}" ; Close Bee + } + } + Gdip_DisposeImage(pBMScreen) +} + +ExitFunc(*) +{ + try StatusBar.Destroy() + try Gdip_Shutdown(pToken) + ExitApp +} \ No newline at end of file diff --git a/submacros/StatMonitor.ahk b/submacros/StatMonitor.ahk index 0277ea5..f4a86ae 100644 --- a/submacros/StatMonitor.ahk +++ b/submacros/StatMonitor.ahk @@ -1,4 +1,4 @@ -/* +/* Natro Macro (https://github.com/NatroTeam/NatroMacro) Copyright © Natro Team (https://github.com/NatroTeam) @@ -20,6 +20,7 @@ You should have received a copy of the license along with Natro Macro. If not, p #Include "Roblox.ahk" #Include "DurationFromSeconds.ahk" #Include "nowUnix.ahk" +#Include "OCR.ahk" #Warn VarUnset, Off @@ -100,7 +101,6 @@ bitmaps["pBMSatisfying"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAEAAA ; other bitmaps["pBMNatroLogo"] := Gdip_BitmapFromBase64("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") -#Include "%A_ScriptDir%\..\nm_image_assets\offset\bitmaps.ahk" @@ -115,10 +115,10 @@ ocr_enabled := 1 ocr_language := "" for k,v in Map("Windows.Globalization.Language","{9B0252AC-0C27-44F8-B792-9793FB66C63E}", "Windows.Graphics.Imaging.BitmapDecoder","{438CCB26-BCEF-4E95-BAD6-23A822E58D01}", "Windows.Media.Ocr.OcrEngine","{5BFFA85A-3384-3540-9940-699120D428A8}") { - CreateHString(k, &hString) + hString := OCR.CreateHString(k) GUID := Buffer(16), DllCall("ole32\CLSIDFromString", "WStr", v, "Ptr", GUID) result := DllCall("Combase.dll\RoGetActivationFactory", "Ptr", hString, "Ptr", GUID, "PtrP", &pClass:=0) - DeleteHString(hString) + OCR.DeleteHString(hString) if (result != 0) { ocr_enabled := 0 @@ -127,7 +127,7 @@ for k,v in Map("Windows.Globalization.Language","{9B0252AC-0C27-44F8-B792-9793FB } if (ocr_enabled = 1) { - list := ocr("ShowAvailableLanguages") + list := getAvailableLang() for lang in ["ko","en-"] ; priority list { Loop Parse list, "`n", "`r" @@ -793,6 +793,13 @@ DetectBuffs() return str } +MultiStrReplace(str, replaceMap) { + for needle, replacement in replaceMap { + str := StrReplace(str, needle, replacement) + } + return str +} + /******************************************************************** * @description: uses OCR to detect the current honey value in BSS * @returns: (string) current honey value or (integer) 0 on failure @@ -825,9 +832,9 @@ DetectHoney() hBM := Gdip_CreateHBITMAPFromBitmap(pBMNew) ;Gdip_SaveBitmapToFile(pBMNew, i A_Index ".png") Gdip_DisposeImage(pBMNew) - pIRandomAccessStream := HBitmapToRandomAccessStream(hBM) + pIRandomAccessStream := OCR.HBitmapToRandomAccessStream(hBM) DllCall("DeleteObject", "Ptr", hBM) - try detected[v := ((StrLen((n := RegExReplace(StrReplace(StrReplace(StrReplace(StrReplace(ocr(pIRandomAccessStream, ocr_language), "o", "0"), "i", "1"), "l", "1"), "a", "4"), "\D"))) > 0) ? n : 0)] := detected.Has(v) ? [detected[v][1]+1, detected[v][2] " " i . A_Index] : [1, i . A_Index] + try detected[v := ((StrLen((n := RegExReplace(MultiStrReplace(OCR(pIRandomAccessStream).Text, Map("o", "0", "i", "1", "l", "1", "a", "4")), "\D"))) > 0) ? n : 0)] := detected.Has(v) ? [detected[v][1]+1, detected[v][2] " " i . A_Index] : [1, i . A_Index] } } @@ -1776,188 +1783,6 @@ maxX(List) return X } -/************************************************************* -* @description: OCR with UWP API -* @author malcev, teadrinker -* @url https://www.autohotkey.com/boards/viewtopic.php?t=72674 -*************************************************************/ -HBitmapToRandomAccessStream(hBitmap) { - static IID_IRandomAccessStream := "{905A0FE1-BC53-11DF-8C49-001E4FC686DA}" - , IID_IPicture := "{7BF80980-BF32-101A-8BBB-00AA00300CAB}" - , PICTYPE_BITMAP := 1 - , BSOS_DEFAULT := 0 - , sz := 8 + A_PtrSize * 2 - - DllCall("Ole32\CreateStreamOnHGlobal", "Ptr", 0, "UInt", true, "PtrP", &pIStream:=0, "UInt") - - PICTDESC := Buffer(sz, 0) - NumPut("uint", sz - , "uint", PICTYPE_BITMAP - , "ptr", hBitmap, PICTDESC) - - riid := CLSIDFromString(IID_IPicture) - DllCall("OleAut32\OleCreatePictureIndirect", "Ptr", PICTDESC, "Ptr", riid, "UInt", false, "PtrP", &pIPicture:=0, "UInt") - ; IPicture::SaveAsFile - ComCall(15, pIPicture, "Ptr", pIStream, "UInt", true, "UIntP", &size:=0, "UInt") - riid := CLSIDFromString(IID_IRandomAccessStream) - DllCall("ShCore\CreateRandomAccessStreamOverStream", "Ptr", pIStream, "UInt", BSOS_DEFAULT, "Ptr", riid, "PtrP", &pIRandomAccessStream:=0, "UInt") - ObjRelease(pIPicture) - ObjRelease(pIStream) - Return pIRandomAccessStream -} - -CLSIDFromString(IID, &CLSID?) { - CLSID := Buffer(16) - if res := DllCall("ole32\CLSIDFromString", "WStr", IID, "Ptr", CLSID, "UInt") - throw Error("CLSIDFromString failed. Error: " . Format("{:#x}", res)) - Return CLSID -} - -ocr(file, lang := "FirstFromAvailableLanguages") -{ - static OcrEngineStatics, OcrEngine, MaxDimension, LanguageFactory, Language, CurrentLanguage:="", BitmapDecoderStatics, GlobalizationPreferencesStatics - if !IsSet(OcrEngineStatics) - { - CreateClass("Windows.Globalization.Language", ILanguageFactory := "{9B0252AC-0C27-44F8-B792-9793FB66C63E}", &LanguageFactory) - CreateClass("Windows.Graphics.Imaging.BitmapDecoder", IBitmapDecoderStatics := "{438CCB26-BCEF-4E95-BAD6-23A822E58D01}", &BitmapDecoderStatics) - CreateClass("Windows.Media.Ocr.OcrEngine", IOcrEngineStatics := "{5BFFA85A-3384-3540-9940-699120D428A8}", &OcrEngineStatics) - ComCall(6, OcrEngineStatics, "uint*", &MaxDimension:=0) - } - text := "" - if (file = "ShowAvailableLanguages") - { - if !IsSet(GlobalizationPreferencesStatics) - CreateClass("Windows.System.UserProfile.GlobalizationPreferences", IGlobalizationPreferencesStatics := "{01BF4326-ED37-4E96-B0E9-C1340D1EA158}", &GlobalizationPreferencesStatics) - ComCall(9, GlobalizationPreferencesStatics, "ptr*", &LanguageList:=0) ; get_Languages - ComCall(7, LanguageList, "int*", &count:=0) ; count - loop count - { - ComCall(6, LanguageList, "int", A_Index-1, "ptr*", &hString:=0) ; get_Item - ComCall(6, LanguageFactory, "ptr", hString, "ptr*", &LanguageTest:=0) ; CreateLanguage - ComCall(8, OcrEngineStatics, "ptr", LanguageTest, "int*", &bool:=0) ; IsLanguageSupported - if (bool = 1) - { - ComCall(6, LanguageTest, "ptr*", &hText:=0) - b := DllCall("Combase.dll\WindowsGetStringRawBuffer", "ptr", hText, "uint*", &length:=0, "ptr") - text .= StrGet(b, "UTF-16") "`n" - } - ObjRelease(LanguageTest) - } - ObjRelease(LanguageList) - return text - } - if (lang != CurrentLanguage) or (lang = "FirstFromAvailableLanguages") - { - if IsSet(OcrEngine) - { - ObjRelease(OcrEngine) - if (CurrentLanguage != "FirstFromAvailableLanguages") - ObjRelease(Language) - } - if (lang = "FirstFromAvailableLanguages") - ComCall(10, OcrEngineStatics, "ptr*", OcrEngine) ; TryCreateFromUserProfileLanguages - else - { - CreateHString(lang, &hString) - ComCall(6, LanguageFactory, "ptr", hString, "ptr*", &Language:=0) ; CreateLanguage - DeleteHString(hString) - ComCall(9, OcrEngineStatics, "ptr", Language, "ptr*", &OcrEngine:=0) ; TryCreateFromLanguage - } - if (OcrEngine = 0) - { - msgbox 'Can not use language "' lang '" for OCR, please install language pack.' - ExitApp - } - CurrentLanguage := lang - } - IRandomAccessStream := file - ComCall(14, BitmapDecoderStatics, "ptr", IRandomAccessStream, "ptr*", &BitmapDecoder:=0) ; CreateAsync - WaitForAsync(&BitmapDecoder) - BitmapFrame := ComObjQuery(BitmapDecoder, IBitmapFrame := "{72A49A1C-8081-438D-91BC-94ECFC8185C6}") - ComCall(12, BitmapFrame, "uint*", &width:=0) ; get_PixelWidth - ComCall(13, BitmapFrame, "uint*", &height:=0) ; get_PixelHeight - if (width > MaxDimension) or (height > MaxDimension) - { - msgbox 'Image is to big - ' width 'x' height '.`nIt should be maximum - ' MaxDimension ' pixels' - ExitApp - } - BitmapFrameWithSoftwareBitmap := ComObjQuery(BitmapDecoder, IBitmapFrameWithSoftwareBitmap := "{FE287C9A-420C-4963-87AD-691436E08383}") - ComCall(6, BitmapFrameWithSoftwareBitmap, "ptr*", &SoftwareBitmap:=0) ; GetSoftwareBitmapAsync - WaitForAsync(&SoftwareBitmap) - ComCall(6, OcrEngine, "ptr", SoftwareBitmap, "ptr*", &OcrResult:=0) ; RecognizeAsync - WaitForAsync(&OcrResult) - ComCall(6, OcrResult, "ptr*", &LinesList:=0) ; get_Lines - ComCall(7, LinesList, "int*", &count:=0) ; count - loop count - { - ComCall(6, LinesList, "int", A_Index-1, "ptr*", &OcrLine:=0) - ComCall(7, OcrLine, "ptr*", &hText:=0) - buf := DllCall("Combase.dll\WindowsGetStringRawBuffer", "ptr", hText, "uint*", &length:=0, "ptr") - text .= StrGet(buf, "UTF-16") "`n" - ObjRelease(OcrLine) - } - Close := ComObjQuery(IRandomAccessStream, IClosable := "{30D5A829-7FA4-4026-83BB-D75BAE4EA99E}") - ComCall(6, Close) ; Close - Close := ComObjQuery(SoftwareBitmap, IClosable := "{30D5A829-7FA4-4026-83BB-D75BAE4EA99E}") - ComCall(6, Close) ; Close - ObjRelease(IRandomAccessStream) - ObjRelease(BitmapDecoder) - ObjRelease(SoftwareBitmap) - ObjRelease(OcrResult) - ObjRelease(LinesList) - return text -} - -CreateClass(str, interface, &Class) -{ - CreateHString(str, &hString) - GUID := CLSIDFromString(interface) - result := DllCall("Combase.dll\RoGetActivationFactory", "ptr", hString, "ptr", GUID, "ptr*", &Class:=0) - if (result != 0) - { - if (result = 0x80004002) - msgbox "No such interface supported" - else if (result = 0x80040154) - msgbox "Class not registered" - else - msgbox "error: " result - } - DeleteHString(hString) -} - -CreateHString(str, &hString) -{ - DllCall("Combase.dll\WindowsCreateString", "wstr", str, "uint", StrLen(str), "ptr*", &hString:=0) -} - -DeleteHString(hString) -{ - DllCall("Combase.dll\WindowsDeleteString", "ptr", hString) -} - -WaitForAsync(&Object) -{ - AsyncInfo := ComObjQuery(Object, IAsyncInfo := "{00000036-0000-0000-C000-000000000046}") - loop - { - ComCall(7, AsyncInfo, "uint*", &status:=0) ; IAsyncInfo.Status - if (status != 0) - { - if (status != 1) - { - ComCall(8, AsyncInfo, "uint*", &ErrorCode:=0) ; IAsyncInfo.ErrorCode - msgbox "AsyncInfo status error: " ErrorCode - ExitApp - } - break - } - sleep 10 - } - ComCall(8, Object, "ptr*", &ObjectResult:=0) ; GetResults - ObjRelease(Object) - Object := ObjectResult -} - Send_WM_COPYDATA(StringToSend, TargetScriptTitle, wParam:=0) { CopyDataStruct := Buffer(3*A_PtrSize) diff --git a/submacros/Status.ahk b/submacros/Status.ahk index 39c2e9a..066ade1 100644 --- a/submacros/Status.ahk +++ b/submacros/Status.ahk @@ -21,6 +21,7 @@ You should have received a copy of the license along with Natro Macro. If not, p #Include "Gdip_ImageSearch.ahk" #Include "JSON.ahk" #Include "DurationFromSeconds.ahk" +#Include "OCR.ahk" #Include "Roblox.ahk" OnError (e, mode) => (mode = "Return") ? -1 : 0 @@ -646,7 +647,6 @@ settings["PriorityListNumeric"] := {enum: 366, type: "int", section: "Settings", bitmaps := Map() bitmaps["moon"] := Gdip_BitmapFromBase64("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") -#Include "%A_ScriptDir%\..\nm_image_assets\offset\bitmaps.ahk" Loop { diff --git a/submacros/background.ahk b/submacros/background.ahk index aef938f..d27aa74 100644 --- a/submacros/background.ahk +++ b/submacros/background.ahk @@ -20,6 +20,7 @@ You should have received a copy of the license along with Natro Macro. If not, p #Include "Gdip_ImageSearch.ahk" #Include "Roblox.ahk" #Include "DurationFromSeconds.ahk" +#Include "OCR.ahk" #Include "nowUnix.ahk" OnError (e, mode) => (mode = "Return") ? -1 : 0 @@ -50,7 +51,6 @@ LastNightMemoryMatch := A_Args[12] pToken := Gdip_Startup() bitmaps := Map(), bitmaps.CaseSense := 0 -#Include "%A_ScriptDir%\..\nm_image_assets\offset\bitmaps.ahk" #Include "%A_ScriptDir%\..\nm_image_assets\night\bitmaps.ahk" CoordMode "Pixel", "Screen" @@ -189,12 +189,12 @@ nm_dayOrNight(){ } } ;return if pollen text is not visible (darkened background) - pBMScreen := Gdip_BitmapFromScreen(windowX+windowWidth//2 "|" windowY "|60|100") - if (Gdip_ImageSearch(pBMScreen, bitmaps["toppollen"], , , , , , 8) != 1) { - Gdip_DisposeImage(pBMScreen) - return - } - Gdip_DisposeImage(pBMScreen) + ; pBMScreen := Gdip_BitmapFromScreen(windowX+windowWidth//2 "|" windowY "|60|100") + ; if (Gdip_ImageSearch(pBMScreen, bitmaps["toppollen"], , , , , , 8) != 1) { + ; Gdip_DisposeImage(pBMScreen) + ; return + ; } + ; Gdip_DisposeImage(pBMScreen) try { pBMScreen := Gdip_BitmapFromScreen(windowX "|" windowY + 2*windowHeight//5 "|" windowWidth "|" 3*windowHeight//5) diff --git a/submacros/natro_macro.ahk b/submacros/natro_macro.ahk index 8d7cf53..263c56e 100644 --- a/submacros/natro_macro.ahk +++ b/submacros/natro_macro.ahk @@ -29,6 +29,7 @@ You should have received a copy of the license along with Natro Macro. If not, p #Include "Roblox.ahk" #Include "DurationFromSeconds.ahk" #Include "nowUnix.ahk" +#include "OCR.ahk" #Warn VarUnset, Off OnError (e, mode) => (mode = "Return") ? -1 : 0 @@ -887,7 +888,7 @@ nm_ReadIni(path) ; GAME DATA ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; nectarnames:=["Comforting", "Refreshing", "Satisfying", "Motivating", "Invigorating"] -planternames:=["PlasticPlanter", "CandyPlanter", "BlueClayPlanter", "RedClayPlanter", "TackyPlanter", "PesticidePlanter", "HeatTreatedPlanter", "HydroponicPlanter", "PetalPlanter", "PlanterOfPlenty", "PaperPlanter", "TicketPlanter"] +planternames:=["PlasticPlanter", "CandyPlanter", "BlueClayPlanter", "RedClayPlanter", "TackyPlanter", "PesticidePlanter", "Heat-TreatedPlanter", "HydroponicPlanter", "PetalPlanter", "PlanterOfPlenty", "PaperPlanter", "TicketPlanter"] fieldnames:=["dandelion", "sunflower", "mushroom", "blueflower", "clover", "strawberry", "spider", "bamboo", "pineapple", "stump", "cactus", "pumpkin", "pinetree", "rose", "mountaintop", "pepper", "coconut"] ComfortingFields:=["Dandelion", "Bamboo", "Pine Tree"] @@ -909,7 +910,7 @@ BambooPlanters:=[["HydroponicPlanter", 1.4, 1.375, 8.73] ; 1.925 , ["PlasticPlanter", 1, 1, 2] ; 1 , ["CandyPlanter", 1, 1, 4] ; 1 , ["RedClayPlanter", 1, 1, 6] ; 1 - , ["HeatTreatedPlanter", 1, 1, 12] ; 1 + , ["Heat-TreatedPlanter", 1, 1, 12] ; 1 , ["PaperPlanter", .75, 1, 1] ; 0.75 , ["TicketPlanter", 2, 1, 2]] ; 2 @@ -922,11 +923,11 @@ BlueFlowerPlanters:=[["HydroponicPlanter", 1.4, 1.345, 8.93] ; 1.883 , ["CandyPlanter", 1, 1, 4] ; 1 , ["RedClayPlanter", 1, 1, 6] ; 1 , ["PesticidePlanter", 1, 1, 10] ; 1 - , ["HeatTreatedPlanter", 1, 1, 12] ; 1 + , ["Heat-TreatedPlanter", 1, 1, 12] ; 1 , ["PaperPlanter", .75, 1, 1] ; 0.75 , ["TicketPlanter", 2, 1, 2]] ; 1 -CactusPlanters:=[["HeatTreatedPlanter", 1.4, 1.215, 9.88] ; 1.701 +CactusPlanters:=[["Heat-TreatedPlanter", 1.4, 1.215, 9.88] ; 1.701 , ["PlanterOfPlenty", 1.5, 1, 16] ; 1.5 , ["RedClayPlanter", 1.2, 1.1075, 5.42] ; 1.29 , ["HydroponicPlanter", 1, 1.25, 9.6] ; 1.25 @@ -939,7 +940,7 @@ CactusPlanters:=[["HeatTreatedPlanter", 1.4, 1.215, 9.88] ; 1.701 , ["PaperPlanter", .75, 1, 1] ; 0.75 , ["TicketPlanter", 2, 1, 2]] ; 2 -CloverPlanters:=[["HeatTreatedPlanter", 1.4, 1.17, 10.26] ; 1.638 +CloverPlanters:=[["Heat-TreatedPlanter", 1.4, 1.17, 10.26] ; 1.638 , ["TackyPlanter", 1, 1.5, 5.34] ; 1.5 , ["PlanterOfPlenty", 1.5, 1, 16] ; 1.5 , ["RedClayPlanter", 1.2, 1.085, 5.53] ; 1.302 @@ -957,7 +958,7 @@ CoconutPlanters:=[["PlanterOfPlenty", 1.5, 1.5, 10.67] ; 2.25 , ["PetalPlanter", 1, 1.447, 9.68] ; 1.447 , ["HydroponicPlanter", 1.4, 1.023, 11.74] ; 1.4322 , ["BlueClayPlanter", 1.2, 1.0115, 5.94] ; 1.2138 - , ["HeatTreatedPlanter", 1, 1.03, 11.66] ; 1.03 + , ["Heat-TreatedPlanter", 1, 1.03, 11.66] ; 1.03 , ["RedClayPlanter", 1, 1.015, 5.92] ; 1.015 , ["PlasticPlanter", 1, 1, 2] ; 1 , ["TackyPlanter", 1, 1, 8] ; 1 @@ -970,7 +971,7 @@ DandelionPlanters:=[["PetalPlanter", 1.5, 1.4235, 9.84] ; 2.13525 , ["PlanterOfPlenty", 1.5, 1, 16] ; 1.5 , ["HydroponicPlanter", 1.4, 1.0485, 11.45] ; 1.4679 , ["BlueClayPlanter", 1.2, 1.02425, 5.86] ; 1.2291 - , ["HeatTreatedPlanter", 1, 1.028, 11.68] ; 1.028 + , ["Heat-TreatedPlanter", 1, 1.028, 11.68] ; 1.028 , ["RedClayPlanter", 1, 1.014, 5.92] ; 1.014 , ["PlasticPlanter", 1, 1, 2] ; 1 , ["CandyPlanter", 1, 1, 4] ; 1 @@ -979,7 +980,7 @@ DandelionPlanters:=[["PetalPlanter", 1.5, 1.4235, 9.84] ; 2.13525 , ["TicketPlanter", 2, 1, 2]] ; 2 MountainTopPlanters:=[["PlanterOfPlenty", 1.5, 1.5, 10.67] ; 2.25 - , ["HeatTreatedPlanter", 1.4, 1.25, 9.6] ; 1.75 + , ["Heat-TreatedPlanter", 1.4, 1.25, 9.6] ; 1.75 , ["RedClayPlanter", 1.2, 1.125, 5.34] ; 1.35 , ["HydroponicPlanter", 1, 1.25, 9.6] ; 1.25 , ["BlueClayPlanter", 1, 1.125, 5.34] ; 1.125 @@ -991,7 +992,7 @@ MountainTopPlanters:=[["PlanterOfPlenty", 1.5, 1.5, 10.67] ; 2.25 , ["PaperPlanter", .75, 1, 1] ; 0.75 , ["TicketPlanter", 2, 1, 2]] ; 2 -MushroomPlanters:=[["HeatTreatedPlanter", 1.4, 1.3425, 8.94] ; 1.8795 +MushroomPlanters:=[["Heat-TreatedPlanter", 1.4, 1.3425, 8.94] ; 1.8795 , ["TackyPlanter", 1, 1.5, 5.34] ; 1.5 , ["PlanterOfPlenty", 1.5, 1, 16] ; 1.5 , ["PesticidePlanter", 1.3, 1, 10] ; 1.3 @@ -1005,7 +1006,7 @@ MushroomPlanters:=[["HeatTreatedPlanter", 1.4, 1.3425, 8.94] ; 1.8795 , ["TicketPlanter", 2, 1, 2]] ; 1 PepperPlanters:=[["PlanterOfPlenty", 1.5, 1.5, 10.67] ; 2.25 - , ["HeatTreatedPlanter", 1.4, 1.46, 8.22] ; 2.044 + , ["Heat-TreatedPlanter", 1.4, 1.46, 8.22] ; 2.044 , ["RedClayPlanter", 1.2, 1.23, 4.88] ; 1.476 , ["PetalPlanter", 1, 1.04, 13.47] ; 1.04 , ["PlasticPlanter", 1, 1, 2] ; 1 @@ -1026,7 +1027,7 @@ PineTreePlanters:=[["HydroponicPlanter", 1.4, 1.42, 8.46] ; 1.988 , ["CandyPlanter", 1, 1, 4] ; 1 , ["RedClayPlanter", 1, 1, 6] ; 1 , ["PesticidePlanter", 1, 1, 10] ; 1 - , ["HeatTreatedPlanter", 1, 1, 12] ; 1 + , ["Heat-TreatedPlanter", 1, 1, 12] ; 1 , ["PaperPlanter", .75, 1, 1] ; 0.75 , ["TicketPlanter", 2, 1, 2]] ; 2 @@ -1036,7 +1037,7 @@ PineapplePlanters:=[["PetalPlanter", 1.5, 1.445, 9.69] ; 2.1675 , ["PesticidePlanter", 1.3, 1, 10] ; 1.3 , ["TackyPlanter", 1.25, 1, 8] ; 1.25 , ["RedClayPlanter", 1.2, 1.015, 5.92] ; 1.218 - , ["HeatTreatedPlanter", 1, 1.03, 11.66] ; 1.03 + , ["Heat-TreatedPlanter", 1, 1.03, 11.66] ; 1.03 , ["HydroponicPlanter", 1, 1.025, 11.71] ; 1.025 , ["BlueClayPlanter", 1, 1.0125, 5.93] ; 1.0125 , ["PlasticPlanter", 1, 1, 2] ; 1 @@ -1048,7 +1049,7 @@ PumpkinPlanters:=[["PetalPlanter", 1.5, 1.285, 10.9] ; 1.9275 , ["PesticidePlanter", 1.3, 1, 10] ; 1.3 , ["RedClayPlanter", 1.2, 1.055, 5.69] ; 1.266 , ["TackyPlanter", 1.25, 1, 8] ; 1.25 - , ["HeatTreatedPlanter", 1, 1.11, 10.82] ; 1.11 + , ["Heat-TreatedPlanter", 1, 1.11, 10.82] ; 1.11 , ["HydroponicPlanter", 1, 1.105, 10.86] ; 1.105 , ["BlueClayPlanter", 1, 1.0525, 5.71] ; 1.0525 , ["PlasticPlanter", 1, 1, 2] ; 1 @@ -1056,7 +1057,7 @@ PumpkinPlanters:=[["PetalPlanter", 1.5, 1.285, 10.9] ; 1.9275 , ["PaperPlanter", .75, 1, 1] ; 0.75 , ["TicketPlanter", 2, 1, 2]] ; 2 -RosePlanters:=[["HeatTreatedPlanter", 1.4, 1.41, 8.52] ; 1.974 +RosePlanters:=[["Heat-TreatedPlanter", 1.4, 1.41, 8.52] ; 1.974 , ["PlanterOfPlenty", 1.5, 1, 16] ; 1.5 , ["PesticidePlanter", 1.3, 1, 10] ; 1.3 , ["RedClayPlanter", 1, 1.205, 4.98] ; 1.205 @@ -1072,7 +1073,7 @@ RosePlanters:=[["HeatTreatedPlanter", 1.4, 1.41, 8.52] ; 1.974 SpiderPlanters:=[["PesticidePlanter", 1.3, 1.6, 6.25] ; 2.08 , ["PetalPlanter", 1, 1.5, 9.33] ; 1.5 , ["PlanterOfPlenty", 1.5, 1, 16] ; 1.5 - , ["HeatTreatedPlanter", 1.4, 1, 12] ; 1.4 + , ["Heat-TreatedPlanter", 1.4, 1, 12] ; 1.4 , ["CandyPlanter", 1.2, 1, 4] ; 1.2 , ["PlasticPlanter", 1, 1, 2] ; 1 , ["BlueClayPlanter", 1, 1, 6] ; 1 @@ -1086,7 +1087,7 @@ StrawberryPlanters:=[["PesticidePlanter", 1, 1.6, 6.25] ; 1.6 , ["CandyPlanter", 1, 1.5, 2.67] ; 1.5 , ["PlanterOfPlenty", 1.5, 1, 16] ; 1.5 , ["HydroponicPlanter", 1.4, 1, 12] ; 1.3 - , ["HeatTreatedPlanter", 1, 1.345, 8.93] ; 1.345 + , ["Heat-TreatedPlanter", 1, 1.345, 8.93] ; 1.345 , ["BlueClayPlanter", 1.2, 1, 6] ; 1.2 , ["RedClayPlanter", 1, 1.1725, 5.12] ; 1.1725 , ["PetalPlanter", 1, 1.155, 12.13] ; 1.155 @@ -1096,7 +1097,7 @@ StrawberryPlanters:=[["PesticidePlanter", 1, 1.6, 6.25] ; 1.6 , ["TicketPlanter", 2, 1, 2]] ; 2 StumpPlanters:=[["PlanterOfPlenty", 1.5, 1.5, 10.67] ; 2.25 - , ["HeatTreatedPlanter", 1.4, 1.03, 11.65] ; 1.442 + , ["Heat-TreatedPlanter", 1.4, 1.03, 11.65] ; 1.442 , ["HydroponicPlanter", 1, 1.375, 8.73] ; 1.375 , ["PesticidePlanter", 1.3, 1, 10] ; 1.3 , ["CandyPlanter", 1.2, 1, 4] ; 1.2 @@ -1113,7 +1114,7 @@ SunflowerPlanters:=[["PetalPlanter", 1.5, 1.3415, 10.44] ; 2.01225 , ["PlanterOfPlenty", 1.5, 1, 16] ; 1.5 , ["PesticidePlanter", 1.3, 1, 10] ; 1.3 , ["RedClayPlanter", 1.2, 1.04175, 5.76] ; 1.2501 - , ["HeatTreatedPlanter", 1, 1.0835, 11.08] ; 1.0835 + , ["Heat-TreatedPlanter", 1, 1.0835, 11.08] ; 1.0835 , ["HydroponicPlanter", 1, 1.075, 11.17] ; 1.075 , ["BlueClayPlanter", 1, 1.0375, 5.79] ; 1.0375 , ["PlasticPlanter", 1, 1, 2] ; 1 @@ -2036,10 +2037,8 @@ hBitmapsSBT := Map(), hBitmapsSBT.CaseSense := 0 #Include "collect\bitmaps.ahk" #Include "kill\bitmaps.ahk" #Include "boost\bitmaps.ahk" -#Include "inventory\bitmaps.ahk" #Include "reconnect\bitmaps.ahk" #Include "fdc\bitmaps.ahk" -#Include "offset\bitmaps.ahk" #Include "perfstats\bitmaps.ahk" #Include "gui\blendershrine_bitmaps.ahk" #Include "quests\bitmaps.ahk" @@ -7638,147 +7637,14 @@ nm_BitterberryFeeder(*) MsgBox "You must have Bee Swarm Simulator open to use this!", "Bitterberry Auto-Feeder", 0x40030 " T20" return } - - script := - ( - ' - #NoTrayIcon - #SingleInstance Force - - #Include "%A_ScriptDir%\lib" - #Include "Gdip_All.ahk" - #Include "Gdip_ImageSearch.ahk" - #Include "Roblox.ahk" - #Include "nm_OpenMenu.ahk" - #Include "nm_InventorySearch.ahk" - - CoordMode "Mouse", "Screen" - OnExit(ExitFunc) - pToken := Gdip_Startup() - - bitmaps := Map() - bitmaps["itemmenu"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAACcAAAAuAQAAAACD1z1QAAAAAnRSTlMAAHaTzTgAAAB4SURBVHjanc2hDcJQGAbAex9NQCCQyA6CqGMswiaM0lGACSoQDWn6I5A4zNnDiY32aCPbuoujA1rNUIsggqZRrgmGdJAd+qwN2YdDdEiPXUCgy3lGQJ6I8VK1ZoT4cQBjVa2tUAH/uTHwvZbcMWfClBduVK2i9/YB0wgl4MlLHxIAAAAASUVORK5CYII=") - bitmaps["questlog"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAACoAAAAnAQAAAABRJucoAAAAAnRSTlMAAHaTzTgAAACASURBVHjajczBCcJAEEbhl42wuSUVmFjJphRL2dLGEuxAxQIiePCw+MswBRgY+OANMxgUoJG1gZj1Bd0lWeIIkKCrgBqjxzcfjxs4/GcKhiBXVyL7M0WEIZiCJVgDoJPPJUGtcV5ksWMHB6jCWQv0dl46ToxqzJZePHnQw9W4/QAf0C04CGYsYgAAAABJRU5ErkJggg==") - bitmaps["beemenu"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAACsAAAAsAQAAAADUI3zVAAAAAnRSTlMAAHaTzTgAAACaSURBVHjadc5BDgIhDAXQT9U4y1m6G24inkyO4lGaOUm9AW7MzMY6HyQxJjaBFwotxdW3UAEjNhCc+/1z+mXGmgCH22Ti/S5bIRoXSMgtmTASBeOFsx6td/lDIgGIJ8Czl6kVRAguGL4mW9NcC8zJUjRvlCXXZH3kxiUYW+sBgewhRPq3exIwEOhYiZHl/nS3HdIBePQBlfvtDUnsNfflK46tAAAAAElFTkSuQmCC") - bitmaps["item"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAAMAAAAUAQMAAAByNRXfAAAAA1BMVEXU3dp/aiCuAAAAC0lEQVR42mMgEgAAACgAAU1752oAAAAASUVORK5CYII=") - bitmaps["bitterberry"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAG8AAAAbCAMAAABFqCGFAAAB11BMVEUbKjUcKzYdLDceLDceLTgfLjkgLzohMDoiMDsjMTwkMj0kMz0lND4mND8oNkApN0EqOEMrOUMsOkQtO0UuPEYvPUcwPkgyQEkzQUo0QUs1Q0w3RU44RU85Rk86SFE8SVM9SlM+S1Q/TFVATVZCT1hDUFlEUVlFUVpGU1xHVFxJVV5KVl9LV19NWWJPW2NRXWVSXmZUYGhVYWhWYWlXYmpXY2tbZm5cZ29daG9eanFibXRibnVkb3ZlcHdoc3ptd35ueX9veoBweoFzfYN0foR1f4V2gIZ4god6hIp7hYt+h41/iY6Aio+FjpSGj5SHkJWKk5iLlJmMlZqNlpqOl5uQmJ2QmZ2Rmp6Sm5+UnKCVnaGZoaWbo6ecpKigp6uhqKyjq66mrbCnrrGnr7Kor7OrsrWss7avtrmwt7myuLu2vL+4v8G5wMK6wMO8wsS+xMa/xcfAxsjBx8nDyMrEyszGzM3HzM7Izc/Jzs/Jz9DK0NHN0tPP1NXQ1dbR1tfS19jV2drX3NzY3N3Z3d7b4ODc4OHe4uLf4+Pg5OTg5eXi5ubj5+fm6urn6+vo7Ovp7ezq7e3r7u7r7+7s8O/t8fDu8fHv8vHw8/Lx9PPx9fTy9fTz9vX09/ZX5XClAAACKElEQVR42u3W61NMYQDH8W9iu7uEhAhJURIphYRci0QiFXKJXAttQnIPXdVWK/3+WHvK6dnZfaY3O443fm9+L34zz2fmzDPnHORt+O/9BS8HJ6mlL2Xys6XJlCVTLbUxepDQJaln9b5ZSXs4J7dsKeZIzB45kvzpRY6XHYLcsiU/Ju+YpOHD8NEdPPDUD8+kL52dwcW9K2kF3cazzqYX8d5Ar9QMQ7qMk/o/JU3WZfnWnx2RVEpWPLSFvJ1FKekVvZIss9v10C9JfXAy0hsswTdu937tx0nepHMgkDCifHPFLLPbn5dQI0k18NpyX05r3ot8nq2sejz+dCVNcwfeDAwq5CW1TzzPZLttNl3CmqA0k0G+or3kd7J7uTRIqqNw7oFJcrwKSbfhvWU2fRfuSw+h1eKxdsjqBeKYT6pz0G4Z7yt0WGbTkys4IFWSPKpwr1rSjzPQbPW+4SYY4U1Dm3V2WyeIHxhOpEpRnoJJnLJ6E3BJ84nwQlS7bTaeHxquwwuLN5XIeRmvVgu1iTJJ09FeB7wys83TNjYXslXR3mg1+Be8XeTe8bt1gbgbga6Msu5wL+lWoG8L62ZkZpt3FeCa/f15VAteLfDJrYkdOFn+NtybS9w9ycw27/tS8A1ZvGXZjTPGGzuYvNfUaM0GX2bVB5mDqgoOFaWkFT+SrLPxVA6VXn5vG+GJl14eG2c99Hrgojz0jhM/4KE3lkK5PPRa4cG/+x/8DdlCsT+3EwaSAAAAAElFTkSuQmCC") - bitmaps["feed"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAADwAAAAUAQMAAADrzcxqAAAABlBMVEUAAAD3//lCqWtQAAAAAXRSTlMAQObYZgAAAE1JREFUeNqNzbENwCAMRNHfpYxLSo/ACB4pG8SjMkImIAiwRIe46lX3+QtzAcE5wQ1cHeKQHhw10EwFwISK6YAvvCVg7LBamuM5fRGFBk/MFx8u1mbtAAAAAElFTkSuQmCC") - bitmaps["greensuccess"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAA4AAAALCAYAAABPhbxiAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAhdEVYdENyZWF0aW9uIFRpbWUAMjAyMzowMzowOCAxNToyMzo1N/c+ABwAAAAdSURBVChTY3T+H/6fgQzABKVJBqMa8YDhr5GBAQBwxAKu5PiUjAAAAA5lWElmTU0AKgAAAAgAAAAAAAAA0lOTAAAAAElFTkSuQmCC") - #Include "%A_ScriptDir%\nm_image_assets\offset\bitmaps.ahk" - - if (MsgBox("BITTERBERRY AUTO FEEDER v0.2 by anniespony#8135``nMake sure BEE SLOT TO MUTATE is always visible``nDO NOT MOVE THE SCREEN OR RESIZE WINDOW FROM NOW ON.``nMAKE SURE BEE IS RADIOACTIVE AT ALL TIMES!", "Bitterberry Auto-Feeder v0.2", 0x40001) = "Cancel") - ExitApp - - bitterberrynos := InputBox("Enter the amount of bitterberry used each time", "How many bitterberry?", "w320 h180 T60").Value - if IsInteger(bitterberrynos) { - if (bitterberrynos > 30) - if (MsgBox("You have entered " bitterberrynos " which is more than 30.``nAre you sure?", "Bitterberry Auto-Feeder v0.2", 0x40034) = "No") - ExitApp - } else { - MsgBox "You must enter a number for Bitterberries!!``nStopping Feeder!", "Bitterberry Auto-Feeder v0.2", 0x40010 - ExitApp - } - - if (MsgBox("After dismissing this message,``nleft click ONLY once on BEE SLOT", "Bitterberry Auto-Feeder v0.2", 0x40001) = "Cancel") - ExitApp - - hwnd := GetRobloxHWND() - ActivateRoblox() - GetRobloxClientPos(hwnd) - offsetY := GetYOffset(hwnd, &offsetfail) - if (offsetfail = 1) { - MsgBox "Unable to detect in-game GUI offset!``nStopping Feeder!``n``nThere are a few reasons why this can happen, including:``n - Incorrect graphics settings``n - Your `'Experience Language`' is not set to English``n - Something is covering the top of your Roblox window``n``nJoin our Discord server for support and our Knowledge Base post on this topic (Unable to detect in-game GUI offset)!", "WARNING!!", "0x40030" - ExitApp - } - - StatusBar := Gui("-Caption +E0x80000 +AlwaysOnTop +ToolWindow -DPIScale") - StatusBar.Show("NA") - hbm := CreateDIBSection(windowWidth, windowHeight), hdc := CreateCompatibleDC(), obm := SelectObject(hdc, hbm) - G := Gdip_GraphicsFromHDC(hdc), Gdip_SetSmoothingMode(G, 2), Gdip_SetInterpolationMode(G, 2) - Gdip_FillRectangle(G, pBrush := Gdip_BrushCreateSolid(0x60000000), -1, -1, windowWidth+1, windowHeight+1), Gdip_DeleteBrush(pBrush) - UpdateLayeredWindow(StatusBar.Hwnd, hdc, windowX, windowY, windowWidth, windowHeight) - - KeyWait "LButton", "D" ; Wait for the left mouse button to be pressed down. - MouseGetPos &beeX, &beeY - Gdip_GraphicsClear(G), Gdip_FillRectangle(G, pBrush := Gdip_BrushCreateSolid(0xd0000000), -1, -1, windowWidth+1, 38), Gdip_DeleteBrush(pBrush) - Gdip_TextToGraphics(G, "Mutating... Right Click or Shift to Stop!", "x0 y0 cffff5f1f Bold Center vCenter s24", "Tahoma", windowWidth, 38) - UpdateLayeredWindow(StatusBar.Hwnd, hdc, windowX, windowY, windowWidth, 38) - SelectObject(hdc, obm), DeleteObject(hbm), DeleteDC(hdc), Gdip_DeleteGraphics(G) - try - { - Hotkey "Shift", ExitFunc, "On" - Hotkey "RButton", ExitFunc, "On" - Hotkey "F11", ExitFunc, "On" - } - Sleep 250 - - Loop - { - if ((pos := nm_InventorySearch("bitterberry", "down", , , , (A_Index = 1) ? 40 : 4)) = 0) - { - MsgBox "You ran out of Bitterberries!", "Bitterberry Auto-Feeder v0.2", 0x40010 - break - } - GetRobloxClientPos(hwnd) - - SendEvent "{Click " windowX+pos[1] " " windowY+pos[2] " 0}" - Send "{Click Down}" - Sleep 100 - SendEvent "{Click " beeX " " beeY " 0}" - Sleep 100 - Send "{Click Up}" - Loop 10 - { - Sleep 100 - pBMScreen := Gdip_BitmapFromScreen(windowX+(54*windowWidth)//100-300 "|" windowY+offsetY+(46*windowHeight)//100-59 "|250|100") - if (Gdip_ImageSearch(pBMScreen, bitmaps["feed"], &pos, , , , , 2, , 2) = 1) - { - Gdip_DisposeImage(pBMScreen) - SendEvent "{Click " windowX+(54*windowWidth)//100-300+SubStr(pos, 1, InStr(pos, ",")-1)+140 " " windowY+offsetY+(46*windowHeight)//100-59+SubStr(pos, InStr(pos, ",")+1)+5 "}" ; Click Number - Sleep 100 - Loop StrLen(bitterberrynos) - { - SendEvent "{Text}" SubStr(bitterberrynos, A_Index, 1) - Sleep 100 - } - SendEvent "{Click " windowX+(54*windowWidth)//100-300+SubStr(pos, 1, InStr(pos, ",")-1) " " windowY+offsetY+(46*windowHeight)//100-59+SubStr(pos, InStr(pos, ",")+1) "}" ; Click Feed - break - } - Gdip_DisposeImage(pBMScreen) - if (A_Index = 10) - continue 2 - } - Sleep 750 - - pBMScreen := Gdip_BitmapFromScreen(windowX+windowWidth//2-295 "|" windowY+offsetY+((4*windowHeight)//10 - 15) "|150|50") - if (Gdip_ImageSearch(pBMScreen, bitmaps["greensuccess"], , , , , , 20) = 1) { - if (MsgBox("SUCCESS!!!!``nKeep this?", "Bitterberry Auto-Feeder v0.2", 0x40024) = "Yes") - { - Gdip_DisposeImage(pBMScreen) - break - } - else - { - ActivateRoblox() - SendEvent "{Click " windowX + (windowWidth//2 - 132) " " windowY + offsetY + ((4*windowHeight)//10 - 150) "}" ; Close Bee - } - } - Gdip_DisposeImage(pBMScreen) - } - ExitApp - - ExitFunc(*) - { - try StatusBar.Destroy() - try Gdip_Shutdown(pToken) - ExitApp - } - ' - ) - - shell := ComObject("WScript.Shell") - exec := shell.Exec('"' exe_path64 '" /script /force *') - exec.StdIn.Write(script), exec.StdIn.Close() + + ; if somebody has ahk open to vs code as default it'd open it in vs code + ; so define A_AhkPath + global BitterBerryPID + try ProcessClose(BitterBerryPID) + + exec := ComObject("WScript.shell").Exec('"' A_AhkPath '" /force "' A_ScriptDir "\BitterBerry.ahk" '"') + return (BitterBerryPID := exec.ProcessID) } nm_BasicEggHatcher(*) { @@ -7788,143 +7654,14 @@ nm_BasicEggHatcher(*) return } - script := - ( - ' - #NoTrayIcon - #SingleInstance Force - - #Include "%A_ScriptDir%\lib" - #Include "Gdip_All.ahk" - #Include "Gdip_ImageSearch.ahk" - #Include "Roblox.ahk" - #Include "nm_OpenMenu.ahk" - #Include "nm_InventorySearch.ahk" - - CoordMode "Mouse", "Screen" - OnExit(ExitFunc) - pToken := Gdip_Startup() - - bitmaps := Map() - bitmaps["itemmenu"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAACcAAAAuAQAAAACD1z1QAAAAAnRSTlMAAHaTzTgAAAB4SURBVHjanc2hDcJQGAbAex9NQCCQyA6CqGMswiaM0lGACSoQDWn6I5A4zNnDiY32aCPbuoujA1rNUIsggqZRrgmGdJAd+qwN2YdDdEiPXUCgy3lGQJ6I8VK1ZoT4cQBjVa2tUAH/uTHwvZbcMWfClBduVK2i9/YB0wgl4MlLHxIAAAAASUVORK5CYII=") - bitmaps["questlog"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAACoAAAAnAQAAAABRJucoAAAAAnRSTlMAAHaTzTgAAACASURBVHjajczBCcJAEEbhl42wuSUVmFjJphRL2dLGEuxAxQIiePCw+MswBRgY+OANMxgUoJG1gZj1Bd0lWeIIkKCrgBqjxzcfjxs4/GcKhiBXVyL7M0WEIZiCJVgDoJPPJUGtcV5ksWMHB6jCWQv0dl46ToxqzJZePHnQw9W4/QAf0C04CGYsYgAAAABJRU5ErkJggg==") - bitmaps["beemenu"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAACsAAAAsAQAAAADUI3zVAAAAAnRSTlMAAHaTzTgAAACaSURBVHjadc5BDgIhDAXQT9U4y1m6G24inkyO4lGaOUm9AW7MzMY6HyQxJjaBFwotxdW3UAEjNhCc+/1z+mXGmgCH22Ti/S5bIRoXSMgtmTASBeOFsx6td/lDIgGIJ8Czl6kVRAguGL4mW9NcC8zJUjRvlCXXZH3kxiUYW+sBgewhRPq3exIwEOhYiZHl/nS3HdIBePQBlfvtDUnsNfflK46tAAAAAElFTkSuQmCC") - bitmaps["item"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAAMAAAAUAQMAAAByNRXfAAAAA1BMVEXU3dp/aiCuAAAAC0lEQVR42mMgEgAAACgAAU1752oAAAAASUVORK5CYII=") - bitmaps["basicegg"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAGIAAAAaCAMAAAB7CnmQAAABuVBMVEUbKjUdLDceLDceLTgfLjkgLzohMDoiMDsjMTwkMj0lND4nNUAoNkApOEIqOEMrOUMsOkQtO0UuPEYvPEYvPUcwPkgxP0kyQEkzQUo0QUs1Qkw2RE03RU44RU85Rk86SFE7SVI8SVNATVZEUVlGUltGU1xKVl9LV19MWWFPW2NQXGRRXWVVYWhWYWlXYmpXY2tdaXBeanFga3JhbHNibXRibnVjbnVkb3ZmcXhncnhoc3ppdHtqdXtsdn1td35ueX9veoBweoFzfYN0foR1f4V2gIZ3gYd4god6hIp+h42Ci5GFjpSGj5SIkZaJkpePl5yQmJ2VnaGWnqKZoaWaoqabo6ecpKidpamfp6qjq66mrbCnr7Kor7Ots7avtrmwt7m1vL63vcC+xMa/xcfAxsjBx8nCyMnDyMrEyszFy8zGzM3HzM7Izc/Jzs/Jz9DN0tPQ1dbR1tfS19jT2NjU2NnV2drV2tvW29zY3N3Z3d7a39/c4OHe4uLg5OTg5eXi5ubj5+fl6ejm6enm6uro7Ovp7ezq7e3r7u7r7+7s8O/t8fDu8fHv8vHw8/Lx9PPx9fTy9fTz9vX09/Y9aLFlAAACKklEQVR42u3Ta1MSUQDG8cfiVmZBUoqmBhVkRtj9JkmoSRGmlbZadiG6mXnpSmG6QWlqCDyfuNlYTu3sMsNM6zufV/9X5zc7Zw+46cMWUTvhg7KdoenNJgDbU1bZa9fxEvXzQt2zWgn4WGVTzs7/JSIkc+eBNGubIKJq1UZwHkiRfHm5xdI8mOW/yySTeTOIWeANmd4GZQdzJJOd9Q1d4wVyBJBJyv0t1v3nZoyJwu1DDncEkDStIZaCsK6QHDgQH+sGhsgndVAWrhDf2qHM8cKQCKM8SbSGUDdIkqt5stiGIHkS/uzHIW+6QtxA3f21lNOaoPa6ZaWfA+GFhR5AEm1A7HhLkp/ONmxvqkeAjMDzuMgSK8Q+nCY5vUQjIgbnL/IrIIk2IOCWyczecvvJd7sAT2K5QqwAd6pf9wl0Uz1WbS0RJbkcA0bIa2ifXf/QoRD8fNEKtM6pRBp4UJ3wo1c9VrSOYN6BAfIwxkge+UOQi3EbAjV9RRdOqceK1hPrdsSVw28JYoPkKPBTcxevFg2JCJqK6rFq64nvUWCK7IcrlbtrU4gJz/gPuQeODe0fZUkYEY+A69nMBUASbXTdvSS/iOuWG8t1U7yLNt27UBciS0G1JdE6wuIdLlAxrrjtR6+GYqQc99ldxyb593X3NVvdZ2ZoRHA13mFtvARIogVh6uaBh5o2nxgG5jRtOvF+N1oLmjabmNwDjGradOIe0Kdp84m1wERJ378B3+p4iisaatgAAAAASUVORK5CYII=") - bitmaps["royaljelly"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAGwAAAAcCAMAAACzmqo+AAAB+FBMVEUbKjUcKzYdLDceLDceLTgfLjkgLzohMDoiMDsjMTwkMj0kMz0lND4mND8nNUAoNkApN0EpOEIqOEMrOUMsOkQtO0UuPEYvPEYvPUcwPkgyQEkzQUo0QUs1Qkw1Q0w3RU44RU85Rk86SFE7SVI8SVM+S1Q/TFVDUFlEUVlFUVpGUltGU1xIVV1KVl9LV19MWWFPW2NWYWlXYmpXY2tbZm5cZ29daG9daXBga3JibXRibnVlcHdpdHttd35weoFxe4FyfIJzfYN0foR1f4V2gIZ3gYd4god5goh6hIp7hYt8hot+h41/iI6Aio+BipCCi5GFjpSFjpOGj5SHkJWIkZaJkpeKk5iKk5eLlJmMlZqNlpqPl5yQmJ2QmZ2Rmp6Sm5+UnKCVnaGaoqabo6ecpKigp6ujq66kq6+lrLCor7Ots7avtrmwt7mxt7qyuLu1vL62vL+3vcC5wMK6wMO8wsS9w8W/xcfAxsjDyMrDycvEyszGzM3HzM7Jzs/K0NHL0NLN0tPO09TP1NXQ1dbR1tfS19jT2NjV2drV2tvW29zX3NzY3N3a39/b4ODc4OHd4eLe4uLf4+Pg5OTg5eXi5ubj5+fk6Ojm6enm6urn6+vo7Ovp7ezq7e3r7u7r7+7s8O/t8fDu8fHv8vHw8/Lx9fTy9fTz9vX09/a7z3nGAAACf0lEQVR42u3W+VOMcQDH8Y9KVkUUkXQqJEqH0OWokHLlzplyRSgJFZWjnEmOtqhWx77/TbNPzHeenbZtZk3GjPcPO7O73/m8dvZ5fnjEPKb/2L+IpcqTI+sBc6s9d2RuR8xBb0wKaWEuXZe+Y69Beul9ZPrVJ6Z1bvBf7eyYOVI7M7YHGMiROucLo0tqwmdtRfEL4/YN/insmfQC+FyW4EiqGIRT1nvr81LeBk//0c5ZMFd1UujaiiEbZlsx2NBOpQMD8fKU8pX3QaoEqJSeQlni0frt0knf2FSOPKW7bJhtReYGWfwEKFdks6txsY5AtmImYDJWGcDYBEwlKds3Vqfo5pGWKF2yYbYVgwV1A1NLdBo4qFVwU7oF96Q64HXB8pA1S5XpG9ugGqBamXbMrJhr1ig1Ax+kx1jfDeNapm1QqLBh6IuR1Raf2NgCTRdhx8yKwcajVAR0Sr1Ah/QK9iq43+lQMVCu5K4fvSm+sZ4B/W7ChpkVg7Fb4SPwUWoDmqxz7VJNvfQI2KR6IMMbw9kHcE3qH5XOznjrmxWDtUo3wB3965rFA6xXSqbSsJhzM2CTu8K2TgIlWuEmWXnAuB2zrRjMHa9s4LAi7rpuO6Z/5UVJugxQqpUPnVcWeWHsl3b0OOtCVAXHteDqWGtsXpsXZlYMxiEF9YMzTZ7SRwA+hUihXwDezXyDuApktXkURjfKU+Rzb8ysGKxbugAMVyU7Uo+NYpUvFYKlFa92ZJXkHrBjuBuyYxelnrCOD1cmhMYVv8EbMytits5L9wkks+IfS1eimwAyK/6xDukMgWRW/GMlCu4ngMyKf+xbuPIJJLPiH6uT7hBAZuVvPMr9BDBOM9MqS26gAAAAAElFTkSuQmCC") - bitmaps["giftedstar"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAgMAAAC5YVYYAAAACVBMVEX9rDT+rDT/rDOj6H2ZAAAAFElEQVR42mNYtYoBgVYyrFoBYQMAf4AKnlh184sAAAAASUVORK5CYII=") - bitmaps["yes"] := Gdip_BitmapFromBase64("iVBORw0KGgoAAAANSUhEUgAAAB0AAAAPAQMAAAAiQ1bcAAAABlBMVEUAAAD3//lCqWtQAAAAAXRSTlMAQObYZgAAAFZJREFUeAEBSwC0/wDDAAfAAEIACGAAfgAQMAA8ABAQABgAIAgAGAAgCAAYACAYABgAP/gAGAAgAAAYAAAAABgAIAAAGAAwAAAYADAAABgAGDAAGAAP4FGfB+0KKAbEAAAAAElFTkSuQmCC") - #Include "%A_ScriptDir%\nm_image_assets\offset\bitmaps.ahk" - - if (MsgBox("WELCOME TO THE BASIC BEE REPLACEMENT PROGRAM!!!!!``nMade by anniespony#8135``n``nMake sure BEE SLOT TO CHANGE is always visible``nDO NOT MOVE THE SCREEN OR RESIZE WINDOW FROM NOW ON.``nMAKE SURE AUTO-JELLY IS DISABLED!!", "Basic Bee Replacement Program", 0x40001) = "Cancel") - ExitApp - - if (MsgBox("After dismissing this message,``nleft click ONLY once on BEE SLOT", "Basic Bee Replacement Program", 0x40001) = "Cancel") - ExitApp - - hwnd := GetRobloxHWND() - ActivateRoblox() - GetRobloxClientPos() - offsetY := GetYOffset(hwnd, &offsetfail) - if (offsetfail = 1) { - MsgBox "Unable to detect in-game GUI offset!``nStopping Feeder!``n``nThere are a few reasons why this can happen, including:``n - Incorrect graphics settings``n - Your `'Experience Language`' is not set to English``n - Something is covering the top of your Roblox window``n``nJoin our Discord server for support and our Knowledge Base post on this topic (Unable to detect in-game GUI offset)!", "WARNING!!", 0x40030 - ExitApp - } - StatusBar := Gui("-Caption +E0x80000 +AlwaysOnTop +ToolWindow -DPIScale") - StatusBar.Show("NA") - hbm := CreateDIBSection(windowWidth, windowHeight), hdc := CreateCompatibleDC(), obm := SelectObject(hdc, hbm) - G := Gdip_GraphicsFromHDC(hdc), Gdip_SetSmoothingMode(G, 2), Gdip_SetInterpolationMode(G, 2) - Gdip_FillRectangle(G, pBrush := Gdip_BrushCreateSolid(0x60000000), -1, -1, windowWidth+1, windowHeight+1), Gdip_DeleteBrush(pBrush) - UpdateLayeredWindow(StatusBar.Hwnd, hdc, windowX, windowY, windowWidth, windowHeight) - - KeyWait "LButton", "D" ; Wait for the left mouse button to be pressed down. - MouseGetPos &beeX, &beeY - Gdip_GraphicsClear(G), Gdip_FillRectangle(G, pBrush := Gdip_BrushCreateSolid(0xd0000000), -1, -1, windowWidth+1, 38), Gdip_DeleteBrush(pBrush) - Gdip_TextToGraphics(G, "Hatching... Right Click or Shift to Stop!", "x0 y0 cffff5f1f Bold Center vCenter s24", "Tahoma", windowWidth, 38) - UpdateLayeredWindow(StatusBar.Hwnd, hdc, windowX, windowY, windowWidth, 38) - SelectObject(hdc, obm), DeleteObject(hbm), DeleteDC(hdc), Gdip_DeleteGraphics(G) - Hotkey "Shift", ExitFunc, "On" - Hotkey "RButton", ExitFunc, "On" - Hotkey "F11", ExitFunc, "On" - Sleep 250 - - pBMC := Gdip_CreateBitmap(2,2), G := Gdip_GraphicsFromImage(pBMC), Gdip_GraphicsClear(G,0xffae792f), Gdip_DeleteGraphics(G) ; Common - pBMM := Gdip_CreateBitmap(2,2), G := Gdip_GraphicsFromImage(pBMM), Gdip_GraphicsClear(G,0xffbda4ff), Gdip_DeleteGraphics(G) ; Mythic - - rj := 0 - Loop - { - if ((pos := (A_Index = 1) ? nm_InventorySearch("basicegg", "up", , , , 70) : (rj = 1) ? nm_InventorySearch("royaljelly", "down", , , 0, 7) : nm_InventorySearch("basicegg", "up", , , 0, 7)) = 0) - { - MsgBox "You ran out of " ((rj = 1) ? "Royal Jellies!" : "Basic Eggs!"), "Basic Bee Replacement Program", 0x40010 - break - } - GetRobloxClientPos(hwnd) - SendEvent "{Click " windowX+pos[1] " " windowY+pos[2] " 0}" - Send "{Click Down}" - Sleep 100 - SendEvent "{Click " beeX " " beeY " 0}" - Sleep 100 - Send "{Click Up}" - Loop 10 - { - Sleep 100 - pBMScreen := Gdip_BitmapFromScreen(windowX+windowWidth//2-250 "|" windowY+offsetY+windowHeight//2-52 "|500|150") - if (Gdip_ImageSearch(pBMScreen, bitmaps["yes"], &pos, , , , , 2, , 2) = 1) - { - Gdip_DisposeImage(pBMScreen) - SendEvent "{Click " windowX+windowWidth//2-250+SubStr(pos, 1, InStr(pos, ",")-1) " " windowY+offsetY+windowHeight//2-52+SubStr(pos, InStr(pos, ",")+1) "}" - break - } - Gdip_DisposeImage(pBMScreen) - if (A_Index = 10) - { - rj := 1 - continue 2 - } - } - Sleep 750 - - pBMScreen := Gdip_BitmapFromScreen(windowX+windowWidth//2-155 "|" windowY+offsetY+((4*windowHeight)//10 - 135) "|310|205"), rj := 0 - if (Gdip_ImageSearch(pBMScreen, pBMM, , 50, 165, 260, 205, 2, , , 5) = 5) { ; Mythic Hatched - if (MsgBox("MYTHIC!!!!``nKeep this?", "Basic Bee Replacement Program", 0x40024) = "Yes") - { - Gdip_DisposeImage(pBMScreen) - break - } - } - else if (Gdip_ImageSearch(pBMScreen, pBMC, , 50, 165, 260, 205, 2, , , 5) = 5) { - rj := 1 - if (Gdip_ImageSearch(pBMScreen, bitmaps["giftedstar"], , 0, 20, 130, 50, 5) = 1) { ; If gifted is hatched, stop - MsgBox "SUCCESS!!!!", "Basic Bee Replacement Program", 0x40020 - Gdip_DisposeImage(pBMScreen) - break - } - } - else if (Gdip_ImageSearch(pBMScreen, bitmaps["giftedstar"], , 0, 20, 130, 50, 5) = 1) { ; Non-Basic Gifted Hatched - if (MsgBox("GIFTED!!!!``nKeep this?", "Basic Bee Replacement Program", 0x40024) = "Yes") - { - Gdip_DisposeImage(pBMScreen) - break - } - } - Gdip_DisposeImage(pBMScreen) - } - ExitApp - - ExitFunc(*) - { - try Gdip_DisposeImage(pBMC), Gdip_DisposeImage(pBMM) - try StatusBar.Destroy() - try Gdip_Shutdown(pToken) - ExitApp - } - ' - ) - - shell := ComObject("WScript.Shell") - exec := shell.Exec('"' exe_path64 '" /script /force *') - exec.StdIn.Write(script), exec.StdIn.Close() + global EggHatcherPID + try ProcessClose(EggHatcherPID) + + exec := ComObject("WScript.shell").Exec('"' A_AhkPath '" /force "' A_ScriptDir "\BasicEgg.ahk" '"') + return (EggHatcherPID := exec.ProcessID) + + ; if somebody has ahk open to vs code as default it'd open it in vs code + ; so define A_AhkPath } nm_GenerateBeeList(*) { @@ -8474,672 +8211,11 @@ nm_MakeSuggestionButton(*){ Run "https://github.com/NatroTeam/NatroMacro/issues/new?assignees=&labels=suggestion%2Cneeds+triage&projects=&template=suggestion.yml" } blc_mutations(*) { - global - local script, exec - try ProcessClose(MGUIPID) - script := - ( - ' - /************************************************************************ - * @description Auto-Jelly is a macro for the game Bee Swarm Simulator on Roblox. It automatically rolls bees for mutations and stops when a bee with the desired mutation is found. It also has the ability to stop on mythic and gifted bees. - * @file auto-jelly.ahk - * @author ninju | .ninju. - * @date 2024/07/24 - * @version 0.0.1 - ***********************************************************************/ - - #SingleInstance Force - #Requires AutoHotkey v2.0 - #Warn VarUnset, Off - ;=============INCLUDES============= - #Include %A_ScriptDir%\lib\Gdip_All.ahk - #include %A_ScriptDir%\lib\Roblox.ahk - #include %A_ScriptDir%\lib\Gdip_ImageSearch.ahk - ;================================== - SendMode("Event") - CoordMode(`'Pixel`', `'Screen`') - CoordMode(`'Mouse`', `'Screen`') - ;================================== - pToken := Gdip_Startup() - OnExit((*) => (closefunction()), -1) - OnError (e, mode) => (mode = "Return") ? -1 : 0 - stopToggle(*) { - global stopping := true - } - class __ArrEx extends Array { - static __New() { - Super.Prototype.includes := ObjBindMethod(this, `'includes`') - } - static includes(arr, val) { - for i, j in arr { - if j = val - return i - } - return 0 - } - } - - if A_ScreenDPI !== 96 - throw Error("This macro requires a display-scale of 100%") - traySetIcon(".\nm_image_assets\birb.ico") - getConfig() { - global - local k, v, p, c, i, section, key, value, inipath, config, f, ini - config := { - mutations: { - Mutations: 0, - Ability: 0, - Gather: 0, - Convert: 0, - Energy: 0, - Movespeed: 0, - Crit: 0, - Instant: 0, - Attack: 0 - }, - bees: { - Bomber: 0, - Brave: 0, - Bumble: 0, - Cool: 0, - Hasty: 0, - Looker: 0, - Rad: 0, - Rascal: 0, - Stubborn: 0, - Bubble: 0, - Bucko: 0, - Commander: 0, - Demo: 0, - Exhausted: 0, - Fire: 0, - Frosty: 0, - Honey: 0, - Rage: 0, - Riley: 0, - Shocked: 0, - Baby: 0, - Carpenter: 0, - Demon: 0, - Diamond: 0, - Lion: 0, - Music: 0, - Ninja: 0, - Shy: 0, - Buoyant: 0, - Fuzzy: 0, - Precise: 0, - Spicy: 0, - Tadpole: 0, - Vector: 0, - selectAll: 0 - }, - GUI : { - xPos: A_ScreenWidth//2-w//2, - yPos: A_ScreenHeight//2-h//2 - }, - extrasettings: { - mythicStop: 0, - giftedStop: 0 - } - } - for i, section in config.OwnProps() - for key, value in section.OwnProps() - %key% := value - if !FileExist(".\settings") - DirCreate(".\settings") - inipath := ".\settings\mutations.ini" - if FileExist(inipath) { - loop parse FileRead(inipath), "``n", "``r" A_Space A_Tab { - switch (c:=SubStr(A_LoopField,1,1)) { - case "[", ";": continue - default: - if (p := InStr(A_LoopField, "=")) - try k := SubStr(A_LoopField, 1, p-1), %k% := IsInteger(v := SubStr(A_LoopField, p+1)) ? Integer(v) : v - } - } - } - ini:="" - for k, v in config.OwnProps() { - ini .= "[" k "]``r``n" - for i in v.OwnProps() - ini .= i "=" %i% "``r``n" - ini .= "``r``n" - } - (f:=FileOpen(inipath, "w")).Write(ini), f.Close() - } - ;===Dimensions=== - w:=500,h:=397 - ;===Bee Array=== - beeArr := ["Bomber", "Brave", "Bumble", "Cool", "Hasty", "Looker", "Rad", "Rascal", "Stubborn", "Bubble", "Bucko", "Commander", "Demo", "Exhausted", "Fire", "Frosty", "Honey", "Rage", "Riley", "Shocked", "Baby", "Carpenter", "Demon", "Diamond", "Lion", "Music", "Ninja", "Shy", "Buoyant", "Fuzzy", "Precise", "Spicy", "Tadpole", "Vector"] - mutationsArr := [ - {name:"Ability", triggers:["rate", "abil", "ity"], full:"AbilityRate"}, - {name:"Gather", triggers:["gath", "herAm"], full:"GatherAmount"}, - {name:"Convert", triggers:["convert", "vertAm"], full:"ConvertAmount"}, - {name:"Instant", triggers:["inst", "antConv"], full:"InstantConversion"}, - {name:"Crit", triggers:["crit", "chance"], full:"CriticalChance"}, - {name:"Attack", triggers:["attack", "att", "ack"], full:"Attack"}, - {name:"Energy", triggers:["energy", "rgy"], full:"Energy"}, - {name:"Movespeed", triggers:["movespeed", "speed", "move"], full:"MoveSpeed"}, - ] - extrasettings:=[ - {name:"mythicStop", text: "Stop on mythics"}, - {name:"giftedStop", text: "Stop on gifteds"} - ] - getConfig() - (bitmaps := Map()).CaseSense:=0 - #Include .\nm_image_assets\mutator\bitmaps.ahk - #include .\nm_image_assets\mutatorgui\bitmaps.ahk - #include .\nm_image_assets\offset\bitmaps.ahk - startGui() { - global - local i,j,y,hBM,x - (mgui := Gui("+E" (0x00080000) " +OwnDialogs -Caption -DPIScale", "Auto-Jelly")).OnEvent("Close", ExitApp) - mgui.Show() - for i, j in [ - {name:"move", options:"x0 y0 w" w " h36"}, - {name:"selectall", options:"x" w-330 " y220 w40 h18"}, - {name:"mutations", options:"x" w-170 " y220 w40 h18"}, - {name:"close", options:"x" w-40 " y5 w28 h28"}, - {name:"roll", options:"x10 y" h-42 " w" w-56 " h30"}, - {name:"help", options:"x" w-40 " y" h-42 " w28 h28"} - ] - mgui.AddText("v" j.name " " j.options) - for i, j in beeArr { - y := (A_Index-1)//8*1 - mgui.AddText("v" j " x" 10+mod(A_Index-1,8)*60 " y" 50+y*40 " w45 h36") - } - for i, j in mutationsArr { - y := (A_Index-1)//4*1 - mgui.AddText("v" j.name " x" 10+mod(A_Index-1,4)*120 " y" 260+y*25 " w40 h18") - } - for i, j in extrasettings { - x := 10 + (w-12)/extrasettings.length * (i-1), y:=(316+h-42)//2-10 - mgui.AddText("v" j.name " x" x " y" y " w40 h18") - } - hBM := CreateDIBSection(w, h) - hDC := CreateCompatibleDC() - SelectObject(hDC, hBM) - G := Gdip_GraphicsFromHDC(hDC) - Gdip_SetSmoothingMode(G, 4) - Gdip_SetInterpolationMode(G, 7) - update := UpdateLayeredWindow.Bind(mgui.hwnd, hDC) - update(xpos < 0 ? 0 : xpos > A_ScreenWidth ? 0 : xpos, ypos < 0 ? 0 : ypos > A_ScreenHeight ? 0 : ypos, w, h) - hovercontrol := "" - DrawGUI() - } - startGUI() - OnMessage(0x201, WM_LBUTTONDOWN) - OnMessage(0x200, WM_MOUSEMOVE) - DrawGUI() { - Gdip_GraphicsClear(G) - Gdip_FillRoundedRectanglePath(G, brush := Gdip_BrushCreateSolid(0xFF131416), 2, 2, w-4, h-4, 20), Gdip_DeleteBrush(brush) - region := Gdip_GetClipRegion(G) - Gdip_SetClipRect(G, 2, 21, w-2, 30, 4) - Gdip_FillRoundedRectanglePath(G, brush := Gdip_BrushCreateSolid("0xFFFEC6DF"), 2, 2, w-4, 40, 20) - Gdip_SetClipRegion(G, region) - Gdip_FillRectangle(G, brush, 2, 20, w-4, 14) - Gdip_DeleteBrush(brush), Gdip_DeleteRegion(region) - Gdip_TextToGraphics(G, "Auto-Jelly", "s20 x20 y5 w460 Near vCenter c" (brush := Gdip_BrushCreateSolid("0xFF131416")), "Comic Sans MS", 460, 30), Gdip_DeleteBrush(brush) - Gdip_DrawImage(G, bitmaps["close"], w-40, 5, 28, 28) - for i, j in beeArr { - ;bitmaps are w45 h36 - y := (A_Index-1)//8 - bm := hovercontrol = j && (%j% || SelectAll) ? j "bghover" : %j% || SelectAll ? j "bg" : hovercontrol = j ? j "hover" : j - Gdip_DrawImage(G, bitmaps[bm], 10+mod(A_Index-1,8)*60, 50+y*40, 45, 36) - } - ;===Switches=== - Gdip_FillRoundedRectanglePath(G, brush := Gdip_BrushCreateSolid("0xFF" . 13*2 . 14*2 . 16*2), w-330, 220, 40, 18, 9), Gdip_DeleteBrush(brush) - Gdip_FillEllipse(G, brush:=Gdip_BrushCreateSolid("0xFFFEC6DF"), selectAll ? w-310 : w-332, 218, 22, 22) - Gdip_TextToGraphics(G, "Select All Bees", "s14 x" w-284 " y220 Near vCenter c" brush, "Comic Sans MS",, 20), Gdip_DeleteBrush(brush) - if !SelectAll { - Gdip_FillEllipse(G, brush:=Gdip_BrushCreateSolid("0xFF" . 13*2 . 14*2 . 16*2), w-330, 220, 18, 18), Gdip_DeleteBrush(brush) - Gdip_DrawLines(G, Pen:=Gdip_CreatePen("0xFFCC0000", 2), [[w-325, 225], [w-317, 233]]) - Gdip_DrawLines(G, Pen , [[w-325, 233], [w-317, 225]]), Gdip_DeletePen(Pen) - } - else - Gdip_DrawLines(G, Pen:=Gdip_CreatePen("0xFF006600", 2), [[w-303, 229], [w-300, 232], [w-295, 225]]), Gdip_DeletePen(Pen) - Gdip_FillRoundedRectanglePath(G, brush := Gdip_BrushCreateSolid("0xFF" . 13*2 . 14*2 . 16*2), w-170, 220, 40, 18, 9), Gdip_DeleteBrush(brush) - Gdip_FillEllipse(G, brush:=Gdip_BrushCreateSolid("0xFFFEC6DF"), mutations ? w-150 : w-172, 218, 22, 22) - Gdip_TextToGraphics(G, "Mutations", "s14 x" w-124 " y220 Near vCenter c" (brush), "Comic Sans MS",, 20), Gdip_DeleteBrush(brush) - if !mutations { - Gdip_FillEllipse(G, brush:= Gdip_BrushCreateSolid("0xFF" . 13*2 . 14*2 . 16*2), w-170, 220, 18, 18), Gdip_DeleteBrush(brush) - Gdip_DrawLines(G, Pen:=Gdip_CreatePen("0xFFCC0000", 2), [[w-165, 225], [w-157, 233]]) - Gdip_DrawLines(G, Pen , [[w-165, 233], [w-157, 225]]), Gdip_DeletePen(Pen) - } - else - Gdip_DrawLines(G, Pen:=Gdip_CreatePen("0xFF006600", 2), [[w-143, 229], [w-140, 232], [w-135, 225]]), Gdip_DeletePen(Pen) - For i, j in mutationsArr { - y := (A_Index-1)//4 - Gdip_FillRoundedRectanglePath(G, brush := Gdip_BrushCreateSolid("0xFF" . 13*2 . 14*2 . 16*2), 10+mod(A_Index-1,4)*120, 260+y*25, 40, 18, 9), Gdip_DeleteBrush(brush) - Gdip_FillEllipse(G, brush:=Gdip_BrushCreateSolid("0xFFFEC6DF"), (%j.name% ? 3.2 : 1) * 8+mod(A_Index-1,4)*120, 258+y*25, 22, 22), Gdip_DeleteBrush(brush) - Gdip_TextToGraphics(G, j.name, "s13 x" 56+mod(A_Index-1,4)*120 " y" 260+y*25 " vCenter c" (brush := Gdip_BrushCreateSolid("0xFFFEC6DF")), "Comic Sans MS", 100, 20), Gdip_DeleteBrush(brush) - if !%j.name% { - Gdip_FillEllipse(G, brush:=Gdip_BrushCreateSolid("0xFF262832"), x:=10+mod(A_Index-1,4)*120, yp:=258+y*25+2, 18, 18), Gdip_DeleteBrush(brush) - Gdip_DrawLines(G, Pen:=Gdip_CreatePen("0xFFCC0000", 2), [[x+5, yp+5 ], [x+13, yp+13]]) - Gdip_DrawLines(G, Pen , [[x+5, yp+13], [x+13, yp+5 ]]), Gdip_DeletePen(Pen) - } - else - Gdip_DrawLines(G, Pen:=Gdip_CreatePen("0xFF006600", 2), [[x:=32.6+mod(A_Index-1,4)*120, yp:=269+y*25], [x+3, yp+3], [x+8, yp-4]]), Gdip_DeletePen(Pen) - } - if !mutations - Gdip_FillRectangle(G, brush:=Gdip_BrushCreateSolid("0x70131416"), 9, 255, w-18, 52), Gdip_DeleteBrush(brush) - Gdip_DrawLine(G, Pen:=Gdip_CreatePen("0xFFFEC6DF", 2), 10, 315, w-12, 315), Gdip_DeletePen(Pen) - ;two more switches for "stop on mythic" and "stop on gifted" - for i, j in extrasettings { - x := 10 + (tw:=(w-12)/extrasettings.length) * (i-1), y:=(316+h-42)//2-10 - Gdip_FillRoundedRectanglePath(G, brush:=Gdip_BrushCreateSolid("0xFF262832"), x, y, 40, 18, 9), Gdip_DeleteBrush(brush), Gdip_DeleteBrush(brush) - Gdip_FillEllipse(G, brush:=Gdip_BrushCreateSolid("0xFFFEC6DF"), %j.name% ? x+18 : x-2, y-2, 22, 22) - Gdip_TextToGraphics(G, j.text, "s14 x" x+46 " y" y " vCenter c" brush, "Comic Sans MS", tw,20), Gdip_DeleteBrush(brush) - if !%j.name% { - Gdip_FillEllipse(G, brush:=Gdip_BrushCreateSolid("0xFF262832"), x, y, 18, 18), Gdip_deleteBrush(brush) - Gdip_DrawLines(G, Pen:=Gdip_CreatePen("0xFFCC0000", 2), [[x+5, y+5 ], [x+13, y+13]]) - Gdip_DrawLines(G, Pen , [[x+5, y+13], [x+13, y+5 ]]), Gdip_DeletePen(Pen) - } - else - Gdip_DrawLines(G, Pen:=Gdip_CreatePen("0xFF006600", 2), [[x+25, y+9], [x+28, y+12], [x+33, y+5]]), Gdip_DeletePen(Pen) - } - if hovercontrol = "roll" - Gdip_FillRoundedRectanglePath(G, brush:=Gdip_BrushCreateSolid("0x30FEC6DF"), 10, h-42, w-56, 30, 10), Gdip_DeleteBrush(brush) - if hovercontrol = "help" - Gdip_FillRoundedRectanglePath(G, brush:=Gdip_BrushCreateSolid("0x30FEC6DF"), w-40, h-42, 30, 30, 10), Gdip_DeleteBrush(brush) - Gdip_TextToGraphics(G, "Roll!", "x10 y" h-40 " Center vCenter s15 c" (brush:=Gdip_BrushCreateSolid("0xFFFEC6DF")),"Comic Sans MS",w-56, 28) - Gdip_TextToGraphics(G, "?", "x" w-39 " y" h-40 " Center vCenter s15 c" brush,"Comic Sans MS",30, 28), Gdip_DeleteBrush(brush) - Gdip_DrawRoundedRectanglePath(G, pen:=Gdip_CreatePen("0xFFFEC6DF", 4), 10, h-42, w-56, 30, 10) - Gdip_DrawRoundedRectanglePath(G, pen, w-40, h-42, 30, 30, 10), Gdip_DeletePen(pen) - update() - } - WM_LBUTTONDOWN(wParam, lParam, msg, hwnd) { - global hovercontrol, mutations, Bomber, Brave, Bumble, Cool, Hasty, Looker, Rad, Rascal - , Stubborn, Bubble, Bucko, Commander, Demo, Exhausted, Fire, Frosty, Honey, Rage - , Riley, Shocked, Baby, Carpenter, Demon, Diamond, Lion, Music, Ninja, Shy, Buoyant - , Fuzzy, Precise, Spicy, Tadpole, Vector, SelectAll, Ability, Gather, Convert, Energy - , Movespeed, Crit, Instant, Attack, mythicStop, giftedStop - MouseGetPos(,,,&ctrl,2) - if !ctrl - return - switch mgui[ctrl].name, 0 { - case "move": - PostMessage(0x00A1,2) - case "close": - while GetKeyState("LButton", "P") - sleep -1 - mousegetpos ,,, &ctrl2, 2 - if ctrl = ctrl2 - PostMessage(0x0112,0xF060) - case "roll": - ReplaceSystemCursors() - blc_start() - case "help": - ReplaceSystemCursors() - Msgbox("This feature allows you to roll royal jellies until you obtain your specified bees and/or mutations!``n``nTo use:``n- Select the bees and mutations you want``n- Make sure your in-game Auto-Jelly settings are right``n- Put a neonberry on the bee you want to change (if trying ``n to obtain a mutated bee) ``n- Use one royal jelly on the bee and click Yes``n- Click on Roll.``n``nTo stop: ``n- Press the escape key``n``nAdditional options:``n- Stop on Gifteds stops on any gifted bee, ``n ignoring the mutation and your bee selection``n- Stop on Mythics stops on any mythic bee, ``n ignoring the mutation and your bee selection", "Auto-Jelly Help", "0x40040") - case "selectAll": - IniWrite(%mgui[ctrl].name% ^= 1, ".\settings\mutations.ini", "bees", mgui[ctrl].name) - case "Bomber", "Brave", "Bumble", "Cool", "Hasty", "Looker", "Rad", "Rascal", "Stubborn", "Bubble", "Bucko", "Commander", "Demo", "Exhausted", "Fire", "Frosty", "Honey", "Rage", "Riley": - if !selectAll - IniWrite(%mgui[ctrl].name% ^= 1, ".\settings\mutations.ini", "bees", mgui[ctrl].name) - case "Shocked", "Baby", "Carpenter", "Demon", "Diamond", "Lion", "Music", "Ninja", "Shy", "Buoyant", "Fuzzy", "Precise", "Spicy", "Tadpole", "Vector": - if !selectAll - IniWrite(%mgui[ctrl].name% ^= 1, ".\settings\mutations.ini", "bees", mgui[ctrl].name) - case "giftedStop", "mythicStop": - IniWrite(%mgui[ctrl].name% ^= 1, ".\settings\mutations.ini", "extrasettings", mgui[ctrl].name) - case "mutations": - IniWrite(%mgui[ctrl].name% ^= 1, ".\settings\mutations.ini", "mutations", mgui[ctrl].name) - default: - if mutations - IniWrite(%mgui[ctrl].name% ^= 1, ".\settings\mutations.ini", "mutations", mgui[ctrl].name) - } - DrawGUI() - } - WM_MOUSEMOVE(wParam, lParam, msg, hwnd) { - global - local ctrl, hover_ctrl, tt := 0 - MouseGetPos(,,,&ctrl,2) - if !ctrl || mgui["move"].hwnd = ctrl || mgui["close"].hwnd = ctrl - return - ReplaceSystemCursors("IDC_HAND") - hovercontrol := mgui[ctrl].name - hover_ctrl := mgui[ctrl].hwnd - DrawGUI() - while ctrl = hover_ctrl { - sleep(20),MouseGetPos(,,,&ctrl,2) - if A_Index > 120 && beeArr.includes(hovercontrol) && !tt - tt:=1,ToolTip(hovercontrol . " Bee") - } - hovercontrol := "" - ToolTip() - ReplaceSystemCursors() - DrawGUI() - } - ReplaceSystemCursors(IDC := "") - { - static IMAGE_CURSOR := 2, SPI_SETCURSORS := 0x57 - , SysCursors := Map( "IDC_APPSTARTING", 32650 - , "IDC_ARROW" , 32512 - , "IDC_CROSS" , 32515 - , "IDC_HAND" , 32649 - , "IDC_HELP" , 32651 - , "IDC_IBEAM" , 32513 - , "IDC_NO" , 32648 - , "IDC_SIZEALL" , 32646 - , "IDC_SIZENESW" , 32643 - , "IDC_SIZENWSE" , 32642 - , "IDC_SIZEWE" , 32644 - , "IDC_SIZENS" , 32645 - , "IDC_UPARROW" , 32516 - , "IDC_WAIT" , 32514 ) - if !IDC - DllCall("SystemParametersInfo", "UInt", SPI_SETCURSORS, "UInt", 0, "UInt", 0, "UInt", 0) - else - { - hCursor := DllCall("LoadCursor", "Ptr", 0, "UInt", SysCursors[IDC], "Ptr") - for k, v in SysCursors - { - hCopy := DllCall("CopyImage", "Ptr", hCursor, "UInt", IMAGE_CURSOR, "Int", 0, "Int", 0, "UInt", 0, "Ptr") - DllCall("SetSystemCursor", "Ptr", hCopy, "UInt", v) - } - } - } - blc_start() { - global stopping:=false - hotkey "~*esc", stopToggle, "On" - selectedBees := [], selectedMutations := [] - for i in beeArr - if %i% || SelectAll - selectedBees.push(i) - if mutations { - selectedMutations := [] - for i in mutationsArr - if %i.name% - selectedMutations.push(i) - } - ocr_enabled := 1 - ocr_language := "" - for k,v in Map("Windows.Globalization.Language","{9B0252AC-0C27-44F8-B792-9793FB66C63E}", "Windows.Graphics.Imaging.BitmapDecoder","{438CCB26-BCEF-4E95-BAD6-23A822E58D01}", "Windows.Media.Ocr.OcrEngine","{5BFFA85A-3384-3540-9940-699120D428A8}") { - CreateHString(k, &hString) - GUID := Buffer(16), DllCall("ole32\CLSIDFromString", "WStr", v, "Ptr", GUID) - result := DllCall("Combase.dll\RoGetActivationFactory", "Ptr", hString, "Ptr", GUID, "PtrP", &pClass:=0) - DeleteHString(hString) - if (result != 0) - { - ocr_enabled := 0 - break - } - } - if !(ocr_enabled) && mutations - msgbox "OCR is disabled. This means that the macro will not be able to detect mutations.",, 0x40010 - list := ocr("ShowAvailableLanguages") - lang:="en-" - Loop Parse list, "``n", "``r" { - if (InStr(A_LoopField, lang) = 1) { - ocr_language := A_LoopField - break - } - } - if (ocr_language = "" && ocr_enabled) - if ((ocr_language := SubStr(list, 1, InStr(list, "``n")-1)) = "") - return msgbox("No OCR supporting languages are installed on your system! Please follow the Knowledge Base guide to install a supported language as a secondary language on Windows.", "WARNING!!", 0x1030) - if !(hwndRoblox:=GetRobloxHWND()) || !(GetRobloxClientPos(), windowWidth) - return msgbox("You must have Bee Swarm Simulator open to use this!", "Auto-Jelly", 0x40030) - if !selectedBees.length - return msgbox("You must select at least one bee to run this macro!", "Auto-Jelly", 0x40030) - yOffset := GetYOffset(hwndRoblox, &fail) - if fail - MsgBox("Unable to detect in-game GUI offset!``nThis means the macro will NOT work correctly!``n``nThere are a few reasons why this can happen:``n- Incorrect graphics settings (check Troubleshooting Guide!)``n- Your Experience Language is not set to English``n- Something is covering the top of your Roblox window``n``nJoin our Discord server for support!", "WARNING!!", 0x1030 " T60") - if mgui is Gui - mgui.hide() - While !stopping { - ActivateRoblox() - click windowX + Round(0.5 * windowWidth + 10) " " windowY + yOffset + Round(0.4 * windowHeight + 230) - sleep 800 - pBitmap := Gdip_BitmapFromScreen(windowX + 0.5*windowWidth - 155 "|" windowY + yOffset + 0.425*windowHeight - 200 "|" 320 "|" 140) - if mythicStop - for i, j in ["Buoyant", "Fuzzy", "Precise", "Spicy", "Tadpole", "Vector"] - if Gdip_ImageSearch(pBitmap, bitmaps["-" j]) || Gdip_ImageSearch(pBitmap, bitmaps["+" j]) { - Gdip_DisposeImage(pBitmap) - msgbox "Found a mythic bee!", "Auto-Jelly", 0x40040 - break 2 - } - if giftedStop - for i, j in beeArr { - if Gdip_ImageSearch(pBitmap, bitmaps["+" j]) { - Gdip_DisposeImage(pBitmap) - msgbox "Found a gifted bee!", "Auto-Jelly", 0x40040 - break 2 - } - } - found := 0 - for i, j in selectedBees { - if Gdip_ImageSearch(pBitmap, bitmaps["-" j]) || Gdip_ImageSearch(pBitmap, bitmaps["+" j]) { - if (!mutations || !ocr_enabled || !selectedMutations.length) { - Gdip_DisposeImage(pBitmap) - if msgbox("Found a match!``nDo you want to keep this?","Auto-Jelly!", 0x40044) = "Yes" - break 2 - else - continue 2 - } - found := 1 - break - } - } - Gdip_DisposeImage(pBitmap) - if !found - continue - pBitmap := Gdip_BitmapFromScreen(windowX + Round(0.5 * windowWidth - 320) "|" windowY + yOffset + Round(0.4 * windowHeight + 17) "|210|90") - pEffect := Gdip_CreateEffect(5, -60,30) - Gdip_BitmapApplyEffect(pBitmap, pEffect) - Gdip_DisposeEffect(pEffect) - hBitmap := Gdip_CreateHBITMAPFromBitmap(pBitmap) - pIRandomAccessStream := HBitmapToRandomAccessStream(hBitmap) - text:= RegExReplace(ocr(pIRandomAccessStream), "i)([\r\n\s]|mutation)*") - found := 0 - for i, j in selectedMutations - for k, trigger in j.triggers - if inStr(text, trigger) { - found := 1 - break - } - if !found - continue - if msgbox("Found a match!``nDo you want to keep this?","Auto-Jelly!", 0x40044) = "Yes" - break - } - hotkey "~*esc", stopToggle, "Off" - mgui.show() - } - closeFunction(*) { - global xPos, yPos - Gdip_Shutdown(pToken) - ReplaceSystemCursors() - try { - mgui.getPos(&xp, &yp) - if !(xp < 0) && !(xp > A_ScreenWidth) && !(yp < 0) && !(yp > A_ScreenHeight) - xPos := xp, yPos := yp - IniWrite(xpos, ".\settings\mutations.ini", "GUI", "xpos") - IniWrite(ypos, ".\settings\mutations.ini", "GUI", "ypos") - } - } - HBitmapToRandomAccessStream(hBitmap) { - static IID_IRandomAccessStream := "{905A0FE1-BC53-11DF-8C49-001E4FC686DA}" - , IID_IPicture := "{7BF80980-BF32-101A-8BBB-00AA00300CAB}" - , PICTYPE_BITMAP := 1 - , BSOS_DEFAULT := 0 - , sz := 8 + A_PtrSize * 2 - - DllCall("Ole32\CreateStreamOnHGlobal", "Ptr", 0, "UInt", true, "PtrP", &pIStream:=0, "UInt") - - PICTDESC := Buffer(sz, 0) - NumPut("uint", sz - , "uint", PICTYPE_BITMAP - , "ptr", hBitmap, PICTDESC) - - riid := CLSIDFromString(IID_IPicture) - DllCall("OleAut32\OleCreatePictureIndirect", "Ptr", PICTDESC, "Ptr", riid, "UInt", false, "PtrP", &pIPicture:=0, "UInt") - ; IPicture::SaveAsFile - ComCall(15, pIPicture, "Ptr", pIStream, "UInt", true, "UIntP", &size:=0, "UInt") - riid := CLSIDFromString(IID_IRandomAccessStream) - DllCall("ShCore\CreateRandomAccessStreamOverStream", "Ptr", pIStream, "UInt", BSOS_DEFAULT, "Ptr", riid, "PtrP", &pIRandomAccessStream:=0, "UInt") - ObjRelease(pIPicture) - ObjRelease(pIStream) - Return pIRandomAccessStream - } - - CLSIDFromString(IID, &CLSID?) { - CLSID := Buffer(16) - if res := DllCall("ole32\CLSIDFromString", "WStr", IID, "Ptr", CLSID, "UInt") - throw Error("CLSIDFromString failed. Error: " . Format("{:#x}", res)) - Return CLSID - } - - ocr(file, lang := "FirstFromAvailableLanguages") - { - static OcrEngineStatics, OcrEngine, MaxDimension, LanguageFactory, Language, CurrentLanguage:="", BitmapDecoderStatics, GlobalizationPreferencesStatics - if !IsSet(OcrEngineStatics) - { - CreateClass("Windows.Globalization.Language", ILanguageFactory := "{9B0252AC-0C27-44F8-B792-9793FB66C63E}", &LanguageFactory) - CreateClass("Windows.Graphics.Imaging.BitmapDecoder", IBitmapDecoderStatics := "{438CCB26-BCEF-4E95-BAD6-23A822E58D01}", &BitmapDecoderStatics) - CreateClass("Windows.Media.Ocr.OcrEngine", IOcrEngineStatics := "{5BFFA85A-3384-3540-9940-699120D428A8}", &OcrEngineStatics) - ComCall(6, OcrEngineStatics, "uint*", &MaxDimension:=0) - } - text := "" - if (file = "ShowAvailableLanguages") - { - if !IsSet(GlobalizationPreferencesStatics) - CreateClass("Windows.System.UserProfile.GlobalizationPreferences", IGlobalizationPreferencesStatics := "{01BF4326-ED37-4E96-B0E9-C1340D1EA158}", &GlobalizationPreferencesStatics) - ComCall(9, GlobalizationPreferencesStatics, "ptr*", &LanguageList:=0) ; get_Languages - ComCall(7, LanguageList, "int*", &count:=0) ; count - loop count - { - ComCall(6, LanguageList, "int", A_Index-1, "ptr*", &hString:=0) ; get_Item - ComCall(6, LanguageFactory, "ptr", hString, "ptr*", &LanguageTest:=0) ; CreateLanguage - ComCall(8, OcrEngineStatics, "ptr", LanguageTest, "int*", &bool:=0) ; IsLanguageSupported - if (bool = 1) - { - ComCall(6, LanguageTest, "ptr*", &hText:=0) - b := DllCall("Combase.dll\WindowsGetStringRawBuffer", "ptr", hText, "uint*", &length:=0, "ptr") - text .= StrGet(b, "UTF-16") "``n" - } - ObjRelease(LanguageTest) - } - ObjRelease(LanguageList) - return text - } - if (lang != CurrentLanguage) or (lang = "FirstFromAvailableLanguages") - { - if IsSet(OcrEngine) - { - ObjRelease(OcrEngine) - if (CurrentLanguage != "FirstFromAvailableLanguages") - ObjRelease(Language) - } - if (lang = "FirstFromAvailableLanguages") - ComCall(10, OcrEngineStatics, "ptr*", &OcrEngine:=0) ; TryCreateFromUserProfileLanguages - else - { - CreateHString(lang, &hString) - ComCall(6, LanguageFactory, "ptr", hString, "ptr*", &Language:=0) ; CreateLanguage - DeleteHString(hString) - ComCall(9, OcrEngineStatics, "ptr", Language, "ptr*", &OcrEngine:=0) ; TryCreateFromLanguage - } - if (OcrEngine = 0) - { - msgbox `'Can not use language "`' lang `'" for OCR, please install language pack.`' - ExitApp - } - CurrentLanguage := lang - } - IRandomAccessStream := file - ComCall(14, BitmapDecoderStatics, "ptr", IRandomAccessStream, "ptr*", &BitmapDecoder:=0) ; CreateAsync - WaitForAsync(&BitmapDecoder) - BitmapFrame := ComObjQuery(BitmapDecoder, IBitmapFrame := "{72A49A1C-8081-438D-91BC-94ECFC8185C6}") - ComCall(12, BitmapFrame, "uint*", &width:=0) ; get_PixelWidth - ComCall(13, BitmapFrame, "uint*", &height:=0) ; get_PixelHeight - if (width > MaxDimension) or (height > MaxDimension) - { - msgbox "Image is to big - " width "x" height ".``nIt should be maximum - " MaxDimension " pixels" - ExitApp - } - BitmapFrameWithSoftwareBitmap := ComObjQuery(BitmapDecoder, IBitmapFrameWithSoftwareBitmap := "{FE287C9A-420C-4963-87AD-691436E08383}") - ComCall(6, BitmapFrameWithSoftwareBitmap, "ptr*", &SoftwareBitmap:=0) ; GetSoftwareBitmapAsync - WaitForAsync(&SoftwareBitmap) - ComCall(6, OcrEngine, "ptr", SoftwareBitmap, "ptr*", &OcrResult:=0) ; RecognizeAsync - WaitForAsync(&OcrResult) - ComCall(6, OcrResult, "ptr*", &LinesList:=0) ; get_Lines - ComCall(7, LinesList, "int*", &count:=0) ; count - loop count - { - ComCall(6, LinesList, "int", A_Index-1, "ptr*", &OcrLine:=0) - ComCall(7, OcrLine, "ptr*", &hText:=0) - buf := DllCall("Combase.dll\WindowsGetStringRawBuffer", "ptr", hText, "uint*", &length:=0, "ptr") - text .= StrGet(buf, "UTF-16") "``n" - ObjRelease(OcrLine) - } - Close := ComObjQuery(IRandomAccessStream, IClosable := "{30D5A829-7FA4-4026-83BB-D75BAE4EA99E}") - ComCall(6, Close) ; Close - Close := ComObjQuery(SoftwareBitmap, IClosable := "{30D5A829-7FA4-4026-83BB-D75BAE4EA99E}") - ComCall(6, Close) ; Close - ObjRelease(IRandomAccessStream) - ObjRelease(BitmapDecoder) - ObjRelease(SoftwareBitmap) - ObjRelease(OcrResult) - ObjRelease(LinesList) - return text - } - - CreateClass(str, interface, &Class) - { - CreateHString(str, &hString) - GUID := CLSIDFromString(interface) - result := DllCall("Combase.dll\RoGetActivationFactory", "ptr", hString, "ptr", GUID, "ptr*", &Class:=0) - if (result != 0) - { - if (result = 0x80004002) - msgbox "No such interface supported" - else if (result = 0x80040154) - msgbox "Class not registered" - else - msgbox "error: " result - } - DeleteHString(hString) - } - - CreateHString(str, &hString) - { - DllCall("Combase.dll\WindowsCreateString", "wstr", str, "uint", StrLen(str), "ptr*", &hString:=0) - } - - DeleteHString(hString) - { - DllCall("Combase.dll\WindowsDeleteString", "ptr", hString) - } - - WaitForAsync(&Object) - { - AsyncInfo := ComObjQuery(Object, IAsyncInfo := "{00000036-0000-0000-C000-000000000046}") - loop - { - ComCall(7, AsyncInfo, "uint*", &status:=0) ; IAsyncInfo.Status - if (status != 0) - { - if (status != 1) - { - ComCall(8, AsyncInfo, "uint*", &ErrorCode:=0) ; IAsyncInfo.ErrorCode - msgbox "AsyncInfo status error: " ErrorCode - ExitApp - } - break - } - sleep 10 - } - ComCall(8, Object, "ptr*", &ObjectResult:=0) ; GetResults - ObjRelease(Object) - Object := ObjectResult - } - ' - ) - exec := ComObject("WScript.shell").Exec('"' exe_path64 '" /script /force *') - exec.StdIn.Write(script), exec.StdIn.Close() - return (MGUIPID := exec.processID) + global AutoJellyPID + try ProcessClose(AutoJellyPID) + + exec := ComObject("WScript.shell").Exec('"' A_AhkPath '" /force "' A_ScriptDir "\AutoJelly.ahk" '"') + return (AutoJellyPID := exec.ProcessID) } ; CREDITS TAB @@ -10539,7 +9615,7 @@ nm_AmuletPrompt(decision:=0, type:=0, *){ } nm_FindItem(chosenItem, *) { global shiftLockEnabled, bitmaps - static items := ["Cog", "Ticket", "SprinklerBuilder", "BeequipCase", "Gumdrops", "Coconut", "Stinger", "Snowflake", "MicroConverter", "Honeysuckle", "Whirligig", "FieldDice", "SmoothDice", "LoadedDice", "JellyBeans", "RedExtract", "BlueExtract", "Glitter", "Glue", "Oil", "Enzymes", "TropicalDrink", "PurplePotion", "SuperSmoothie", "MarshmallowBee", "Sprout", "MagicBean", "FestiveBean", "CloudVial", "NightBell", "BoxOFrogs", "AntPass", "BrokenDrive", "7ProngedCog", "RoboPass", "Translator", "SpiritPetal", "Present", "Treat", "StarTreat", "AtomicTreat", "SunflowerSeed", "Strawberry", "Pineapple", "Blueberry", "Bitterberry", "Neonberry", "MoonCharm", "GingerbreadBear", "AgedGingerbreadBear", "WhiteDrive", "RedDrive", "BlueDrive", "GlitchedDrive", "ComfortingVial", "InvigoratingVial", "MotivatingVial", "RefreshingVial", "SatisfyingVial", "PinkBalloon", "RedBalloon", "WhiteBalloon", "BlackBalloon", "SoftWax", "HardWax", "CausticWax", "SwirledWax", "Turpentine", "PaperPlanter", "TicketPlanter", "FestivePlanter", "PlasticPlanter", "CandyPlanter", "RedClayPlanter", "BlueClayPlanter", "TackyPlanter", "PesticidePlanter", "HeatTreatedPlanter", "HydroponicPlanter", "PetalPlanter", "ThePlanterOfPlenty", "BasicEgg", "SilverEgg", "GoldEgg", "DiamondEgg", "MythicEgg", "StarEgg", "GiftedSilverEgg", "GiftedGoldEgg", "GiftedDiamondEgg", "GiftedMythicEgg", "RoyalJelly", "StarJelly", "BumbleBeeEgg", "BumbleBeeJelly", "RageBeeJelly", "ShockedBeeJelly"] + static items := ["Cog", "Ticket", "SprinklerBuilder", "BeequipCase", "Gumdrops", "Coconut", "Stinger", "Snowflake", "MicroConverter", "Honeysuckle", "Whirligig", "FieldDice", "SmoothDice", "LoadedDice", "JellyBeans", "RedExtract", "BlueExtract", "Glitter", "Glue", "Oil", "Enzymes", "TropicalDrink", "PurplePotion", "SuperSmoothie", "MarshmallowBee", "Sprout", "MagicBean", "FestiveBean", "CloudVial", "NightBell", "BoxOFrogs", "AntPass", "BrokenDrive", "7ProngedCog", "RoboPass", "Translator", "SpiritPetal", "Present", "Treat", "StarTreat", "AtomicTreat", "SunflowerSeed", "Strawberry", "Pineapple", "Blueberry", "Bitterberry", "Neonberry", "MoonCharm", "GingerbreadBear", "AgedGingerbreadBear", "WhiteDrive", "RedDrive", "BlueDrive", "GlitchedDrive", "ComfortingVial", "InvigoratingVial", "MotivatingVial", "RefreshingVial", "SatisfyingVial", "PinkBalloon", "RedBalloon", "WhiteBalloon", "BlackBalloon", "SoftWax", "HardWax", "CausticWax", "SwirledWax", "Turpentine", "PaperPlanter", "TicketPlanter", "FestivePlanter", "PlasticPlanter", "CandyPlanter", "RedClayPlanter", "BlueClayPlanter", "TackyPlanter", "PesticidePlanter", "Heat-TreatedPlanter", "HydroponicPlanter", "PetalPlanter", "ThePlanterOfPlenty", "BasicEgg", "SilverEgg", "GoldEgg", "DiamondEgg", "MythicEgg", "StarEgg", "GiftedSilverEgg", "GiftedGoldEgg", "GiftedDiamondEgg", "GiftedMythicEgg", "RoyalJelly", "StarJelly", "BumbleBeeEgg", "BumbleBeeJelly", "RageBeeJelly", "ShockedBeeJelly"] GetRobloxClientPos() DetectHiddenWindows 1 if windowWidth == 0 { @@ -20725,102 +19801,50 @@ ba_getNextPlanter(nextfield){ } return [nextPlanterName, nextPlanterNectarBonus, nextPlanterGrowBonus, nextPlanterGrowTime] } -ba_placePlanter(fieldName, planter, planterNum, atField:=0){ - global BambooFieldCheck, BlueFlowerFieldCheck, CactusFieldCheck, CloverFieldCheck, CoconutFieldCheck, DandelionFieldCheck, MountainTopFieldCheck, MushroomFieldCheck, PepperFieldCheck, PineTreeFieldCheck, PineappleFieldCheck, PumpkinFieldCheck, RoseFieldCheck, SpiderFieldCheck, StrawberryFieldCheck, StumpFieldCheck, SunflowerFieldCheck, MaxAllowedPlanters, LostPlanters, bitmaps - - nm_updateAction("Planters") - - nm_setShiftLock(0) - - planterName := planter[1] - if (atField = 0) - { - nm_Reset() - nm_OpenMenu("itemmenu") - nm_setStatus("Traveling", (planterName . " (" . fieldName . ")")) - nm_gotoPlanter(fieldName, 0) - } - - planterPos := nm_InventorySearch(planterName, "up", 4) - - if (planterPos = 0) ; planter not in inventory - { - nm_setStatus("Missing", planterName) - LostPlanters.=planterName - ba_saveConfig_() - return 0 - } - else - { - GetRobloxClientPos() - MouseMove windowX+planterPos[1], windowY+planterPos[2] - } - KeyWait "F14", "T120 L" ; wait for gotoPlanter finish - nm_endWalk() - - nm_setStatus("Placing", planterName) - hwnd := GetRobloxHWND() - offsetY := GetYOffset(hwnd) +placePlanter(planterName) { Loop 10 { GetRobloxClientPos(hwnd) - pBMScreen := Gdip_BitmapFromScreen(windowX "|" windowY+offsetY+150 "|" windowWidth//2 "|" Max(480, windowHeight-offsetY-150)) - if (A_Index = 1) - { - ; wait for red vignette effect to disappear - Loop 40 - { - if (Gdip_ImageSearch(pBMScreen, bitmaps["item"], , , , 6, , 2) = 1) - break - else - { - if (A_Index = 40) - { - Gdip_DisposeImage(pBMScreen) - nm_setStatus("Missing", planterName) - LostPlanters.=planterName - ba_saveConfig_() - return 0 - } - else - { - Sleep 50 - Gdip_DisposeImage(pBMScreen) - pBMScreen := Gdip_BitmapFromScreen(windowX "|" windowY+offsetY+150 "|" windowWidth//2 "|" Max(480, windowHeight-offsetY-150)) - } - } - } + TextInRegion := findTextInRegion(planterName,, windowX, windowY, 360, windowHeight, true) + if TextInRegion.Has("Word") { + word := TextInRegion["Word"] + planterPos := [30, word.BoundingRect.y + word.BoundingRect.h // 2] } - - if ((Gdip_ImageSearch(pBMScreen, bitmaps[planterName], &planterPos, , , 306, , 10, , 5) != 1) || (Gdip_ImageSearch(pBMScreen, bitmaps["yes"], , windowWidth//2-250, , , , 2, , 2) = 1)) { - Gdip_DisposeImage(pBMScreen) - break - } - Gdip_DisposeImage(pBMScreen) - - MouseClickDrag "Left", windowX+30, windowY+SubStr(planterPos, InStr(planterPos, ",")+1)+190, windowX+windowWidth//2, windowY+windowHeight//2, 5 + + MouseClickDrag "Left", windowX+30, windowY + planterPos[2], windowX+windowWidth//2, windowY+windowHeight//2, 5 Sleep 200 + + TextInRegion := findTextInRegion("Yes",, windowX + windowWidth // 4, windowY + windowHeight//2, windowWidth // 4, windowHeight//2, true) + if TextInRegion.Has("Word") { + word := TextInRegion["Word"] + yesPos := [word.BoundingRect.x, word.BoundingRect.y] + break ; yes detected. + } } + + Detected := false Loop 50 { GetRobloxClientPos(hwnd) loop 3 { - pBMScreen := Gdip_BitmapFromScreen(windowX+windowWidth//2-250 "|" windowY+windowHeight//2-52 "|500|150") - if (Gdip_ImageSearch(pBMScreen, bitmaps["yes"], &pos, , , , , 2, , 2) = 1) { - MouseMove windowX+windowWidth//2-250+SubStr(pos, 1, InStr(pos, ",")-1), windowY+windowHeight//2-52+SubStr(pos, InStr(pos, ",")+1) + TextInRegion := findTextInRegion("Yes",, windowX + windowWidth // 4, windowY + windowHeight//2, windowWidth // 4, windowHeight//2, true) + if TextInRegion.Has("Word") { + word := TextInRegion["Word"] + yesPos := [word.BoundingRect.x, word.BoundingRect.y] + MouseMove yespos[1] + windowX, yespos[2] + windowY Sleep 150 Click - sleep 100 - Gdip_DisposeImage(pBMScreen) - MouseMove windowX+350, windowY+offsetY+100 + Sleep 100 + MouseMove windowX + 350, windowY + offsetY + 100 + Detected := true + } else if Detected { ; ensurance break 2 } - Gdip_DisposeImage(pBMScreen) - Sleep 50 ; delay in case of lag + Sleep 50 } - + if (A_Index = 50) { nm_setStatus("Missing", planterName) LostPlanters.=planterName @@ -20852,6 +19876,46 @@ ba_placePlanter(fieldName, planter, planterNum, atField:=0){ return 4 } } +} + +ba_placePlanter(fieldName, planter, planterNum, atField:=0){ + global BambooFieldCheck, BlueFlowerFieldCheck, CactusFieldCheck, CloverFieldCheck, CoconutFieldCheck, DandelionFieldCheck, MountainTopFieldCheck, MushroomFieldCheck, PepperFieldCheck, PineTreeFieldCheck, PineappleFieldCheck, PumpkinFieldCheck, RoseFieldCheck, SpiderFieldCheck, StrawberryFieldCheck, StumpFieldCheck, SunflowerFieldCheck, MaxAllowedPlanters, LostPlanters, bitmaps + + nm_updateAction("Planters") + + nm_setShiftLock(0) + + planterName := planter[1] + if (atField = 0) + { + nm_Reset() + nm_OpenMenu("itemmenu") + nm_setStatus("Traveling", (planterName . " (" . fieldName . ")")) + nm_gotoPlanter(fieldName, 0) + } + + planterPos := nm_InventorySearch(planterName, "up", 4) + + if (planterPos = 0) ; planter not in inventory + { + nm_setStatus("Missing", planterName) + LostPlanters.=planterName + ba_saveConfig_() + return 0 + } + else + { + GetRobloxClientPos() + MouseMove windowX+30, planterPos[2] + } + + KeyWait "F14", "T120 L" ; wait for gotoPlanter finish + nm_endWalk() + + nm_setStatus("Placing", planterName) + hwnd := GetRobloxHWND() + offsetY := GetYOffset(hwnd) + placePlanter(planterName) return 1 } ba_harvestPlanter(planterNum){ @@ -21268,89 +20332,8 @@ mp_PlantPlanter(PlanterIndex) { nm_setStatus("Placing", MPlanterName) hwnd := GetRobloxHWND() offsetY := GetYOffset(hwnd) - Loop 10 - { - GetRobloxClientPos(hwnd) - pBMScreen := Gdip_BitmapFromScreen(windowX "|" windowY+offsetY+150 "|" windowWidth//2 "|" Max(480, windowHeight-offsetY-150)) - if (A_Index = 1) - { - ; wait for red vignette effect to disappear - Loop 40 - { - if (Gdip_ImageSearch(pBMScreen, bitmaps["item"], , , , 6, , 2) = 1) - break - else - { - if (A_Index = 40) - { - Gdip_DisposeImage(pBMScreen) - nm_setStatus("Missing", MPlanterName) - return 0 - } - else - { - Sleep 50 - Gdip_DisposeImage(pBMScreen) - pBMScreen := Gdip_BitmapFromScreen(windowX "|" windowY+offsetY+150 "|" windowWidth//2 "|" Max(480, windowHeight-offsetY-150)) - } - } - } - } - - if ((Gdip_ImageSearch(pBMScreen, bitmaps[MPlanterName], &planterPos, , , 306, , 10, , 5) != 1) || (Gdip_ImageSearch(pBMScreen, bitmaps["yes"], , windowWidth//2-250, , , , 2, , 2) = 1)) { - Gdip_DisposeImage(pBMScreen) - break - } - Gdip_DisposeImage(pBMScreen) - - MouseClickDrag "Left", windowX+30, windowY+SubStr(planterPos, InStr(planterPos, ",")+1)+190, windowX+windowWidth//2, windowY+windowHeight//2, 5 - Sleep 200 - } - Loop 50 - { - GetRobloxClientPos(hwnd) - loop 3 { - pBMScreen := Gdip_BitmapFromScreen(windowX+windowWidth//2-250 "|" windowY+windowHeight//2-52 "|500|150") - if (Gdip_ImageSearch(pBMScreen, bitmaps["yes"], &pos, , , , , 2, , 2) = 1) { - MouseMove windowX+windowWidth//2-250+SubStr(pos, 1, InStr(pos, ",")-1), windowY+windowHeight//2-52+SubStr(pos, InStr(pos, ",")+1) - Sleep 150 - Click - sleep 100 - Gdip_DisposeImage(pBMScreen) - MouseMove windowX+350, windowY+offsetY+100 - break 2 - } - Gdip_DisposeImage(pBMScreen) - Sleep 50 ; delay in case of lag - } - - if (A_Index = 50) { - nm_setStatus("Missing", MPlanterName) - return 0 - } - - Sleep 100 - } - - Loop 10 - { - Sleep 100 - imgPos := nm_imgSearch("3Planters.png",30,"lowright") - If (imgPos[1] = 0){ - nm_setStatus("Error", "3 Planters already placed!") - Sleep 500 - return 3 - } - imgPos := nm_imgSearch("planteralready.png",30,"lowright") - If (imgPos[1] = 0){ - return 2 - } - imgPos := nm_imgSearch("standing.png",30,"lowright") - If (imgPos[1] = 0){ - return 4 - } - } + placePlanter(MPlanterName) PlanterName%PlanterIndex% := MPlanterName PlanterField%PlanterIndex% := MFieldName