├── .gitignore
├── Gruntfile.js
├── LICENSE
├── README.md
├── Scripting.md
├── build.sh
├── example
    ├── hello_world.js
    └── lib.js
├── hacking
    ├── golf
    │   └── lockpick.429.js
    └── lockpick.js
├── include
    ├── access.js
    ├── classes.js
    ├── cmp.js
    ├── color.js
    ├── color_attribute.js
    ├── dtr.js
    ├── fmt_date.js
    ├── fmt_script.js
    ├── fmt_upgrade.js
    ├── fmt_user.js
    ├── is_npc.js
    ├── nfo_operand.js
    ├── nfo_script.js
    ├── nfo_user.js
    ├── npc_static.js
    ├── parse_timestr.js
    ├── rarity.js
    ├── recover.js
    ├── regex_corrupt.js
    ├── security.js
    ├── sort.js
    └── stdlib.js
├── nix
    ├── connect-scripts-dir.sh
    └── fix-resolution.sh
├── old
    ├── README.md
    ├── crack.js
    ├── mode.js
    ├── qr.js
    ├── starter
    │   └── nuutec.js
    └── t1
    │   ├── crack.js
    │   └── harvest.js
├── package.json
├── poc
    ├── is_npc.js
    ├── parse_timestr.js
    └── recover.js
└── tools
    ├── access_log.js
    ├── allsec.js
    ├── bank_statement.js
    ├── call.js
    ├── harvest.js
    ├── market_browse.js
    ├── qr_decode.js
    ├── updatedb.js
    └── upgrade_log.js


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Logs
 2 | logs
 3 | *.log
 4 | npm-debug.log*
 5 | 
 6 | # Runtime data
 7 | pids
 8 | *.pid
 9 | *.seed
10 | 
11 | # Directory for instrumented libs generated by jscoverage/JSCover
12 | lib-cov
13 | 
14 | # Coverage directory used by tools like istanbul
15 | coverage
16 | 
17 | # nyc test coverage
18 | .nyc_output
19 | 
20 | # Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
21 | .grunt
22 | 
23 | # node-waf configuration
24 | .lock-wscript
25 | 
26 | # Compiled binary addons (http://nodejs.org/api/addons.html)
27 | build/Release
28 | 
29 | # Dependency directories
30 | node_modules
31 | jspm_packages
32 | 
33 | # Optional npm cache directory
34 | .npm
35 | 
36 | # Optional REPL history
37 | .node_repl_history
38 | 
39 | # Generated directories
40 | build
41 | release
42 | 


--------------------------------------------------------------------------------
/Gruntfile.js:
--------------------------------------------------------------------------------
  1 | module.exports = function(grunt) {
  2 |     "use strict";
  3 | 
  4 |     function prepare_for_uglify(code) {
  5 |         code = code.replace(/#s\./g, "SCRIPTOR.");
  6 |         code = code.replace(/#db\./g, "DATABASE.");
  7 |         code = code.replace(/([\s\S]*)/, "($1)();");
  8 | 
  9 |         return code;
 10 |     }
 11 | 
 12 |     function prepare_for_upload(code) {
 13 |         code = code.replace(/^\!([\s\S]*)\(\);$/, "$1");
 14 |         code = code.replace(/^\(([\s\S]*)\)\(\);$/, "$1");
 15 |         code = code.replace(/DATABASE\./g, "#db.");
 16 |         code = code.replace(/SCRIPTOR\./g, "#s.");
 17 | 
 18 |         return code;
 19 |     }
 20 | 
 21 |     function calculate_dependencies(required, library) {
 22 |         library = library || [];
 23 |         var dependencies = {};
 24 |         var current;
 25 |         var uses = [];
 26 |         while (required.length) {
 27 |             current = required.shift();
 28 |             if (current in dependencies) continue;
 29 |             if (library.indexOf(current) > -1) {
 30 |                 if (uses.indexOf(current) == -1) {
 31 |                     uses.push(current);
 32 |                 }
 33 |                 continue;
 34 |             }
 35 |             var source = grunt.file.read("include/" + current + ".js");
 36 |             var includes = source.match(/.*INCLUDE\(\w+\).*/g) || [];
 37 |             includes = includes.map(function(value) { return value.replace(/.*\((.*)\).*/, "$1"); });
 38 |             required = required.concat(includes);
 39 |             dependencies[current] = includes;
 40 |         }
 41 |         var unordered = [];
 42 |         for (var key in dependencies) { unordered.push({ 'file': key, 'deps': dependencies[key] }); }
 43 |         var ordered = [];
 44 |         while (unordered.length) {
 45 |             current = unordered.shift();
 46 |             var nodeps = true;
 47 |             for (var item in current.deps) {
 48 |                 if (current.deps[item] in dependencies) { nodeps = false; break; }
 49 |             }
 50 |             if (nodeps) {
 51 |                 delete dependencies[current.file];
 52 |                 ordered.push(current.file);
 53 |             } else {
 54 |                 unordered.push(current);
 55 |             }
 56 |         }
 57 | 
 58 |         return [ordered, uses];
 59 |     }
 60 | 
 61 |     function generate_includes(includes, library) {
 62 |         library = library || [];
 63 |         var code = "";
 64 |         var i;
 65 |         if (library.length) {
 66 |             code += "var __lib__ = SCRIPTOR." + grunt.config('meta.user') + ".lib();\n";
 67 |             for (i in library) {
 68 |                 code += "var " + library[i] + " = __lib__." + library[i] + ";\n";
 69 |             }
 70 |         }
 71 |         for (i in includes) {
 72 |             var file = includes[i];
 73 |             var tmp = grunt.file.read("include/" + file + ".js");
 74 |             tmp = tmp.replace(/.*INCLUDE\(\w+\).*/g, "");
 75 |             code += "var " + file + " = " + tmp + ";\n";
 76 |         }
 77 |         return code;
 78 |     }
 79 | 
 80 |     function create_lib() {
 81 |         var required = grunt.config('meta.lib');
 82 |         if (!required.length) return;
 83 |         grunt.log.write('Request library with ').write(required).writeln(' ... ');
 84 |         grunt.log.write('Calculating dependencies... ');
 85 |         var tmp = calculate_dependencies(required);
 86 | 
 87 |         grunt.config('meta.lib', tmp[0]);
 88 |         grunt.log.ok();
 89 | 
 90 |         required = grunt.config('meta.lib');
 91 |         grunt.log.write('Generate library with ').write(required).write(' ... ');
 92 | 
 93 |         var code = "function (){\n";
 94 |         code += generate_includes(required);
 95 |         code += "return {\n";
 96 |         for (var i in required) {
 97 |             var file = required[i];
 98 |             code += file + " : " + file + ",\n";
 99 |         }
100 |         code += "};\n}";
101 | 
102 |         grunt.file.write("build/lib.js", prepare_for_uglify(code));
103 |         grunt.log.ok();
104 |     }
105 | 
106 |     grunt.initConfig({
107 |         meta: {
108 |             user: grunt.option("user") || "dr_dvorak",
109 |             lib: [].concat(grunt.option("lib") || []),
110 |         },
111 |         clean: {
112 |             build: ["build/"],
113 |             release: ["release/"],
114 |         },
115 |         copy: {
116 |             pre: {
117 |                 expand: true,
118 |                 flatten: true,
119 |                 src: ["tools/*.js", "hacking/*.js", "poc/*.js"],
120 |                 dest: "build/",
121 |                 options: {
122 |                     process: function(content) {
123 |                         // Determine includes
124 |                         var includes = content.match(/.*INCLUDE\(\w+\).*/g);
125 |                         if (includes) {
126 |                             includes = includes.map(function(value) {
127 |                                 return value.replace(/.*\((.*)\).*/, "$1");
128 |                             });
129 |                             var tmp = calculate_dependencies(includes, grunt.config('meta.lib'));
130 |                             includes = generate_includes(tmp[0], tmp[1]);
131 |                             content = content.replace(/.*INCLUDE\(\w+\).*/, includes);
132 |                             content = content.replace(/.*INCLUDE\(\w+\).*/g, "");
133 |                         }
134 | 
135 |                         // prepare code for linting and uglifing
136 |                         return prepare_for_uglify(content);
137 |                     }
138 |                 }
139 |             },
140 |             post: {
141 |                 expand: true,
142 |                 flatten: true,
143 |                 src: ["build/*.js"],
144 |                 dest: "release/",
145 |                 options: {
146 |                     process: prepare_for_upload
147 |                 }
148 |             }
149 |         },
150 |         jshint: {
151 |             files: ["Gruntfile.js", "build/*.js"]
152 |         },
153 |         jsbeautifier: {
154 |             files: ["include/*.js", "tools/*.js", "hacking/*.js", "poc/*.js", "Gruntfile.js",
155 |                 "package.json"
156 |             ],
157 |             options: {
158 |                 js: {
159 |                     braceStyle: "collapse-preserve-inline",
160 |                     wrapLineLength: 120
161 |                 }
162 |             }
163 |         },
164 |         uglify: {
165 |             options: {
166 |                 mangle: true,
167 |                 compress: true,
168 |                 beautify: true
169 |             },
170 |             all: {
171 |                 files: [{
172 |                     expand: true,
173 |                     src: "build/*.js",
174 |                 }]
175 |             }
176 |         }
177 |     });
178 | 
179 |     grunt.loadNpmTasks("grunt-contrib-clean");
180 |     grunt.loadNpmTasks("grunt-contrib-copy");
181 |     grunt.loadNpmTasks("grunt-contrib-jshint");
182 |     grunt.loadNpmTasks("grunt-contrib-uglify");
183 |     grunt.loadNpmTasks("grunt-jsbeautifier");
184 | 
185 |     grunt.registerTask('lib', 'Assemble the library', create_lib);
186 | 
187 |     grunt.registerTask("default", ["dynamic"]);
188 |     grunt.registerTask("dynamic", "build static scripts", ["clean", "jsbeautifier", 'lib', "copy:pre", "jshint",
189 |         "uglify", "copy:post", "clean:build"
190 |     ]);
191 |     grunt.registerTask("static", "build static scripts", ["clean", "jsbeautifier", "copy:pre", "jshint",
192 |         "uglify", "copy:post", "clean:build"
193 |     ]);
194 | };
195 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                     GNU GENERAL PUBLIC LICENSE
  2 |                        Version 3, 29 June 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 |                             Preamble
  9 | 
 10 |   The GNU General Public License is a free, copyleft license for
 11 | software and other kinds of works.
 12 | 
 13 |   The licenses for most software and other practical works are designed
 14 | to take away your freedom to share and change the works.  By contrast,
 15 | the GNU General Public License is intended to guarantee your freedom to
 16 | share and change all versions of a program--to make sure it remains free
 17 | software for all its users.  We, the Free Software Foundation, use the
 18 | GNU General Public License for most of our software; it applies also to
 19 | any other work released this way by its authors.  You can apply it to
 20 | your programs, too.
 21 | 
 22 |   When we speak of free software, we are referring to freedom, not
 23 | price.  Our General Public Licenses are designed to make sure that you
 24 | have the freedom to distribute copies of free software (and charge for
 25 | them if you wish), that you receive source code or can get it if you
 26 | want it, that you can change the software or use pieces of it in new
 27 | free programs, and that you know you can do these things.
 28 | 
 29 |   To protect your rights, we need to prevent others from denying you
 30 | these rights or asking you to surrender the rights.  Therefore, you have
 31 | certain responsibilities if you distribute copies of the software, or if
 32 | you modify it: responsibilities to respect the freedom of others.
 33 | 
 34 |   For example, if you distribute copies of such a program, whether
 35 | gratis or for a fee, you must pass on to the recipients the same
 36 | freedoms that you received.  You must make sure that they, too, receive
 37 | or can get the source code.  And you must show them these terms so they
 38 | know their rights.
 39 | 
 40 |   Developers that use the GNU GPL protect your rights with two steps:
 41 | (1) assert copyright on the software, and (2) offer you this License
 42 | giving you legal permission to copy, distribute and/or modify it.
 43 | 
 44 |   For the developers' and authors' protection, the GPL clearly explains
 45 | that there is no warranty for this free software.  For both users' and
 46 | authors' sake, the GPL requires that modified versions be marked as
 47 | changed, so that their problems will not be attributed erroneously to
 48 | authors of previous versions.
 49 | 
 50 |   Some devices are designed to deny users access to install or run
 51 | modified versions of the software inside them, although the manufacturer
 52 | can do so.  This is fundamentally incompatible with the aim of
 53 | protecting users' freedom to change the software.  The systematic
 54 | pattern of such abuse occurs in the area of products for individuals to
 55 | use, which is precisely where it is most unacceptable.  Therefore, we
 56 | have designed this version of the GPL to prohibit the practice for those
 57 | products.  If such problems arise substantially in other domains, we
 58 | stand ready to extend this provision to those domains in future versions
 59 | of the GPL, as needed to protect the freedom of users.
 60 | 
 61 |   Finally, every program is threatened constantly by software patents.
 62 | States should not allow patents to restrict development and use of
 63 | software on general-purpose computers, but in those that do, we wish to
 64 | avoid the special danger that patents applied to a free program could
 65 | make it effectively proprietary.  To prevent this, the GPL assures that
 66 | patents cannot be used to render the program non-free.
 67 | 
 68 |   The precise terms and conditions for copying, distribution and
 69 | modification follow.
 70 | 
 71 |                        TERMS AND CONDITIONS
 72 | 
 73 |   0. Definitions.
 74 | 
 75 |   "This License" refers to version 3 of the GNU General Public License.
 76 | 
 77 |   "Copyright" also means copyright-like laws that apply to other kinds of
 78 | works, such as semiconductor masks.
 79 | 
 80 |   "The Program" refers to any copyrightable work licensed under this
 81 | License.  Each licensee is addressed as "you".  "Licensees" and
 82 | "recipients" may be individuals or organizations.
 83 | 
 84 |   To "modify" a work means to copy from or adapt all or part of the work
 85 | in a fashion requiring copyright permission, other than the making of an
 86 | exact copy.  The resulting work is called a "modified version" of the
 87 | earlier work or a work "based on" the earlier work.
 88 | 
 89 |   A "covered work" means either the unmodified Program or a work based
 90 | on the Program.
 91 | 
 92 |   To "propagate" a work means to do anything with it that, without
 93 | permission, would make you directly or secondarily liable for
 94 | infringement under applicable copyright law, except executing it on a
 95 | computer or modifying a private copy.  Propagation includes copying,
 96 | distribution (with or without modification), making available to the
 97 | public, and in some countries other activities as well.
 98 | 
 99 |   To "convey" a work means any kind of propagation that enables other
100 | parties to make or receive copies.  Mere interaction with a user through
101 | a computer network, with no transfer of a copy, is not conveying.
102 | 
103 |   An interactive user interface displays "Appropriate Legal Notices"
104 | to the extent that it includes a convenient and prominently visible
105 | feature that (1) displays an appropriate copyright notice, and (2)
106 | tells the user that there is no warranty for the work (except to the
107 | extent that warranties are provided), that licensees may convey the
108 | work under this License, and how to view a copy of this License.  If
109 | the interface presents a list of user commands or options, such as a
110 | menu, a prominent item in the list meets this criterion.
111 | 
112 |   1. Source Code.
113 | 
114 |   The "source code" for a work means the preferred form of the work
115 | for making modifications to it.  "Object code" means any non-source
116 | form of a work.
117 | 
118 |   A "Standard Interface" means an interface that either is an official
119 | standard defined by a recognized standards body, or, in the case of
120 | interfaces specified for a particular programming language, one that
121 | is widely used among developers working in that language.
122 | 
123 |   The "System Libraries" of an executable work include anything, other
124 | than the work as a whole, that (a) is included in the normal form of
125 | packaging a Major Component, but which is not part of that Major
126 | Component, and (b) serves only to enable use of the work with that
127 | Major Component, or to implement a Standard Interface for which an
128 | implementation is available to the public in source code form.  A
129 | "Major Component", in this context, means a major essential component
130 | (kernel, window system, and so on) of the specific operating system
131 | (if any) on which the executable work runs, or a compiler used to
132 | produce the work, or an object code interpreter used to run it.
133 | 
134 |   The "Corresponding Source" for a work in object code form means all
135 | the source code needed to generate, install, and (for an executable
136 | work) run the object code and to modify the work, including scripts to
137 | control those activities.  However, it does not include the work's
138 | System Libraries, or general-purpose tools or generally available free
139 | programs which are used unmodified in performing those activities but
140 | which are not part of the work.  For example, Corresponding Source
141 | includes interface definition files associated with source files for
142 | the work, and the source code for shared libraries and dynamically
143 | linked subprograms that the work is specifically designed to require,
144 | such as by intimate data communication or control flow between those
145 | subprograms and other parts of the work.
146 | 
147 |   The Corresponding Source need not include anything that users
148 | can regenerate automatically from other parts of the Corresponding
149 | Source.
150 | 
151 |   The Corresponding Source for a work in source code form is that
152 | same work.
153 | 
154 |   2. Basic Permissions.
155 | 
156 |   All rights granted under this License are granted for the term of
157 | copyright on the Program, and are irrevocable provided the stated
158 | conditions are met.  This License explicitly affirms your unlimited
159 | permission to run the unmodified Program.  The output from running a
160 | covered work is covered by this License only if the output, given its
161 | content, constitutes a covered work.  This License acknowledges your
162 | rights of fair use or other equivalent, as provided by copyright law.
163 | 
164 |   You may make, run and propagate covered works that you do not
165 | convey, without conditions so long as your license otherwise remains
166 | in force.  You may convey covered works to others for the sole purpose
167 | of having them make modifications exclusively for you, or provide you
168 | with facilities for running those works, provided that you comply with
169 | the terms of this License in conveying all material for which you do
170 | not control copyright.  Those thus making or running the covered works
171 | for you must do so exclusively on your behalf, under your direction
172 | and control, on terms that prohibit them from making any copies of
173 | your copyrighted material outside their relationship with you.
174 | 
175 |   Conveying under any other circumstances is permitted solely under
176 | the conditions stated below.  Sublicensing is not allowed; section 10
177 | makes it unnecessary.
178 | 
179 |   3. Protecting Users' Legal Rights From Anti-Circumvention Law.
180 | 
181 |   No covered work shall be deemed part of an effective technological
182 | measure under any applicable law fulfilling obligations under article
183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
184 | similar laws prohibiting or restricting circumvention of such
185 | measures.
186 | 
187 |   When you convey a covered work, you waive any legal power to forbid
188 | circumvention of technological measures to the extent such circumvention
189 | is effected by exercising rights under this License with respect to
190 | the covered work, and you disclaim any intention to limit operation or
191 | modification of the work as a means of enforcing, against the work's
192 | users, your or third parties' legal rights to forbid circumvention of
193 | technological measures.
194 | 
195 |   4. Conveying Verbatim Copies.
196 | 
197 |   You may convey verbatim copies of the Program's source code as you
198 | receive it, in any medium, provided that you conspicuously and
199 | appropriately publish on each copy an appropriate copyright notice;
200 | keep intact all notices stating that this License and any
201 | non-permissive terms added in accord with section 7 apply to the code;
202 | keep intact all notices of the absence of any warranty; and give all
203 | recipients a copy of this License along with the Program.
204 | 
205 |   You may charge any price or no price for each copy that you convey,
206 | and you may offer support or warranty protection for a fee.
207 | 
208 |   5. Conveying Modified Source Versions.
209 | 
210 |   You may convey a work based on the Program, or the modifications to
211 | produce it from the Program, in the form of source code under the
212 | terms of section 4, provided that you also meet all of these conditions:
213 | 
214 |     a) The work must carry prominent notices stating that you modified
215 |     it, and giving a relevant date.
216 | 
217 |     b) The work must carry prominent notices stating that it is
218 |     released under this License and any conditions added under section
219 |     7.  This requirement modifies the requirement in section 4 to
220 |     "keep intact all notices".
221 | 
222 |     c) You must license the entire work, as a whole, under this
223 |     License to anyone who comes into possession of a copy.  This
224 |     License will therefore apply, along with any applicable section 7
225 |     additional terms, to the whole of the work, and all its parts,
226 |     regardless of how they are packaged.  This License gives no
227 |     permission to license the work in any other way, but it does not
228 |     invalidate such permission if you have separately received it.
229 | 
230 |     d) If the work has interactive user interfaces, each must display
231 |     Appropriate Legal Notices; however, if the Program has interactive
232 |     interfaces that do not display Appropriate Legal Notices, your
233 |     work need not make them do so.
234 | 
235 |   A compilation of a covered work with other separate and independent
236 | works, which are not by their nature extensions of the covered work,
237 | and which are not combined with it such as to form a larger program,
238 | in or on a volume of a storage or distribution medium, is called an
239 | "aggregate" if the compilation and its resulting copyright are not
240 | used to limit the access or legal rights of the compilation's users
241 | beyond what the individual works permit.  Inclusion of a covered work
242 | in an aggregate does not cause this License to apply to the other
243 | parts of the aggregate.
244 | 
245 |   6. Conveying Non-Source Forms.
246 | 
247 |   You may convey a covered work in object code form under the terms
248 | of sections 4 and 5, provided that you also convey the
249 | machine-readable Corresponding Source under the terms of this License,
250 | in one of these ways:
251 | 
252 |     a) Convey the object code in, or embodied in, a physical product
253 |     (including a physical distribution medium), accompanied by the
254 |     Corresponding Source fixed on a durable physical medium
255 |     customarily used for software interchange.
256 | 
257 |     b) Convey the object code in, or embodied in, a physical product
258 |     (including a physical distribution medium), accompanied by a
259 |     written offer, valid for at least three years and valid for as
260 |     long as you offer spare parts or customer support for that product
261 |     model, to give anyone who possesses the object code either (1) a
262 |     copy of the Corresponding Source for all the software in the
263 |     product that is covered by this License, on a durable physical
264 |     medium customarily used for software interchange, for a price no
265 |     more than your reasonable cost of physically performing this
266 |     conveying of source, or (2) access to copy the
267 |     Corresponding Source from a network server at no charge.
268 | 
269 |     c) Convey individual copies of the object code with a copy of the
270 |     written offer to provide the Corresponding Source.  This
271 |     alternative is allowed only occasionally and noncommercially, and
272 |     only if you received the object code with such an offer, in accord
273 |     with subsection 6b.
274 | 
275 |     d) Convey the object code by offering access from a designated
276 |     place (gratis or for a charge), and offer equivalent access to the
277 |     Corresponding Source in the same way through the same place at no
278 |     further charge.  You need not require recipients to copy the
279 |     Corresponding Source along with the object code.  If the place to
280 |     copy the object code is a network server, the Corresponding Source
281 |     may be on a different server (operated by you or a third party)
282 |     that supports equivalent copying facilities, provided you maintain
283 |     clear directions next to the object code saying where to find the
284 |     Corresponding Source.  Regardless of what server hosts the
285 |     Corresponding Source, you remain obligated to ensure that it is
286 |     available for as long as needed to satisfy these requirements.
287 | 
288 |     e) Convey the object code using peer-to-peer transmission, provided
289 |     you inform other peers where the object code and Corresponding
290 |     Source of the work are being offered to the general public at no
291 |     charge under subsection 6d.
292 | 
293 |   A separable portion of the object code, whose source code is excluded
294 | from the Corresponding Source as a System Library, need not be
295 | included in conveying the object code work.
296 | 
297 |   A "User Product" is either (1) a "consumer product", which means any
298 | tangible personal property which is normally used for personal, family,
299 | or household purposes, or (2) anything designed or sold for incorporation
300 | into a dwelling.  In determining whether a product is a consumer product,
301 | doubtful cases shall be resolved in favor of coverage.  For a particular
302 | product received by a particular user, "normally used" refers to a
303 | typical or common use of that class of product, regardless of the status
304 | of the particular user or of the way in which the particular user
305 | actually uses, or expects or is expected to use, the product.  A product
306 | is a consumer product regardless of whether the product has substantial
307 | commercial, industrial or non-consumer uses, unless such uses represent
308 | the only significant mode of use of the product.
309 | 
310 |   "Installation Information" for a User Product means any methods,
311 | procedures, authorization keys, or other information required to install
312 | and execute modified versions of a covered work in that User Product from
313 | a modified version of its Corresponding Source.  The information must
314 | suffice to ensure that the continued functioning of the modified object
315 | code is in no case prevented or interfered with solely because
316 | modification has been made.
317 | 
318 |   If you convey an object code work under this section in, or with, or
319 | specifically for use in, a User Product, and the conveying occurs as
320 | part of a transaction in which the right of possession and use of the
321 | User Product is transferred to the recipient in perpetuity or for a
322 | fixed term (regardless of how the transaction is characterized), the
323 | Corresponding Source conveyed under this section must be accompanied
324 | by the Installation Information.  But this requirement does not apply
325 | if neither you nor any third party retains the ability to install
326 | modified object code on the User Product (for example, the work has
327 | been installed in ROM).
328 | 
329 |   The requirement to provide Installation Information does not include a
330 | requirement to continue to provide support service, warranty, or updates
331 | for a work that has been modified or installed by the recipient, or for
332 | the User Product in which it has been modified or installed.  Access to a
333 | network may be denied when the modification itself materially and
334 | adversely affects the operation of the network or violates the rules and
335 | protocols for communication across the network.
336 | 
337 |   Corresponding Source conveyed, and Installation Information provided,
338 | in accord with this section must be in a format that is publicly
339 | documented (and with an implementation available to the public in
340 | source code form), and must require no special password or key for
341 | unpacking, reading or copying.
342 | 
343 |   7. Additional Terms.
344 | 
345 |   "Additional permissions" are terms that supplement the terms of this
346 | License by making exceptions from one or more of its conditions.
347 | Additional permissions that are applicable to the entire Program shall
348 | be treated as though they were included in this License, to the extent
349 | that they are valid under applicable law.  If additional permissions
350 | apply only to part of the Program, that part may be used separately
351 | under those permissions, but the entire Program remains governed by
352 | this License without regard to the additional permissions.
353 | 
354 |   When you convey a copy of a covered work, you may at your option
355 | remove any additional permissions from that copy, or from any part of
356 | it.  (Additional permissions may be written to require their own
357 | removal in certain cases when you modify the work.)  You may place
358 | additional permissions on material, added by you to a covered work,
359 | for which you have or can give appropriate copyright permission.
360 | 
361 |   Notwithstanding any other provision of this License, for material you
362 | add to a covered work, you may (if authorized by the copyright holders of
363 | that material) supplement the terms of this License with terms:
364 | 
365 |     a) Disclaiming warranty or limiting liability differently from the
366 |     terms of sections 15 and 16 of this License; or
367 | 
368 |     b) Requiring preservation of specified reasonable legal notices or
369 |     author attributions in that material or in the Appropriate Legal
370 |     Notices displayed by works containing it; or
371 | 
372 |     c) Prohibiting misrepresentation of the origin of that material, or
373 |     requiring that modified versions of such material be marked in
374 |     reasonable ways as different from the original version; or
375 | 
376 |     d) Limiting the use for publicity purposes of names of licensors or
377 |     authors of the material; or
378 | 
379 |     e) Declining to grant rights under trademark law for use of some
380 |     trade names, trademarks, or service marks; or
381 | 
382 |     f) Requiring indemnification of licensors and authors of that
383 |     material by anyone who conveys the material (or modified versions of
384 |     it) with contractual assumptions of liability to the recipient, for
385 |     any liability that these contractual assumptions directly impose on
386 |     those licensors and authors.
387 | 
388 |   All other non-permissive additional terms are considered "further
389 | restrictions" within the meaning of section 10.  If the Program as you
390 | received it, or any part of it, contains a notice stating that it is
391 | governed by this License along with a term that is a further
392 | restriction, you may remove that term.  If a license document contains
393 | a further restriction but permits relicensing or conveying under this
394 | License, you may add to a covered work material governed by the terms
395 | of that license document, provided that the further restriction does
396 | not survive such relicensing or conveying.
397 | 
398 |   If you add terms to a covered work in accord with this section, you
399 | must place, in the relevant source files, a statement of the
400 | additional terms that apply to those files, or a notice indicating
401 | where to find the applicable terms.
402 | 
403 |   Additional terms, permissive or non-permissive, may be stated in the
404 | form of a separately written license, or stated as exceptions;
405 | the above requirements apply either way.
406 | 
407 |   8. Termination.
408 | 
409 |   You may not propagate or modify a covered work except as expressly
410 | provided under this License.  Any attempt otherwise to propagate or
411 | modify it is void, and will automatically terminate your rights under
412 | this License (including any patent licenses granted under the third
413 | paragraph of section 11).
414 | 
415 |   However, if you cease all violation of this License, then your
416 | license from a particular copyright holder is reinstated (a)
417 | provisionally, unless and until the copyright holder explicitly and
418 | finally terminates your license, and (b) permanently, if the copyright
419 | holder fails to notify you of the violation by some reasonable means
420 | prior to 60 days after the cessation.
421 | 
422 |   Moreover, your license from a particular copyright holder is
423 | reinstated permanently if the copyright holder notifies you of the
424 | violation by some reasonable means, this is the first time you have
425 | received notice of violation of this License (for any work) from that
426 | copyright holder, and you cure the violation prior to 30 days after
427 | your receipt of the notice.
428 | 
429 |   Termination of your rights under this section does not terminate the
430 | licenses of parties who have received copies or rights from you under
431 | this License.  If your rights have been terminated and not permanently
432 | reinstated, you do not qualify to receive new licenses for the same
433 | material under section 10.
434 | 
435 |   9. Acceptance Not Required for Having Copies.
436 | 
437 |   You are not required to accept this License in order to receive or
438 | run a copy of the Program.  Ancillary propagation of a covered work
439 | occurring solely as a consequence of using peer-to-peer transmission
440 | to receive a copy likewise does not require acceptance.  However,
441 | nothing other than this License grants you permission to propagate or
442 | modify any covered work.  These actions infringe copyright if you do
443 | not accept this License.  Therefore, by modifying or propagating a
444 | covered work, you indicate your acceptance of this License to do so.
445 | 
446 |   10. Automatic Licensing of Downstream Recipients.
447 | 
448 |   Each time you convey a covered work, the recipient automatically
449 | receives a license from the original licensors, to run, modify and
450 | propagate that work, subject to this License.  You are not responsible
451 | for enforcing compliance by third parties with this License.
452 | 
453 |   An "entity transaction" is a transaction transferring control of an
454 | organization, or substantially all assets of one, or subdividing an
455 | organization, or merging organizations.  If propagation of a covered
456 | work results from an entity transaction, each party to that
457 | transaction who receives a copy of the work also receives whatever
458 | licenses to the work the party's predecessor in interest had or could
459 | give under the previous paragraph, plus a right to possession of the
460 | Corresponding Source of the work from the predecessor in interest, if
461 | the predecessor has it or can get it with reasonable efforts.
462 | 
463 |   You may not impose any further restrictions on the exercise of the
464 | rights granted or affirmed under this License.  For example, you may
465 | not impose a license fee, royalty, or other charge for exercise of
466 | rights granted under this License, and you may not initiate litigation
467 | (including a cross-claim or counterclaim in a lawsuit) alleging that
468 | any patent claim is infringed by making, using, selling, offering for
469 | sale, or importing the Program or any portion of it.
470 | 
471 |   11. Patents.
472 | 
473 |   A "contributor" is a copyright holder who authorizes use under this
474 | License of the Program or a work on which the Program is based.  The
475 | work thus licensed is called the contributor's "contributor version".
476 | 
477 |   A contributor's "essential patent claims" are all patent claims
478 | owned or controlled by the contributor, whether already acquired or
479 | hereafter acquired, that would be infringed by some manner, permitted
480 | by this License, of making, using, or selling its contributor version,
481 | but do not include claims that would be infringed only as a
482 | consequence of further modification of the contributor version.  For
483 | purposes of this definition, "control" includes the right to grant
484 | patent sublicenses in a manner consistent with the requirements of
485 | this License.
486 | 
487 |   Each contributor grants you a non-exclusive, worldwide, royalty-free
488 | patent license under the contributor's essential patent claims, to
489 | make, use, sell, offer for sale, import and otherwise run, modify and
490 | propagate the contents of its contributor version.
491 | 
492 |   In the following three paragraphs, a "patent license" is any express
493 | agreement or commitment, however denominated, not to enforce a patent
494 | (such as an express permission to practice a patent or covenant not to
495 | sue for patent infringement).  To "grant" such a patent license to a
496 | party means to make such an agreement or commitment not to enforce a
497 | patent against the party.
498 | 
499 |   If you convey a covered work, knowingly relying on a patent license,
500 | and the Corresponding Source of the work is not available for anyone
501 | to copy, free of charge and under the terms of this License, through a
502 | publicly available network server or other readily accessible means,
503 | then you must either (1) cause the Corresponding Source to be so
504 | available, or (2) arrange to deprive yourself of the benefit of the
505 | patent license for this particular work, or (3) arrange, in a manner
506 | consistent with the requirements of this License, to extend the patent
507 | license to downstream recipients.  "Knowingly relying" means you have
508 | actual knowledge that, but for the patent license, your conveying the
509 | covered work in a country, or your recipient's use of the covered work
510 | in a country, would infringe one or more identifiable patents in that
511 | country that you have reason to believe are valid.
512 | 
513 |   If, pursuant to or in connection with a single transaction or
514 | arrangement, you convey, or propagate by procuring conveyance of, a
515 | covered work, and grant a patent license to some of the parties
516 | receiving the covered work authorizing them to use, propagate, modify
517 | or convey a specific copy of the covered work, then the patent license
518 | you grant is automatically extended to all recipients of the covered
519 | work and works based on it.
520 | 
521 |   A patent license is "discriminatory" if it does not include within
522 | the scope of its coverage, prohibits the exercise of, or is
523 | conditioned on the non-exercise of one or more of the rights that are
524 | specifically granted under this License.  You may not convey a covered
525 | work if you are a party to an arrangement with a third party that is
526 | in the business of distributing software, under which you make payment
527 | to the third party based on the extent of your activity of conveying
528 | the work, and under which the third party grants, to any of the
529 | parties who would receive the covered work from you, a discriminatory
530 | patent license (a) in connection with copies of the covered work
531 | conveyed by you (or copies made from those copies), or (b) primarily
532 | for and in connection with specific products or compilations that
533 | contain the covered work, unless you entered into that arrangement,
534 | or that patent license was granted, prior to 28 March 2007.
535 | 
536 |   Nothing in this License shall be construed as excluding or limiting
537 | any implied license or other defenses to infringement that may
538 | otherwise be available to you under applicable patent law.
539 | 
540 |   12. No Surrender of Others' Freedom.
541 | 
542 |   If conditions are imposed on you (whether by court order, agreement or
543 | otherwise) that contradict the conditions of this License, they do not
544 | excuse you from the conditions of this License.  If you cannot convey a
545 | covered work so as to satisfy simultaneously your obligations under this
546 | License and any other pertinent obligations, then as a consequence you may
547 | not convey it at all.  For example, if you agree to terms that obligate you
548 | to collect a royalty for further conveying from those to whom you convey
549 | the Program, the only way you could satisfy both those terms and this
550 | License would be to refrain entirely from conveying the Program.
551 | 
552 |   13. Use with the GNU Affero General Public License.
553 | 
554 |   Notwithstanding any other provision of this License, you have
555 | permission to link or combine any covered work with a work licensed
556 | under version 3 of the GNU Affero General Public License into a single
557 | combined work, and to convey the resulting work.  The terms of this
558 | License will continue to apply to the part which is the covered work,
559 | but the special requirements of the GNU Affero General Public License,
560 | section 13, concerning interaction through a network will apply to the
561 | combination as such.
562 | 
563 |   14. Revised Versions of this License.
564 | 
565 |   The Free Software Foundation may publish revised and/or new versions of
566 | the GNU General Public License from time to time.  Such new versions will
567 | be similar in spirit to the present version, but may differ in detail to
568 | address new problems or concerns.
569 | 
570 |   Each version is given a distinguishing version number.  If the
571 | Program specifies that a certain numbered version of the GNU General
572 | Public License "or any later version" applies to it, you have the
573 | option of following the terms and conditions either of that numbered
574 | version or of any later version published by the Free Software
575 | Foundation.  If the Program does not specify a version number of the
576 | GNU General Public License, you may choose any version ever published
577 | by the Free Software Foundation.
578 | 
579 |   If the Program specifies that a proxy can decide which future
580 | versions of the GNU General Public License can be used, that proxy's
581 | public statement of acceptance of a version permanently authorizes you
582 | to choose that version for the Program.
583 | 
584 |   Later license versions may give you additional or different
585 | permissions.  However, no additional obligations are imposed on any
586 | author or copyright holder as a result of your choosing to follow a
587 | later version.
588 | 
589 |   15. Disclaimer of Warranty.
590 | 
591 |   THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
592 | APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
596 | PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
597 | IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
599 | 
600 |   16. Limitation of Liability.
601 | 
602 |   IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
610 | SUCH DAMAGES.
611 | 
612 |   17. Interpretation of Sections 15 and 16.
613 | 
614 |   If the disclaimer of warranty and limitation of liability provided
615 | above cannot be given local legal effect according to their terms,
616 | reviewing courts shall apply local law that most closely approximates
617 | an absolute waiver of all civil liability in connection with the
618 | Program, unless a warranty or assumption of liability accompanies a
619 | copy of the Program in return for a fee.
620 | 
621 |                      END OF TERMS AND CONDITIONS
622 | 
623 |             How to Apply These Terms to Your New Programs
624 | 
625 |   If you develop a new program, and you want it to be of the greatest
626 | possible use to the public, the best way to achieve this is to make it
627 | free software which everyone can redistribute and change under these terms.
628 | 
629 |   To do so, attach the following notices to the program.  It is safest
630 | to attach them to the start of each source file to most effectively
631 | state the exclusion of warranty; and each file should have at least
632 | the "copyright" line and a pointer to where the full notice is found.
633 | 
634 |     {one line to give the program's name and a brief idea of what it does.}
635 |     Copyright (C) {year}  {name of author}
636 | 
637 |     This program is free software: you can redistribute it and/or modify
638 |     it under the terms of the GNU General Public License as published by
639 |     the Free Software Foundation, either version 3 of the License, or
640 |     (at your option) any later version.
641 | 
642 |     This program is distributed in the hope that it will be useful,
643 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
644 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
645 |     GNU General Public License for more details.
646 | 
647 |     You should have received a copy of the GNU General Public License
648 |     along with this program.  If not, see <http://www.gnu.org/licenses/>.
649 | 
650 | Also add information on how to contact you by electronic and paper mail.
651 | 
652 |   If the program does terminal interaction, make it output a short
653 | notice like this when it starts in an interactive mode:
654 | 
655 |     {project}  Copyright (C) {year}  {fullname}
656 |     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 |     This is free software, and you are welcome to redistribute it
658 |     under certain conditions; type `show c' for details.
659 | 
660 | The hypothetical commands `show w' and `show c' should show the appropriate
661 | parts of the General Public License.  Of course, your program's commands
662 | might be different; for a GUI interface, you would use an "about box".
663 | 
664 |   You should also get your employer (if you work as a programmer) or school,
665 | if any, to sign a "copyright disclaimer" for the program, if necessary.
666 | For more information on this, and how to apply and follow the GNU GPL, see
667 | <http://www.gnu.org/licenses/>.
668 | 
669 |   The GNU General Public License does not permit incorporating your program
670 | into proprietary programs.  If your program is a subroutine library, you
671 | may consider it more useful to permit linking proprietary applications with
672 | the library.  If this is what you want to do, use the GNU Lesser General
673 | Public License instead of this License.  But first, please read
674 | <http://www.gnu.org/philosophy/why-not-lgpl.html>.
675 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # ｈａｃｋｍｕｄ
 2 | 
 3 | In this repository I put some scripts I developed for the game hackmud.
 4 | Maybe they are useful maybe not, you are free to test, change or fork.
 5 | 
 6 | ## Diretories
 7 | 
 8 | ### include
 9 | 
10 | Here are some functions that are useful in a lot of scripts.
11 | To make them reusable they are separated into extra files.
12 | I tried to use some prefixes to do extra grouping.
13 | 
14 | Prefix | Meaning
15 | --- | ---
16 | fmt_ | formatting of values or objects, useful for displaying
17 | nfo_ | get additional info for a value (e.g. level of script)
18 | 
19 | ### tools
20 | 
21 | Scripts that beautifies your game experience.
22 | 
23 | Name | Usage
24 | --- | ---
25 | access_log.js | parses your access log and displays it slightly different
26 | bank_statement.js | parses your transactions and displays a bank statement
27 | call.js | calls the given scriptor with the given arguments and displays some additional info
28 | market_browse.js | parses the available upgrades on the market and displays the cheapest item ob each type and rarity
29 | qr_decode.js | decodes a QR code
30 | 
31 | ### hacking
32 | 
33 | Scripts for hacking usage, e.g. lockpicks, locscraping.
34 | 
35 | ### poc
36 | 
37 | Proof of concepts, here are some special tools that are not really useful but
38 | to test some functions.
39 | 
40 | ### example
41 | 
42 | Some examples like `hello_world` and a mockup for a lib
43 | 
44 | ## Usage
45 | 
46 | ```bash
47 | $ npm install
48 | $ npm run-script build
49 | ```
50 | 
51 | This builds, lints and shrinks the scripts and place the results in `release` directory.
52 | You can copy the file directly to your scripts folder.
53 | Depending on your operating system this is `%APPDATA%\hackmud\<username>\scripts\` (Windows) or `$HOME/.config/hackmud/<username>/scripts/` (Linux & Mac).
54 | The upload them with `#up <scriptname>`.
55 | 
56 | ### Static build
57 | 
58 | ```bash
59 | $ npm run-script build -- static
60 | ```
61 | 
62 | This includes all library functions, no lib is generated.
63 | 
64 | ### Dynamic build
65 | 
66 | ```bash
67 | $ npm run-script build -- dynamic --user=<username> [--lib=<include> --lib=<include> ...]
68 | ```
69 | 
70 | This generates a lib with the defined includes, wich is used by the other generated scripts.
71 | 
72 | ## Todo
73 | 
74 | * Automatically determine include per library (create library)


--------------------------------------------------------------------------------
/Scripting.md:
--------------------------------------------------------------------------------
 1 | # Scripting
 2 | 
 3 | ## Basics
 4 | 
 5 | ### Scriptor
 6 | 
 7 | ## Database (`#db`)
 8 | 
 9 | ## Standard Library (`#s.scripts.lib()`)
10 | 
11 | | Function | Description |
12 | | --- | --- |
13 | | `ok()` | Helper that returns `{ ok:true }`. You can use it in your script as return Value. |
14 | | `not_impl()` | Helper that returns `{ ok:false, msg:"not implemented" }` |
15 | | `log(item)` | Adds the `item` to an Array of logmessages, you can use it insteed of `<stdout>`. See `get_log`.|
16 | | `get_log()` |  Returns the array of logmessages, you putted with `log`. |
17 | | `rand_int(min, max)` | Returns a random integer between `min` and `max`. |
18 | | `are_ids_eq` | |
19 | | `is_obj(item)` | Returns `true` if `item` is an `Object` |
20 | | `is_str` | |
21 | | `is_num` | |
22 | | `is_int` | |
23 | | `is_neg` | |
24 | | `is_arr` | |
25 | | `is_func` | |
26 | | `is_def` | |
27 | | `is_valid_name` | |
28 | | `dump` | |
29 | | `clone` | |
30 | | `merge` | |
31 | | `get_values` | |
32 | | `hash_code` | |
33 | | `to_gc_str` | |
34 | | `to_gc_num` | |
35 | | `to_game_timestr(date)` | formats `date` like `YYMMDD.HHMM` |
36 | | `cap_str_len` | |
37 | | `each` | |
38 | | `select` | |
39 | | `count` | |
40 | | `select_one` | |
41 | | `map` | |
42 | | `shuffle` | |
43 | | `sort_asc` | |
44 | | `sort_desc` | |
45 | | `num_sort_asc` | |
46 | | `num_sort_desc` | |
47 | | `max_val_index` | |
48 | | `add_time` | |
49 | | `security_level_names` | |
50 | | `get_security_level_name` | |
51 | | `create_rand_string` | |
52 | | `get_user_from_script(script)` | returns teh user part of a scriptname like `<user>.<script>` |
53 | | `u_sort_num_arr_desc` | |
54 | | `can_continue_execution` | |
55 | | `can_continue_execution_error` | |
56 | | `date` | |
57 | | `get_date` | |
58 | | `get_date_utcsecs` | |
59 | | `math` | |
60 | | `array` | |
61 | | `parse_int` | |
62 | | `parse_float` | |
63 | | `json` | |
64 | 


--------------------------------------------------------------------------------
/build.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | npm run-script build -- static
4 | 


--------------------------------------------------------------------------------
/example/hello_world.js:
--------------------------------------------------------------------------------
1 | function(context, args) { // greetings:"Hello World!"
2 |     return {
3 |         ok: true,
4 |         msg: args.greetings || "Hello World!"
5 |     };
6 | }
7 | 


--------------------------------------------------------------------------------
/example/lib.js:
--------------------------------------------------------------------------------
 1 | function(context, args) {
 2 | 
 3 |     // Example function
 4 |     function subtraction(minuend, subtrahend) {
 5 |         return minuend - subtrahend;
 6 |     }
 7 | 
 8 |     // Export the symbols
 9 |     return {
10 |         difference: subtraction
11 |     };
12 | }
13 | 


--------------------------------------------------------------------------------
/hacking/golf/lockpick.429.js:
--------------------------------------------------------------------------------
1 | function(e,{l}){var n,a,c=["unlock","release","open"],o=[2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97],r=["red","lime","blue","orange","green","purple","yellow","cyan"],t={},i="",d="";do(n=d.match(/!(\w+)!.*$/))&&(i=n[1],a=0),"E"==i[0]&&(t[i]=c[a++]),"d"==i[0]&&(t[i]=a++),"e"==i[0]&&(t[i]=o[a++]),"c"==i[0]&&(t[i]=r[a++],"1"==i[3]&&(t.color_digit=t[i].length)),d=l.call(t);while(!d.match(/terminated/))}
2 | 


--------------------------------------------------------------------------------
/hacking/lockpick.js:
--------------------------------------------------------------------------------
 1 | // length 809 chars/ comprimised 565 chars
 2 | // Improvements:
 3 | // - remove dtr import (15)
 4 | // - remove return (25)
 5 | // - interating over 2-99 for ez_prime (~89) (not recommended heavy runtime)
 6 | // - for color_complement or triad iterating over colors (95)
 7 | // doing all shrinks to 340 chars
 8 | 
 9 | function(context, args) { // lock:#s.<user>.<script>
10 |     var lock = args.lock;
11 |     var d = #s.dtr.lib();
12 |     var commands = ["unlock", "release", "open"];
13 |     var primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97];
14 |     var color = ["red", "lime", "blue", "orange", "green", "purple", "yellow", "cyan"];
15 |     args = {};
16 |     var type = "",
17 |         tmp, result = "",
18 |         index;
19 | 
20 |     do {
21 |         tmp = result.match(/`N(\w+)`.*$/);
22 |         if (tmp) {
23 |             type = tmp[1];
24 |             index = 0;
25 |         }
26 |         if (type[0] == "E") { // EZ_xx
27 |             args[type] = commands[index++];
28 |         }
29 |         if (type[0] == "d") { // digit
30 |             args[type] = index++;
31 |         }
32 |         if (type[0] == "e") { // ez_prime
33 |             args[type] = primes[index++];
34 |         }
35 |         if (type[0] == "c") { // c00x
36 |             args[type] = color[index++];
37 |             if (type[3] == "1") { // c001
38 |                 args.color_digit = args[type].length;
39 |             } else if (type[3] == "2") { // c002
40 |                 args.c002_complement = color[(index + 3) % 8];
41 |             } else if (type[3] == "3") { // c003
42 |                 args.c003_triad_1 = color[(index + 6) % 8];
43 |                 args.c003_triad_2 = color[index];
44 |             }
45 |         }
46 |         result = lock.call(args);
47 |     } while (!result.match(/terminated/));
48 | 
49 |     return {
50 |         ok: true,
51 |         msg: d.pp(args)
52 |     };
53 | }
54 | 


--------------------------------------------------------------------------------
/include/access.js:
--------------------------------------------------------------------------------
1 | // access levels
2 | {
3 |     TRUST: ["TRUST", 'V'],
4 |     PRIVATE: ["PRIVATE", 'C'],
5 |     HIDDEN: ["HIDDEN", 0],
6 |     PUBLIC: ["PUBLIC", 1]
7 | }
8 | 


--------------------------------------------------------------------------------
/include/classes.js:
--------------------------------------------------------------------------------
1 | // known classes
2 | ["architect", "infiltrator", "scavenger", "executive"]
3 | 


--------------------------------------------------------------------------------
/include/cmp.js:
--------------------------------------------------------------------------------
 1 | function(a, b, comperator) {
 2 |     var i, result;
 3 | 
 4 |     INCLUDE(stdlib);
 5 | 
 6 |     // add compare two elements
 7 |     if (!stdlib.is_def(comperator)) {
 8 |         return a < b ? -1 : a > b ? 1 : 0;
 9 |     } else if (stdlib.is_func(comperator)) {
10 |         return comperator(a, b);
11 |     } else if (stdlib.is_int(comperator)) {
12 |         return sign(comperator) * cmp(a[abs(comperator)], b[abs(comperator)]);
13 |     } else if (stdlib.is_str(comperator)) {
14 |         // var [_, sign, key] = comperator.match(/([+-]?)(.*)/);
15 |         var match = comperator.match(/([+-]?)(.*)/);
16 |         var key = match[2];
17 |         var multiplicator = match[1] == "-" ? -1 : 1;
18 |         return multiplicator * cmp(a[key], b[key]);
19 |     } else if (stdlib.is_arr(comperator)) {
20 |         result = 0;
21 |         for (i in comperator) {
22 |             result = cmp(a, b, comperator[i]);
23 |             if (0 !== result) break;
24 |         }
25 |         return result;
26 |     } else if (stdlib.is_obj(comperator)) {
27 |         result = 0;
28 |         for (i in comperator) {
29 |             result = cmp(a[i], b[i], comperator[i]);
30 |             if (0 !== result) break;
31 |         }
32 |         return result;
33 |     }
34 |     return 0;
35 | }
36 | 


--------------------------------------------------------------------------------
/include/color.js:
--------------------------------------------------------------------------------
 1 | function(string, color) {
 2 |     var pre = "`" + color;
 3 |     var post = "`";
 4 | 
 5 |     if (color == '+') {
 6 |         pre = "`V";
 7 |     } else if (color == '!') {
 8 |         pre = "`N";
 9 |     } else if (color == '-') {
10 |         pre = "`C";
11 |     }
12 | 
13 |     return string.replace(/(\w+)/g, pre + "$1" + post);
14 | }
15 | 


--------------------------------------------------------------------------------
/include/color_attribute.js:
--------------------------------------------------------------------------------
 1 | function(coloring, length) {
 2 |     INCLUDE(color);
 3 | 
 4 |     var result = coloring[0];
 5 |     if (length) {
 6 |         result = result.substr(0, length);
 7 |     }
 8 | 
 9 |     return color(result, coloring[1]);
10 | }
11 | 


--------------------------------------------------------------------------------
/include/dtr.js:
--------------------------------------------------------------------------------
1 | // dtrs lib
2 | /* beautify ignore:start */
3 | #s.dtr.lib()
4 | /* beautify ignore:end */
5 | 


--------------------------------------------------------------------------------
/include/fmt_date.js:
--------------------------------------------------------------------------------
1 | function(date) {
2 |     INCLUDE(stdlib);
3 | 
4 |     return stdlib.to_game_timestr(stdlib.is_obj(date) ? date : new Date(date));
5 | }
6 | 


--------------------------------------------------------------------------------
/include/fmt_script.js:
--------------------------------------------------------------------------------
 1 | function(script) {
 2 |     if (!script) return;
 3 |     var result = script.name;
 4 | 
 5 |     INCLUDE(security);
 6 |     INCLUDE(access);
 7 |     INCLUDE(color_attribute);
 8 | 
 9 |     if (script.valid) {
10 |         result = color_attribute(security[script.level], 1) + color_attribute(access[script.access], 1) + " " + result;
11 |     } else {
12 |         result = "  (" + result + ")";
13 |     }
14 | 
15 |     return result;
16 | }
17 | 


--------------------------------------------------------------------------------
/include/fmt_upgrade.js:
--------------------------------------------------------------------------------
 1 | function(upgrade) {
 2 |     if (!upgrade) return;
 3 | 
 4 |     INCLUDE(color);
 5 | 
 6 |     var result = upgrade.name;
 7 |     if ('rarity' in upgrade) {
 8 |         result = color(result, upgrade.rarity);
 9 |     }
10 |     return result;
11 | }
12 | 


--------------------------------------------------------------------------------
/include/fmt_user.js:
--------------------------------------------------------------------------------
1 | function(user) {
2 |     if (!user) return;
3 |     var result = user.name;
4 |     if (user.valid) {} else {
5 |         result = " (" + result + ")";
6 |     }
7 |     return result;
8 | }
9 | 


--------------------------------------------------------------------------------
/include/is_npc.js:
--------------------------------------------------------------------------------
1 | // check if user is an npc
2 | function(name) {
3 |     var last_action = #s.users.last_action({ name: [name, "gibson"] });
4 |     return last_action[0] && last_action[0].t.getTime() == last_action[1].t.getTime();
5 | }
6 | 


--------------------------------------------------------------------------------
/include/nfo_operand.js:
--------------------------------------------------------------------------------
 1 | function(operand) {
 2 |     var result = typeof(operand);
 3 |     switch (result) {
 4 |         case 'string':
 5 |         case 'number':
 6 |             result += " (" + operand + ")";
 7 |             break;
 8 |         case 'object':
 9 |             var key;
10 |             if (operand instanceof Array) {
11 |                 result = [];
12 |                 for (key in operand) {
13 |                     result.push(nfo_operand(operand[key]));
14 |                 }
15 |             } else {
16 |                 result = {};
17 |                 for (key in operand) {
18 |                     result[key] = nfo_operand(operand[key]);
19 |                 }
20 |             }
21 |             break;
22 |     }
23 |     return result;
24 | }
25 | 


--------------------------------------------------------------------------------
/include/nfo_script.js:
--------------------------------------------------------------------------------
 1 | function(script_name) {
 2 |     var result = { name: script_name, valid: false };
 3 | 
 4 |     INCLUDE(stdlib);
 5 | 
 6 |     var tmp = #s.scripts.get_level(result);
 7 |     if (stdlib.is_int(tmp)) {
 8 |         result.valid = true;
 9 |         result.access = #s.scripts.get_access_level(result);
10 |         result.level = tmp;
11 |     }
12 | 
13 |     return result;
14 | }
15 | 


--------------------------------------------------------------------------------
/include/nfo_user.js:
--------------------------------------------------------------------------------
 1 | function(user_name) {
 2 |     var result = { name: user_name, valid: false };
 3 | 
 4 |     var last_action = #s.users.last_action({ name: [user_name, "gibson"] });
 5 |     if (last_action[0]) {
 6 |         result.valid = true;
 7 |         result.last_action = last_action[0].t;
 8 |         result.npc = last_action[0].t.getTime() == last_action[1].t.getTime();
 9 |     }
10 | 
11 |     return result;
12 | }
13 | 


--------------------------------------------------------------------------------
/include/npc_static.js:
--------------------------------------------------------------------------------
 1 | // names of known npc
 2 | ["amal_robo", "archaic", "bluebun", "bunnybat_hut", "context",
 3 |     "core", "cyberdine", "empty_nest", "futuretech", "gibson",
 4 |     "halperyon", "kill_9_1", "kill_bio", "legion_bible", "legion_intl",
 5 |     "light", "lowell_extermination", "marco_polo", "merrymoor_pharma",
 6 |     "nation_of_wales", "nuutec", "protein_prevention", "ros13",
 7 |     "ros_13_update_checker", "setec_gas", "sn_w", "soylentbean",
 8 |     "suborbital_airlines", "tandoori", "the_holy_checksum",
 9 |     "turing_testing", "tyrell", "vacuum_rescue", "welsh_measles_info",
10 |     "weyland", "world_pop"
11 | ]
12 | 


--------------------------------------------------------------------------------
/include/parse_timestr.js:
--------------------------------------------------------------------------------
1 | function(date) {
2 |     // Convert hackmud timestr to date object
3 |     var iso = date.replace(/(\d{2})(\d{2})(\d{2})\.(\d{2})(\d{2})/, "20$1-$2-$3T$4:$5-04:00");
4 |     return new Date(iso);
5 | }
6 | 


--------------------------------------------------------------------------------
/include/rarity.js:
--------------------------------------------------------------------------------
1 | // rarities
2 | [
3 |     ["noob", 0],
4 |     ["kiddie", 1],
5 |     ["h4x0r", 2],
6 |     ["h4rdc0r3", 3]
7 | ]
8 | 


--------------------------------------------------------------------------------
/include/recover.js:
--------------------------------------------------------------------------------
 1 | // recover a corrupted response of a script
 2 | function(scriptor, args) {
 3 |     INCLUDE(stdlib);
 4 |     INCLUDE(regex_corrupt);
 5 | 
 6 |     var result = stdlib.json.ostringify(scriptor.call(args)).split(regex_corrupt);
 7 |     while (result.length > 1) {
 8 |         var info = stdlib.json.ostringify(scriptor.call(args)).split(regex_corrupt);
 9 |         info.push("");
10 |         var iter_recover = -1;
11 |         var iter_info = 0;
12 |         var restored_last = -1;
13 |         var restored = [];
14 | 
15 |         // assume same length of both outputs
16 |         for (var index in result) {
17 |             if (iter_recover < 0) {
18 |                 restored.push(result[index]);
19 |                 restored_last++;
20 |                 iter_recover++;
21 |             } else {
22 |                 restored[restored_last] += info[iter_info][iter_recover++] + result[index];
23 |             }
24 |             iter_recover += result[index].length;
25 |             while (iter_recover >= info[iter_info].length) {
26 |                 iter_recover -= info[iter_info++].length + 1;
27 |             }
28 |         }
29 | 
30 |         result = restored;
31 |     }
32 | 
33 |     return stdlib.json.oparse(result[0]);
34 | }
35 | 


--------------------------------------------------------------------------------
/include/regex_corrupt.js:
--------------------------------------------------------------------------------
1 | // regular expression of corrupt char
2 | INCLUDE(stdlib);
3 | 
4 | new RegExp("`[" + stdlib.colors + "][" + stdlib.corruption_chars + "]`", "g")
5 | // or static
6 | // /`\w[¡¢£¤¥¦§¨©ª]`/g
7 | 


--------------------------------------------------------------------------------
/include/security.js:
--------------------------------------------------------------------------------
1 | // security levels
2 | [
3 |     ["NULLSEC", 'D'],
4 |     ["LOWSEC", 'F'],
5 |     ["MIDSEC", 'H'],
6 |     ["HIGHSEC", 'h'],
7 |     ["FULLSEC", 'L']
8 | ]
9 | 


--------------------------------------------------------------------------------
/include/sort.js:
--------------------------------------------------------------------------------
 1 | function(array, order) {
 2 |     // sort with given order
 3 |     INCLUDE(stdlib);
 4 |     INCLUDE(cmp);
 5 | 
 6 |     if (stdlib.is_func(order)) {
 7 |         return array.sort(order);
 8 |     }
 9 |     return array.sort(function(a, b) {
10 |         return cmp(a, b, order);
11 |     });
12 | }
13 | 


--------------------------------------------------------------------------------
/include/stdlib.js:
--------------------------------------------------------------------------------
1 | // standard library
2 | /* beautify ignore:start */
3 | #s.scripts.lib()
4 | /* beautify ignore:end */
5 | 


--------------------------------------------------------------------------------
/nix/connect-scripts-dir.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | set -euo pipefail
 3 | 
 4 | git_root=$(git rev-parse --show-toplevel)
 5 | 
 6 | # Set up the scripts directory for both users.
 7 | for user in "shad0wfyr3" "dr_dvorak" ; do
 8 | 
 9 |     dst="${git_root}/release"
10 |     user_dir="$HOME/.config/hackmud/${user}/scripts"
11 |     mkdir -p $user_dir
12 | 
13 |     echo 'Linking $src to $dst:'
14 |     echo "  [src] ${dst}"
15 |     echo "  [dst] ${user_dir}"
16 | 
17 |     rm -rf $user_dir
18 |     ln -s "${dst}" "${user_dir}"
19 | 
20 |     echo "Done."
21 | 
22 | done
23 | 


--------------------------------------------------------------------------------
/nix/fix-resolution.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | sed -i'' 's,Fullscreen mode" type="int">1</pref>,Fullscreen mode" type="int">0</pref>,' $HOME/.config/unity3d/DrizzlyBear/hackmud/prefs
4 | 


--------------------------------------------------------------------------------
/old/README.md:
--------------------------------------------------------------------------------
  1 | # t1 targets
  2 | 
  3 | - accenture
  4 | - amal_robo
  5 | - atbrady
  6 | - bluebun
  7 | - halperyon
  8 | - nuutec
  9 | - protein_prevention
 10 | - ros13
 11 | - suborbital_airlines
 12 | 
 13 | # t2 targets
 14 | 
 15 | - bunnybat_hut
 16 | - setec_gas
 17 | - soylentbean
 18 | - suborbital_airlines
 19 | - weyland
 20 | 
 21 | # strange targets
 22 | 
 23 | - `blackstar` generates scripts that don't exist
 24 | 
 25 | # shortcuts
 26 | 
 27 |     /u = sys.upgrades
 28 |     /fs = scripts.fullsec
 29 |     /hl = kernel.hardline
 30 |     /dc = kernel.hardline {dc:true}
 31 |     /lock = mode{m:"lock"}
 32 |     /dev = mode{m:"dev"}
 33 |     /us = scripts.user
 34 | 
 35 | # safe targets
 36 | 
 37 | - nuutec
 38 | - suborbital_airlines
 39 | - weyland
 40 | 
 41 | # db notes
 42 | 
 43 | From [here](https://www.hackmud.com/forums/new_players/how_to_script_please_):
 44 | 
 45 | - count: #db.c()
 46 | - insert: #db.i()
 47 | - update: #db.u()
 48 | - remove: #db.r()
 49 | - find: #db.f()
 50 | - findAndModify: #db.m()
 51 | - save: #db.s()
 52 | 
 53 | ## example db usage
 54 | 
 55 |     function(c,a) {
 56 |         // Remove any old test documents.
 57 |         #db.r({ script:"test" })
 58 |         // Insert a new test document.
 59 |         #db.i({ script:"test", value:"myvalue" })
 60 |         // Save an update to the existing test document.
 61 |         #db.s({ script:"test", value:"mynewvalue" })
 62 |         // Return the test document.
 63 |         return #db.f({ script:"test" }).first()
 64 |     }
 65 | 
 66 | # items
 67 | 
 68 |     tier_1 lock         c001
 69 |     tier_1 lock         c002
 70 |     tier_1 lock         c003
 71 |     tier_1 lock         ez_21
 72 |     tier_1 lock         ez_35
 73 |     tier_1 lock         ez_40
 74 |     tier_1 lock         w4rn
 75 |     tier_1 script       w4rn_message
 76 |     tier_1 script       expose_access_log_v1
 77 |     tier_1 script       log_writer_v1
 78 |     tier_1 script_space script_slot_v1
 79 |     tier_1 script_space char_count_v1
 80 |     tier_1 script_space public_script_v1
 81 | 
 82 | # various commands
 83 | 
 84 |     sys.migrate      // bypass the tutorial
 85 |     sys.status       // get system status
 86 |     accts.xfer_gc_to // transfer money to another account
 87 | 
 88 | # how to t2
 89 | 
 90 | 1. Find a FULLSEC entry, look at the pages, get usernames.
 91 |    Note: `dtr.ls` is useful for this.
 92 | 1. Find a HIGHSEC/MIDSEC entry for the same user.
 93 | 1. Execute the following command and find a username where this works: `user.script {username:"theuser", action:"order_qrs"}`
 94 | 1. Parse the QR codes and find the ID.
 95 | 
 96 | # useful links
 97 | 
 98 | - [How to find t2 NPCs](http://steamcommunity.com/sharedfiles/filedetails/?id=771040875)
 99 | - [Decoding small QR codes by hand](http://blog.qartis.com/decoding-small-qr-codes-by-hand/)
100 | - [How to Read QR Symbols Without Your Mobile Telephone](http://www.ams.org/samplings/feature-column/fc-2013-02)
101 | 
102 | # useful scripts
103 | 
104 | - `scripts.get_level {name:"script-id"}`
105 | - `dtr.man{list:true}`
106 | 
107 | # investigate these
108 | 
109 | - https://github.com/NimVek/hackmud/blob/master/tools/qr_decode.js
110 | 
111 | - `buttslol.str`: Script golfing library to store static strings in the #db
112 | - `dtr.best_items`: Record and compare best item stats
113 | - `dtr.lib`: Convenience Library - Feature Requests Welcome!
114 | - `dtr.ls`: List all callable scripts
115 | - `dtr.man`: View manual pages for scripts
116 | - `ez.conspec`: Hack T2 CON_SPEC locks
117 | - `fezmonkey.trust`: List trust scripts by security level
118 | - `happybill.npcs`: lists npcs in full/high/midsec
119 | - `lore.qr`: a qr code decoder
120 | - `lore.shim`: introspect scraping and cracking scripts
121 | - `math.scripts`: Get list of npc OR user scripts for a security level.
122 | - [highsec] `n00bish.t2solver`: Automated T2 npc farmer
123 | 


--------------------------------------------------------------------------------
/old/crack.js:
--------------------------------------------------------------------------------
 1 | function (context, a) { // t:#s.username.target
 2 |   var ez=["open","release","unlock"],
 3 |       //primes=[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129],
 4 |       primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97],
 5 |       colors = ["red", "orange", "yellow", "green", "lime", "blue", "cyan", "purple"],
 6 |       ret, args = {}, success=false,
 7 |       unlocked = /(LOCK_UNLOCKED)\s(ez_[0-9]{2}|c00[1-3])/g,
 8 |       locked = /LOCK_ERROR/g,
 9 |       locks = /(EZ_[0-9]{2}|c00[1-3])/g,
10 |       lock_list = [],
11 |       ret, i, lock // these are used later
12 |   function check_next(args, next) {
13 |     ret = a.t.call(args)
14 |     if (ret.includes("is missing") || ret.includes("unlocked") || ret.includes("Denied")) {
15 |       return true
16 |     }
17 |   }
18 |   while (!success) {
19 |     ret = a.t.call(args)
20 |     if (!locked.test(ret)) {
21 |       success = true
22 |       break
23 |     }
24 |     while (lock = locks.exec(ret)) {
25 |       lock_list.push(lock[1])
26 |     }
27 |     lock = lock_list[lock_list.length - 1].toLowerCase()
28 |     switch (lock) {
29 |       case "ez_21":
30 |       case "ez_35":
31 |       case "ez_40":
32 |         for (i=0; i<3; i++) {
33 |           args[lock] = ez[i]
34 |           if (check_next(args)) { break }
35 |         }
36 |         // Stop processing ez_21 locks here
37 |         if (lock == "ez_21") { break }
38 |         else if (lock == "ez_35") {
39 |           // Process the rest of ez_35 locks.
40 |           for (i=0; i<10; i++) {
41 |             args.digit = i
42 |             if (check_next(args)) { break }
43 |           }
44 |         }
45 |         else if (lock == "ez_40") {
46 |           // Process the rest of ez_40 locks.
47 |           for (i=0; i<primes.length; i++) {
48 |             args.ez_prime = primes[i]
49 |             if (check_next(args)) { break }
50 |           }
51 |         }
52 |         // Stop processing ez_35 or ez_40 locks.
53 |         break
54 |       case "c001":
55 |       case "c002":
56 |       case "c003":
57 |         // Identify the base lock value.
58 |         for (i=0; i<8; i++) {
59 |           args[lock] = colors[i]
60 |           if (check_next(args)) { break }
61 |         }
62 |         // Stop processing c001 locks here
63 |         if (lock == "c001") {
64 |           for (i=0; i<10; i++) {
65 |             args.color_digit = i
66 |             if (check_next(args)) { break }
67 |           }
68 |           break
69 |         }
70 |         // Set the first triad value.
71 |         for (i=0; i<8; i++) {
72 |           if (lock == "c002") { args["c002_complement"] = colors[i] }
73 |           if (lock == "c003") { args["c003_triad_1"]    = colors[i] }
74 |           if (check_next(args)) { break }
75 |         }
76 |         // Stop processing c002 locks here
77 |         if (lock == "c002") { break }
78 |         // Set the second triad value.
79 |         for (i=0; i<8; i++) {
80 |           args["c003_triad_2"] = colors[i]
81 |           if (check_next(args)) { break }
82 |         }
83 |         // stop processing c003 locks here
84 |         break
85 |     }
86 |   }
87 |   return {ok:success, msg:ret, args:args}
88 | }
89 | 


--------------------------------------------------------------------------------
/old/mode.js:
--------------------------------------------------------------------------------
 1 | function (c, a)
 2 | {
 3 |     var i, out
 4 | 
 5 |     function unload() {
 6 |         out = #s.sys.upgrades()
 7 |         for (i=0; i < out.length; i++) {
 8 |             #s.sys.upgrades({unload:i})
 9 |         }
10 |     }
11 | 
12 |     function load_locks() {
13 |         // Load the locks.
14 |         for (i = 0; i < 6; i++) {
15 |             #s.sys.upgrades({load:i})
16 |         }
17 |     }
18 | 
19 |     function load_all() {
20 |         // Load the first 15 upgrades.
21 |         for (i = 0; i < 15; i++) {
22 |             #s.sys.upgrades({load:i})
23 |         }
24 |     }
25 | 
26 |     if (a == null) {
27 |         unload()
28 |         load_all()
29 |     } else if (a.m == "lock") {
30 |         unload()
31 |         load_locks()
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/old/qr.js:
--------------------------------------------------------------------------------
  1 | function(context,a) {
  2 |     var ls,
  3 |         out = #s.setec_gas.memberlogin({username:"cheechfiend91", get:"order_qrs"}),
  4 |         cs = out.filter(function(l) {
  5 |             // Exclude non-QR code entries.
  6 |             return !l.includes("missing")
  7 |         }).map(function(qrc) {
  8 |             // Drop off the empty line at the end of each QR code.
  9 |             ls = qrc.split('\n')
 10 |             ls = ls.slice(0,ls.length-1)
 11 |             return ls
 12 |         }),
 13 |         ret = "",
 14 |         c = cs[0]
 15 | 
 16 |     cs.forEach(function(c) {
 17 |         var width = c[0].length,
 18 |             h = c.length*2, // height
 19 |             qra = new Array(h), // QR Array
 20 |             r1, r2, i, j, version, fi = 0, ecl, dataMask, ecc
 21 | 
 22 |         function qrToString() {
 23 |             var qr2 = "", line, x
 24 |             for (i = 0; i < h; i++) {
 25 |                 line = ""
 26 |                 for (j = 0; j < h; j++) {
 27 |                     x = qra[i][j]
 28 |                     if (x == -1) {
 29 |                         line += "X"
 30 |                     } else if (x == -2) {
 31 |                         line += "M"
 32 |                     } else if (x == 0) {
 33 |                         line += "█" // "1"
 34 |                     } else if (x == 1) {
 35 |                         line += " " // "0"
 36 |                     } else {
 37 |                         line += x
 38 |                     }
 39 |                 }
 40 |                 qr2 += line + "\n"
 41 |             }
 42 |             return qr2
 43 |         }
 44 | 
 45 |         // Convert symbols to arrays (2 bit rows per 1 symbol row)
 46 |         for (i = 0; i < h/2; i++) {
 47 |             // Make two new rows.
 48 |             r1 = new Array(width)
 49 |             r1.fill(0,0,width)
 50 |             r2 = new Array(width)
 51 |             r2.fill(0,0,width)
 52 |             for (j = 0; j < width; j++) {
 53 |                 switch(c[i][j]) {
 54 |                     case "█":
 55 |                         r1[j] = 1
 56 |                         r2[j] = 1
 57 |                         break
 58 |                     case "▀":
 59 |                         r1[j] = 1
 60 |                         break
 61 |                     case "▄":
 62 |                         r2[j] = 1
 63 |                         break
 64 |                     //case " ": // this case is not needed, since the value is already 0
 65 |                     //    break // this case is not needed, since the value is already 0
 66 |                 }
 67 |             }
 68 |             qra[i*2]   = r1
 69 |             qra[i*2+1] = r2
 70 |         }
 71 | 
 72 |         // Drop off the last line filled with zeros.
 73 |         qra = qra.slice(0, qra.length-1)
 74 |         h--
 75 | 
 76 |         // Print the QR code, along with markers for post-processing.
 77 |         ret += "===BEGIN QR CODE===\n"
 78 |         ret += qrToString() + "\n"
 79 |         ret += "===END QR CODE===\n"
 80 | 
 81 |         // Calculate the version.
 82 |         version = Math.floor((h - 17) / 4)
 83 | 
 84 |         // Calculate the error correction level. 
 85 |         ecl = qra[8][0] + qra[8][1]*2
 86 | 
 87 |         // Calculate the data mask.
 88 |         dataMask = qra[8][2] + qra[8][3]*2 + qra[8][3]*3
 89 | 
 90 |         // Define the error correction levels.
 91 |         // L = 3
 92 |         // M = 2 // not sure if these levels need to be switched
 93 |         // Q = 1 // not sure if these levels need to be switched
 94 |         // H = 0
 95 |         // More info here:
 96 |         // - http://blog.qrstuff.com/2011/12/14/qr-code-error-correction
 97 |         // - http://www.qrcoded.co.uk/qr-code-error-correction-levels/
 98 |         ecc = {
 99 |             // L
100 |             3: {
101 |                 7: 156,
102 |                 8: 194,
103 |                 9: 232
104 |             },
105 |             // M
106 |             2: {
107 |                 7: 124,
108 |                 8: 154,
109 |                 9: 182
110 |             },
111 |             // Q
112 |             1: {
113 |                 7: 88,
114 |                 8: 110,
115 |                 9: 132
116 |             },
117 |             // H
118 |             0: {
119 |                 7: 66,
120 |                 8: 86,
121 |                 9: 100
122 |             }
123 |         }
124 | 
125 |         // TODO: Investigate these. I still think these are not defined correctly.
126 |         // Define the 8 masks.
127 |         // i = row, j = col
128 |         function isMasked(mask, row, col) {
129 |             // Masks are defined using the information here:
130 |             // https://en.wikipedia.org/wiki/QR_code#/media/File:QR_Format_Information.svg
131 |             // black = 1, white = 0
132 |             switch (mask) {
133 |                 // case 0: return ((i*j) % 2) + ((i*j) % 3) == 0
134 |                 // case 1: return i % 2 == 0
135 |                 // case 2: return ((i*j) %3 + i + j) % 2 == 0
136 |                 // case 3: return (i+j) % 3 == 0
137 |                 // case 4: return (Math.floor(i/2) + Math.floor(j/3)) % 2 == 0
138 |                 // case 5: return (i+j) % 2 == 0
139 |                 // case 6: return ((i*j) %3 + i * j) % 2 == 0
140 |                 // case 7: return j % 3 == 0
141 |                 // case 1:
142 |                 // case 2:
143 |                 // case 4:
144 |                 // case 3:
145 |                 // case 7:
146 |                 // // return (j % 3) == 0
147 |                 // // return (((i * j) % 2 + (i * j) % 3) % 2) == 0
148 |                 // // return (((i * j) % 3 + (i + j) % 2) % 2) == 0
149 |                 // // confirmed the following via bruteforce
150 |                 // //case 0: return ((i * j) % 2 + (i * j) % 3) == 0       // # confirmations: 1
151 |                 // case 0: return ((i + j) % 2) == 0                       // # confirmations: 1
152 |                 // //case 1: return (i % 2) == 0                           // # confirmations: 1
153 |                 // case 5: return (Math.floor((i / 2) + (j / 3)) % 2) == 0 // # confirmations: 1, 2 
154 |                 // case 6: return ((i + j) % 3) == 0                       // # confirmations: 1, 2
155 |                 case 0: return (row + col) % 2 == 0                                 // confirmed for 00000000, 44444444, 5
156 |                 case 1: return row % 2 == 0                                         // confirmed for 11
157 |                 case 2: return col % 3 == 0                                         // confirmed for 
158 |                 case 3: return (row + col) % 3 == 0                                 // confirmed for 
159 |                 case 4: return (Math.floor(row / 2) + Math.floor(col / 3)) % 2 == 0 // confirmed for 
160 |                 case 5: return ((row * col) % 2) + ((row * col) % 3) == 0           // confirmed for 22   333333, 55, 7777777
161 |                 case 6: return (((row * col) % 2) + ((row * col) % 3)) % 2 == 0     // confirmed for 22,  333,       777
162 |                 case 7: return (((row + col) % 2) + ((row * col) % 3)) % 2 == 0     // confirmed for 
163 |             }
164 |         }
165 |         var x
166 |         // Apply the appropriate mask (flip the bits)
167 |         for (j = h-1; j >= 0; j--) {
168 |             for (i = h-1; i >= 0; i--) {
169 |                 if (isMasked(dataMask, j, i)) {
170 |                     if (qra[j][i] == 0) {
171 |                         qra[j][i] = 1
172 |                     } else {
173 |                         qra[j][i] = 0
174 |                     }
175 |                 }
176 |             }
177 |         }
178 | 
179 |         // Calculate the encoding.
180 |         var enc = qra[h-1][h-1]
181 |         enc = (enc * 2) + qra[h-1][h-2]
182 |         enc = (enc * 2) + qra[h-2][h-1]
183 |         enc = (enc * 2) + qra[h-2][h-2]
184 |         if (enc == 4) {
185 |             ret += "valid mask: " + dataMask + "\n"
186 |         }
187 | 
188 |         // Debug data. TODO: Remove this.
189 |         ret += qrToString() + "\n"
190 | 
191 |         // ar = avoid region
192 |         // Avoid the region by marking it as non-traversable.
193 |         function ar(x, y, w, h) {
194 |             for (i = x; i < x+w; i++) {
195 |                 for (j = y; j < y+h; j++) {
196 |                     qra[j][i] = -1
197 |                 }
198 |             }
199 |         }
200 | 
201 |         // Avoid corners. This includes version info.
202 |         ar(  0,   0, 9, 9) // top left
203 |         ar(h-8,   0, 8, 9) // top right
204 |         ar(  0, h-8, 9, 8) // bottom left
205 | 
206 |         // Avoid alignment markers.
207 |         var hh = Math.floor(h/2)-2 // half height (roughly)
208 |         ar( hh,   4, 5, 5) // top middle
209 |         ar(  4,  hh, 5, 5) // center left
210 |         ar( hh,  hh, 5, 5) // center middle
211 |         ar(h-9,  hh, 5, 5) // center right
212 |         ar( hh, h-9, 5, 5) // bottom middle
213 |         ar(h-9, h-9, 5, 5) // bottom right
214 | 
215 |         // Avoid timing patterns. Go edge-to-edge to save characters.
216 |         ar(6, 0, 1, h) // vertical
217 |         ar(0, 6, h, 1) // horizontal
218 | 
219 |         // Avoid versions.
220 |         ar(   0, h-11, 6, 3) // vertical
221 |         ar(h-11,    0, 3, 6) // horizontal
222 | 
223 |         // Debug data. TODO: Remove this.
224 |         //ret += qrToString() + "\n"
225 | 
226 |         // Parse the data.
227 |         var byte = 0,
228 |             numId = 0,
229 |             len = -1,
230 |             numBits = 0,
231 |             bytes = [],
232 |             result = "",
233 |             goingUp = true,
234 |             rightCol = h-1,
235 |             jcc = false, // just changed columns
236 |             reachedEnd = false
237 |         for (j = h-3; ; ) {
238 |             for (i = rightCol; i >= rightCol-1; i--) {
239 |                 if (rightCol < 0) {
240 |                     // This if statement should never happen unless the parser is broken.
241 |                     reachedEnd = true
242 |                     break
243 |                 }
244 |                 // This is a fancy for loop to handle two columns, starting with
245 |                 // the right column.
246 |                 x = qra[j][i]
247 |                 // Make sure this is valid data (not masked or marked for avoiding).
248 |                 if (x >= 0) {
249 |                     numBits++
250 |                     byte = (byte << 1) + qra[j][i]
251 |                     if (len == -1) {
252 |                         qra[j][i] = "L"
253 |                     } else {
254 |                         qra[j][i] = String.fromCharCode(numId+97)
255 |                     }
256 |                     if (numBits == 4 && byte == 0) {
257 |                         qra[j][i] = "E"
258 |                         reachedEnd = true
259 |                         break
260 |                     }
261 |                     if (numBits == 8) {
262 |                         // Save the byte.
263 |                         bytes.push(byte)
264 |                         numId = (numId+1) % 10
265 | 
266 |                         // Reset variables.
267 |                         numBits = 0
268 |                         byte = 0
269 |                     }
270 |                 }
271 |             }
272 |             if (reachedEnd) {
273 |                 break
274 |             }
275 | 
276 |             if (j == 0) {
277 |                 if (jcc) {
278 |                     jcc = false
279 |                     j++
280 |                     goingUp = false
281 |                 } else {
282 |                     rightCol -= 2
283 |                     jcc = true
284 |                 }
285 |             } else if (j == h-1) {
286 |                 if (jcc) {
287 |                     jcc = false
288 |                     j--
289 |                     goingUp = true
290 |                 } else {
291 |                     rightCol -= 2
292 |                     jcc = true
293 |                 }
294 |             } else if (goingUp) {
295 |                 j--
296 |             } else {
297 |                 j++
298 |             }
299 |         }
300 | 
301 |         // Rearange the codewords.
302 |         var nb, results = []
303 |         for (nb = 2; nb < 5; nb++) {
304 |             var numBlocks = nb,
305 |                 currentBlock = 0,
306 |                 blocks = [],
307 |                 result = "",
308 |                 hi, lo
309 |             // Initialize the blocks.
310 |             for (i = 0; i < numBlocks; i++) {
311 |                 blocks.push([])
312 |             }
313 |             for (i = 0; i < bytes.length; i++) {
314 |                 // Move to the next block.
315 |                 if (++currentBlock == numBlocks) {
316 |                     currentBlock = 0
317 |                 }
318 |                 // Add the current byte to the current block.
319 |                 blocks[currentBlock].push(bytes[i])
320 |             }
321 |             // Iterate through the blocks and make a new byte array.
322 |             var bytes2 = []
323 |             for (i = 0; i < numBlocks; i++) {
324 |                 // Add each byte from the current block to the new byte array.
325 |                 for (j = 0; j < blocks[i].length; j++) {
326 |                     bytes2.push(blocks[i][j])
327 |                 }
328 |             }
329 |             // Iterate through the new byte array, making a third byte array based on the low and high values of each adjacent byte.
330 |             // We can skip the encoding (the first low), since it is already known, as well as the last high byte because we just don't care right now.
331 |             var bytes3 = []
332 |             for (i = 0; i < bytes2.length-1; i++) {
333 |                 lo = bytes2[i]  >> 4
334 |                 hi = (bytes2[i+1] & 15) << 4
335 |                 var b = lo + hi
336 |                 bytes3.push(b)
337 |                 result += String.fromCharCode(b)
338 |             }
339 |             results.push(result)
340 |         }
341 | 
342 |         if (enc != 4) {
343 |             ret += "Not byte encoded.\n"
344 |         }
345 |         ret += "blocks: " + blocks + "\n"
346 |         ret += "blocks[0]: " + blocks[0] + "\n"
347 |         ret += "blocks[1]: " + blocks[1] + "\n"
348 |         ret += "     ecl: " + ecl + "\n"
349 |         ret += "datamask: " + dataMask + "\n"
350 |         ret += " version: " + version + "\n"
351 |         ret += "maxwords: " + ecc[ecl][version] + "\n"
352 |         ret += "encoding: " + enc + "\n"
353 |         ret += "  length: " + len + "\n"
354 |         ret += "   bytes: " + bytes + "\n"
355 |         ret += "  bytes2: " + bytes2 + "\n"
356 |         ret += "  bytes3: " + bytes3 + "\n"
357 |         //ret += " qra.len: " + qra.length + "\n"
358 |         //ret += "brcorner: " + qra[h-1][h-1] + "\n"
359 |         //ret += "[h-1][h-1]: " + qra[h-1][h-1] + "\n"
360 |         //ret += "[h-1][h-2]: " + qra[h-1][h-2] + "\n"
361 |         //ret += "[h-2][h-1]: " + qra[h-2][h-1] + "\n"
362 |         //ret += "[h-2][h-2]: " + qra[h-2][h-2] + "\n"
363 |         ret += "bytes.length: " + bytes.length + "\n"
364 |         ret += "results: " + results
365 | 
366 |         return ret
367 |     })
368 | 
369 |     return ret
370 | 
371 |     // Useful links:
372 |     // - http://www.thonky.com/qr-code-tutorial/format-version-information
373 |     // - http://www.thonky.com/qr-code-tutorial/mask-patterns
374 |     // - https://github.com/zxing/zxing/blob/master/core/src/main/java/com/google/zxing/qrcode/decoder/DataMask.java#L129-L137
375 |     // - https://github.com/zxing/zxing/blob/master/core/src/main/java/com/google/zxing/qrcode/decoder/Version.java#L139-L176
376 |     // - https://github.com/zxing/zxing/blob/master/core/src/main/java/com/google/zxing/qrcode/decoder/BitMatrixParser.java#L164
377 |     // - https://github.com/dlbeer/quirc/blob/master/lib/decode.c
378 |     
379 |     // With ECC, the data blocks (8 bits) are interleaved
380 |     // so, if you just decode the bistream directly, the result is something like this:
381 |     // [data0][data4][data1][data5][data2][data6][data3][data7][ecc0][ecc4][ecc1][ecc5][ecc2][ecc6][ecc3][ecc7]
382 |     // ( that might not be exactly right, but that's the idea )
383 |     // but data 0 contains the 4 bits of type information, and then 4 bits of the length
384 |     // the OTHER 4 bits of the length, and the first 4 bits of payload, are in data1
385 |     // the rest of THAT data byte is in data2, and so on.
386 | }
387 | 


--------------------------------------------------------------------------------
/old/starter/nuutec.js:
--------------------------------------------------------------------------------
 1 | function(c, a) {
 2 |     var dPr = #s.nuutec.entry({"see":"happening"}),
 3 |         dPa = #s.nuutec.entry({"see":"about_us"}),
 4 |         rePr = /(date for|continues on|of the|developments on) ([a-z0-9_]+(.sh|.exe)?)/ig,
 5 |         rePa = /(strategy )([a-z0-9_]+)/ig,
 6 |         m,
 7 |         prs = [],
 8 |         pas = [],
 9 |         ts = []
10 |     while (m = rePr.exec(dPr)) {
11 |         prs.push(m[2])
12 |     }
13 |     while (m = rePa.exec(dPa)) {
14 |         pas.push(m[2])
15 |     }
16 |     prs.forEach(function(p) {
17 |         ts.push(#s.nuutec.entry({see:"employees", p:pas[0], project:p}))
18 |     })
19 |     return ts
20 | }
21 | 


--------------------------------------------------------------------------------
/old/t1/crack.js:
--------------------------------------------------------------------------------
 1 | function (context, a) { // t:#s.username.target
 2 |   var ez=["open","release","unlock"],
 3 |       primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97],
 4 |       colors = ["red", "orange", "yellow", "green", "lime", "blue", "cyan", "purple"],
 5 |       ret, args = {}, success=false,
 6 |       unlocked = /(LOCK_UNLOCKED)\s(ez_[0-9]{2}|c00[1-3])/g,
 7 |       locked = /LOCK_ERROR/g,
 8 |       locks = /(EZ_[0-9]{2}|c00[1-3])/g,
 9 |       lock_list = [],
10 |       ret, i, lock // these are used later
11 |   function check_next(args, next) {
12 |     ret = a.t.call(args)
13 |     if (ret.includes("is missing") || ret.includes("unlocked") || ret.includes("Denied")) {
14 |       return true
15 |     }
16 |   }
17 |   while (!success) {
18 |     ret = a.t.call(args)
19 |     if (!locked.test(ret)) {
20 |       success = true
21 |       break
22 |     }
23 |     while (lock = locks.exec(ret)) {
24 |       lock_list.push(lock[1])
25 |     }
26 |     lock = lock_list[lock_list.length - 1].toLowerCase()
27 |     switch (lock) {
28 |       case "ez_21":
29 |       case "ez_35":
30 |       case "ez_40":
31 |         for (i=0; i<3; i++) {
32 |           args[lock] = ez[i]
33 |           if (check_next(args)) { break }
34 |         }
35 |         // Stop processing ez_21 locks here
36 |         if (lock == "ez_21") { break }
37 |         else if (lock == "ez_35") {
38 |           // Process the rest of ez_35 locks.
39 |           for (i=0; i<10; i++) {
40 |             args.digit = i
41 |             if (check_next(args)) { break }
42 |           }
43 |         }
44 |         else if (lock == "ez_40") {
45 |           // Process the rest of ez_40 locks.
46 |           for (i=0; i<primes.length; i++) {
47 |             args.ez_prime = primes[i]
48 |             if (check_next(args)) { break }
49 |           }
50 |         }
51 |         // Stop processing ez_35 or ez_40 locks.
52 |         break
53 |       case "c001":
54 |       case "c002":
55 |       case "c003":
56 |         // Identify the base lock value.
57 |         for (i=0; i<8; i++) {
58 |           args[lock] = colors[i]
59 |           if (check_next(args)) { break }
60 |         }
61 |         // Stop processing c001 locks here
62 |         if (lock == "c001") {
63 |           for (i=0; i<10; i++) {
64 |             args.color_digit = i
65 |             if (check_next(args)) { break }
66 |           }
67 |           break
68 |         }
69 |         // Set the first triad value.
70 |         for (i=0; i<8; i++) {
71 |           if (lock == "c002") { args["c002_complement"] = colors[i] }
72 |           if (lock == "c003") { args["c003_triad_1"]    = colors[i] }
73 |           if (check_next(args)) { break }
74 |         }
75 |         // Stop processing c002 locks here
76 |         if (lock == "c002") { break }
77 |         // Set the second triad value.
78 |         for (i=0; i<8; i++) {
79 |           args["c003_triad_2"] = colors[i]
80 |           if (check_next(args)) { break }
81 |         }
82 |         // stop processing c003 locks here
83 |         break
84 |     }
85 |   }
86 |   return {ok:success, msg:ret, args:args}
87 | }
88 | 


--------------------------------------------------------------------------------
/old/t1/harvest.js:
--------------------------------------------------------------------------------
  1 | function (c, a) // t:#s.username.target
  2 | {
  3 |     // Handle the case with no arguments passed.
  4 |     if (a == null) {
  5 |         // Get all FULLSEC targets.
  6 |         var f = #s.scripts.fullsec();
  7 | 
  8 |         // Get the publics and entries.
  9 |         var l = f.filter(function(v){
 10 |             return (v.includes(".pub") || v.includes(".entry")) &&
 11 |                    // Filter out known malicious entries.
 12 |                    !(v.includes("accenture") &&
 13 |                      v.includes("blackcore")
 14 |                     )
 15 |         })
 16 | 
 17 |         return {
 18 |             usage: "harvest{t:#s.user.target}",
 19 |             fullsec_targets: l
 20 |         }
 21 |     }
 22 | 
 23 |     // Define some variables.
 24 |     var b = a.t.call().split("\n"),                    // banner
 25 |         pages = b[b.length-1]                          // take the last line of the banner
 26 |         .split("|").map(function(v) {                  // split the pages up
 27 |             return v.trim()                            // trim whitespace
 28 |         }).filter(function(v) {
 29 |             return v.length > 0                        // filter out empty results from this list
 30 |         }),
 31 |         args = {},                                     // arguments passed to the function passed in to this script
 32 |         out = a.t.call({}), out2,                      // generic output variable
 33 |         none = out.match(/with ([a-z]+):"([a-z]+)"/i)  // parse the output of the function with no parameters passed in
 34 | 
 35 |     // Add a check based on some money theft scripts that all shared parsing errors.
 36 |     if (none == null) {
 37 |         out2 = a.t.call({})
 38 |         return {
 39 |             error: "Parsing failed: this is a potentially malicious server. If the glitches in out1 and out2 look the same, then it is almost certainly malicious.",
 40 |             out1: out,
 41 |             out2: out2
 42 |         }
 43 |     }
 44 | 
 45 |     // Continue defining variables.
 46 |     var cmd = none[1],                                 // the command used to view pages
 47 |         cw = none[2],                                  // the codeword needed to access the projects
 48 |         rePr = /(date for|continues on|of the|developments on) ([a-z0-9_]+(.sh|.exe)?)/ig, // regex for projects
 49 |         rePa = /(strategy )([a-z0-9_]+)/ig,                                                // regex for password(s)
 50 |         m,
 51 |         es = [],  // entries
 52 |         prs = [], // projects
 53 |         pas = [], // passwords
 54 |         ts = []   // targets
 55 | 
 56 |     // Look for projects and passwords in each of the pages.
 57 |     pages.forEach(function(v) {
 58 |         args = {}
 59 |         // Craft the arguments that will be called.
 60 |         // e.g.: {"see":"about_us"}
 61 |         args[cmd] = v
 62 | 
 63 |         // Call the function with the custom arguments.
 64 |         out = a.t.call(args)
 65 | 
 66 |         // Search for projects.
 67 |         while (m = rePr.exec(out)) {
 68 |             prs.push(m[2])
 69 |         }
 70 | 
 71 |         // Search for passwords.
 72 |         while (m = rePa.exec(out)) {
 73 |             pas.push(m[2])
 74 |         }
 75 |     })
 76 | 
 77 |     // Gather the results from each of the projects (and assume only one password was found).
 78 |     prs.forEach(function(p) {
 79 |         // Call the function with the custom arguments.
 80 |         // Note: The password parameter can either be p, pass, or password.
 81 |         //       Therefore, we pass in all three, since it ignores unneeded parameters.
 82 |         out = a.t.call({
 83 |             p:pas[0],        // password
 84 |             pass:pas[0],     // password
 85 |             password:pas[0], // password
 86 |             project:p,       // project
 87 |             [cmd]:cw,        // codeword
 88 |         })
 89 | 
 90 |         // Parse each entry and filter out none, empty, nil, error, etc.
 91 |         if (typeof(out) == "string") {
 92 |             out = out.split("\n")
 93 |         }
 94 |         out.forEach(function(e){
 95 |             // Make prefer unidentified entries (they seem to have more success).
 96 |             if (e && e.includes(".") && e.includes("_")) {
 97 |                 ts.push(e)
 98 |             }
 99 |         })
100 |         if (ts.length > 0) {
101 |             var safety = #s.scripts.get_level({ name: ts[0] })
102 |             if (safety != "FULLSEC") {
103 |                 return "STOP. THIS IS MALICOUS."
104 |             }
105 |         }
106 |     })
107 | 
108 |     return ts
109 | }
110 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "hackmud",
 3 |     "license": "GPL-3.0",
 4 |     "private": true,
 5 |     "repository": "NimVek/hackmud",
 6 |     "devDependencies": {
 7 |         "grunt": "latest",
 8 |         "grunt-contrib-clean": "latest",
 9 |         "grunt-contrib-copy": "latest",
10 |         "grunt-contrib-jshint": "latest",
11 |         "grunt-contrib-uglify": "latest",
12 |         "grunt-jsbeautifier": "latest"
13 |     },
14 |     "scripts": {
15 |         "build": "grunt"
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/poc/is_npc.js:
--------------------------------------------------------------------------------
 1 | function(context, args) { // name:""
 2 | 
 3 |     INCLUDE(is_npc);
 4 | 
 5 |     if (!args || !args.name) {
 6 |         return {
 7 |             ok: false,
 8 |             msg: "Usage: " + context.this_script + ' { name:"' + context.caller + '" }'
 9 |         };
10 |     }
11 | 
12 |     var result = is_npc(args.name);
13 | 
14 |     return {
15 |         ok: true,
16 |         msg: args.name + " is " + (result ? "NPC" : "human")
17 |     };
18 | 
19 | }
20 | 


--------------------------------------------------------------------------------
/poc/parse_timestr.js:
--------------------------------------------------------------------------------
 1 | function(context, args) { // date:""
 2 | 
 3 |     INCLUDE(stdlib);
 4 |     INCLUDE(parse_timestr);
 5 | 
 6 |     if (!args || !args.date || !args.date.match(/^\d{6}\.\d{4}$/)) {
 7 |         return {
 8 |             ok: false,
 9 |             msg: "Usage: " + context.this_script + ' { date:"' + stdlib.to_game_timestr(stdlib.get_date()) + '" }'
10 |         };
11 |     }
12 | 
13 |     var date = parse_timestr(args.date);
14 | 
15 |     return {
16 |         ok: !isNaN(date.getTime()),
17 |         msg: date.toString()
18 |     };
19 | }
20 | 


--------------------------------------------------------------------------------
/poc/recover.js:
--------------------------------------------------------------------------------
 1 | function(context, args) { // scriptor:#s.<scriptor>
 2 |     INCLUDE(recover);
 3 | 
 4 |     if (!args || !args.scriptor) {
 5 |         return {
 6 |             ok: false,
 7 |             msg: context.this_script + " { scriptor:<scriptor> [, args:<arguments>] }"
 8 |         };
 9 |     }
10 | 
11 |     return recover(args.scriptor, args.args);
12 | }
13 | 


--------------------------------------------------------------------------------
/tools/access_log.js:
--------------------------------------------------------------------------------
 1 | function(context, args) {
 2 |     var log = #s.sys.access_log();
 3 | 
 4 |     INCLUDE(stdlib);
 5 |     INCLUDE(dtr);
 6 |     INCLUDE(parse_timestr);
 7 |     INCLUDE(nfo_user);
 8 |     INCLUDE(nfo_script);
 9 |     INCLUDE(fmt_user);
10 |     INCLUDE(fmt_date);
11 |     INCLUDE(fmt_script);
12 |     INCLUDE(color);
13 | 
14 |     var result = [];
15 | 
16 |     stdlib.each(log, function(_, entry) {
17 |         var match = entry.msg.match(/ from (\w+\.\w+)$/);
18 |         if (match) {
19 |             entry.from = nfo_script(match[1]);
20 |         }
21 |         match = entry.msg.match(/^(Connection|Breach attempt|System access) from /);
22 |         if (match) {
23 |             if (match[1].match(/attempt/i)) {
24 |                 entry.type = "attempt";
25 |                 entry.level = 2;
26 |             } else if (match[1].match(/access/i)) {
27 |                 entry.type = "access";
28 |                 entry.level = 3;
29 |             } else {
30 |                 entry.type = "connect";
31 |                 entry.level = entry.from.valid ? 1 : 0;
32 |             }
33 |         }
34 |         match = entry.msg.match(/^(\w+\.\w+) execution from /);
35 |         if (match) {
36 |             entry.type = "exec";
37 |             entry.script = nfo_script(match[1]);
38 |             entry.level = 4;
39 |             if (match[1] === "sys.write_log") {
40 |                 entry.args = result.pop().msg;
41 |             }
42 |         }
43 |         result.push(entry);
44 |     });
45 | 
46 |     if (context.is_scriptor || context.calling_script) {
47 |         return result;
48 |     }
49 | 
50 |     result = result.filter(function(entry) {
51 |         return entry.level > 0;
52 |     });
53 | 
54 |     var titles = [
55 |         { name: color("date", 'V'), key: "t", func: fmt_date },
56 |         { name: color("from", 'V'), key: "from", func: fmt_script },
57 |         { name: color("type", 'V'), key: "type" },
58 |         { name: color("script", 'V'), key: "script", func: fmt_script },
59 |         { name: color("args", 'V'), key: "args" }
60 |     ];
61 | 
62 |     return {
63 |         ok: true,
64 |         msg: dtr.columns(result, titles, { pre: "", suf: "" }, true)
65 |     };
66 | }
67 | 


--------------------------------------------------------------------------------
/tools/allsec.js:
--------------------------------------------------------------------------------
 1 | function(context, args) { // count:5
 2 | 
 3 |     INCLUDE(npc_static);
 4 |     INCLUDE(fmt_script);
 5 |     INCLUDE(stdlib)
 6 |     INCLUDE(dtr);
 7 |     INCLUDE(sort);
 8 | 
 9 |     var lookup = npc_static.reduce(function(hash, element) {
10 |         hash[element] = true;
11 |         return hash;
12 |     }, {});
13 | 
14 |     var result = [];
15 | 
16 |     function add_scripts(list, level) {
17 |         stdlib.each(list, function(_, script) {
18 |             var user = stdlib.get_user_from_script(script);
19 |             if (lookup[user]) {
20 |                 result.push({ name: script, valid: true, access: "PUBLIC", level: level });
21 |             }
22 |         });
23 |     }
24 | 
25 |     add_scripts(#s.scripts.fullsec(), 4);
26 |     add_scripts(#s.scripts.highsec(), 3);
27 |     add_scripts(#s.scripts.midsec(), 2);
28 |     add_scripts(#s.scripts.lowsec(), 1);
29 |     add_scripts(#s.scripts.nullsec(), 0);
30 | 
31 |     if (context.is_scriptor || context.calling_script) {
32 |         return result;
33 |     }
34 | 
35 |     result = sort(result, ["name"]);
36 | 
37 |     var titles = [
38 |         { name: "+script+", key: "script", func: fmt_script }
39 |     ];
40 | 
41 |     result = result.map(function(element) { return [element]; });
42 | 
43 |     return {
44 |         ok: true,
45 |         msg: dtr.columns(result, titles, { pre: "", suf: "" }, true)
46 |     };
47 | 
48 | }
49 | 


--------------------------------------------------------------------------------
/tools/bank_statement.js:
--------------------------------------------------------------------------------
 1 | function(context, args) { // count:5
 2 |     var caller = context.caller;
 3 |     var list = #s.accts.transactions(args);
 4 | 
 5 |     INCLUDE(stdlib);
 6 |     INCLUDE(dtr);
 7 | 
 8 |     var balance = -1;
 9 |     if (!args || !args.from && !args.to && !args.script) {
10 |         balance = #s.accts.balance();
11 |     }
12 | 
13 |     stdlib.each(list, function(_, transaction) {
14 |         transaction.time = stdlib.to_game_timestr(transaction.time);
15 |         transaction.description = transaction.memo || transaction.script;
16 |         if (transaction.sender == caller) {
17 |             transaction.withdrawal = transaction.amount;
18 |             transaction.opposit = transaction.recipient;
19 |         } else {
20 |             transaction.deposit = transaction.amount;
21 |             transaction.opposit = transaction.sender;
22 |         }
23 |         if (balance >= 0) {
24 |             transaction.balance = balance;
25 |             balance += (transaction.withdrawal || 0) - (transaction.deposit || 0);
26 |         }
27 |     });
28 | 
29 |     var titles = [
30 |         { name: "+date+", key: "time" },
31 |         { name: "+description+", key: "description" },
32 |         { name: "+opposit+", key: "opposit" },
33 |         { name: "+withdrawals+", key: "withdrawal", dir: -1, func: dtr.expandGC },
34 |         { name: "+deposits+", key: "deposit", dir: -1, func: dtr.expandGC }
35 |     ];
36 | 
37 |     if (balance >= 0) {
38 |         titles.push({ name: "+balance+", key: "balance", dir: -1, func: dtr.expandGC });
39 |     }
40 | 
41 |     var usage =
42 |         '\n\nFor more transactions, add count:<"all" or number>\nFilter for sender, recipient or script, add from:"<user>", to:"<user>" or script:"<script>".\n';
43 | 
44 |     return {
45 |         ok: true,
46 |         msg: dtr.columns(list.reverse(), titles, { pre: "", suf: "" }, true) + usage
47 |     };
48 | }
49 | 


--------------------------------------------------------------------------------
/tools/call.js:
--------------------------------------------------------------------------------
 1 | function(context, args) { // scriptor:#s.<scriptor>
 2 |     INCLUDE(nfo_operand);
 3 |     INCLUDE(stdlib);
 4 |     INCLUDE(nfo_script);
 5 | 
 6 |     if (!args || !args.scriptor) {
 7 |         return {
 8 |             ok: false,
 9 |             msg: context.this_script + " { scriptor:<scriptor> [, args:<arguments>, nfo:true, decolor:true] }"
10 |         };
11 |     }
12 | 
13 |     var scriptor = args.scriptor;
14 |     var result = scriptor.call(args.args);
15 | 
16 |     if (args.nfo) {
17 |         result = nfo_operand(result);
18 |     }
19 | 
20 |     if (args.decolor) {
21 |         result = stdlib.json.ostringify(result);
22 |         result = result.replace(/([!`+-])(\w+)\1/g, "$1 $2$1");
23 |         result = stdlib.json.oparse(result);
24 |     }
25 | 
26 |     return {
27 |         info: nfo_script(scriptor.name),
28 |         result: result
29 |     };
30 | }
31 | 


--------------------------------------------------------------------------------
/tools/harvest.js:
--------------------------------------------------------------------------------
  1 | function(context, args) { // t:#s.username.target
  2 |     // Handle the case with no arguments passed.
  3 |     if (args === null) {
  4 |         // Get all FULLSEC targets.
  5 |         var fullsec_targets = #s.scripts.fullsec();
  6 | 
  7 |         // Get the publics and entries.
  8 |         var publics_and_entries = fullsec_targets.filter(function(v) {
  9 |             return (v.includes(".pub") || v.includes(".entry")) &&
 10 |                 // Filter out known malicious entries.
 11 |                 !(v.includes("accenture") ||
 12 |                     v.includes("arino") ||
 13 |                     v.includes("blackcore") ||
 14 |                     v.includes("blackstar") ||
 15 |                     v.includes("dynamo_corp") ||
 16 |                     v.includes("jinteki_corp") ||
 17 |                     v.includes("l4sh") ||
 18 |                     v.includes("lunar_systems") ||
 19 |                     v.includes("n_inc") ||
 20 |                     v.includes("onion") ||
 21 |                     v.includes("perimeter_systems") ||
 22 |                     v.includes("ploogle") ||
 23 |                     v.includes("pwnhub") ||
 24 |                     v.includes("reinit") ||
 25 |                     v.includes("rozas")
 26 |                 );
 27 |         });
 28 | 
 29 |         return {
 30 |             usage: "harvest{t:#s.username.target}",
 31 |             fullsec_targets: publics_and_entries
 32 |         };
 33 |     }
 34 | 
 35 |     var highsec_targets = #s.scripts.highsec();
 36 |     var midsec_targets = #s.scripts.midsec();
 37 |     var hm_targets = highsec_targets.concat(midsec_targets);
 38 | 
 39 |     // Extract the banner of the script.
 40 |     var banner = args.t.call().split("\n");
 41 | 
 42 |     // Extract the pages from the banner using the following process:
 43 |     // - take the last line of the banner, which is where the list of pages is
 44 |     // - split the pages up using the '|' character
 45 |     // - trim off whitespace from each page name
 46 |     // - remove any empty entries from the resulting list
 47 |     var pages = banner[banner.length - 1]
 48 |         .split("|").map(function(v) {
 49 |             return v.trim();
 50 |         }).filter(function(v) {
 51 |             return v.length > 0;
 52 |         });
 53 | 
 54 |     // Prepare a variable to hold arguments that will be passed to the function passed in to this script.
 55 |     var function_args = {};
 56 | 
 57 |     // Create a generic output variable.
 58 |     var output_generic = args.t.call({});
 59 | 
 60 |     // Parse the output of the function with no parameters passed in.
 61 |     var no_parameters_result = output_generic.match(/with ([a-z]+):"([a-z]+)"/i);
 62 | 
 63 |     // This is a flag that can be set to a string to indicate the script should stop.
 64 |     var stop_flag = null;
 65 | 
 66 |     // Add a check based on some money theft scripts that all shared parsing errors.
 67 |     if (no_parameters_result === null) {
 68 |         return {
 69 |             error: "Parsing failed: this is a potentially malicious server. If the glitches in out1 and out2 look the same, then it is almost certainly malicious.",
 70 |             out1: output_generic,
 71 |             out2: args.t.call({})
 72 |         };
 73 |     }
 74 | 
 75 |     // Extract the command used to view pages.
 76 |     var view_command = no_parameters_result[1];
 77 | 
 78 |     // Extract the codeword needed to access the projects.
 79 |     var codeword = no_parameters_result[2];
 80 | 
 81 |     // Define a regex for projects, passwords, and users.
 82 |     var regex_projects = /(date for|continues on|of the|developments on) ([a-z0-9_]+(.sh|.exe)?)/ig;
 83 |     var regex_passwords = /(strategy )([a-z0-9_]+)/ig;
 84 |     var regex_users = /([a-z0-9_]+) (of project|when being)/ig;
 85 | 
 86 |     // Declare iteration variables and arrays that are used later.
 87 |     var m, i;
 88 |     var projects = [];
 89 |     var passwords = [];
 90 |     var users = [];
 91 |     var t1_targets = [];
 92 | 
 93 |     // Look for projects and passwords in each of the pages.
 94 |     pages.forEach(function(page) {
 95 |         function_args = {};
 96 |         // Craft the arguments that will be called.
 97 |         // e.g.: {"see":"about_us"}
 98 |         function_args[view_command] = page;
 99 | 
100 |         // Call the function with the custom arguments.
101 |         output_generic = args.t.call(function_args);
102 | 
103 |         // Search for projects.
104 |         do {
105 |             m = regex_projects.exec(output_generic);
106 |             if (m === null) {
107 |                 break;
108 |             }
109 |             projects.push(m[2]);
110 |         } while (true);
111 | 
112 |         // Search for passwords.
113 |         do {
114 |             m = regex_passwords.exec(output_generic);
115 |             if (m === null) {
116 |                 break;
117 |             }
118 |             passwords.push(m[2]);
119 |         } while (true);
120 | 
121 |         // Search for users.
122 |         do {
123 |             m = regex_users.exec(output_generic);
124 |             if (m === null) {
125 |                 break;
126 |             }
127 |             users.push(m[1]);
128 |         } while (true);
129 |     });
130 | 
131 |     // Gather the results from each of the projects (and assume only one password was found).
132 |     projects.forEach(function(project) {
133 |         // Call the function with the custom arguments.
134 |         // Note: The password parameter can be any ofe the following:
135 |         //         - p
136 |         //         - pass
137 |         //         - password
138 |         //       Therefore, we pass in all three, since it ignores unneeded parameters.
139 |         var cw_key = [view_command];
140 |         output_generic = args.t.call({
141 |             p: passwords[0],
142 |             pass: passwords[0],
143 |             password: passwords[0],
144 |             project: project,
145 |             cw_key: codeword,
146 |         });
147 | 
148 |         // Parse each entry and filter out none, empty, nil, error, etc.
149 |         if (typeof(output_generic) == "string") {
150 |             output_generic = output_generic.split("\n");
151 |         }
152 | 
153 |         output_generic.forEach(function(entry) {
154 |             // Make prefer unidentified entries (they seem to have more success).
155 |             if (entry && entry.includes(".") && entry.includes("_")) {
156 |                 t1_targets.push(entry);
157 |             }
158 |         });
159 | 
160 |         // For the first target, make sure it is a fullsec target before continuing.
161 |         if (t1_targets.length > 0) {
162 |             var safety = #s.scripts.get_level({ name: t1_targets[0] });
163 |             if (safety != 4) { // 4 = FULLSEC
164 |                 stop_flag = "STOP. THIS IS MALICOUS.";
165 |                 return;
166 |             }
167 |         }
168 |     });
169 | 
170 |     if (stop_flag !== null) {
171 |         return stop_flag;
172 |     }
173 | 
174 |     // Gather matching HIGHSEC and MIDSEC targets.
175 |     var t2_targets = [];
176 |     var target_author = args.t.name.split(".")[0];
177 | 
178 |     for (i = 0; i < hm_targets.length; i++) {
179 |         if (hm_targets[i].includes(target_author)) {
180 |             t2_targets.push(hm_targets[i]);
181 |         }
182 |     }
183 | 
184 |     return {
185 |         t1_targets: t1_targets,
186 |         users: users,
187 |         t2_targets: t2_targets
188 |     };
189 | }
190 | 


--------------------------------------------------------------------------------
/tools/market_browse.js:
--------------------------------------------------------------------------------
 1 | function(context, args) {
 2 |     INCLUDE(stdlib);
 3 |     INCLUDE(dtr);
 4 |     INCLUDE(sort);
 5 |     INCLUDE(classes);
 6 | 
 7 |     args = args || {};
 8 |     if (!(args.name || args.type || args.tier || args.class || args.cost)) {
 9 |         var balance = #s.accts.balance();
10 |         args.cost = { "$lte": balance };
11 |     }
12 | 
13 |     var order = args.order || ["tier", "type", "name", "rarity"],
14 |         list = #s.market.browse(args),
15 |         market = {};
16 | 
17 |     if (list.length === 0) {
18 |         return {
19 |             ok: false,
20 |             msg: "No suitable upgrades found.\nUsage: " + context.this_script +
21 |                 ' { name:"<upgrade name", type:"<lock, script_space, script>", tier:<1-4>, class:"<architect, executive, infitrator, scavenger>", cost:<num or GC str>, order:<array of properties> }'
22 |         };
23 |     }
24 | 
25 |     stdlib.each(list, function(_, item) {
26 |         var id = "" + item.rarity + "-" + item.name;
27 |         if (!(null === item.i || id in market)) {
28 |             market[id] = item;
29 |         }
30 |     });
31 | 
32 |     list = [];
33 |     for (var id in market) {
34 |         var item = #s.market.browse({ i: market[id].i });
35 |         for (var key in item.upgrade)
36 |             item[key] = item.upgrade[key];
37 |         item.class = item.up_class;
38 |         list.push(item);
39 |     }
40 | 
41 |     list = sort(list, order);
42 | 
43 |     var titles = [
44 |         { name: "Name", key: "name" },
45 |         { name: "Rarity", key: "rarity", func: dtr.coloredRarityLevel },
46 |         { name: "Cost", key: "cost", dir: -1, func: dtr.expandGC },
47 |         { name: "Token", key: "i" },
48 |         { name: "Type", key: "type" },
49 |         {
50 |             name: "Class",
51 |             key: "class",
52 |             func: function(value) {
53 |                 return classes[value];
54 |             }
55 |         },
56 |         { name: "Tier", key: "tier", dir: 0 }
57 |     ];
58 | 
59 |     titles.sort(function(a, b) {
60 |         return order.indexOf(a.key) != -1 ? order.indexOf(b.key) != -1 ? order.indexOf(a.key) - order.indexOf(b
61 |             .key) : -1 : order.indexOf(b.key) != -1 ? 1 : 0;
62 |     });
63 | 
64 |     return {
65 |         ok: true,
66 |         msg: dtr.columns(list, titles, { pre: "", suf: "" }, true)
67 |     };
68 | }
69 | 


--------------------------------------------------------------------------------
/tools/qr_decode.js:
--------------------------------------------------------------------------------
  1 | function(context, args) { // qr:<string>
  2 |     var caller = context.caller;
  3 | 
  4 |     if (!args || !args.qr) {
  5 |         return { ok: false, msg: context.this_script + " { qr:<string> }" };
  6 |     }
  7 | 
  8 |     var qr = args.qr.split('\n');
  9 | 
 10 |     function decode(code) {
 11 | 
 12 |         var pattern = {
 13 |             ' ': [0, 0],
 14 |             '\u2580': [1, 0],
 15 |             '\u2584': [0, 1],
 16 |             '\u2588': [1, 1]
 17 |         };
 18 | 
 19 |         function bit(x, y) {
 20 |             return pattern[code[y >> 1][x]][y & 1];
 21 |         }
 22 | 
 23 |         var info = {};
 24 |         info.dimension = code[0].length;
 25 |         info.version = (info.dimension - 17) >> 2;
 26 | 
 27 |         var tmp = 0;
 28 |         var i;
 29 |         for (i = 0; i < 5; i++) {
 30 |             tmp = (tmp << 1) | bit(i, 8);
 31 |         }
 32 |         tmp ^= 0x15;
 33 |         info.ecl = tmp >> 3;
 34 |         info.mask = tmp % 0x8;
 35 | 
 36 |         var masks = [
 37 |             function(x, y) { return ((x + y) & 0x1) === 0; },
 38 |             function(x, y) { return (x & 0x1) === 0; },
 39 |             function(x, y) { return (y % 3) === 0; },
 40 |             function(x, y) { return ((x + y) % 3) === 0; },
 41 |             // function (x,y) { return (((x>>1) + Math.floor(y / 3)) & 0x1) === 0;},
 42 |             function(x, y) { return (((y >> 1) + Math.floor(x / 3)) & 0x1) === 0; },
 43 |             function(x, y) { return (((x * y) & 0x1) + ((x * y) % 3)) === 0; },
 44 |             function(x, y) { return ((((x * y) & 0x1) + ((x * y) % 3)) & 0x1) === 0; },
 45 |             function(x, y) { return (((((x + y) & 0x1) + ((x * y) % 3)) & 0x1) === 0); }
 46 |         ];
 47 | 
 48 |         function databit(x, y) {
 49 |             return masks[info.mask](x, y) ^ bit(x, y);
 50 |         }
 51 | 
 52 |         function get_alignment(version) {
 53 |             var result = [];
 54 |             var step = 28 - (Math.floor(168 / (version + 7)) & 0xfe);
 55 | 
 56 |             var i = 4 * version + 10;
 57 |             do {
 58 |                 result.unshift(i);
 59 |                 i -= step;
 60 |             } while (i > 6);
 61 |             result.unshift(6);
 62 |             return result;
 63 |         }
 64 |         var alignment = get_alignment(info.version);
 65 | 
 66 |         function is_data(x, y) {
 67 |             if ((x == 6) || (y == 6)) return true;
 68 |             if ((x < 9) && (y < 9)) return true;
 69 |             if ((x < 9) && (y > info.dimension - 9)) return true;
 70 |             if ((x > info.dimension - 9) && (y < 9)) return true;
 71 |             if (info.version > 6) {
 72 |                 if ((x < 7) && (y > info.dimension - 12)) return true;
 73 |                 if ((x > info.dimension - 12) && (y < 7)) return true;
 74 |             }
 75 |             var max = alignment.length;
 76 |             for (var i = 0; i < max; i++) {
 77 |                 for (var j = 0; j < max; j++) {
 78 |                     if ((i === 0 && (j === 0 || j == max - 1)) || (i == max - 1 && j === 0)) {
 79 |                         continue;
 80 |                     }
 81 |                     if ((Math.abs(x - alignment[i]) < 3) && (Math.abs(y - alignment[j]) < 3)) {
 82 |                         return true;
 83 |                     }
 84 |                 }
 85 |             }
 86 |             return false;
 87 |         }
 88 | 
 89 |         function get_codewords(count) {
 90 |             var result = [];
 91 | 
 92 |             var up = true;
 93 |             var bits = 0;
 94 |             var byte = 0;
 95 |             for (var x = info.dimension - 1; x > 0; x -= 2) {
 96 |                 if (x == 6) x--;
 97 |                 for (var z = 0; z < info.dimension; z++) {
 98 |                     var y = up ? info.dimension - z - 1 : z;
 99 |                     for (var col = 0; col < 2; col++) {
100 |                         if (!is_data(x - col, y)) {
101 |                             bits++;
102 |                             byte <<= 1;
103 |                             if (databit(x - col, y)) {
104 |                                 byte |= 1;
105 |                             }
106 |                             if (bits == 8) {
107 |                                 result.push(byte);
108 |                                 bits = 0;
109 |                                 byte = 0;
110 |                                 if (--count === 0) {
111 |                                     return result;
112 |                                 }
113 |                             }
114 |                         }
115 |                     }
116 |                 }
117 |                 up = !up;
118 |             }
119 |             return result;
120 |         }
121 | 
122 |         /* beautify preserve:start */
123 |         var blocks = [[
124 |         // Medium
125 |             null, [1, 16], [ 1, 28], [ 1, 44], [ 2, 64], [ 2, 86], [ 4, 108], [ 4, 124],
126 |             [ 4, 154], [ 5, 182], [ 5, 216], [ 5, 254], [ 8, 290], [ 9, 334],
127 |             [ 9, 365], [ 10, 415], [ 10, 453], [ 11, 507], [ 13, 563], [ 14, 627],
128 |             [ 16, 669], [ 17, 714], [ 17, 782], [ 18, 860], [ 20, 914], [ 21, 1000],
129 |             [ 23, 1062], [ 25, 1128], [ 26, 1193], [ 28, 1267], [ 29, 1373],
130 |             [ 31, 1455], [ 33, 1541], [ 35, 1631], [ 37, 1725], [ 38, 1812],
131 |             [ 40, 1914], [ 43, 1992], [ 45, 2102], [ 47, 2216], [ 49, 2334]
132 |         ],[
133 |         // Low
134 |             null, [ 1, 19], [ 1, 34], [ 1, 55], [ 1, 80], [ 1, 108], [ 2, 136],
135 |             [ 2, 156], [ 2, 194], [ 2, 232], [ 4, 274], [ 4, 324], [ 4, 370],
136 |             [ 4, 428], [ 4, 461], [ 6, 523], [ 6, 589], [ 6, 647], [ 6, 721],
137 |             [ 7, 795], [ 8, 861], [ 8, 932], [ 9, 1006], [ 9, 1094], [ 10, 1174],
138 |             [ 12, 1276], [ 12, 1370], [ 12, 1468], [ 13, 1531], [ 14, 1631],
139 |             [ 15, 1735], [ 16, 1843], [ 17, 1955], [ 18, 2071], [ 19, 2191],
140 |             [ 19, 2306], [ 20, 2434], [ 21, 2566], [ 22, 2702], [ 24, 2812],
141 |             [ 25, 2956]
142 |         ],[
143 |         // High
144 |             null, [ 1, 9], [ 1, 16], [ 2, 26], [ 4, 36], [ 4, 46], [ 4, 60], [ 5, 66],
145 |             [ 6, 86], [ 8, 100], [ 8, 122], [ 11, 140], [ 11, 158], [ 16, 180],
146 |             [ 16, 197], [ 18, 223], [ 16, 253], [ 19, 283], [ 21, 313], [ 25, 341],
147 |             [ 25, 385], [ 25, 406], [ 34, 442], [ 30, 464], [ 32, 514], [ 35, 538],
148 |             [ 37, 596], [ 40, 628], [ 42, 661], [ 45, 701], [ 48, 745], [ 51, 793],
149 |             [ 54, 845], [ 57, 901], [ 60, 961], [ 63, 986], [ 66, 1054], [ 70, 1096],
150 |             [ 74, 1142], [ 77, 1222], [ 81, 1276]
151 |         ],[
152 |         // Quater
153 |             null, [1, 13], [ 1, 22], [ 2, 34], [ 2, 48], [ 4, 62], [ 4, 76], [ 6, 88],
154 |             [ 6, 110], [ 8, 132], [ 8, 154], [ 8, 180], [ 10, 206], [ 12, 244],
155 |             [ 16, 261], [ 12, 295], [ 17, 325], [ 16, 367], [ 18, 397], [ 21, 445],
156 |             [ 20, 485], [ 23, 512], [ 23, 568], [ 25, 614], [ 27, 664], [ 29, 718],
157 |             [ 34, 754], [ 34, 808], [ 35, 871], [ 38, 911], [ 40, 985], [ 43, 1033],
158 |             [ 45, 1115], [ 48, 1171], [ 51, 1231], [ 53, 1286], [ 56, 1354],
159 |             [ 59, 1426], [ 62, 1502], [ 65, 1582], [ 68, 1666]
160 |         ]];
161 |         /* beautify preserve:end */
162 | 
163 |         var counts = blocks[info.ecl][info.version];
164 | 
165 |         var words = get_codewords(counts[1]);
166 | 
167 |         // var [ c, all ] = counts;
168 |         var c = counts[0];
169 |         var all = counts[1];
170 |         tmp = [];
171 |         for (i = 0; i < c; i++) {
172 |             tmp.push([]);
173 |         }
174 |         var remain = all % c;
175 |         for (i = 0; i < all - remain; i++) {
176 |             tmp[i % c].push(words[i]);
177 |         }
178 |         for (i = remain; i > 0; i--) {
179 |             tmp[c - i].push(words[all - i]);
180 |         }
181 |         blocks = [];
182 |         for (i = 0; i < c; i++) {
183 |             blocks = blocks.concat(tmp[i]);
184 |         }
185 | 
186 |         var cursor = 0;
187 | 
188 |         function getbits(count) {
189 |             var result = 0;
190 |             while (count > 0) {
191 |                 var tmp = Math.min(count, (8 - (cursor & 0x7)));
192 |                 result = (result << tmp) | ((blocks[cursor >> 3] >> (8 - (cursor & 0x7) - tmp)) & ((1 << tmp) - 1));
193 |                 cursor += tmp;
194 |                 count -= tmp;
195 |             }
196 |             return result;
197 |         }
198 | 
199 |         function getbytes() {
200 |             var count;
201 |             if (info.version < 10) {
202 |                 count = getbits(8);
203 |             } else {
204 |                 count = getbits(16);
205 |             }
206 |             var result = "";
207 |             while (count--) {
208 |                 result += String.fromCharCode(getbits(8));
209 |             }
210 |             return result;
211 |         }
212 | 
213 |         var results = [];
214 |         while (cursor / 8 < blocks.length) {
215 |             var encoding = getbits(4);
216 |             if (encoding === 0) {
217 |                 return results;
218 |             } else if (encoding == 4) {
219 |                 results.push(getbytes());
220 |             } else {
221 |                 return results;
222 |             }
223 |         }
224 | 
225 |         return results;
226 |     }
227 | 
228 |     return decode(qr);
229 | }
230 | 


--------------------------------------------------------------------------------
/tools/updatedb.js:
--------------------------------------------------------------------------------
1 | function(context, args) {
2 |     // Query the database.
3 |     //var insert = #db.i({ test: "test" });
4 |     var result = #db.f().array;
5 |     return result;
6 | }
7 | 


--------------------------------------------------------------------------------
/tools/upgrade_log.js:
--------------------------------------------------------------------------------
 1 | function(context, args) {
 2 |     var log = #s.sys.upgrade_log();
 3 | 
 4 |     INCLUDE(stdlib);
 5 |     INCLUDE(dtr);
 6 |     INCLUDE(parse_timestr);
 7 |     INCLUDE(nfo_user);
 8 |     INCLUDE(fmt_user);
 9 |     INCLUDE(fmt_date);
10 |     INCLUDE(fmt_upgrade);
11 | 
12 |     var result = [];
13 | 
14 |     stdlib.each(log, function(_, line) {
15 |         var entry = { line: line };
16 |         var match = line.match(/^(\d{6}\.\d{4})\s+(.*)$/);
17 |         if (match) {
18 |             entry.date = parse_timestr(match[1]);
19 |             entry.line = line = match[2];
20 |         }
21 |         match = line.match(/\s+(from|to)\s+(\w+)$/);
22 |         if (match) {
23 |             entry.counterpart = nfo_user(match[2]);
24 |             entry.direction = (match[1] == 'to' ? '<' : '>');
25 |         }
26 |         match = line.match(/^`(\d)(\w+)`\s+\((\w+)\)\s+/);
27 |         if (match) {
28 |             entry.upgrade = {
29 |                 rarity: +match[1],
30 |                 name: match[2],
31 |                 sn: match[3]
32 |             };
33 |         }
34 |         result.push(entry);
35 |     });
36 | 
37 |     if (context.is_scriptor || context.calling_script) {
38 |         return result;
39 |     }
40 | 
41 |     var titles = [
42 |         { name: "+date+", key: "date", func: fmt_date },
43 |         { name: "+counterpart+", key: "counterpart", func: fmt_user },
44 |         { name: "", key: "direction" },
45 |         { name: "+upgrade+", key: "upgrade", func: fmt_upgrade }
46 |     ];
47 | 
48 |     return {
49 |         ok: true,
50 |         msg: dtr.columns(result, titles, { pre: "", suf: "" }, true)
51 |     };
52 | }
53 | 


--------------------------------------------------------------------------------