fixthissite

But this is suggesting focus is as simple as flicking a switch at random intervals. If Jagex were detecting such patterns in clicking (whether a user is focused or not), I really don't think they'd be checking only a player's focus level (kinda like you said, high and low), but also what they could be focusing on depending on at what moment during the activity. Like you said, you gotta account for irl activities such as watching tv, but I'm sure the amount of activities (and the attention required from those activities) can differ between countries, making it difficult to create a "silver bullet" system for focusing WITHOUT letting the individual botter (not scripter) adjust the settings how they feel it should be, ensuring focusing is unique on every bot. I'm not downing the idea at all; I actually really like the idea of changed tempo of clicks. It just seems unfinished, as if a few things were overlooked. If Jagex was checking how focused a player is as a bot scouting technique, I'm sure it would be a lot more elaborate than simply seeing if there's any periodical changes in click tempo. What I'm saying is if you really feel this is something that they'd check for, go all in with it; think of every possibility. Otherwise, it could be a cause of getting caught faster. If a bot is going at a somewhat constant pace (not 100% constant, but somewhat steady pace), there's not much evidence behind it being a bot; it could be a guy fueled up on red bull. But this is adding the possibility of a pattern (albiet one that may be hard to replicate depending on the implementation), and that's why I'm saying if it's not done correctly, it could actually cause bots to be more detectable.

Nice to see an eager mind at work on preventing bans Although focus might play a factor between distinguishing humans from bots, I don't think it's something they'd try to account for, seeing how diverse people can be in that aspect. I stay calm when I used to PK; tensing up would make me choke. The focus one might have can go from totally afk to spam clicking everything, and the times they'd have more focus differ. Bots don't wanna afk, and you'd have to find the "right moments" to get up to spam clicking levels. If not implemented right, I feel it would make bots more distinguishable from humans, and implementing it well would require time that can be used for something that may be more beneficial. This is just my opinion though. Thanks for putting the time into this! Sounds really neat, but needs more meat on it. Do developers have to implement their own focus system? Do bot users adjust the focus settings to make it unique to each bot, and not just each script? How could we prevent a botter from adjusting the settings to something which would make them easier to spot?

Metaprogramming is uncommon around these parts, but is use substantially in frameworks such as Spring and Hibernate. It's been becoming more popular with the release of Java 8, which allows you to annotate just about anything.I used it in this situation to reduce the amount of typing needed by the client (the person using this code). I wanted you guys to easily wire nodes to other nodes when you create the node class, without altering the current node design (to avoid confusion). I also gave the job of creating the actual node objects to the node managers, so you won't have to worry about accidentally creating an excess object, or forgetting to add a node that's needed by another node. As for the crazy code, you'll see a lot of Class<? extends Node>, which is probably what's throwing you off. Every class in your program has a class object (can be received with the instance method getClass() or a class literal: ClassName.class). As you're using this code, you'll notice yourself using quite a few class literals; that's what the Class<? extends Node> type is for: Class<? extends Node> clazz = BankNode.class; But you don't need to be reading that stuff anyways, unless you're really interested in the code behind all this.

Past accounts (if you know of any): dog_ Current account: Novak Reasoning: The only one I could find was for account sharing, not sure if that was the cause though, as it wasn't mentioned. It was also in 2014, so I'm not sure if he got unbanned and banned for another reason. I feel this member could be harmful to the community. He argues, passing around false info, and resorts to trolling once he has realized he's unsure of what he is talking about. He is very good friends with SwizzBeat, who is also banned (a thread to unban swizz was created, which was denied. Not too surprised). I noticed when he first mentioned we encountered on another site: REMOVED We debate it for a bit. He tries stating that although the system he proposed is more efficient, it's not as complex as this, which is easily debatable. I then go on to ask who he is: REMOVED He didn't mention it. When I asked him again, he finally pmed me saying he was "dog": REMOVED I clearly remember a "dog" who I got into an altercation with on another site. I accuse him of ban-evading, knowing the OSBot account he used. He replied with "nobody is ban evading you moron, please report me so that the mods laugh in your face". I replied, trying to confirm his account, in which he replied with: REMOVED Doesn't make much sense. But if you look at his history from "the other site", you'll be able to see his reckless behavior and lack of knowledge, which he tries to spread like cancer (he does have SOME knowledge obviously, but he talks a lot in which he doesn't care to look into). He doesn't defend himself easily, then resorts to trolling as you can tell in the pms (with the "deobing RS client", which he irrelevantly refers to). Here are some more pics of the conversation: REMOVED

How is a simple annotation "over-complicating things"? I'm sorry if you don't understand the language enough to use an annotation (which they really aren't that hard; I even gave an example), but the verbosity is not a problem for the functionality it gives. Even beginners can easily use this kind of syntax, and seeing how it's aimed at people who use the node framework, I don't see a problem. Please, mind telling me who you are on the other site, so I know who I'm talking to from there?

I was just stating facts. If you stated facts, maybe we would get to a conclusion. So what if I'm defensive? If I feel I'm correct, what's wrong with defending myself? If you aren't giving me any reasons as to why this code is inefficient, how are others supposed to be aware? By the way, mind saying who you are on the other site? And just for kicks, check out The Billion Dollar Mistake by Tony Hoare, where the inventor of the null pointer said himself it was a mistake.

Your proposal requires more processing than this. Using these systems, all the heavy work is done before onLoop starts, and the heavy work doesn't take long at all. As for naming, it's nice to know you have preferences. We all do. I'm going based off what I've seen to be popular, not what each person likes best. It was requested, so it's definitely not irrelevant. Some scripts are more advanced than others, which require increased decomposition to maintain. Not to mention, the lack of effort needed by the client as well as the type safety. Maybe you should post your test system and let the developers decide which is easiest to use.

DOWNLOAD (since JARs are not allowed to be used in scripts, the .rar contains the source files, which you can include in your project) UPDATED: The two systems have been merged. Let me know if there are any issues. Two people came to me asking how to implement certain functionality: 1. To link certain nodes to other nodes. Since some nodes won't come after other nodes (Bank will only come after WalkToBank), there's no reason to loop through EVERY node in the script depending on the current node. How could one implement a system that only check to see which node shohld be next out of the possible nodes, not all the nodes. 2. To allow other nodes to execute while the current node is executing. When the current node is WalkToBank and your player has low hp, the script will not eat, since the current node is WalkToBank and not eat. You could add a priority system, but the problem is not "performing one node before the other"; it's performing one node while another node is processing. There exists an asynchronous node executor, which executes a node on a background thread. But this does not account for possible memory incosnistencies by implementing memory barriers. Not to mention, such a burden isn't actually needed; a single-threaded system could give the same functionality, without the need for atomicy and synchronization, as long as the script is running at a specific frame rate (a guide on that coming soon; pm me if you aren't sure what that means). I have packaged both together. I haven't tested it with an actual script (performed some lazy tests), so let me know if there are any problems with it. NodeLinkerManager The idea is to take a group of nodes, and "map" them to a specific node. For example, the WalkToBank would only be followed to the Bank node, and in a pk script, a WalkToWild node will only be followed by FightPlayer and LookForPlayer. We want to link nodes to their possible outcomes. Usually, a node based script looks like this: class MyScript extends Script { private List<Node> nodes; public void onStart() { nodes = new ArrayList<>(); nodes.add(new WalkToBank(this)); // add other nodes } public int onLoop() { for(Node node : nodes) if(node.canProcess()) node.process(); } } abstract class Node { private MethodProvider api; protected Node(MethodProvider provider) { this.api = api; } protected MethodProvider api() { return api; } public abstract void process(); public abstract boolean canProcess(); } final class WalkToBank extends Node { // ... } The problem with this is, depending on the amount of nodes (which increase as decomposition is applied), the for loop in the onLoop method could take longer than it needs. This is because it could be checking nodes that could not possibly come after the current node. Instead, we want to check only the nodes that could possibly come after the current node. For this, you must specify which nodes can come after which nodes. This is done through the @Linked annotation: import fts.node.Node; @Linked(nodes = { Bank.class }) final class WalkToBank extends Node { // ...same as usual } The other difference is how you add nodes. First, you need to declare the NodeLinkerManager in your script. You then add the type of the node you want. Any linked nodes that are specified through the @Linked annotation are instantiated, as well as the node you specified. To ensure no excess objects are created, NodeLinkerManager handles ALL instantiation; you simply specify the type of a node through a class literal: final class MyScript extends Script { private NodeLinkerManager manager; public void onStart() { manager = new NodeLinkerManager(this); manager.add(WalkToBank.class); } public int onLoop() { manager.process(); return 2; } } NodeFragmentManager There are some actions that should be performed while other actions are performing. For example, if you are fighting, you might wanna check if you should eat or pot. You could hard-code the logic into the Fight node, but what if there are actions that apply to all nodes? The node fragment system sees those actions as "node fragments". A NodeFragment is the exact same thing as a Node, other than the ability to specify a NodeFragment when creating a node. You would specify the NodeFragment through the @Fragmented annotation: @Fragmented(fragments = { Eat.class; }) final class WalkToBank extends Node { // ... } final class Eat extends NodeFragment { // ...same as a regular Node } When the current node is WalkToBank, Eat will also process. This will allow the bot to eat while it's walking to the bank (if needed).

Trafficking. I suggest posting this somewhere other than the spam forum ;) Good question though, seeing how just about everything that isn't already covered is against the rules.

Math is important ;) Marketing is a skill in itself. Doesn't matter how good your services may be, if you don't market correctly, you could get nowhere (or possibly even further away than you were). With that said, I suggest finding someone to help you market; someone who has a way with words (rhetoric).

Rather than creating the path all at once, why not generate your next "random" movement after reaching/finding the location you are currently walking to. You generate (asynchronously) a bunch of "next possible step" nodes and choose one. That way, you can generate billions upon billions of different paths. For those saying "the time itll take to process all those nodes" should pick up a multithreading book at some point. For those saying "too much memory", read up on how HotSpot manages garbage collecting. Trying it won't hurt. Creating paths before-hand is pretty damn insane if you're looking for realism.

Just to clear things up, although IntelliJ is a more advanced IDE, using it for scripting is an overkill. Yeah, the indexing is nice when you have tons of files between multiple languages, which is a big reason a developer may choose IntelliJ. But for programs with like 10 to 20 classes all written in Java, using IntelliJ is like killing an ant with a flamethrower. Once again, it comes down to preference. Some people like the feel of IntelliJ, some like the feel of Eclipse. I've used both, and my opinion is, Eclipse is just fine. Leave it alone guys. Btw, if you look, everyone is all "IntelliJ or get out", but give no reasons.... hmmm...

So I'm a beginner?Honestly, a lot of advanced developers still prefer to use vim. It's all about the person.

Nope. There are some bonus features, other than parallelism, but none of which you could be taking advantage of in this code

Nice, I'm sure it will help out quite a few people. Here's some advice to hopefully improve the readability (and managability) of your code: No need to check if entity != null twice (if statement and else if statement). Simply do if(entity != null) { if(menu.isOpen()) { } else { } } You have quite a few un-needed return statements. Rather than calling return when options == null, format your code to allow the flow of execution "do nothing" until the return statement at the bottom: private boolean hoverEntityOption(Entity entity, String option) throws InterruptedException { if(entity == null) return false; if(menu.isOpen()) { List<Option> options = menu.getMenu(); if(options != null) { Rectangle optionRec = null; for(int index = 0; index < options.size(); index++) { if(options.get(index).action.equals(option)) { optionRec = menu.getOptionRectangle(index); if(optionRec != null) { if(!optionRec.contains(mouse.getPosition())) { int x = menu.getX() + Script.random(10, 160); int y = menu.getY() + 23 + index * 15; Script.sleep(Script.random(200, 400)); return mouse.move(x, y); } } } } } } else { EntityDestination ed = new EntityDestination(bot, entity); mouse.click(ed, true); } return false; } As you can tell, I also fixed up the wierd scoping. If you ever find yourself declaring the tracker variable for a for loop outside of the loop, best believe you have a structuring problem. You were breaking from the loop, just to have another block of code (which depends on the tracker variable; the whole reason you have the for loop) return from the entire method. I would recommend the Stream API to decrease the amount of time it takes to iterate through a collection, as Alek suggested, but it might interfere with how you're specifying your mouse location. Still quite a bit of cognition needed to understand the method. We can lower it through decomposition: private boolean hoverOverEntityOption(Entity entity, String option) throws InterruptedException { if(entity == null) return false; if(menu.isOpen()) return moveMouse(option); else clickEntity(entity); return false; } private boolean moveMouse(String option) { List<Option> options = menu.getMenu(); if(options != null) for(int index = 0; index < options.size(); index++) if(options.get(index).action.equals(option)) { optionRec = menu.getOptionRectangle(index); if(optionRec != null) if(!optionRec.contains(mouse.getPosition())) { int x = menu.getX() + Script.random(10, 160); int y = menu.getY() + 23 + index * 15; Script.sleep(Script.random(200, 400)); return mouse.move(x, y); } } } private void clickEntity(Entity entity) { EntityDestination ed = new EntityDestination(getBot(), entity); mouse.click(ed, true); } Keep up the good work man

I'm not saying take all limits off; just blur the line between AIO, single tasked scripts and any other kind of script that may appear. Limiting the audience of a developer's script due to their experience is a pretty harsh thing to do, considering they're simply trying to provide good quality product. If people like the product more than what's currently out there, it makes sense that the developer(s) deserve the cash. I totally understand the rules, ensuring scripts don't drop down to un-imaginable prices. But preventing such competition to allow scripters with little experience to compete on the market for prices of $5 to $10 is a bit out there, and gives them no reason to truely improve their skills. "Life without competition is life without progress; a static society where the cream does not rise to the top because there would be no goals and no desire to march to the different drum beat and take something farther than it's ever been taken before."

Thanks for leading me to that. I haven't checked out the Upload Request section, since I haven't had a reason to go there (until now, obviously). But dividing the market in such a way slows down progress, as stated before.. I understand you guys want to allow less savy developers to have a chance on the market, but that handicaps the quality of scripts, seeing how people aren't forced to bring new things to the table in order to keep their business. I've stated before (many times) that most scripts are rehashes of other scripts, with a few slight modifications. Scripters have also agreed to this. Heated competition would force developers to increase their skills to stay alive on the market, which results in more innovation and better quality. How am I supposed to know without asking? That's all I did, please don't take it personal. I'm sure if you were in my position, you'd question it too. To give an example of the progress I'm talking about, why aren't AIO scripts more popular? Why is the transfer so slow? If a framework for easily making AIO scripts were available, would the prices change? Why are consumers still paying $7 for a script that performs 1 task (in a variety of ways in different locations, but 1 task)? If an AIO script was made cheaper than a single task script, developers will be forced to learn how to and start creating AIO scripts to stay in the market. That's progress. As for the next step, who knows. At this rate, we'll probably not find out within this lifetime

So a monopoly is not allowed, no matter how good the product/service may be? Not in the sense that one developer will be behind it, taking all the income. Comsumers should be able to decide what they want to buy, without quality being a concern, if it's possible to do so, which in this case, it is. Rules like this only slow down the progress of the community, as developers are not forced to innovate, leaving programmers to keep doing the ordinary. We won't get very far that way. No offense to the rules set in place (would be nice if there was a place to reference them), I understand their intentions, but I think the majority of the community would much prefer a community moving at a fast pace. I can't speak for them, but some kind of poll would allow them to decide.

Divinity is competing on the market, yeah? Why does he get say in the price of another competer's script?

Where do true AIO scripts, covering multiple possibly all skills? Are they allowed to be priced at normal script prices, more specifically within the $5 to $10 margin?

Are scripts allowed to be priced at any amount the developer chooses?

Verify what? The code doesn't contain any viruses, which the developers will be able to clearly see. No need to worry

Nice to see new scripters Are you looking for code improvements? I can see quite a few things you could do to make managing your code a lot easier. Let me know if you're interested

~

Gotta show the code for your first error. The second one is stating that there is already a class/enum/interface/annotation named "main".