Kolmafia - User contributions [en]

Pulls remaining

2011-07-07T16:20:29Z

That FN Ninja: pulls_remaining returns -1 if you can_interact()

{{
#vardefine:name|pulls_remaining}}{{
#vardefine:return_type|int}}{{

FunctionPage|
name={{#var:name}}|

function1={{Function|
name={{#var:name}}|
aggregate={{#var:aggregate}}|
return_type={{#var:return_type}}|
return_also={{#var:return_also}}|
}}|

function_description=Returns the number of pulls remaining for the day for characters in-Ronin, 0 if you are in hardcore, and -1 otherwise.|

code1={{CodeSample|
title=Code Sample|
description=The following checks to see if you've forgotten to use up your daily pulls.|
code=
<syntaxhighlight>
if (pulls_remaining() > 0) {
print("You still have " + pulls_remaining() + " pulls you can make today.");
} else {
print("You're all set on daily pulls.");
}
</syntaxhighlight>}}|
special=Returns 0 when not logged in.
}}

[[Category:Item Management]]

Talk:CLI Reference

2010-07-15T16:10:58Z

That FN Ninja:

should we add that Csend will add make it's own message to the recipient if it is not given?--[[User:Icon315|Icon315]] 21:47, 21 April 2010 (UTC)
:That's the kind of detail that should go on it's own page if the command is important enough to get its own page. --[[User:Bale|Bale]] 01:03, 22 April 2010 (UTC)

I agree with Bale. My thoughts so far on CLI commands;
* Obvious stuff that anyone can figure out by looking at this table doesn't warrant it's own page.
* Stuff that behaves ''exactly'' the same as an ASH command should probably say so and link to the function page
** If it isn't ''exactly'' the same, but close enough that a line or two of explanation will clarify the difference, still link to the function but edit the function's CLI section to explain the difference.
** Said functions don't need their own pages
* Stuff that has a similar or identically named ASH function, but behaves ''significantly'' differently on the CLI, should have it's own page (with the command as a link).
** If the command names are the same, the cli command should be "command (CLI)" (ie "eat (CLI)", if eat needed its own page)
** If the command has no ASH function with the same name, the "(CLI)" part can be omitted (we can always move a page later if an ASH equiv. is added)
* Create page names with alphanumeric characters when at all possible. Ie don't use "!" but rather "bang"

All additional thoughts on this are welcome. --[[User:StDoodle|StDoodle (#1059825)]] 03:17, 22 April 2010 (UTC)

: My thought is that you've covered everything perfectly. This should be our bible for CLI pages. --[[User:Bale|Bale]] 03:38, 22 April 2010 (UTC)

Bale recently explained a limitation with the acquire command that I was previously unaware of in [http://kolmafia.us/showthread.php?4575 this thread]. Perhaps acquire needs it's own page to account for this information? --[[User:That FN Ninja|That FN Ninja]] 16:10, 15 July 2010 (UTC)

==FYI==

You can't simply copypasta stuff into these wiki tables; remember, the pipe character (<nowiki>|</nowiki>) is treated special in templates! Use <nowiki>{{!}}</nowiki> instead, or <nowiki><nowiki></nowiki>''Stuff''<nowiki></</nowiki><nowiki>nowiki></nowiki> tags. (P.S. You should see the source for this fyi...) This, by the way, is the reason a lot of parameter options appear to be missing. --[[User:StDoodle|StDoodle (#1059825)]] 03:26, 22 April 2010 (UTC)

Ugh, what a mess. Sometimes, <nowiki>{{!}}</nowiki> results in a <nowiki><pre></nowiki> tag or something inside of wiki tables. On the other hand, similar FUBARS happen when using <nowiki>&#124;</nowiki> ''outside'' of tables on a wiki. Long story short; inside of a table, use <nowiki>&#124;</nowiki> for <nowiki>|</nowiki> and outside of a table use <nowiki>{{!}}</nowiki>. Messy enough for you? --[[User:StDoodle|StDoodle (#1059825)]] 03:59, 2 May 2010 (UTC)

File talk:Item category.png

2010-07-04T19:33:27Z

That FN Ninja: KoLmafia uses tradeable spelled with an 'e'

I like the new image. Nice work. However, since the ASH function KoLmafia uses for is_tradeable() is spelled with an 'e', the image should probably use tradeable spelled with an 'e' as well for consistency and to prevent confusion. --[[User:That FN Ninja|That FN Ninja]] 19:33, 4 July 2010 (UTC)

Data Structures

2010-07-02T04:06:02Z

That FN Ninja: The "Declarations" section was listed twice. Deleted the duplicate.

{{TOCright}}

KoLmafia supports complex data structures such as maps and records made from simple [[Data Types|data types]].

== Maps ==
Most of this information was copied directly from ASH Maps Tutorial, by Veracity (http://kolmafia.sourceforge.net/advanced.html#maps)

A map is indexed by one data type (the key) and associates that key with another (or the same) data type (the value). The key can be any ASH simple data type: boolean, int, float, string, item, location, class, stat, skill, effect, familiar, slot, or monster. The value can be any ASH data type at all: a simple type, a record, or can be another map. This effectively allows multi-dimensional maps and. In fact, that's how the syntax we provide for multi-dimensional maps actually operate: maps of maps of maps ...

You can declare a map any time you can declare a variable: as a top level (global) variable, as a function parameter, or as a local variable in any scope.

You can fetch data from a map any time you can provide a data value: in an expression, as a function parameter, on the right side of an assignment statement, from a "return" statement, as so on. You can pass around entire maps, individual elements, or intermediate maps: "slices".

=== Declarations ===

The syntax for declaring the data type of a map:

<pre>
<data type> [ <key type>, ... ] <aggregate_name>
</pre>

For example:

{{CodeSample
|code=<syntaxhighlight>
string [item] map1;
float [class, string, int] another_map;
</syntaxhighlight>}}

=== Assignments ===

If you use a map on the left side of an assignment, you set the whole map at once to the new value.

{{CodeSample
|code=<syntaxhighlight>
int [item] my_pricelist;
int [item] new_pricelist;

/* Some code that updates new_pricelist */

my_pricelist = new_pricelist;
</syntaxhighlight>}}

If you specify a map and a complete set of indices (of the correct types) on the left side of an assignment statement, you set a single element.

{{CodeSample
|code=<syntaxhighlight>
int [item] my_pricelist;
my_pricelist[ $item[ pail ] ] = 1000;
</syntaxhighlight>}}

If you specify a map and a prefix of indices (of the correct type), you directly set one of the intermediate maps, a "slice".

{{CodeSample
|code=<syntaxhighlight>
float [string, int, string] my_map;
float [int, string] slice1;

/* Some code that fills slice1 */
my_map[ "slice1" ] = slice1;
</syntaxhighlight>}}

=== References ===

The syntax for referencing an element (or slice) of a map:

<pre>
<aggregate name>[ <key expression>, ... ]
</pre>

All the key expressions will be evaluated at run time. If you specify all the keys the map expects, you fetch data of the type specified by the map. If you specify fewer keys than the map expects, you get an intermediate map, a "slice".

As an example:
{{
CodeSample|
code=
<syntaxhighlight>
boolean [string, string] props;
</syntaxhighlight>}}

might be used to hold "properties" associated with names.
{{
CodeSample|
code=
<syntaxhighlight>
props[ "dog", "mammal" ] = true;
props[ "dog", "pet" ] = true;
props[ "dog", "fun" ] = false;
props[ "turtle", "mammal" ] = false;
props[ "turtle", "pet" ] = true;
props[ "turtle", "fun" ] = false;
props[ "aardvark", "mammal" ] = true;
props[ "aardvark", "pet" ] = false;
props[ "aardvark", "fun" ] = true;
</syntaxhighlight>}}

references:

<pre>
props[ "dog", "mammal"] => true
boolean [string] animal = props[ "turtle" ];
animal[ "fun" ] => false
</pre>

=== Contains ===

You can test the presence of a key in a map using the "contains" operator:

<pre>
<aggregate reference expression> contains <key expression>
</pre>

Where <aggregate reference expression> must evaluate at run time to a map or slice, and must evaluate at run time to a key of the appropriate type. (Note that that is enforced at parse time; ASH can tell the datatype any expression will produce).

<pre>
props contains "dog" => true
props contains "elephant" => false
props[ "aardvark" ] contains "fun" => true
animal contains "pet" => true
animal contains "favorite food" => false
</pre>

=== Remove ===

You can remove a key-value association from a map using the "remove" unary operator:

<pre>
remove <aggregate reference>
</pre>

For clarification, an aggregate reference is "<map name>[ <index 1> ... <index n> ]" where <map name>[ <index 1> ... <index n-1> ] specifies the "slice" and <index n> specifies the "key". Which is just what you expect, if you fully specify the indices; for a single dimensional map, "map[10]" -> "map" is the slice and 10 is the key. The "remove" operator removes the "key" from the "slice". For example:

{{CodeSample|code=<syntaxhighlight>
string [int] map1;
map1[5] = "foo";
print( count( map1 ) + " " + map1 contains 5 + " " + map1[5] );
print( "remove: " + remove map1[5] );
print( count( map1 ) + " " + map1 contains 5 + " " + map1[5] );
print( "remove: " + remove map1[5] );
int [string, string] map2;
map2["me","you"] = 17;
print( count( map2["me"] ) + " " + map2["me"] contains "you" + " " + map2["me","you"] );
print( "remove: " + remove map2["me", "you"] );
print( count( map2["me"] ) + " " + map2["me"] contains "you" + " " + map2["me","you"] );
print( "remove: " + remove map2["me", "you"] );
print( count( map2 ) + " " + map2["me"] );
print( "remove: " + remove map2["me"] );
print( count( map2 ) + " " + map2["me"] );
</syntaxhighlight>}}

yields:

<pre>
1 true foo
remove: foo
0 false
remove:
1 true 17
remove: 17
0 false 0
remove: 0
1 aggregate int [string]
remove: aggregate int [string]
0 aggregate int [string]
</pre>

=== Clear ===

You can remove all <code>key => value</code> entries from a map using the following syntax:

{{CodeSample|code=<syntaxhighlight>clear <aggregate>;</syntaxhighlight>}}

=== Sort ===

From http://kolmafia.us/showthread.php?t=1738

The syntax is:
{{CodeSample|code=<syntaxhighlight>sort aggregate by keyExpr;</syntaxhighlight>}}
<code>aggregate</code> is a reference to the object to be sorted - arrays are probably the most useful things to sort, but any mapping type can be used (even multidimensional maps, but note that you can only sort along a single dimension at a time). The reference must not be enclosed in parentheses, as that would look like a call to a function named <code>sort()</code> - which is still perfectly valid, "sort" has not become a [[Reserved Words|reserved word]].

<code>keyExpr</code> is an arbitrary expression that defines how the items should be ordered. It is evaluated once for every entry in the aggregate, in a scope with two additional variables implicitly defined: '<code>index</code>' and '<code>value</code>', holding the details of that entry. The value of the <code>keyExpr</code> is used as the sort key; typically it would be an <code>int</code> or <code>string</code>, but can be any ASH type that can be compared via "<" and the other relational operators.

The most basic form of sorting would therefore be "<code>sort ... by value</code>", but many useful things can be done with the use of a more complex <code>keyExpr</code> - the only real restriction is that the expression should not modify the object you're sorting. For example, if you had an array of items, you could sort it "<code>by autosell_price(value)</code>". An array of weapon items could be sorted "<code>by -get_power(value)</code>" to put it in decreasing order of power. If the elements of your aggregate are records, you'd need to use something like "<code>by value.fieldName</code>", since the records themselves can't be meaningfully compared.

After the sort statement, the aggregate will have exactly the same sets of keys and values as before (even if the keys weren't consecutive), and the iteration order of the keys will be the same, but the values will likely be associated with different keys. The sort is stable - in other words, elements with sort keys that compare as equal will remain in the same order. This means that you can sort on multiple criteria by simply performing separate sorts for each of the criteria, in increasing order of significance.

A few more examples of things you can do:
* "<code>by -value</code>" sorts integers in decreasing order (there's no similar trick for <code>string</code> values).
* "<code>by -index</code>" reverses the existing order of an array (or map with integer keys).
* "<code>by random(1000000)</code>" shuffles into a random order.
* "<code>by otherArray[index]</code>" uses values from a parallel array as the sort keys (you'd then need to do "<code>sort otherArray by value;</code>" if you wanted the two arrays to remain in sync).

== Records ==

(copy-pasted from Veracity's post introducing the record [http://kolmafia.us/showthread.php?t=280])

Starting with SVN revision 1311 of KoLmafia, ASH now supports a new kind of structured data: the record. Here is a little example of how you declare a record and variables of the new type you've created by doing so.

{{CodeSample|code=<syntaxhighlight>
record my_type {
int ifield;
string sfield;
record {
int first;
int second;
} rfield;
int [int, int] mfield;
};

my_type rvar;
my_type [int] mrvar;
</syntaxhighlight>}}

What I've done with the above is declare a new data type which I've named "my_type". Having declared the new type, I can use it (almost) anywhere that I can use a built-in type name. I declared a variable, "rvar", of that type, and I defined a map, "mrvar", which maps keys of type integer to values of type my_type.

The new type, "my_type" is a "composite" type. It contains four fields. "ifield" is an integer. "sfield" is a string. "rfield" is another composite field: an anonymous record containing two integers named "first" and "second". Finally, "mfield" is a map from [int, int] to int.

As you can see, a record can combine data of all the types ASH supports: primitive, aggregate, and composite.

Having defined the new data type and several variables using it, here are some examples of how to access the fields.

{{CodeSample|code=<syntaxhighlight>
rvar.ifield = 10;
rvar.sfield = "secret";
rvar.rfield.first = 1000;
rvar.sfield.second = 2000;
rvar.mfield[ 2, 3 ] = 12;

mrvar[ 1 ] = rvar;

foreach key in mrvar
foreach key1, key2 in mrvar[key].mfield
print( "val = " + mrvar[key].mfield[key1,key2] );
</syntaxhighlight>}}

As you can see, if you have a variable that is a record, you access the fields of the record by following the variable name with ".<field name>". The resulting value will be of whatever type you declared in the definition of the record. If the value is a map, you can give a list of keys within [], just like any other map. If the value is another record, you can access the fields of the nested record by using another ".<field name>".

If you are familiar with Pascal "records" or C/C++ "structs", this should all be comfortably familiar.

Finally, if you create a map whose values is a record, the file_to_map and map_to_file built-in ASH functions will Do The Right Thing; they will efficiently and reliably save and restore your data.
{{RFI|I, for one, don't have a good handle on multi-dimensional maps. Any effort to clarify how they are defined & accessed would be greatly appreciated.|Don't worry about formatting for now; I'll get to that once the info is there, unless you're feeling super-ambitious.}}
{{Format}}

[[Category:ASH Scripting]]

Talk:Adventure

2010-06-26T21:39:01Z

That FN Ninja:

jasonharper said we can supply a macro as the third parameter; any ideas on usage? KoL macros require line breaks in a picky manner, but setting my string to have "\n" doesn't work... or am I sup'd to use a macro's name? --[[User:StDoodle|StDoodle (#1059825)]] 21:21, 29 April 2010 (UTC)

:I think he means to use the macro's name. Try it. --[[User:Bale|Bale]] 21:23, 29 April 2010 (UTC)

Wow!! The wiki has come a long ways since I was last on here in December. It's beautiful! I don't know if this is the right place for this, but I think it would be helpful to have a list of special events that cause adventure to stop and return false besides conditions being satisfied. Demon name and hobo glyph are already listed, but I think there are a lot more. I don't know that many, but looking over Zarqon's MacGuffin script I saw several. I just tested out the Sietch in Time adventure. adventure(my_adventures(), $location[desert (ultrahydrated)]) stopped adventuring and returned false when I received the Sietch in Time adventure. What do you guys think?

In hardcore

2009-12-23T05:16:06Z

That FN Ninja:

[[boolean]] [[in_hardcore()]]

This function returns ''true'' if the logged-in character is currently subject to Hardcore restrictions. If not subject to such restrictions this function returns ''false''.

The following example attempts to pull items from storage if the character is in Ronin:

<code>
if (![[can_interact()]] && ![[in_hardcore()]] && [[storage_amount()|storage_amount]]($[[item]][not-a-pipe]) > 0)
[[take_storage()|take_storage]](1,$[[item]][not-a-pipe]);
</code>
[[Category:Your Character | In hardcore()]]
[[Category:Ash Functions |In hardcore()]]

When not logged in, this function returns ''false''.

My spleen use

2009-12-23T05:06:57Z

That FN Ninja: Created page with 'int my_spleen_use() Returns the logged-in character's current spleen damage as an int.'

[[int]] [[my_spleen_use()]]

Returns the logged-in character's current spleen damage as an [[int]].

Spleen limit

2009-12-23T05:05:17Z

That FN Ninja:

[[int]] [[spleen_limit()]]

Returns the logged-in character's maximum spleen damage as an [[int]]. For most characters, the returned value will be 15. The number is raised by 5 for characters with Spleen of Steel.

Spleen limit

2009-12-23T05:00:55Z

That FN Ninja:

[[int]] [[spleen_limit()]]

This function returns the logged-in character's maximum spleen amount as an [[int]].

Spleen limit

2009-12-23T05:00:10Z

That FN Ninja: Created page with 'int spleen_limit() This function returns the logged-in character's maximum fullness level as an int.'

[[int]] [[spleen_limit()]]

This function returns the logged-in character's maximum fullness level as an [[int]].

My name

2009-12-23T04:42:29Z

That FN Ninja: my_name() is not case sensative.

[[string]] [[my_name()]]

This function returns the logged-in character's name as a [[string]].

This example imports different breakfast scripts depending on which character is running the script.
<code>
if ([[my_name()]] == "zammywarrior") {
[[import]] <Zammy Morning.ash>;
}
else if ([[my_name()]] == "hippymon") {
[[import]] <Hippy Morning.ash>;
}
</code>

Note that capitalization is not strictly adhered to. When using [[my_name()]] the following examples are functionally equivalent:

<code>
if ([[my_name()]] == "That FN Ninja") {
[[comments| // code]]
}
</code>

<code>
if ([[my_name()]] == "that fn ninja") {
[[comments|// code]]
}
</code>
[[Category:Your Character | My name()]]
[[Category:Ash Functions | My name()]]

When not logged in, this function returns an empty string.