Jarvis101

First to kill is a very complicated feature, and is dependent on class and build. I think what would be better is a database of monster and monster mods, and a list of commands like attack, run, try to kite, only use certain skill with power/frenzy/endurance charges etc etc... so that we could write our own action scripts. Need a medic - Read above oops not here - zone dependent, and fickle. A single content update could change everything. aoe timed skills - 10 clicks per second is almost identical to holding the button. If you want, you can ramp it up in the config.ini my tab is full - would require a parsing of stash, and with premium stash tabs, it would likely require a dynamic array. Vectors could be used to achieve this but either way it's a lot of work. Let's get the basic functions working, like pickit. Im human - AHK?

This really should be in the trading sections.

Diablo 2 bots had a + parameter that came in very handy. It would be awesome to see something like this with our pickit. Example : [Category] == "Chest" && [Rarity] == "Rare" # [base_maximum_life] >= 60 && ([base_fire_damage_resistance_%] + [base_cold_damage_resistance_%] + [base_lightning_damage_resistance_%]) >= "75" && [stashItem] == "true"

Then use someone elses script. Mine won't vendor any currency or legendaries, and has a decent setup.

Probably not TOO hard to implement. One more mem addy and another regex, would allow smart pickit to remain useful while leveling up, and wanting to keep things like rings for vendoring recipes.

I was thinking of when the bot id's the item, it checks its stats vs a crafting config. The result would be checked against a pickit. example : Item gets id'd, checks if it is to be sold, if so, run through craft check. loop process until crafting tries are used up. But yeah, I can see a dozen problems with this code. Wrote it last night after being up for 20 hours.

Not sure if you started work on crafting orbs... but I got bored and threw something together. //Code for crafting //usage of namespace using namespace std; //main controllers (gui elements) bool has_craftables; bool craft; int current_roll; int max_rolls; //Crafting settings (config elements) bool alchemy; bool fusing; bool socketing; bool chaos; bool regal; bool chrome; bool exalt; //Crafting commands (eg. in config, use [Alch] == "true" bool alch; bool fuse; bool socket; bool Croll; bool Rroll; bool color; bool ex; //function declarations bool init(); bool load_craft(); void start_craft(); main()//The item parse { if(!init()) { //handle error if(!load_craft()) { //handle error } } else { if(craft == true) { start_craft(); } } } bool init() { bool flag = true; bool loadfilecheck = true; //Place holder for the function used to load the settings //initializing unused variables has_craftables = false; craft = false; max_rolls = 0; //This would be where you load crafting setting if(!loadfilecheck) { //error message here flag = false; } return flag; } bool load_craft() { //This is where you load the config file } void start_craft() { if(has_craftables == true) { while(current_roll < max_rolls) { if(alchemy == true) { //check item against craft parameters and set the variable to true if a true match is found if(alch == true) { //go to stash //find orb //craft current_roll++; } } if(regal == true) { //check item against craft parameters and set the variable to true if a true match is found if(Rroll == true) { //go to stash //find orb // current_roll++; } } if(chaos == true) { //check item against craft parameters and set the variable to true if a true match is found if(Croll == true) { //go to stash //find orb //craft current_roll++; } } if(socketing == true) { //check item against craft parameters and set the variable to true if a true match is found if(socket == true) { //go to stash //find orb //craft current_roll++; } } if(fusing == true) { //check item against craft parameters and set the variable to true if a true match is found if(fuse == true) { //go to stash //find orb //craft current_roll++; } } if(chrome == true) { //check item against craft parameters and set the variable to true if a true match is found if(color == true) { //go to stash //find orb //craft current_roll++; } } if(exalt == true) { //check item against craft parameters and set the variable to true if a true match is found if(ex == true) { //go to stash //find orb //craft current_roll++; } } } } }

That's why you use meds?

Player auctions is less greedy

afaik, you would need to access the donor forums, buy items with your fg then sell those items to people you know. jsp really is a huslters market.

Each pointer will point to a certain block in the memory. Each memory block is comprised of 8 bits (8 hex values), and once you've stored the data you need in that block, the remainder values in that block will be 0x00. What you're suggesting would require a search matrix, which would need to analyze multiple memory blocks at once. Still doable, but it's a steep road, and it only gets steeper.

possibly, but it's not like people don't already do it. And it would be nice to have the option.

You're right about pointers and memory addresses, but it's a bit more complicated then searching for an identical hex value... Example : Memory address you're looking for - item mod value. You know the mod value you're looking for is 52. You look for the value 34(52 in hex). 800 addresses return, including the 52 in your currently logged ip, the 52 hp monster on the map, etc etc etc x800. Like I said it takes sifting.

Thing is, when messing with memory you can do a LOT of damage. Not just to the running program, but you could corrupt a data sector in your RAM or your HDD if you don't know what you're doing. It's not like interpreted code, or scripting languages, or high level languages, where there are safeguards that prevent you from typing your way to a new pc... You're dealing with raw buffer data, and if you don't know what you're doing (or someone unwittingly makes a change to the file), then bad things can happen

Suggestion : An option to suicide a character so it loses its xp, once it reaches a certain level. Use : Farming a difficulty without exceeding the drop reduction thresh hold. How : Find XP mem addy's and clvl mem addy, and just have some simple checksums to run a suicide code. Place variable checksum controller in gui under main with a level cap and checkbox for use.

For navigating the waypoint menu, yes. For finding the waypoint itself, no.

Send Alkpone a private message with your transaction ID, account name, and e-mail address. He'll get to upgrading you when he has time.

Many of you, like me, want the bot to be updated right away. The difference between most of you and me however, is that I somewhat understand what is needed to update the bot. My goal : to try and educate the masses of people who don't know what work goes behind each update. What's so complicated about a poe patch, that the bot doesn't work anymore? When a program is compiled (translated from source code to binary instructions (from programming language to .exe)), Every aspect in the program is loaded and stored in various places systematically. Because of this, people can look at a specific spot in the memory (like a bookmark in a book), and figure out what's there and what to do with it. When a patch comes out, the source code is changed. This means that everything isn't sorted and stored the same way, and so when we try and read from our bookmarks, the information there isn't related to the things we're trying to do. In order to fix this, we need to find the new offsets (make new bookmarks), for the data that we want to work with. What does this mean? What exactly do the devs need to do to "make new bookmarks"? Take a look at this picture. It's a screen shot of some random program loaded in some random dissassembly program : I've only outlined some of the aspects, but for a general idea, developers need to sift through and match up thousands of memory addresses and hex data, and verify that the match ups they made are in the right part of the program. This is a tedious task, and it takes a very long time. For me myself and I, if I had to do this I would be bald 5 times over. With me so far? Good, here's where it gets complicated! After hours of countless sifting, and matching, and checking, and re-sifting, and re-matching, and re-checking, then moving to the next memory offset - repeat as many times as you actually look in the memory for something (look for waypoint, look for a piece of the environment (a rock), look for an item that dropped, etc etc etc)... Once you finally have all the new offsets, you need to go back into the program you wrote that reads based off the "book marks" you've made, replace the old "bookmarks" with the new "bookmarks" and hope that you didn't mix anything up. Then you need to run the program a few times, and make sure that everything is working as intended. If it is not, you go right back to step one, and repeat the procedure until you have everything working right. So for those of you that want your update NOW, I suggest you learn how to do this, find the new offsets yourself, and send them to the dev team to help them out. It would go a long way in speeding up the process. Otherwise, please keep the questions to a minimum, because when counting to one thousand, if someone interrupts you, it's easy to lose your place.

What kind of a computer are you running, and what are your vm specs?

So, I'm loving the new pickit system. Granted it could use a bit of clarification in the explanation (as the examples, and actual given "working" list don't exactly match), but overall I love it. I'm thinking, with this new system, there might be a way to temporarily patch over the "picking up junk" issue. I'm assuming that when you're in town, your inventory gets parsed before going on a run, so it knows whether to ID/Sell/Stash stuff. Maybe you could add a parameter such as [Junk] == "true" that prevents the bot from picking it up, while still selling it to the vendor when your inventory is parsed. With something like this, we could do a blanket cover for all items via [Category] and [Junk] so that the bot recognizes the other stuff in the inventory that you don't want to keep. Example

Why someone would want to tunnel vision themselves in with microsoft I have no idea -.-. I'd suggest learning opengl and it's variations. Once you get over the pipelines hurdle, it's actually pretty simple and very powerful.

While it theoretically is possible by searching the memory for the values you're working off, you also need to consider the fact that #1 even if this is done, multiple results would come up, and you'd need a way to sift through it #2 you're assuming the memory values that you need to alter haven't changed, and #3 getting the memory dumps via code (Which is how you would need to do it in order to automate it), is much more complicated than just running a dbg program and looking at it manually. TL;DR : What you're asking for is a lot of work and would delay work on essential functions and algorithms which are still being developed.

So I was checking out the requests forum and decided to write up some functions you can use for delayed and conditional skill usage. It was late when I wrote this so it could probably be made more efficient. * Notes - the program was written as standalone to debug - couts were used for debugging/place holding purposes. Remove them when applying. - I did not include any file streams as 1) i don't have access to source code, and 2) I'm sure you guys want to handle the usage of config files -will probably look better as a class and could probably use children, however it's late and I just want to get this posted. //Declaring my headers #include "stdafx.h" #include <iostream> #include <ctime> #include <string> //Declaring my namespace using namespace std; //Declaring my functions void TotTime(); // ******** This function needs to be copy and pasted for each skill that uses a timer, // then edited to match skill parameters void Timer(int seconds); void useSkill(); //function holding placeholder code for calling upon the function to use skills void SkillSlot1(); //determines how to use the skill in slot x. all skillslot functions other than 1 are //blank, copy paste code and edit as needed for other skills. void SkillSlot2(); //determines how to use the skill in slot x void SkillSlot3(); //determines how to use the skill in slot x void SkillSlot4(); //determines how to use the skill in slot x void SkillSlot5(); //determines how to use the skill in slot x void SkillSlot6(); //determines how to use the skill in slot x void SkillSlot7(); //determines how to use the skill in slot x void SkillSlot8(); //determines how to use the skill in slot x void FunctionThatUsesSkills(); //a function that determines when to use certain skills. Probably redundant bool shouldibeused(); //funcion that determines whether a skill should be used or not and returns a bool void attackspeed(); //probably a misdirecting function name. Used to delay the time between attacks void initvariables(); //initialization and/or loading of variables bool Totemdeath(); // A function to break the timer, and an example for totem death. //Declaring my public variables float atkspd; bool takeaction; float totemuptime; bool totemhasdied; bool checktotemdeath; //skill id's used to determine method of use in skillslotx() int skill[8]; //Main int _tmain(int argc, _TCHAR* argv[]) { initvariables(); //initialize variables and/or load configurations FunctionThatUsesSkills(); return 0; } //Functions void initvariables() { atkspd = 1; bool takeaction = true; totemuptime = 10; totemhasdied = false; skill[0] = 1; skill[1] = 0; skill[2] = 0; skill[3] = 0; skill[4] = 0; skill[5] = 0; skill[6] = 0; skill[7] = 0; } void FunctionThatUsesSkills() { bool Skill1params; // This variable is to dictate whether the situation warrents // the usage of a skill Skill1params = shouldibeused(); while (Skill1params == true) { SkillSlot1(); } } bool shouldibeused() { // An example of parameters you would use bool Incombat = true; // automatically assuming skill should be used if (Incombat = true) { return true; } else { return false; } } void SkillSlot1() { bool isaninstantskill; int skillcheck; skillcheck = skill[0]; //the latter variable (skill1) will need to be changed when copying this function // You would arrange the skill ID's to have instant id's to be numbered below non // instant ID's if (skillcheck == 0) { isaninstantskill = true; } else if (skillcheck == 1) { isaninstantskill = false; } else { cout << "error" << endl; } // End of determining type of skill, begin determining what to do with skill if (isaninstantskill == true) { while (takeaction = true) { takeaction = false; useSkill(); attackspeed(); } } else if (isaninstantskill == false) { // ******** This section of code needs to be edited to match skill parameters if (skillcheck == 1) { while(takeaction = true) { takeaction = false; useSkill(); TotTime(); //wait for next cast } } // ******** This section of code needs to be edited to match skill parameters } } void SkillSlot2(){} void SkillSlot3(){} void SkillSlot4(){} void SkillSlot5(){} void SkillSlot6(){} void SkillSlot7(){} void SkillSlot8(){} void useSkill() { cout << "this is the normal code to use a skill" << endl; } void TotTime() { checktotemdeath = true; for (float uptime = totemuptime; uptime!= 0; uptime--) //int uptime = x; where x is the time //inbetween casts { Timer(1); if(Totemdeath()==true) { break; } } takeaction = true; } bool Totemdeath() { if(checktotemdeath == true) { if(totemhasdied == true) { return true; } } else { return false; } } void attackspeed() { for (float uptime = atkspd; uptime!=0; uptime--) //int uptime = x; where x is the time inbetween casts { Timer(1); } takeaction = true; } void Timer(int seconds) { clock_t totemtimer; totemtimer = clock() + seconds * CLOCKS_PER_SEC; while (clock() < totemtimer) {} } Hope you guys can use this.

The only way I could think of doing this would be to intercept the packets, and experimentally go through all the data in a sandbox environment until you know what's what. it's tedious and inefficient, and probably not of much help.