typed-adventureland
Version:
Strong TypeScript declarations for the game AdventureLand
654 lines (653 loc) • 28.8 kB
TypeScript
import { CharacterEntity } from "./entities/character-entity";
import { MonsterEntity } from "./entities/monster-entity";
import { SlotType, TradeSlotType } from "./entities/slots";
import { Entity } from "./entity";
import { ItemInfo } from "./items";
import { IPosition, PositionReal, PositionSmart, ICoordReal } from "./position";
import { EventKey } from "./types/GTypes/events";
import { BoosterKey, ItemKey } from "./types/GTypes/items";
import { MapKey } from "./types/GTypes/maps";
import { MonsterKey } from "./types/GTypes/monsters";
import { NpcKey } from "./types/GTypes/npcs";
import { SkillKey } from "./types/GTypes/skills";
import { BetterUXWrapper } from "./types/GTypes/utils";
export interface CanStackArgs {
/** If true, will ignore the pvp flag. For an example, see bank_store. */
ignore_pvp?: boolean;
}
export {};
declare global {
function get_characters(): OnlineCharacter[];
function is_monster(entity: Entity): entity is MonsterEntity;
function is_character(entity: Entity): entity is CharacterEntity;
function resolving_promise<T>(data: T): Promise<T>;
function sleep(ms: number): Promise<void>;
function calculate_item_value(item: ItemInfo, m?: number): number;
function open_stand(inventoryIndex?: number): Promise<any>;
function close_stand(): Promise<any>;
function get_party(): Record<string, PartyCharacter>;
function is_object(arg: unknown): boolean;
function destroy(itemSlot: number): Promise<{
success: boolean;
place: "destroy";
}>;
/**
* Moves the item at slot `slot` to slot `destSlot`.
* Combines into slot `destSlot` if possible.
* @param destSlot If combination is possible, items will end up here.
* @param slot Second slot to swap/combine.
*/
function swap(destSlot: number, slot: number): Promise<unknown>;
/**
* Created a new item instance (ALWAYS) with exactly `count` items
* taken from the slot `slot`.
* @param slot Slot to split.
* @param count How many items should be in the new slot.
*/
function split(slot: number, count: number): Promise<unknown>;
/** Shuffles the elements of the array. */
function shuffle<T>(arr: Array<T>): Array<T>;
/** Sends a message in chat. */
function say(message: string): void;
function unmap_key(key: string): void;
function map_key(key: string, thing: string, arg?: string): void;
function load_code(nameOrSlot: string | number, onerror?: any): void;
/**
* Accept a magiport request from a mage
* @param name The name of the mage offering a magiport
*/
function accept_magiport(name: string): void;
/**
* Accept the party invititation of another character (i.e. join their party)
* @param name The name of the character offering a party invite
*/
function accept_party_invite(name: string): void;
/**
* Accept the request of another character to join your party (i.e. let them join your party)
* @param name The name of the character to allow in to your party
*/
function accept_party_request(name: string): void;
/**
* Activate an item (likely a booster)
* @param inventoryPosition The position of the item in your inventory
*/
function activate(inventoryPosition: number): void;
/**
* Attack another monster or a player with your normal attack
* @param target The target entity to attack (`parent.entities`)
* @returns A promise containing information about the attack, such as the projectile, or a promise cointaining the error why the attack didn't work
*/
function attack(target: Entity): Promise<any>;
/**
* Buy an item from an NPC. This function can buy things with gold or shells.
* @param item The name of the item you wish to purchase (`G.items`)
* @param quantity How many items to buy. The default is to buy one item
*/
function buy(item: ItemKey, quantity?: number): Promise<{
cost: number;
num: number;
name: ItemKey;
q: number;
success: true;
response: "buy_success";
place: "buy";
}>;
/**
* Buy an item from an NPC using only gold. If you want to buy things with shells, use `buy_with_shells`.
* @param item The name of the item you wish to purchase (`G.items`)
* @param quantity How many items to buy. The default is to buy one item
*/
function buy_with_gold(item: ItemKey, quantity?: number): Promise<any>;
/**
* Buy an item from an NPC using only shells. If you want to buy things with gold, use `buy_with_gold`
* @param item The name of the item you wish to purchase (`G.items`)
* @param quantity How many items to buy. The default is to buy one item
*/
function buy_with_shells(item: ItemKey, quantity?: number): Promise<any>;
/**
* Check if you can attack the given target. This function also checks status conditions by calling `parent.is_disabled(character)` which checks statuses such as `rip` and `stunned`.
* NOTE: If you just want to check the cooldown, consider using `is_on_cooldown("attack")`
* @param target The target entity to check if you can attack (`parent.entities`)
* @returns TRUE if the target is attackable, FALSE otherwise.
*/
function can_attack(target: Entity): boolean;
/**
* Check if you can heal the given target.
* @param target The target entity to check if you can heal (`parent.entities`)
*/
function can_heal(target: Entity): boolean;
/**
* Checks if the given entity can transport. If given your own character, it will also check if you are already transporting
* @param entity The entity to check
* @returns TRUE if you are not currently transporting, and can transport, FALSE otherwise
*/
function can_transport(entity: Entity): boolean;
/**
* Checks if the skill is usable by the given character. Also checks if the given skill is on cooldown.
* @param skill The skill to check
* @param returns TRUE if not on cooldown, FALSE otherwise.
*/
function can_use(skill: SkillKey): boolean;
function can_stack(itemA: ItemInfo, itemB: ItemInfo, additionalQuantity?: number, args?: CanStackArgs): boolean;
/**
* Quick check to see if you can use the door.
* This can return false positives, so you should check `can_use_door` if this returns true.
* @param map A given map (from `G.maps`)
* @param door The given door (from `G.maps[map].doors`)
* @param x The x position on the map
* @param y The y position on the map
* @returns TRUE if the door can be used from the given position, FALSE otherwise
*/
function is_door_close(map: MapKey, door: DoorInfo, x: number, y: number): boolean;
/**
* Checks if you can use the given door from the given position
* This function is costly, so only check when is_door_close is true.
* @param map A given map (from `G.maps`)
* @param door The given door (from `G.maps[map].doors`)
* @param x The x position on the map
* @param y The y position on the map
* @returns TRUE if the door can be used from the given position, FALSE otherwise
*/
function can_use_door(map: MapKey, door: DoorInfo, x: number, y: number): boolean;
/**
* Formats a floating number to a pretty string.
*
* @param num The number to format
*
* @returns A pretty string
*
* @example to_pretty_float(123456.789) // "123,456.78"
*/
function to_pretty_float(num: number): string;
/**
* Formats a number to a pretty string.
*
* @param num The number to format
*
* @returns A pretty string
*
* @example to_pretty_num(123456.789) // "123,456"
*/
function to_pretty_num(num: number): string;
/**
* Formats a number to a pretty string, with a given edge.
* The number will only be formatted if it's greater than or equal to the edge.
*
* @param num The number to format
* @param edge The edge to decide whether to format or not (default: 10000)
*
* @returns A pretty string
*
* @example to_pretty_num(123456.789, 100000) // "123,456"
* @example to_pretty_num(1234.789, 10000) // "1234.789"
*/
function smart_num(num: number, edge?: number): string;
/**
* Shrinks a number to its nearest unit.
* The thresholds are:
* - 1e3 (K)
* - 1e6 (M)
* - 1e9 (B)
* - 1e12 (T)
* @param num The number to shrink
*
* @returns A string with the number and its unit
*
* @example to_shrinked_num(123456.789) // "123K"
* @example to_shrinked_num(1234567) // "1.2M"
*/
function to_shrinked_num(num: number): string;
/**
* Changes the target of the player. Use in association with `get_targeted_monster()`.
* @param target A given target (from `parent.entities`)
*/
function change_target(target?: Entity): void;
/**
* Clears all drawings from the window. Use this function to clean up `draw_circle` and `draw_line`.
*/
function clear_drawings(): void;
/**
* Runs the given code snippet for the given character.
* @param character The name of the character
* @param code The code snippet to run (using eval)
*/
function command_character(character: string, code: string): void;
/**
* Compounds the three items for a chance at obtaining 1 higher level item of the same kind.
* @param itemSlot1 The inventory position of the first item
* @param itemSlot2 The inventory position of the second item
* @param itemSlot3 The inventory position of the third item
* @param scrollSlot The inventory position of the scroll to use to combine the three items
* @param offeringSlot The inventory position of the offering (e.g. Primordial Essence) to use
* @param onlyCalculate If set to true, no action if performed and the success chance is returned.
*/
function compound(itemSlot1: number, itemSlot2: number, itemSlot3: number, scrollSlot: number, offeringSlot?: number | null, onlyCalculate?: false): Promise<BetterUXWrapper<CompoundSuccessResponse | CompoundFailureResponse>>;
function compound(itemSlot1: number, itemSlot2: number, itemSlot3: number, scrollSlot: number, offeringSlot: number | null | undefined, onlyCalculate: true): Promise<CompoundCalculateResponse>;
export type CompoundSuccessResponse = {
success: boolean;
level: number;
num: number;
};
export type CompoundCalculateResponse = {
calculate: boolean;
chance: number;
item: ItemInfo;
scroll: string;
grace: number;
success: boolean;
response: string;
place: string;
};
export type CompoundFailureResponse = {
reason: string;
};
/**
* Consumes the given item (e.g. Candy Pop)
* @param item The inventory position of the item
*/
function consume(item: number): void;
export type CraftSuccessResponse = {
num: number;
name: ItemKey;
success: true;
response: "craft";
place: "craft";
};
export type CraftFailureResponse = {
failed: true;
reason: string;
};
/**
* Crafts the given item if you can craft that item, you have the required items, and you have enough gold.
* @param name The name of the item to craft (`G.craft`)
*/
function auto_craft(name: ItemKey): Promise<BetterUXWrapper<CraftSuccessResponse | CraftFailureResponse>>;
/**
* Crafts the given items. Note: Some recipes might require gold to craft, too.
* @param item0 The inventory position of the item to be put in the top left crafting slot
* @param item1 The inventory position of the item to be put in the top middle crafting slot
* @param item2 The inventory position of the item to be put in the top right crafting slot
* @param item3 The inventory position of the item to be put in the center left crafting slot
* @param item4 The inventory position of the item to be put in the center middle crafting slot
* @param item5 The inventory position of the item to be put in the center right crafting slot
* @param item6 The inventory position of the item to be put in the bottom left crafting slot
* @param item7 The inventory position of the item to be put in the bottom middle crafting slot
* @param item8 The inventory position of the item to be put in the bottom right crafting slot
*/
function craft(item0: number, item1?: number, item2?: number, item3?: number, item4?: number, item5?: number, item6?: number, item7?: number, item8?: number): Promise<BetterUXWrapper<CraftSuccessResponse | CraftFailureResponse>>;
/**
* Overrides the character to walk at `Math.min(parent.character.speed, cruise_speed)` speed.
* @param speed The speed at which to walk at
*/
function cruise(speed: number): void;
/** Feed this function a value like (character.apiercing - target.armor) and it spits out a multiplier so you can adjust your expected damage */
function damage_multiplier(difference: number): number;
function distance(from: IPosition | PositionReal, to: IPosition | PositionReal): number;
function equip(inventoryPostion: number, slot?: SlotType): Promise<unknown>;
function dismantle(inventoryPostion: number): Promise<unknown>;
/**
* Will html_escape the message before displaying it.
* If the message is an object, it will be stringified.
* @param message The string or object with potential html that should be escaped.
* @param color Can be used to override the color of the message. Any CSS color is fine.
*
* @see game_log if you want to print text as-is.
* @see log if you don't want to escape the text but still stringify objects.
*/
function safe_log(message: any, color?: string): void;
/**
* Displays a log message in the game log. This is not the chat and other players can't see it.
* @param message The message that will be printed. Should NOT contain html.
* @param color Can be used to override the color of the message. Any CSS color is fine.
*
* @warning This function won't escape html. See `safe_log` if you want to log unsafe data.
*
* @see safe_log if you want to escape a string or object that might contain html.
* @see log if you want to stringify an object.
*/
function game_log(message: any, color?: string): void;
/**
* Displays a string in the game logs. If the message is an object, it will be stringified.
*
* @param message A string or an object that should be stringified.
* @param color Can be used to override the color of the message. Any CSS color is fine.
*
* @see game_log if you want to print text as-is.
* @see safe_log if you want to escape a string or object that might contain html.
*/
function log(message: any, color?: string): void;
/**
* Retrieves a value stored in localstorage.
* @param key The key to retrieve.
*/
function get<T>(key: string): T;
function get_targeted_monster(): MonsterEntity | null;
function get_target(): CharacterEntity | Entity | null;
function get_target_of(entity: Entity): Entity | null;
function get_player(name: string): CharacterEntity;
function get_nearest_monster(args: {
/**
* Maximum attack the monster should have.
*/
max_att?: number;
/**
* Minimum XP the monster should give.
*/
min_xp?: number;
/**
* Only return monsters that target this "name" or player object
*/
target?: string | {
name: string;
};
/**
* Only pick monsters that don't have any target.
*/
no_target?: boolean;
/**
* Checks if the character can move to the target.
*/
path_check?: boolean;
/**
* Type of the monsters, for example "goo", can be referenced from `show_json(G.monsters)`.
*
* @since [08/02/17]
*/
type?: string;
}): MonsterEntity | null;
function heal(target: Entity): any;
function use_hp_or_mp(): void;
/** Checks whether or not we can attack other players */
function is_pvp(): boolean;
function is_in_range(entity: Entity, skill?: SkillKey): boolean;
function is_transporting(entity: Entity): boolean;
function is_moving(entity: Entity): boolean;
function is_on_cooldown(skill: string): boolean;
/** returns true if you are silenced or disabled */
function is_silenced(entity: Entity): boolean;
/** returns true if you are dead, stunned, fingered, stoned, deepfreezed or sleeping */
function is_disabled(entity: Entity): boolean;
/**
* If no ID is given, it will loot some chests.
* @param id The ID of a chest (from `parent.chests`)
*/
function loot(id?: string): Promise<any>;
function mssince(date: Date): number;
function reduce_cooldown(skill: SkillKey, ms: number): void;
function respawn(): any;
/** Quantity defaults to 1 if not set */
function sell(inventoryPostion: number, quantity?: number): any;
function send_cm(to: string | string[], data: any): any;
function send_gold(to: string | {
name: string;
}, amount: number): any;
function send_item(to: string | {
name: string;
}, inventoryPostion: number, quantity?: number): Promise<BetterUXWrapper<{
response: "item_sent";
/** Character you sent the item to */
name: string;
/** Item you sent */
item: ItemKey;
/** Quantity sent */
q: number;
/** Slot the item you sent was in */
num: number;
place: "send";
success: true;
} | {
response: string;
reason: string;
failed: true;
place: "send";
}>>;
function send_local_cm(to: string, data: any): any;
/**
*
* @param to player name
* @param subject
* @param message
* @param item // 0th slot is sent
*/
function send_mail(to: string, subject: string, message: string, item: boolean): any;
/**
*
* @param name name could be a player object, name, or id
* @param isRequest If isRequest is set to true, it will send a party request
*/
function send_party_invite(name: any, isRequest?: boolean): any;
function send_party_request(name: string): any;
function leave_party(): Promise<void>;
function get_active_characters(): {
[characterName: string]: "self" | "starting" | "loading" | "active" | "code";
};
/**
* Renders the object as json inside the game.
* @param value Whatever you want to display.
*/
function show_json(value: any): void;
function set(key: string, value: unknown): unknown;
function set_message(text: string, color?: string): any;
function simple_distance(from: IPosition | PositionReal, to: IPosition | PositionReal): number;
function start_character(characterName: string, codeSlotOrName?: string | number): any;
/** stops moving, or channeled actions */
function stop(action?: string): any;
function stop_character(name: string): any;
/** For buying things off players' merchants */
function trade_buy(target: Entity, trade_slot: TradeSlotType, quantity?: number): any;
/** For selling things to player merchants */
function trade_sell(target: Entity, trade_slot: TradeSlotType, quantity?: number): any;
function transport(map: MapKey, spawn?: number): any;
function unequip(slot: SlotType | TradeSlotType): any;
/** Used to leave jail, cyberland and maybe others. */
function leave(): Promise<unknown>;
function upgrade(item_slot: number, scroll_slot: number, offering_slot?: number | null, only_calculate?: false): Promise<{
success: boolean;
level: number;
stat?: boolean;
stat_type?: string;
/** Slot index */
num: number;
}>;
function upgrade(item_slot: number, scroll_slot: number, offering_slot: number | null | undefined, only_calculate: true): Promise<{
success: boolean;
level: number;
/** Success chance */
chance: number;
stat?: boolean;
stat_type?: string;
/** Slot index */
num: number;
}>;
function exchange(item_slot: number): Promise<{
success: boolean;
/** Slot index */
num: number;
/** The item obtained from the exchange. Can be undefined if gold or nothing. */
reward?: ItemKey;
}>;
/**
* Lists an item as selling in the merchant stand.
* @param inventoryPosition
* @param tradeSlot
* @param price
* @param quantity
*/
function trade(inventoryPosition: number, tradeSlot: number | TradeSlotType, price: number, quantity: number): unknown;
/**
* Lists an item as wanted in the merchant stand.
* @param slot
* @param name
* @param price
* @param q
* @param level
*/
function wishlist(slot: TradeSlotType | number, name: ItemKey, price: number, level?: number, q?: number): unknown;
/**
* Will start a giveaway where characters can enlist in hope of getting the item.
* @param slot Giveaway slot to add the item into.
* @param inventoryPosition Inventory slot of the item to giveaway.
* @param q Quantity to giveaway.
* @param minutes How long the giveaway should last.
*/
function giveaway(slot: number, inventoryPosition: number, q: number, minutes: number): unknown;
/**
* Joins a giveaway for the specified item
* @param characterName Name of the character you want to join the giveaway of
* @param slot_name Trade slot containing the item you want to join the giveaway of
* @param rid Unique id of the item you want to join the giveaway of
*/
function join_giveaway(characterName: string, slot_name: TradeSlotType, rid: string): unknown;
export type ShiftResult = {
name: BoosterKey;
success: boolean;
response: "data";
place: "booster";
};
/**
* Will change the type of the booster to the specified one.
* @param inventoryPosition Inventory slot of the booster to shift.
* @param toBooster Type the booster should be of.
*/
function shift(inventoryPosition: number, toBooster: BoosterKey): Promise<ShiftResult>;
function join(eventName: EventKey): Promise<any>;
/**
* MOVEMENT METHODS
*/
/**
* returns the position of the npc with the specified id, the first map it encounters with the npc is returned, it does not priortize your current map.
* @param id The key of the npc from G.npcs
*/
function find_npc(id: NpcKey): IPosition;
/** This function uses move() if it can, otherwise it uses smart_move() */
export function xmove(entity: PositionReal): Promise<boolean>;
export function xmove(x: number, y: number): Promise<boolean>;
/**
* It validates against the map geometry from G.geometry doing 2d "raycasting" to see if we will hit a wall if we go in a straight line
* Checks if the you can move from `[position.x, position.y] to [position.going_x, position.going_y]
* @param entity The moveable entity you want to check is movable
* @returns TRUE if you can move there, FALSE otherwise
*/
export function can_move(position: IPosition & {
going_x: number;
going_y: number;
base?: {
h: number;
v: number | null;
vn: number;
};
}): boolean;
/**
* Checks if you can move your character to the given destination on your current map from your current position
* @param destination A position object containing the destination coordinates
* @returns TRUE if you can move there, FALSE otherwise
*/
export function can_move_to(destination: ICoordReal): boolean;
/**
* Checks if you can move your character to the given destination on your current map
* @param x The x-coordinate that you want to move to
* @param y The y-coordinate that you want to move to
* @returns TRUE if you can move there, FALSE otherwise
*/
export function can_move_to(x: number, y: number): boolean;
export type MoveFailureResponse = {
reason: string | "unable" | "interrupted";
};
/**
* The promise returned is not upon arrival at the destination, it's upon the server confirming it recieved your request.
* @param x
* @param y
*/
export function move(x: number, y: number): Promise<MoveResponse>;
export type MoveResponse = void | MoveFailureResponse;
export type SmartMoveMapPosition = "town" | "upgrade" | "exchange" | "potions" | "scrolls" | "compound";
export type SmartMoveToDestination = NpcKey | IPosition | MapKey | MonsterKey | SmartMoveMapPosition;
export type SmartMoveSuccess = {
success: true;
};
export type SmartMoveFailure = {
success: false;
reason: string | "invalid";
};
export type SmartMoveResponse = SmartMoveSuccess | SmartMoveFailure;
export function smart_move(destination: SmartMoveToDestination | {
to: SmartMoveToDestination;
return?: boolean;
},
/**
* a callback function with true or false ad the argument depending on smart_move success or failure
* @deprecated on_done function is an old callback function for compatibility, smart_move also returns a Promise [25/03/20]
*/
on_done?: () => Promise<void | boolean>): Promise<SmartMoveResponse>;
/**
* Checks if the given entity can walk (i.e. move). If given your own character, it will also check if you are already transporting.
* @param entity The entity to check
* @returns TRUE if you are not currently transporting, and can walk, FALSE otherwise
*/
export function can_walk(entity: Entity): boolean;
/** Contains information about smart_move() */
let smart: IPosition & {
/** If searching and false, we are still searching. If */
found: boolean;
/** If .moving == true, we are moving or searching */
moving: boolean;
plot: PositionSmart[];
/** If ().moving == false && .searching == true), we are searching for a path. */
searching: boolean;
start_x: number;
start_y: number;
/** A settable flag. If true, smart_move will use town teleports to move around */
use_town: boolean;
};
}
/**
* Contains elements that describe a door
* [0]: The x-position of the door
* [1]: The y-position of the door
* [2]: The width of the door
* [3]: The height of the door
* [4]: The map that this door leads to (use in combination with [5] (spawn))
* [5]: The spawn that this door leads to (use in combination with [4] (map))
* [6]: The spawn that this door is close to on the current map
* [7]: ??? Maybe "locked" or "ulocked"?
* [8]: ??? There's reference to "complicated" in smart_move?
*/
export type DoorInfo = [number, number, number, number, MapKey, number?, number?, string?, string?];
export interface OnlineCharacter {
x: number;
y: number;
map: MapKey;
in: string;
name: string;
level: number;
skin: string;
server: string;
secret: string;
cx?: {
head?: string;
hair?: string;
};
online: number;
type: string;
id: string;
}
export interface PartyCharacter {
x: number;
y: number;
map: MapKey;
in: string;
skin: string;
level: number;
type: string;
/** This number refers to the percent of gold you get when one of the party members loots a chest */
share: number;
pdps: number;
l: number;
xp: number;
luck: number;
gold: number;
cx?: {
head?: string;
hair?: string;
};
}