Caractéristiques
- Bobber analyse des résultats d'essai de 95% + de précision à grande vitesse
- Poissons de numérisation des résultats d'essai de 70% + de précision
- Facile à changer constantes pour les retouches
- Prend en charge une résolution (oui, même les non-standard comme vraiment tendu)
- Prise en charge CosmosUI
- Trouver des dynamiques de couleurs RVB (fonctionne dans pratiquement toute la lumière)
- AFK-Away

Utilisez
1. Copier / Coller le code ci-dessous dans AC Tool (qui se trouve à http://www.actool.net
2. Exécuter WoW en mode fenêtré
3. compétence de pêche mis dans la fente "0"
5. Sous Options vidéo (appuyez sur Echap pour faire apparaître le menu principal), décochez la case "Hardware Cursor"
6. Zoom en mode première personne
7. constantes d'examen dans le script, en particulier «RunCount de fixer combien de fois le script devrait fonctionner
8. Exécutez la macro

Notes
- Pour de meilleurs résultats, essayez de désactiver toutes les options graphiques de fantaisie off («Points clés du terrain», notamment en vertu de Shaders .. prend tout l'éclat de l'eau) et utiliser une basse résolution (peut-être moins de 800 × 600, plus la plus rapide)
- Si vous rencontrez des problèmes pour trouver le flotteur, où la souris va tout simplement sur le flotteur et s'arrête jamais, ou va un peu passé le flotteur avant d'arrêter, essayez d'augmenter la «scanSpeed« constante. Effectuez cette opération uniquement après avoir éteint tous les graphiques de fantaisie et de diminuer la résolution
- S'il vous plaît s'il vous plaît s'il vous plaît poissons loin de la civilisation. Nous avons besoin de la publicité aussi peu que possible, thankyouverymuch.
- Essayez de trouver un endroit où vous êtes de niveau avec l'eau. Exécuter le script une fois ou deux fois et note la plus haute ligne où le script scanne pour le bouchon. Puis jetez 15 ou alors jette à la main et où la plus haute note va coulé. Essayez de faire correspondre ces deux lignes, vous obtiendrez des résultats beaucoup plus rapidement.
- Si le bouchon est atterrissage en dehors de la zone de balayage, adject l'analyse constantes de pourcentage de surface dans la macro afin d'inclure les zones où les terres flotteur.
- Vous pouvez désactiver AFK Away si vous voulez discuter lors de la pêche

Future
- Le isnt scanner poissons les meilleurs à l'heure actuelle, sera certainement besoin de peaufinage. Je vais essayer d'obtenir que le travail mieux dans une future mise à jour.
- Un système de gestion des stocks pour ouvrir automatiquement les conteneurs tels que les palourdes, les bouteilles, coffres, etc
- Une option permettant de quitter la pêche après un certain laps de temps
- Une option pour activer les horaires aléatoires entre les moulages / cliquant sur des poissons / etc

Le Bot


CODE

/ / WoW pêche Bot v1.1
/ / Fait par QuietKnight

/ / Change
/ / V1.1
/ / + Ajout de l'option pour désactiver AFK Killer
/ / + Ajout des changements journal
/ /
/ / V1.0
/ / + Version initiale

/ / Instructions spéciales:
/ / - Mettez vos compétences de pêche dans la fente "0"
/ / - Zoom en première personne mode
/ / - Sous Options vidéo, décochez la case "Hardware Cursor"

SetActiveWindow mondiale de Warcraft

Constantes

/////////////////////////
/ / CONSTANTES VARIABLES / /
/////////////////////////

/ / Compte Run
/ / Combien de fois le script doit essayer de poissons
RunCount = 10

/ / Vitesse
/ / C'est la première vitesse de balayage. La valeur est faible, plus le scan va,
/ / Et plus le nombre, le ralentissement de la numérisation va. Si vous rencontrez des problèmes
/ / Où le isnt analyse initiale de trouver le flotteur et simple numérisation de droit sur elle,
/ / Essayez d'augmenter ce nombre lentement.
scanSpeed = 60

/ / Boîte de distances Scan
/ / Ce sont les distances des côtés de l'écran pour rechercher un leurre
/ / Ce sont mesurées en pourcentage de l'écran dans la direction appropriée
scanLeftDist = 0.3
scanRightDist = 0.3
scanTopDist = 0.4
scanBottomDist = 0,25

/ / Plage de luminosité
/ / C'est le nombre de valeurs RGB sur et sous la «lueur d'espoir» qui est le
/ / Leurre à comparer. Fondamentalement, si vous obtenez le message "Pas de poisson à crochet,
/ / Essayez d'augmenter à la fois un peu les chiffres, et si les bobs bobber mais vous n'avez pas de capture
/ / Quelque chose, essayez de diminuer un peu les deux numéros. Cela peut changer d'environnement
/ / À l'environnement. Aussi, en règle générale ne devrais brightRangeUp être très élevé.
brightRangeDown = 50
brightRangeUp = 10

/ / Distance de luminosité
/ / Ne marche pas question ce qu'il fait, mais au fond, le laisser seul, sauf si vous avez des
/ / Problèmes effectivement attraper le poisson. Si vous rencontrez des problèmes et que vous voulez
/ / De ruser, règle générale, plus la résolution est élevée, plus le nombre,
/ / Le numéro de série, mais ne devrait être entre 2 à 6 MIN MAX. Si vous commencez
/ / Devient trop de wack avec cela, vous ne serez jamais attraper un poisson
brightDist = 3

/ / AFK Away
/ / Défini à 1 pour utiliser AFK Away (qui appuie sur Entrée deux fois avant chaque lancer) ou
/ / 0 pour désactiver AFK Away entièrement. Ceci vient en utile si vous souhaitez
/ / Chat sur WoW pendant la pêche.
afkAway = 0

/////////////////////////////
/ / Constantes non CHANGABLE / /
/////////////////////////////

/ / Optimal scan ratios étape
widthToWindowRatio = 0,056
heightToWindowRatio = 0,075

/ / Scanbox
scanTop = 0
scanBottom = 0
scanLeft = 0
scanRight = 0
scanStepX 0 =
scanStepY 0 =
scanSuccess = 0

/ / The Box
boxMinX 0 =
boxMaxX 0 =
boxMinY 0 =
boxMaxY 0 =
boxCenterY 0 =
boxCenterX 0 =

boxScanStep = 4

boxAvgWidth = 0
boxAvgHeight = 0

/ / Vars Divers
x = 0
y = 0
i = 0
j = 0

/ / Vars Mouse
isMouseOrange = 0
mouseX 0 =
mouseY 0 =

/ Emplacement Lure /
lureInitLocX 0 =
lureInitLocY 0 =

/ Info / RGB
brightX 0 =
Brighty 0 =
brightTotal = 0
brightR 0 =
brightG 0 =
brightB 0 =
brightRMin = 0
brightRMax = 0
brightGMin = 0
brightGMax = 0
brightBMin = 0
brightBMax = 0
curTotal = 0

/ / Splash
éclaboussé = 0

Fin

///////////////
/ / Proc Main / /
///////////////

Delay 1000
Appel CalculateScanBoxConstants

Loop $ RunCount
Touches de 0
Delay 1000
Appel FindLureInitial
Appel FindBoxCenter

Calculer x = $ boxMaxX-10
MousePos $ x, $ boxCenterY
Retard $ scanSpeed

Appel GetRGBValue
Appel WaitForSplash

Si $ afkAway = 1
Delay 2500
KeyDown {return} 250
KeyDown {return} 250
Delay 2000
Autres
Delay 5000
Fin

Fin


////////////////
/ / Procédures / /
////////////////

CalculateScanBoxConstants procédure


scanTop Compute = {} + windowtop Tronc ({} * $ WindowHeight scanTopDist)
Calculer scanBottom = ({} + {windowtop WindowHeight}) - Tronc ({} * $ WindowHeight scanBottomDist)
scanLeft Compute = {} + WindowLeft Tronc ({} * $ WindowWidth scanLeftDist)
Calculer scanRight = ({} + {WindowLeft WindowWidth}) - Tronc ({} * $ WindowWidth scanRightDist)

Calculer boxAvgWidth = trunc ({} * $ WindowWidth widthToWindowRatio)
Calculer boxAvgHeight = trunc ({} * $ WindowHeight heightToWindowRatio)

Calculer scanStepX $ = boxAvgWidth
Calculer scanStepY = trunc ($ boxAvgHeight / 2)

Fin

Procédure FindLureInitial
scanSuccess SetConst = 0
Calculer y = $ scanTop

Bien que scanSuccess $ y <= $ scanBottom ET = 0 $

Calculer i = {} LoopNo MOD 2

Si $ i = 0
Timestamp, même dans
Calculer x = $ scanLeft
Autres
Timestamp En Odd
Calculer x = $ scanLeft + Tronc ($ boxAvgWidth / 2)
Fin

Alors que $ x <= $ $ scanSuccess scanRight ET = 0
/ / Déplacez la souris et attendre une seconde (d'attente est nécessaire!)
MousePos $ x, $ y
Retard $ scanSpeed

Appel isMouseOrange

/ / Si la souris est orange
Si $ isMouseOrange = 1
SetConst lureInitLocX $ = x
SetConst lureInitLocY = $ y
scanSuccess SetConst = 1
Fin

Calculer x = $ x + $ scanStepX
Fin

Calculer y = $ y + $ scanStepY
Fin

Fin

Procédure FindBoxCenter

/ / Trouver X min
scanSuccess SetConst = 0
Calculer x = $ lureInitLocX
Calculer y = lureInitLocY $
Alors $ scanSuccess = 0

/ / Déplacez la souris et attendre une seconde (d'attente est nécessaire!)
MousePos $ x, $ y
Retard $ scanSpeed

Appel isMouseOrange

Si $ isMouseOrange = 0
SetConst boxMinX $ = x
scanSuccess SetConst = 1
Autres
Calculer x = $ x - $ boxScanStep
Fin
Fin

/ / Trouver max X
scanSuccess SetConst = 0
Calculer x = $ lureInitLocX
Calculer y = lureInitLocY $
Alors $ scanSuccess = 0

/ / Déplacez la souris et attendre une seconde (d'attente est nécessaire!)
MousePos $ x, $ y
Retard $ scanSpeed

Appel isMouseOrange

Si $ isMouseOrange = 0
SetConst boxMaxX $ = x
scanSuccess SetConst = 1
Autres
Calculer x = x + boxScanStep $ $
Fin
Fin

/ / Trouver Y min
scanSuccess SetConst = 0
Calculer x = $ lureInitLocX
Calculer y = lureInitLocY $
Alors $ scanSuccess = 0

/ / Déplacez la souris et attendre une seconde (d'attente est nécessaire!)
MousePos $ x, $ y
Retard $ scanSpeed

Appel isMouseOrange

Si $ isMouseOrange = 0
SetConst boxMinY = $ y
scanSuccess SetConst = 1
Autres
Calculer y = $ y - boxScanStep $
Fin
Fin

/ / Trouver max Y
scanSuccess SetConst = 0
Calculer x = $ lureInitLocX
Calculer y = lureInitLocY $
Alors $ scanSuccess = 0

/ / Déplacez la souris et attendre une seconde (d'attente est nécessaire!)
MousePos $ x, $ y
Retard $ scanSpeed

Appel isMouseOrange

Si $ isMouseOrange = 0
SetConst boxMaxY = $ y
scanSuccess SetConst = 1
Autres
Calculer y = $ y + $ boxScanStep
Fin
Fin


Calculer boxCenterX = Tronc (($ + $ boxMinX boxMaxX) / 2)
Calculer boxCenterY = Tronc ((boxMinY $ + boxMaxY $) / 2)

SetConst lureInitLocX $ = boxCenterX
SetConst lureInitLocY $ = boxCenterY

Fin

Procédure GetRGBValue

SetConst $ brightTotal = 0

Calculer y = boxCenterY $
Calculer i = boxCenterY $ + Tronc ((boxMaxY $ - $ boxCenterY) / 3)

Alors que $ y <= $ i

Calculer x = $ boxMinX
Si $ x $ <= boxCenterX

LoadRGB $ x, $ y
Calculer curTotal = {} + {RGBRed RGBGreen} + {} RGBBlue

Si $> $ curTotal brightTotal
Calculer brightTotal = $ curTotal

SetConst brightR = {} RGBRed
SetConst brightG = {} RGBGreen
SetConst brightB = {} RGBBlue

brightRMin Compute = $ brightR - $ brightRangeDown
brightRMax Compute = $ brightR + brightRangeUp $
brightGMin Compute = brightG $ - $ brightRangeDown
brightGMax Compute = brightRangeUp brightG $ + $
brightBMin Compute = $ brightB - $ brightRangeDown
brightBMax Compute = $ brightB + brightRangeUp $

SetConst brightX $ = x
SetConst Brighty = $ y
Fin

Calculer x = $ x + 2
Fin

Calculer y = $ y + 2
Fin

Fin

Procédure WaitForSplash

SetConst $ éclaboussé = 0

Appel isMouseOrange

Alors $ éclaboussé = 0 AND $ isMouseOrange = 1
Délai de 100

/ / Vérifier au comptant
LoadRGB $ brightX, Brighty $
Si {RGBRed}> $ {brightRMax OU RGBRed} <$ {brightRMin OU RGBGreen}> $ {brightGMax OU RGBGreen} <$ {brightGMin OU RGBBlue}> $ {brightBMax OU RGBBlue} <$ brightBMin

/ / Vérifier en haut à gauche
Calculer x = $ brightX-brightDist $
Calculer y = Brighty $ $-brightDist
LoadRGB $ x, $ y
Si {RGBRed}> $ {brightRMax OU RGBRed} <$ {brightRMin OU RGBGreen}> $ {brightGMax OU RGBGreen} <$ {brightGMin OU RGBBlue}> $ {brightBMax OU RGBBlue} <$ brightBMin

/ / Vérifier en haut à droite
Calculer x = $ brightX + brightDist $
Calculer y = Brighty $ $-brightDist
LoadRGB $ x, $ y
Si {RGBRed}> $ {brightRMax OU RGBRed} <$ {brightRMin OU RGBGreen}> $ {brightGMax OU RGBGreen} <$ {brightGMin OU RGBBlue}> $ {brightBMax OU RGBBlue} <$ brightBMin

/ / En bas à gauche Vérifier
Calculer x = $ brightX-brightDist $
Calculer y = brightDist Brighty $ + $
LoadRGB $ x, $ y
Si {RGBRed}> $ {brightRMax OU RGBRed} <$ {brightRMin OU RGBGreen}> $ {brightGMax OU RGBGreen} <$ {brightGMin OU RGBBlue}> $ {brightBMax OU RGBBlue} <$ brightBMin

/ / Vérifie en bas à droite
Calculer x = $ brightX + brightDist $
Calculer y = brightDist Brighty $ + $
LoadRGB $ x, $ y
Si {RGBRed}> $ {brightRMax OU RGBRed} <$ {brightRMin OU RGBGreen}> $ {brightGMax OU RGBGreen} <$ {brightGMin OU RGBBlue}> $ {brightBMax OU RGBBlue} <$ brightBMin

/ / Vérifier en haut à gauche (étendu)
Calculer x = $ brightX-($ 2 * brightDist)
Calculer y = $ Brighty-($ 2 * brightDist)
LoadRGB $ x, $ y
Si {RGBRed}> $ {brightRMax OU RGBRed} <$ {brightRMin OU RGBGreen}> $ {brightGMax OU RGBGreen} <$ {brightGMin OU RGBBlue}> $ {brightBMax OU RGBBlue} <$ brightBMin

/ / Vérifier en haut à droite (étendu)
Calculer x = $ brightX + ($ 2 * brightDist)
Calculer y = $ Brighty-($ 2 * brightDist)
LoadRGB $ x, $ y
Si {RGBRed}> $ {brightRMax OU RGBRed} <$ {brightRMin OU RGBGreen}> $ {brightGMax OU RGBGreen} <$ {brightGMin OU RGBBlue}> $ {brightBMax OU RGBBlue} <$ brightBMin

/ / Vérifie en bas à gauche (étendu)
Calculer x = $ brightX-($ 2 * brightDist)
Calculer y = Brighty $ + (* brightDist $ 2)
LoadRGB $ x, $ y
Si {RGBRed}> $ {brightRMax OU RGBRed} <$ {brightRMin OU RGBGreen}> $ {brightGMax OU RGBGreen} <$ {brightGMin OU RGBBlue}> $ {brightBMax OU RGBBlue} <$ brightBMin

/ / Vérifie en bas à droite (étendu)
Calculer x = $ brightX + ($ 2 * brightDist)
Calculer y = Brighty $ + (* brightDist $ 2)
LoadRGB $ x, $ y
Si {RGBRed}> $ {brightRMax OU RGBRed} <$ {brightRMin OU RGBGreen}> $ {brightGMax OU RGBGreen} <$ {brightGMin OU RGBBlue}> $ {brightBMax OU RGBBlue} <$ brightBMin

SetConst éclaboussé 1 =
RightClick Shift
Retard 500

Fin
Fin
Fin
Fin
Fin
Fin
Fin
Fin
Fin

Appel isMouseOrange

Fin
Fin

isMouseOrange procédure
SetConst $ isMouseOrange = 0

/ / Obtenir la couleur de la souris
Calculer mouseX = {} MouseX + 4
Calculer mouseY = {} MouseY + 4
LoadRGB $ mouseX, mouseY $

/ / Si la souris est orange (la variance a ajouté pour faire bonne mesure ..)
Si {} RGBRed> 210 = {ET RGBRed} <= 218 et {} RGBGreen> = 160 ET {RGBGreen} <= 168 et {} RGBBlue> = 84 ET {RGBBlue} <= 92
SetConst $ isMouseOrange = 1
Fin
Fin




ajustements qui ont travaillé

Est utilisé Menethil après peaufiner les choses

mon Tweaks:
/////////////////////////
/ / CONSTANTES VARIABLES / /
/////////////////////////

/ / Compte Run
/ / Combien de fois le script doit essayer de poissons
RunCount = 10000

/ / Vitesse
/ / C'est la première vitesse de balayage. La valeur est faible, plus le scan va,
/ / Et plus le nombre, le ralentissement de la numérisation va. Si vous rencontrez des problèmes
/ / Où le isnt analyse initiale de trouver le flotteur et simple numérisation de droit sur elle,
/ / Essayez d'augmenter ce nombre lentement.
scanSpeed = 65

/ / Boîte de distances Scan
/ / Ce sont les distances des côtés de l'écran pour rechercher un leurre
/ / Ce sont mesurées en pourcentage de l'écran dans la direction appropriée
scanLeftDist = 0,25
scanRightDist = 0,25
scanTopDist = 0.4
scanBottomDist = 0,25

/ / Plage de luminosité
/ / C'est le nombre de valeurs RGB sur et sous la «lueur d'espoir» qui est le
/ / Leurre à comparer. Fondamentalement, si vous obtenez le message "Pas de poisson à crochet,
/ / Essayez d'augmenter à la fois un peu les chiffres, et si les bobs bobber mais vous n'avez pas de capture
/ / Quelque chose, essayez de diminuer un peu les deux numéros. Cela peut changer d'environnement
/ / À l'environnement. Aussi, en règle générale ne devrais brightRangeUp être très élevé.
brightRangeDown = 45
brightRangeUp = 9

/ / Distance de luminosité
/ / Ne marche pas question ce qu'il fait, mais au fond, le laisser seul, sauf si vous avez des
/ / Problèmes effectivement attraper le poisson. Si vous rencontrez des problèmes et que vous voulez
/ / De ruser, règle générale, plus la résolution est élevée, plus le nombre,
/ / Le numéro de série, mais ne devrait être entre 2 à 6 MIN MAX. Si vous commencez
/ / Devient trop de wack avec cela, vous ne serez jamais attraper un poisson
brightDist = 3

/ / AFK Away
/ / Défini à 1 pour utiliser AFK Away (qui appuie sur Entrée deux fois avant chaque lancer) ou
/ / 0 pour désactiver AFK Away entièrement. Ceci vient en utile si vous souhaitez
/ / Chat sur WoW pendant la pêche.
afkAway = 1

Essayez World of Warcraft Gold à la Bourse de MMORPG!

Classé dans: World of Warcraft Gold

Comme ce poste? Abonnez-vous à mon flux RSS et obtenir plus de charges!