text
stringlengths 33
161k
|
|---|
plugins {
application
`maven-publish`
id("com.github.johnrengelman.shadow") version "8.1.1"
kotlin("jvm") version("1.9.21")
}
val darkanVersion: String = "1.9.0"
val ktVer: String = "1.9.21"
application {
group = "rs.darkan"
version = darkanVersion
mainClass.set("com.rs.Launcher")
}
java {
toolchain.languageVersion = JavaLanguageVersion.of(21)
}
repositories {
mavenLocal()
mavenCentral()
maven("https://gitlab.com/api/v4/projects/42379000/packages/maven")
}
dependencies {
implementation("rs.darkan:core:1.6.8")
implementation("org.jetbrains.kotlin:kotlin-stdlib:$ktVer")
implementation("org.jetbrains.kotlin:kotlin-stdlib-common:$ktVer")
implementation("org.jetbrains.kotlin:kotlin-scripting-common:$ktVer")
implementation("org.jetbrains.kotlin:kotlin-scripting-jvm:$ktVer")
implementation("org.jetbrains.kotlin:kotlin-scripting-jvm-host:$ktVer")
implementation("org.jetbrains.kotlin:kotlin-main-kts:$ktVer")
implementation("org.jetbrains.kotlin:kotlin-script-runtime:$ktVer")
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.0-RC2")
implementation("org.openjdk.jmh:jmh-core:1.37")
implementation("com.google.code.gson:gson:2.10.1")
implementation("com.google.guava:guava:33.0.0-jre")
implementation("org.mongodb:mongodb-driver-sync:4.11.1")
implementation("org.mongodb:mongodb-driver-core:4.11.1")
implementation("io.netty:netty-all:4.1.104.Final")
implementation("io.undertow:undertow-core:2.3.10.Final")
implementation("it.unimi.dsi:fastutil:8.5.12")
implementation("com.trivago:fastutil-concurrent-wrapper:0.2.2")
// TODO: Deprecated. Upstream dead. Replace with unirest
implementation("com.squareup.okhttp3:okhttp:4.12.0")
}
tasks.withType<ShadowJar> {
isZip64 = true
mergeServiceFiles()
}
publishing {
val ciProjectId: String? = System.getenv("CI_PROJECT_ID")
val ciJobToken: String? = System.getenv("CI_JOB_TOKEN")
val ciPipelineId: String? = System.getenv("CI_PIPELINE_ID")
if (ciProjectId == null || ciJobToken == null || ciPipelineId == null) {
println("Failed to get project id, job token or pipeline id.")
return@publishing
}
publications.create<MavenPublication>("library") {
version = "${darkanVersion}-${ciPipelineId}"
artifact("build/libs/world-server-${darkanVersion}-all.jar")
}
repositories.maven {
name = "GitLab"
url = uri("https://gitlab.com/api/v4/projects/${ciProjectId}/packages/maven")
credentials(HttpHeaderCredentials::class) {
name = "Job-Token"
value = ciJobToken
}
authentication.create("header", HttpHeaderAuthentication::class)
}
}
|
rootProject.name = "world-server"
|
/*
* OpenRS Cache Library
* Copyright (c) 2011 Graham and `Discardedx2
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package me.kfricilone.vyre.asm.script;
/**
* Created by Kyle Fricilone on May 10, 2018.
*/
public enum CS2InstructionType
{
PUSH_CONSTANT_INT,
PUSH_VAR,
POP_VAR,
PUSH_VARBIT,
POP_VARBIT,
PUSH_CONSTANT_STRING,
BRANCH,
BRANCH_NOT,
BRANCH_EQUALS,
BRANCH_LESS_THAN,
BRANCH_GREATER_THAN,
BRANCH_LESS_THAN_OR_EQUALS,
BRANCH_GREATER_THAN_OR_EQUALS,
PUSH_INT_LOCAL,
POP_INT_LOCAL,
PUSH_STRING_LOCAL,
POP_STRING_LOCAL,
JOIN_STRING,
POP_INT_DISCARD,
POP_STRING_DISCARD,
GOSUB_WITH_PARAMS,
DEFINE_ARRAY,
PUSH_ARRAY_INT,
POP_ARRAY_INT,
SWITCH,
PUSH_LONG_CONSTANT,
POP_LONG_DISCARD,
PUSH_LONG_LOCAL,
POP_LONG_LOCAL,
LONG_BRANCH_NOT,
LONG_BRANCH_EQUALS,
LONG_BRANCH_LESS_THAN,
LONG_BRANCH_GREATER_THAN,
LONG_BRANCH_LESS_THAN_OR_EQUALS,
LONG_BRANCH_GREATER_THAN_OR_EQUALS,
PUSH_ARRAY_INT_LEAVE_INDEX_ON_STACK,
PUSH_ARRAY_INT_AND_INDEX,
POP_ARRAY_INT_LEAVE_VALUE_ON_STACK,
BRANCH_IF_TRUE,
BRANCH_IF_FALSE,
CC_CREATE,
CC_DELETE,
CC_DELETEALL,
CC_INVALIDATE,
IF_SENDTOFRONT,
IF_SENDTOBACK,
CC_SENDTOFRONT,
CC_SENDTOBACK,
IF_RESUME_PAUSEBUTTON,
CC_RESUME_PAUSEBUTTON,
BASEIDKIT,
BASECOLOUR,
BASEMATERIAL,
SETGENDER,
SETOBJ,
CC_SETPOSITION,
CC_SETSIZE,
CC_SETHIDE,
CC_SETASPECT,
CC_SETNOCLICKTHROUGH,
CC_SETSCROLLPOS,
CC_SETCOLOUR,
CC_SETFILL,
CC_SETTRANS,
CC_SETLINEWID,
CC_SETGRAPHIC,
CC_SET2DANGLE,
CC_SETTILING,
CC_SETMODEL,
CC_SETMODELANGLE,
CC_SETMODELANIM,
CC_SETMODELORTHOG,
CC_SETMODELTINT,
CC_SETMODELLIGHTING,
CC_RESETMODELLIGHTING,
CC_SETTEXT,
CC_SETTEXTFONT,
CC_SETTEXTALIGN,
CC_SETTEXTSHADOW,
CC_SETTEXTANTIMACRO,
CC_SETOUTLINE,
CC_SETGRAPHICSHADOW,
CC_SETVFLIP,
CC_SETHFLIP,
CC_SETSCROLLSIZE,
CC_SETALPHA,
CC_SETMODELZOOM,
CC_SETLINEDIRECTION,
CC_SETMODELORIGIN,
CC_SETMAXLINES,
CC_SETPARAM_INT,
CC_SETPARAM_STRING,
CC_SETRECOL,
CC_SETRETEX,
CC_SETFONTMONO,
CC_SETPARAM,
CC_SETCLICKMASK,
CC_SETOBJECT,
CC_SETNPCHEAD,
CC_SETPLAYERHEAD_SELF,
CC_SETNPCMODEL,
CC_SETPLAYERMODEL,
CC_SETOBJECT_NONUM,
CC_SETLINKFRIEND,
CC_SETLINKFRIENDCHAT,
CC_SETLINKPLAYERGROUP,
CC_SETLINKACTIVECLANCHANNEL,
CC_RESETLINKPLAYER,
CC_SETOBJECT_WEARCOL,
CC_SETOBJECT_WEARCOL_NONUM,
CC_SETPLAYERMODEL_SELF,
CC_SETOBJECT_ALWAYSNUM,
CC_SETOBJECT_WEARCOL_ALWAYSNUM,
CC_SETOP,
CC_SETDRAGGABLE,
CC_SETDRAGRENDERBEHAVIOUR,
CC_SETDRAGDEADZONE,
CC_SETDRAGDEADTIME,
CC_SETOPBASE,
CC_SETTARGETVERB,
CC_CLEAROPS,
CC_SETTARGETCURSORS,
CC_SETOPCURSOR,
CC_SETPAUSETEXT,
CC_SETTARGETOPCURSOR,
CC_SETOPCHAR,
CC_SETOPTCHAR,
CC_SETOPKEY,
CC_SETOPTKEY,
CC_SETOPKEYRATE,
CC_SETOPTKEYRATE,
CC_SETOPKEYIGNOREHELD,
CC_SETOPTKEYIGNOREHELD,
CC_SETMOUSEOVERCURSOR,
CC_SETONCLICK,
CC_SETONHOLD,
CC_SETONRELEASE,
CC_SETONMOUSEOVER,
CC_SETONMOUSELEAVE,
CC_SETONDRAG,
CC_SETONTARGETLEAVE,
CC_SETONVARTRANSMIT,
CC_SETONTIMER,
CC_SETONOP,
CC_SETONDRAGCOMPLETE,
CC_SETONCLICKREPEAT,
CC_SETONMOUSEREPEAT,
CC_SETONINVTRANSMIT,
CC_SETONSTATTRANSMIT,
CC_SETONTARGETENTER,
CC_SETONSCROLLWHEEL,
CC_SETONCHATTRANSMIT,
CC_SETONKEY,
CC_SETONGAMEPADBUTTON,
CC_SETONGAMEPADBUTTONHELD,
CC_SETONGAMEPADAXIS,
CC_SETONGAMEPADTRIGGER,
CC_SETONFRIENDTRANSMIT,
CC_SETONCLANTRANSMIT,
CC_SETONMISCTRANSMIT,
CC_SETONDIALOGABORT,
CC_SETONSUBCHANGE,
CC_SETONSTOCKTRANSMIT,
CC_SETONCAMFINISHED,
CC_SETONRESIZE,
CC_SETONVARCTRANSMIT,
CC_SETONVARCSTRTRANSMIT,
CC_SETONOPT,
CC_SETONCLANSETTINGSTRANSMIT,
CC_SETONCLANCHANNELTRANSMIT,
CC_SETONVARCLANTRANSMIT,
CC_SETONPLAYERGROUPTRANSMIT,
CC_SETONPLAYERGROUPVARPTRANSMIT,
CC_SETONCAMERAUPDATETRANSMIT,
CC_CLEARSCRIPTHOOKS,
CC_CALLONRESIZE,
IF_SETPOSITION,
IF_SETSIZE,
IF_SETHIDE,
IF_SETASPECT,
IF_SETNOCLICKTHROUGH,
IF_SETSCROLLPOS,
IF_SETCOLOUR,
IF_SETFILL,
IF_SETTRANS,
IF_SETLINEWID,
IF_SETGRAPHIC,
IF_SET2DANGLE,
IF_SETTILING,
IF_SETMODEL,
IF_SETMODELANGLE,
IF_SETMODELANIM,
IF_SETMODELORTHOG,
IF_SETMODELTINT,
IF_SETMODELLIGHTING,
IF_RESETMODELLIGHTING,
IF_SETTEXT,
IF_SETTEXTFONT,
IF_SETTEXTALIGN,
IF_SETTEXTSHADOW,
IF_SETTEXTANTIMACRO,
IF_SETOUTLINE,
IF_SETGRAPHICSHADOW,
IF_SETVFLIP,
IF_SETHFLIP,
IF_SETSCROLLSIZE,
IF_SETALPHA,
IF_SETMODELZOOM,
IF_SETLINEDIRECTION,
IF_SETMODELORIGIN,
IF_SETMAXLINES,
IF_SETPARAM_INT,
IF_SETPARAM_STRING,
IF_SETRECOL,
IF_SETRETEX,
IF_SETFONTMONO,
IF_SETCLICKMASK,
IF_SETOBJECT,
IF_SETNPCHEAD,
IF_SETPLAYERHEAD_SELF,
IF_SETNPCMODEL,
IF_SETPLAYERMODEL,
IF_SETOBJECT_NONUM,
IF_SETLINKFRIEND,
IF_SETLINKFRIENDCHAT,
IF_SETLINKPLAYERGROUP,
IF_SETLINKACTIVECLANCHANNEL,
IF_RESETLINKPLAYER,
IF_SETOBJECT_WEARCOL,
IF_SETOBJECT_WEARCOL_NONUM,
IF_SETPLAYERMODEL_SELF,
IF_SETOBJECT_ALWAYSNUM,
IF_SETOBJECT_WEARCOL_ALWAYSNUM,
IF_SETOP,
IF_SETDRAGGABLE,
IF_SETDRAGRENDERBEHAVIOUR,
IF_SETDRAGDEADZONE,
IF_SETDRAGDEADTIME,
IF_SETOPBASE,
IF_SETTARGETVERB,
IF_CLEAROPS,
IF_SETTARGETCURSORS,
IF_SETOPCURSOR,
IF_SETPAUSETEXT,
IF_SETTARGETOPCURSOR,
IF_SETOPCHAR,
IF_SETOPTCHAR,
IF_SETOPKEY,
IF_SETOPTKEY,
IF_SETOPKEYRATE,
IF_SETOPTKEYRATE,
IF_SETOPKEYIGNOREHELD,
IF_SETOPTKEYIGNOREHELD,
IF_SETMOUSEOVERCURSOR,
IF_SETONCLICK,
IF_SETONHOLD,
IF_SETONRELEASE,
IF_SETONMOUSEOVER,
IF_SETONMOUSELEAVE,
IF_SETONDRAG,
IF_SETONTARGETLEAVE,
IF_SETONVARTRANSMIT,
IF_SETONTIMER,
IF_SETONOP,
IF_SETONDRAGCOMPLETE,
IF_SETONCLICKREPEAT,
IF_SETONMOUSEREPEAT,
IF_SETONINVTRANSMIT,
IF_SETONSTATTRANSMIT,
IF_SETONTARGETENTER,
IF_SETONSCROLLWHEEL,
IF_SETONCHATTRANSMIT,
IF_SETONKEY,
IF_SETONGAMEPADBUTTON,
IF_SETONGAMEPADBUTTONHELD,
IF_SETONGAMEPADAXIS,
IF_SETONGAMEPADTRIGGER,
IF_SETONFRIENDTRANSMIT,
IF_SETONCLANTRANSMIT,
IF_SETONMISCTRANSMIT,
IF_SETONDIALOGABORT,
IF_SETONSUBCHANGE,
IF_SETONSTOCKTRANSMIT,
IF_SETONCAMFINISHED,
IF_SETONRESIZE,
IF_SETONVARCTRANSMIT,
IF_SETONVARCSTRTRANSMIT,
IF_SETONOPT,
IF_SETONCLANSETTINGSTRANSMIT,
IF_SETONCLANCHANNELTRANSMIT,
IF_SETONVARCLANTRANSMIT,
IF_SETONPLAYERGROUPTRANSMIT,
IF_SETONPLAYERGROUPVARPTRANSMIT,
IF_SETONCAMERAUPDATETRANSMIT,
IF_CLEARSCRIPTHOOKS,
IF_CALLONRESIZE,
IF_NPC_SETCUSTOMBODYMODEL,
CC_NPC_SETCUSTOMBODYMODEL,
IF_NPC_SETCUSTOMHEADMODEL,
CC_NPC_SETCUSTOMHEADMODEL,
IF_NPC_SETCUSTOMRECOL,
CC_NPC_SETCUSTOMRECOL,
IF_NPC_SETCUSTOMRETEX,
CC_NPC_SETCUSTOMRETEX,
MES,
RETURN,
IF_CLOSE,
RESUME_COUNTDIALOG,
RESUME_NAMEDIALOG,
RESUME_STRINGDIALOG,
ABORT_DIALOG,
OPPLAYER,
RESUME_OBJDIALOG,
IF_DRAGPICKUP,
CC_DRAGPICKUP,
IF_OPENSUBCLIENT,
IF_CLOSESUBCLIENT,
OPPLAYERT,
MES_TYPED,
SETUP_MESSAGEBOX,
RESUME_HSLDIALOG,
RESUME_CLANFORUMQFCDIALOG,
SOUND_SYNTH,
SOUND_SONG,
SOUND_JINGLE,
SOUND_SYNTH_VOLUME,
SOUND_SONG_VOLUME,
SOUND_JINGLE_VOLUME,
SOUND_VORBIS_VOLUME,
SOUND_SPEECH_VOLUME,
SOUND_SYNTH_RATE,
SOUND_VORBIS_RATE,
EMAIL_VALIDATION_SUBMIT_CODE,
EMAIL_VALIDATION_CHANGE_ADDRESS,
EMAIL_VALIDATION_ADD_NEW_ADDRESS,
FRIEND_SETRANK,
FRIEND_SETNOTES,
FRIEND_ADD,
FRIEND_DEL,
IGNORE_ADD,
IGNORE_DEL,
IGNORE_SETNOTES,
FC_KICKUSER,
FC_JOINCHAT,
FC_LEAVECHAT,
IGNORE_ADD_TEMP,
AFFINEDCLANSETTINGS_ADDBANNED_FROMCHANNEL,
AFFINEDCLANSETTINGS_SETMUTED_FROMCHANNEL,
ACTIVECLANCHANNEL_KICKUSER,
OC_FINDRESTART,
CHAT_SETFILTER,
CHAT_SENDABUSEREPORT,
CHAT_SETMODE,
CHAT_SENDPUBLIC,
CHAT_SENDPRIVATE,
ACTIVECHATPHRASE_PREPARE,
ACTIVECHATPHRASE_SEND,
ACTIVECHATPHRASE_SENDPRIVATE,
ACTIVECHATPHRASE_SETDYNAMICINT,
ACTIVECHATPHRASE_SETDYNAMICOBJ,
CHATPHRASE_FINDRESTART,
WORLDMAP_3DVIEW_ENABLE,
WORLDMAP_3DVIEW_DISABLE,
WORLDMAP_3DVIEW_SETLODDISTANCE,
WORLDMAP_SETCATEGORYPRIORITY,
WORLDMAP_3DVIEW_SETTEXTFONT,
WORLDMAP_DISABLETEXTSIZE,
WORLDMAP_DISABLETYPE,
WORLDMAP_3DVIEW_SETLIGHTING,
WORLDMAP_SETZOOM,
WORLDMAP_SETMAP,
WORLDMAP_JUMPTOSOURCECOORD,
WORLDMAP_JUMPTODISPLAYCOORD,
WORLDMAP_SETMAP_COORD,
WORLDMAP_FLASHELEMENT,
WORLDMAP_SETMAP_COORD_OVERRIDE,
WORLDMAP_DISABLEELEMENTS,
WORLDMAP_FLASHELEMENTCATEGORY,
WORLDMAP_DISABLEELEMENTCATEGORY,
WORLDMAP_DISABLEELEMENT,
WORLDMAP_CLOSEMAP,
FULLSCREEN_EXIT,
SETWINDOWMODE,
SETDEFAULTWINDOWMODE,
OPENURL,
URLENCODE,
SPLINE_NEW,
SPLINE_ADDPOINT,
QUIT,
OPENURL_NOLOGIN,
WRITECONSOLE,
FORMATMINIMENU,
DEFAULTMINIMENU,
SETDEFAULTCURSORS,
SETHARDCODEDOPCURSORS,
DOCHEAT,
NOTIFY_ACCOUNTCREATED,
NOTIFY_ACCOUNTCREATESTARTED,
SETSUBMENUMINLENGTH,
OPENURL_SHIM,
CAM_MOVETO,
CAM_LOOKAT,
CAM_MOVEALONG,
CAM_RESET,
CAM_FORCEANGLE,
CAM_INC_X,
CAM_DEC_X,
CAM_INC_Y,
CAM_DEC_Y,
CAM_SETFOLLOWHEIGHT,
CAM_FOLLOWCOORD,
CAM_SMOOTHRESET,
CAM_REMOVEROOF,
CAM2_SETLOOKATMODE,
CAM2_SETPOSITIONMODE,
CAM2_SETLOOKATACCELERATION,
CAM2_SETPOSITIONACCELERATION,
CAM2_SETLOOKATMAXSPEED,
CAM2_SETPOSITIONMAXSPEED,
CAM2_SETDEPTHPLANES,
CAM2_SETFIELDOFVIEW,
CAM2_SETLOOKATPOINT_POINT,
CAM2_SETPOSITIONPOINT_POINT,
CAM2_GETPOSITIONPOINT_POINT,
CAM2_SETLOOKATENTITY_PLAYER,
CAM2_SETLOOKATENTITY_NPC,
CAM2_SETPOSITIONENTITY_PLAYER,
CAM2_SETPOSITIONENTITY_NPC,
CAM2_SETFIELDOFVIEWSCREEN,
CAM2_SETPOSITIONSPLINE_SPLINE,
CAM2_SETLOOKATSPLINE_SPLINE,
CAM2_REMOVEEFFECT,
CAM2_REMOVEALLEFFECTS,
CAM2_SETLOOKATACCELERATION_AXIS,
CAM2_SETPOSITIONACCELERATION_AXIS,
CAM2_SETLOOKATMAXSPEED_AXIS,
CAM2_SETPOSITIONMAXSPEED_AXIS,
CAM2_SETCOLLISIONMODE,
CAM2_SETPOSITIONPOINTCOLLISION,
CAM2_UPDATEEFFECT_ZTILT,
CAM2_SETTRAILDISTANCE,
CAM2_SETLINEARMOVEMENTMODE,
CAM2_SETSPRINGPROPERTIES,
CAM2_SETLOOKATANGULARINTERPOLATION,
CAM2_SETPOSITIONANGULARINTERPOLATION,
CAM2_SETLOOKATSPRINGPROPERTIES,
CAM2_SETPOSITIONSPRINGPROPERTIES,
CAM2_ENABLE,
CAM2_SETSNAPDISTANCES,
CAM2_RESETSNAPDISTANCES,
LOGIN_REQUEST,
CAM2_SETLOOKATORIENTATION_VECTOR,
CAM2_SETLOOKATORIENTATION_XROTATION,
CAM2_SETLOOKATORIENTATION_YROTATION,
CAM2_SETLOOKATORIENTATION_XMOVEMENT,
CAM2_SETLOOKATORIENTATION_ZMOVEMENT,
CAM2_SETLOOKATORIENTATION_MAXDISTANCECLAMPING,
LOGIN_CONTINUE,
LOGIN_RESETREPLY,
RESEND_UID_PASSPORT_REQUEST,
CREATE_AVAILABLEREQUEST,
CREATE_NAME_AVAILABLEREQUEST,
CREATE_SUGGEST_NAME_REQUEST,
CREATE_CREATEREQUEST,
CREATE_CONNECTREQUEST,
CREATE_STEP_REACHED,
LOBBY_ENTERGAME,
LOBBY_ENTERLOBBY,
LOBBY_LEAVELOBBY,
CREATE_SETUNDER13,
LOGIN_CANCEL,
LOGIN_REQUEST_SOCIAL_NETWORK,
LOBBY_ENTERLOBBY_SOCIAL_NETWORK,
DETAIL_BRIGHTNESS,
DETAIL_REMOVEROOFS_OPTION,
DETAIL_GROUNDDECOR_ON,
DETAIL_IDLEANIMS_MANY,
DETAIL_FLICKERING_ON,
DETAIL_SPOTSHADOWS_ON,
DETAIL_HARDSHADOWS,
DETAIL_SHADOWQUALITY,
DETAIL_LIGHTDETAIL_HIGH,
DETAIL_WATERDETAIL_HIGH,
DETAIL_FOG_ON,
DETAIL_ANTIALIASING,
DETAIL_ANTIALIASING_QUALITY,
DETAIL_STEREO,
DETAIL_SOUNDVOL,
DETAIL_MUSICVOL,
DETAIL_BGSOUNDVOL,
DETAIL_REMOVEROOFS_OPTION_OVERRIDE,
DETAIL_PARTICLES,
DETAIL_ANTIALIASING_DEFAULT,
DETAIL_BUILDAREA,
DETAIL_BLOOM,
DETAIL_CUSTOMCURSORS,
DETAIL_IDLEANIMS,
DETAIL_GROUNDBLENDING,
DETAIL_TOOLKIT,
DETAIL_TOOLKIT_DEFAULT,
DETAIL_CPUUSAGE,
DETAIL_TEXTURING,
DETAIL_MAXSCREENSIZE,
DETAIL_SPEECHVOL,
DETAIL_LOGINVOL,
DETAIL_LOADINGSCREENTYPE,
DETAIL_DRAWDISTANCE,
DETAIL_SKYDETAIL,
DETAIL_ANIMDETAIL,
DETAIL_DISKCACHESIZE,
VIEWPORT_SETFOV,
VIEWPORT_SETZOOM,
VIEWPORT_CLAMPFOV,
WORLDLIST_SORT,
WORLDLIST_AUTOWORLD,
WORLDLIST_PINGWORLDS,
IF_DEBUG_BUTTON1,
IF_DEBUG_BUTTON2,
IF_DEBUG_BUTTON3,
IF_DEBUG_BUTTON4,
IF_DEBUG_BUTTON5,
IF_DEBUG_BUTTON6,
IF_DEBUG_BUTTON7,
IF_DEBUG_BUTTON8,
IF_DEBUG_BUTTON9,
IF_DEBUG_BUTTON10,
IF_DEBUG_TARGET,
IF_TRIGGEROP,
CC_TRIGGEROP,
FORCE_INTERFACE_DRAG,
CANCEL_INTERFACE_DRAG,
TARGETMODE_ACTIVE,
TARGETMODE_CANCEL,
AUTOSETUP_SETHIGH,
AUTOSETUP_SETMEDIUM,
AUTOSETUP_SETLOW,
AUTOSETUP_SETMIN,
AUTOSETUP_SETCUSTOM,
AUTOSETUP_BLACKFLAGLAST,
VIDEO_ADVERT_FORCE_REMOVE,
VIDEO_ADVERT_ALLOW_SKIP,
BUG_REPORT,
ARRAY_SORT,
CC_FIND,
IF_FIND,
CC_GETX,
CC_GETY,
CC_GETWIDTH,
CC_GETHEIGHT,
CC_GETHIDE,
CC_GETLAYER,
CC_GETPARENTLAYER,
CC_GETCOLOUR,
CC_GETSCROLLX,
CC_GETSCROLLY,
CC_GETTEXT,
CC_GETSCROLLWIDTH,
CC_GETSCROLLHEIGHT,
CC_GETMODELZOOM,
CC_GETMODELANGLE_X,
CC_GETMODELANGLE_Z,
CC_GETMODELANGLE_Y,
CC_GETTRANS,
CC_GETMODELXOF,
CC_GETMODELYOF,
CC_GETGRAPHIC,
CC_PARAM,
CC_GET2DANGLE,
CC_GETMODEL,
CC_GETFONTGRAPHIC,
CC_GETGRAPHICDIMENSIONS,
CC_GETFONTMETRICS,
CC_GETINVOBJECT,
CC_GETINVCOUNT,
CC_GETID,
CC_GETTARGETMASK,
CC_GETOP,
CC_GETOPBASE,
CC_GETCHARINDEXATPOS,
CC_GETCHARPOSATINDEX,
IF_GETX,
IF_GETY,
IF_GETWIDTH,
IF_GETHEIGHT,
IF_GETHIDE,
IF_GETLAYER,
IF_GETPARENTLAYER,
IF_GETCOLOUR,
IF_GETSCROLLX,
IF_GETSCROLLY,
IF_GETTEXT,
IF_GETSCROLLWIDTH,
IF_GETSCROLLHEIGHT,
IF_GETMODELZOOM,
IF_GETMODELANGLE_X,
IF_GETMODELANGLE_Z,
IF_GETMODELANGLE_Y,
IF_GETTRANS,
IF_GETMODELXOF,
IF_GETMODELYOF,
IF_GETGRAPHIC,
IF_GET2DANGLE,
IF_GETMODEL,
IF_GETFONTGRAPHIC,
IF_GETGRAPHICDIMENSIONS,
IF_GETFONTMETRICS,
IF_GETINVOBJECT,
IF_GETINVCOUNT,
IF_HASSUB,
IF_GETNEXTSUBID,
IF_HASSUBMODAL,
IF_HASSUBOVERLAY,
IF_GETTARGETMASK,
IF_GETOP,
IF_GETOPBASE,
IF_GETCHARINDEXATPOS,
IF_GETCHARPOSATINDEX,
CLIENTCLOCK,
INV_GETOBJ,
INV_GETNUM,
INV_TOTAL,
INV_TOTALCAT,
INV_SIZE,
INV_STOCKBASE,
INV_GETVAR,
STAT,
STAT_BASE,
STAT_VISIBLE_XP,
STAT_BASE_ACTUAL,
STAT_VISIBLE_XP_ACTUAL,
FACING_FINE,
COORD,
COORDX,
COORDY,
COORDZ,
COORD_FINE,
COORDX_FINE,
COORDY_FINE,
COORDZ_FINE,
COORDLEVEL_FINE,
MOVECOORD_FINE,
COORD_GRIDTOFINE,
COORD_FINETOGRID,
MAP_MEMBERS,
MAP_PRELOAD,
MAP_LOADEDPERCENT,
INVOTHER_GETOBJ,
INVOTHER_GETNUM,
INVOTHER_TOTAL,
INVOTHER_GETVAR,
STAFFMODLEVEL,
REBOOTTIMER,
MAP_WORLD,
RUNENERGY_VISIBLE,
RUNWEIGHT_VISIBLE,
PLAYERMOD,
PLAYERMODLEVEL,
PLAYERMEMBER,
COMLEVEL_ACTIVE,
GENDER,
MAP_QUICKCHAT,
INV_FREESPACE,
INV_TOTALPARAM,
INV_TOTALPARAM_STACK,
MAP_LANG,
MOVECOORD,
AFFILIATE,
PROFILE_CPU,
PLAYERDEMO,
APPLET_HASFOCUS,
FROMBILLING,
GET_MOUSEX,
GET_MOUSEY,
GET_ACTIVE_MINIMENU_ENTRY,
GET_SECOND_MINIMENU_ENTRY,
GET_MINIMENU_LENGTH,
NPC_FIND_ACTIVE_MINIMENU_ENTRY,
PLAYER_FIND_ACTIVE_MINIMENU_ENTRY,
GET_CURRENTCURSOR,
GET_SELFYANGLE,
MAP_ISOWNER,
GET_MOUSEBUTTONS,
SELF_PLAYER_UID,
GET_MINIMENU_TARGET,
ENUM_STRING,
ENUM,
ENUM_HASOUTPUT,
ENUM_HASOUTPUT_STRING,
ENUM_GETOUTPUTCOUNT,
ENUM_GETREVERSECOUNT,
ENUM_GETREVERSECOUNT_STRING,
ENUM_GETREVERSEINDEX,
ENUM_GETREVERSEINDEX_STRING,
FRIEND_COUNT,
FRIEND_GETNAME,
FRIEND_GETWORLD,
FRIEND_GETRANK,
FRIEND_GETNOTES,
FRIEND_GETWORLDFLAGS,
FRIEND_TEST,
FRIEND_GETWORLDNAME,
FC_GETCHATDISPLAYNAME,
FC_GETCHATCOUNT,
FC_GETCHATUSERNAME,
FC_GETCHATUSERWORLD,
FC_GETCHATUSERRANK,
FC_GETCHATMINKICK,
FC_GETCHATRANK,
IGNORE_COUNT,
IGNORE_GETNAME,
IGNORE_GETNOTES,
IGNORE_TEST,
FC_ISSELF,
FC_GETCHATOWNERNAME,
FC_GETCHATUSERWORLDNAME,
FRIEND_PLATFORM,
FRIEND_GETSLOTFROMNAME,
IGNORE_GETSLOTFROMNAME,
PLAYERCOUNTRY,
IGNORE_IS_TEMP,
FC_GETCHATUSERNAME_UNFILTERED,
IGNORE_GETNAME_UNFILTERED,
FRIEND_IS_REFERRER,
FRIEND_IS_REFERRED,
ACTIVECLANSETTINGS_FIND_LISTENED,
ACTIVECLANSETTINGS_FIND_AFFINED,
ACTIVECLANSETTINGS_GETCLANNAME,
ACTIVECLANSETTINGS_GETALLOWUNAFFINED,
ACTIVECLANSETTINGS_GETRANKTALK,
ACTIVECLANSETTINGS_GETRANKKICK,
ACTIVECLANSETTINGS_GETRANKLOOTSHARE,
ACTIVECLANSETTINGS_GETCOINSHARE,
ACTIVECLANSETTINGS_GETAFFINEDCOUNT,
ACTIVECLANSETTINGS_GETAFFINEDDISPLAYNAME,
ACTIVECLANSETTINGS_GETAFFINEDRANK,
ACTIVECLANSETTINGS_GETAFFINEDMUTED,
ACTIVECLANSETTINGS_GETBANNEDCOUNT,
ACTIVECLANSETTINGS_GETBANNEDDISPLAYNAME,
ACTIVECLANSETTINGS_GETAFFINEDEXTRAINFO,
ACTIVECLANSETTINGS_GETCURRENTOWNER_SLOT,
ACTIVECLANSETTINGS_GETREPLACEMENTOWNER_SLOT,
ACTIVECLANSETTINGS_GETAFFINEDSLOT,
ACTIVECLANSETTINGS_GETSORTEDAFFINEDSLOT,
ACTIVECLANSETTINGS_GETAFFINEDJOINRUNEDAY,
ACTIVECLANCHANNEL_FIND_LISTENED,
ACTIVECLANCHANNEL_FIND_AFFINED,
ACTIVECLANCHANNEL_GETCLANNAME,
ACTIVECLANCHANNEL_GETRANKKICK,
ACTIVECLANCHANNEL_GETRANKTALK,
ACTIVECLANCHANNEL_GETUSERCOUNT,
ACTIVECLANCHANNEL_GETUSERDISPLAYNAME,
ACTIVECLANCHANNEL_GETUSERRANK,
ACTIVECLANCHANNEL_GETUSERWORLD,
ACTIVECLANCHANNEL_GETUSERSLOT,
ACTIVECLANCHANNEL_GETSORTEDUSERSLOT,
CLANPROFILE_FIND,
STOCKMARKET_GETOFFERTYPE,
STOCKMARKET_GETOFFERITEM,
STOCKMARKET_GETOFFERPRICE,
STOCKMARKET_GETOFFERCOUNT,
STOCKMARKET_GETOFFERCOMPLETEDCOUNT,
STOCKMARKET_GETOFFERCOMPLETEDGOLD,
STOCKMARKET_ISOFFEREMPTY,
STOCKMARKET_ISOFFERSTABLE,
STOCKMARKET_ISOFFERFINISHED,
STOCKMARKET_ISOFFERADDING,
ADD,
SUB,
MULTIPLY,
DIVIDE,
RANDOM,
RANDOMINC,
INTERPOLATE,
ADDPERCENT,
SETBIT,
CLEARBIT,
TESTBIT,
MODULO,
POW,
INVPOW,
AND,
OR,
MIN,
MAX,
SCALE,
RANDOM_SOUND_PITCH,
HSVTORGB,
NOT,
APPEND_NUM,
APPEND,
APPEND_SIGNNUM,
GET_COL_TAG,
LOWERCASE,
FROMDATE,
TEXT_GENDER,
TOSTRING,
COMPARE,
PARAHEIGHT,
PARAWIDTH,
PARALINE,
TEXT_SWITCH,
ESCAPE,
APPEND_CHAR,
CHAR_ISPRINTABLE,
CHAR_ISALPHANUMERIC,
CHAR_ISALPHA,
CHAR_ISNUMERIC,
STRING_LENGTH,
SUBSTRING,
REMOVETAGS,
STRING_INDEXOF_CHAR,
STRING_INDEXOF_STRING,
CHAR_TOLOWERCASE,
CHAR_TOUPPERCASE,
TOSTRING_LOCALISED,
STRINGWIDTH,
STRING_DISTANCE,
FORMAT_DATETIME_FROM_MINUTES,
CLANFORUMQFC_TOSTRING,
OC_NAME,
OC_OP,
OC_IOP,
OC_COST,
OC_STACKABLE,
OC_CATEGORY,
OC_HASVAROBJ,
OC_CERT,
OC_UNCERT,
OC_SHARD,
OC_UNSHARD,
OC_SHARDCOUNT,
OC_WEARPOS,
OC_WEARPOS2,
OC_WEARPOS3,
OC_MEMBERS,
OC_PARAM,
OC_ICURSOR,
OC_MULTISTACKSIZE,
OC_FIND,
OC_FINDNEXT,
OC_MINIMENU_COLOUR_OVERRIDDEN,
OC_MINIMENU_COLOUR,
NPC_PARAM,
OBJECT_PARAM,
STRUCT_PARAM,
SEQ_PARAM,
SEQLENGTH,
BAS_GETANIM_READY,
CHAT_GETFILTER_PUBLIC,
CHAT_GETHISTORY_BYTYPEANDLINE,
CHAT_GETHISTORY_BYUID,
CHAT_GETFILTER_PRIVATE,
CHAT_PLAYERNAME,
CHAT_GETFILTER_TRADE,
CHAT_GETHISTORYLENGTH,
CHAT_GETNEXTUID,
CHAT_GETPREVUID,
CHAT_PLAYERNAME_UNFILTERED,
CHATCAT_GETDESC,
CHATCAT_GETSUBCATCOUNT,
CHATCAT_GETSUBCAT,
CHATCAT_GETPHRASECOUNT,
CHATCAT_GETPHRASE,
CHATPHRASE_GETTEXT,
CHATPHRASE_GETAUTORESPONSECOUNT,
CHATPHRASE_GETAUTORESPONSE,
CHATCAT_GETSUBCATSHORTCUT,
CHATCAT_GETPHRASESHORTCUT,
CHATCAT_FINDSUBCATBYSHORTCUT,
CHATCAT_FINDPHRASEBYSHORTCUT,
CHATPHRASE_GETDYNAMICCOMMANDCOUNT,
CHATPHRASE_GETDYNAMICCOMMAND,
CHATPHRASE_GETDYNAMICCOMMANDPARAM_ENUM,
CHATPHRASE_FIND,
CHATPHRASE_FINDNEXT,
KEYHELD_ALT,
KEYHELD_CTRL,
KEYHELD_SHIFT,
WORLDMAP_3DVIEW_ACTIVE,
WORLDMAP_3DVIEW_GETCOORDFINE,
WORLDMAP_3DVIEW_GETLODDISTANCE,
WORLDMAP_GETCATEGORYPRIORITY,
WORLDMAP_3DVIEW_GETTEXTFONT,
WORLDMAP_3DVIEW_GETSCREENPOSITION,
WORLDMAP_GETDISABLETEXTSIZE,
WORLDMAP_GETDISABLETYPE,
WORLDMAP_GETZOOM,
WORLDMAP_GETMAP,
WORLDMAP_GETMAPNAME,
WORLDMAP_GETSIZE,
WORLDMAP_GETDISPLAYPOSITION,
WORLDMAP_GETCONFIGORIGIN,
WORLDMAP_GETCONFIGSIZE,
WORLDMAP_GETCONFIGBOUNDS,
WORLDMAP_LISTELEMENT_START,
WORLDMAP_LISTELEMENT_NEXT,
WORLDMAP_COORDINMAP,
WORLDMAP_GETCONFIGZOOM,
WORLDMAP_ISLOADED,
WORLDMAP_GETSOURCEPOSITION,
WORLDMAP_GETDISPLAYCOORD,
WORLDMAP_GETSOURCECOORD,
WORLDMAP_GETDISABLEELEMENTS,
WORLDMAP_GETDISABLEELEMENTCATEGORY,
WORLDMAP_GETDISABLEELEMENT,
WORLDMAP_GETCURRENTMAP,
WORLDMAP_FINDNEARESTELEMENT,
FULLSCREEN_ENTER,
FULLSCREEN_MODECOUNT,
FULLSCREEN_GETMODE,
FULLSCREEN_LASTMODE,
GETWINDOWMODE,
GETDEFAULTWINDOWMODE,
SPLINE_LENGTH,
LASTLOGIN,
MINIMENUOPEN,
GETCLIPBOARD,
HAS_HTML5,
HAS_NXT,
CLIENTTYPE,
IS_GAMESCREEN_STATE,
CAM_GETANGLE_XA,
CAM_GETANGLE_YA,
CAM_GETFOLLOWHEIGHT,
CAM2_GETCONTROLMODE,
CAM2_GETLOOKATMODE,
CAM2_GETPOSITIONMODE,
CAM2_GETPOSITIONENTITY_ANGLEOFFSETS,
CAM2_ADDEFFECT_SHAKE,
CAM2_GETPOSITIONENTITY_LOOKATANGLEOFFSETS,
CAM2_GETPOSITIONENTITY_LOOKATANGLE,
CAM2_GETPOSITIONENTITY_LOOKATDISTANCE,
CAM2_ADDEFFECT_ZTILT,
CAM2_ISENABLED,
CAM2_LEGACYCAM_READY,
CAM_MODEISFOLLOWPLAYER,
LOGIN_REPLY,
LOGIN_HOPTIME,
LOGIN_BAN_DURATION,
CREATE_REPLY,
CREATE_EMAIL_VALIDATE_REPLY,
CREATE_NAME_VALIDATE_REPLY,
CREATE_SUGGEST_NAME_REPLY,
CREATE_CONNECT_REPLY,
LOGIN_DISALLOWRESULT,
LOBBY_ENTERGAMEREPLY,
LOBBY_ENTERLOBBYREPLY,
USERFLOWFLAGS,
AUTOMATEDTESTFLAGS,
CREATE_UNDER13,
LOGIN_LAST_TRANSFER_REPLY,
LOGIN_INPROGRESS,
LOGIN_QUEUE_POSITION,
LOGIN_DISALLOWTRIGGER,
CREATE_GET_EMAIL,
LOGIN_ACCOUNTAPPEAL,
DETAILGET_BRIGHTNESS,
DETAILGET_REMOVEROOFS_OPTION,
DETAILGET_GROUNDDECOR_ON,
DETAILGET_IDLEANIMS_MANY,
DETAILGET_FLICKERING_ON,
DETAILGET_SPOTSHADOWS_ON,
DETAILGET_HARDSHADOWS,
DETAILGET_SHADOWQUALITY,
DETAILGET_LIGHTDETAIL_HIGH,
DETAILGET_WATERDETAIL_HIGH,
DETAILGET_FOG_ON,
DETAILGET_ANTIALIASING,
DETAILGET_ANTIALIASING_QUALITY,
DETAILGET_STEREO,
DETAILGET_SOUNDVOL,
DETAILGET_MUSICVOL,
DETAILGET_BGSOUNDVOL,
DETAILGET_PARTICLES,
DETAILGET_ANTIALIASING_DEFAULT,
DETAILGET_BUILDAREA,
DETAILGET_BLOOM,
DETAILGET_CUSTOMCURSORS,
DETAILGET_IDLEANIMS,
DETAILGET_GROUNDBLENDING,
DETAILGET_TOOLKIT,
DETAILGET_TOOLKIT_DEFAULT,
DETAILGET_CPUUSAGE,
DETAILGET_TEXTURING,
DETAILGET_PERFORMANCE_METRIC,
DETAILGET_MAXSCREENSIZE,
DETAILGET_SPEECHVOL,
DETAILGET_LOGINVOL,
DETAILGET_SAFEMODE,
DETAILGET_LOADINGSCREENTYPE,
DETAILGET_ORTHOGRAPHIC,
DETAILGET_CANCHOOSESAFEMODE,
DETAILGET_CHOSESAFEMODE,
DETAILGET_SKYDETAIL,
DETAILGET_DRAWDISTANCE,
DETAILGET_MAXDISKCACHESIZE,
DETAILGET_MINDISKCACHESIZE,
DETAILGET_RECOMMENDEDDISKCACHESIZE,
DETAILGET_DISKCACHESIZE,
DETAILGET_ANIMDETAIL,
VIEWPORT_GETEFFECTIVESIZE,
VIEWPORT_GETZOOM,
VIEWPORT_GETFOV,
DATE_MINUTES,
DATE_RUNEDAY,
DATE_RUNEDAY_FROMDATE,
DATE_YEAR,
DATE_ISLEAPYEAR,
DATE_RUNEDAY_TODATE,
DATE_MINUTES_FROMRUNEDAY,
WORLDLIST_FETCH,
WORLDLIST_START,
WORLDLIST_NEXT,
WORLDLIST_SWITCH,
WORLDLIST_SPECIFIC,
WORLDLIST_SPECIFIC_THISWORLD,
IF_GETTOP,
IF_DEBUG_GETOPENIFCOUNT,
IF_DEBUG_GETOPENIFID,
IF_DEBUG_GETNAME,
IF_DEBUG_GETCOMCOUNT,
IF_DEBUG_GETCOMNAME,
IF_DEBUG_GETSERVERTRIGGERS,
OPCOUNT,
MEC_TEXT,
MEC_SPRITE,
MEC_TEXTSIZE,
MEC_CATEGORY,
MEC_PARAM,
USERDETAIL_QUICKCHAT,
USERDETAIL_LOBBY_MEMBERSHIP,
USERDETAIL_LOBBY_RECOVERYDAY,
USERDETAIL_LOBBY_UNREADMESSAGES,
USERDETAIL_LOBBY_LASTLOGINDAY,
USERDETAIL_LOBBY_LASTLOGINADDRESS,
USERDETAIL_LOBBY_EMAILSTATUS,
USERDETAIL_LOBBY_CCEXPIRY,
USERDETAIL_LOBBY_GRACEEXPIRY,
USERDETAIL_LOBBY_DOBREQUESTED,
USERDETAIL_DOB,
USERDETAIL_LOBBY_MEMBERSSTATS,
USERDETAIL_LOBBY_PLAYAGE,
USERDETAIL_LOBBY_JCOINS_BALANCE,
USERDETAIL_LOBBY_LOYALTY_BALANCE,
AUTOSETUP_DOSETUP,
AUTOSETUP_GETLEVEL,
VIDEO_ADVERT_PLAY,
VIDEO_ADVERT_HAS_FINISHED,
GET_ENTITY_SAY,
GET_DISPLAYNAME_WITHEXTRAS,
GET_NPC_NAME,
GET_NPC_VISLEVEL,
GET_ENTITY_SCREEN_POSITION,
IF_GET_GAMESCREEN,
IF_SET_GAMESCREEN_ENABLED,
GET_ENTITY_OVERLAY_HEIGHT,
GET_NPC_STAT,
IS_NPC_ACTIVE,
IS_NPC_VISIBLE,
IS_TARGETED_ENTITY,
NPC_TYPE,
GET_LOC_SCREEN_POSITION,
GET_OBJ_SCREEN_POSITION,
GET_LOC_OVERLAY_HEIGHT,
GET_OBJ_OVERLAY_HEIGHT,
GET_LOC_BOUNDING_BOX,
GET_OBJ_BOUNDING_BOX,
GET_ENTITY_BOUNDING_BOX,
QUEST_GETNAME,
QUEST_GETSORTNAME,
QUEST_TYPE,
QUEST_GETDIFFICULTY,
QUEST_GETMEMBERS,
QUEST_POINTS,
QUEST_QUESTREQ_COUNT,
QUEST_QUESTREQ,
QUEST_QUESTREQ_MET,
QUEST_POINTSREQ,
QUEST_POINTSREQ_MET,
QUEST_STATREQ_COUNT,
QUEST_STATREQ_STAT,
QUEST_STATREQ_LEVEL,
QUEST_STATREQ_MET,
QUEST_VARPREQ_COUNT,
QUEST_VARPREQ_DESC,
QUEST_VARPREQ_MET,
QUEST_VARBITREQ_COUNT,
QUEST_VARBITREQ_DESC,
QUEST_VARBITREQ_MET,
QUEST_ALLREQMET,
QUEST_STARTED,
QUEST_FINISHED,
QUEST_PARAM,
MAP_BUILD_COMPLETE,
SOUND_SONG_STOP,
SOUND_GROUP_START,
SOUND_GROUP_STOP,
SOUND_VORBIS_VOLUME_RATE_GROUP,
SOUND_MIXBUSS_ADD,
SOUND_MIXBUSS_SETLEVEL,
SOUND_DISTANCEFOCUSFILTER_SETPARAMS,
PRELOAD_PERCENT,
SHADER_PRELOAD_ALLOW,
SHADER_PRELOAD_PERCENT,
SHADER_PRELOAD_THROTTLE,
CAN_RUN_JAVA_CLIENT,
FPS_STATS,
RUNJAVASCRIPT,
WORLDMAP_JUMPTOSOURCECOORD_INSTANT,
WORLDMAP_JUMPTODISPLAYCOORD_INSTANT,
WORLDMAP_SETFLASHLOOPS,
WORLDMAP_SETFLASHLOOPS_DEFAULT,
WORLDMAP_SETFLASHTICS,
WORLDMAP_SETFLASHTICS_DEFAULT,
WORLDMAP_PERPETUALFLASH,
WORLDMAP_STOPCURRENTFLASHES,
PLAYER_GROUP_FIND,
PLAYER_GROUP_MEMBER_COUNT,
PLAYER_GROUP_MEMBER_GET_SAME_WORLD_VAR,
PLAYER_GROUP_MEMBER_GET_RANK,
PLAYER_GROUP_MEMBER_GET_TEAM,
PLAYER_GROUP_MEMBER_GET_LAST_SEEN_NODE_ID,
PLAYER_GROUP_MEMBER_GET_STATUS,
PLAYER_GROUP_MEMBER_IS_ONLINE,
PLAYER_GROUP_MEMBER_IS_MEMBER,
PLAYER_GROUP_MEMBER_GET_DISPLAYNAME,
PLAYER_GROUP_MEMBER_GET_JOIN_XP,
PLAYER_GROUP_MEMBER_IS_OWNER,
PLAYER_GROUP_BANNED_COUNT,
PLAYER_GROUP_BANNED_GET_DISPLAYNAME,
PLAYER_GROUP_GET_DISPLAYNAME,
PLAYER_GROUP_GET_MAX_SIZE,
PLAYER_GROUP_GET_CREATE_MINS_SINCE_EPOCH,
PLAYER_GROUP_GET_CREATE_SECONDS_TO_NOW,
PLAYER_GROUP_IS_MEMBERS_ONLY,
PLAYER_GROUP_GET_OVERALL_STATUS,
PLAYER_GROUP_GET_OWNER_SLOT,
TTV_LOGIN,
TTV_LOGIN_GETSTATE,
TTV_LOGOUT,
TTV_LIBRARY_GETSTATE,
TTV_LIBRARY_REQUEST,
TTV_STREAM_GETSTATE,
TTV_STREAM_START,
TTV_STREAM_STOP,
TTV_STREAM_SETTITLE,
TTV_STREAM_GETVIEWERS,
TTV_STREAM_GETQUALITY,
TTV_STREAM_SETSMOOTHRESIZE,
TTV_CHAT_GETSTATE,
TTV_CHAT_SENDMESSAGE,
TTV_WEBCAM_GETSTATE,
TTV_WEBCAM_SUPPORTED,
TTV_WEBCAM_GETDEVICE_COUNT,
TTV_WEBCAM_GETDEVICE_BYINDEX,
TTV_WEBCAM_GETDEVICE_BYUNIQUENAME,
TTV_WEBCAM_GETCAP_COUNT,
TTV_WEBCAM_GETCAP_BYINDEX,
TTV_WEBCAM_GETCAP_BYUNIQUEID,
TTV_WEBCAM_START,
TTV_WEBCAM_STOP,
TTV_WEBCAM_FLIP,
TTV_LIVESTREAMS_UPDATE,
TTV_LIVESTREAMS_GETSTREAM_START,
TTV_LIVESTREAMS_GETSTREAM_NEXT,
TTV_SETDEBUGOUPUT,
TTV_HASPREREQUISITES,
OS_ISMAC,
OS_ISWINDOWS,
OS_ISLINUX,
OS_PHYSICALMEMORYSIZE,
GETGRIDCOORDRELATIVETOCAMERA,
MOVESCRIPTED,
TELEMETRY_GET_GROUP_COUNT,
TELEMETRY_GET_GROUP_INDEX,
TELEMETRY_GET_GROUP_ID,
TELEMETRY_GET_ROW_COUNT,
TELEMETRY_GET_ROW_INDEX,
TELEMETRY_GET_ROW_ID,
TELEMETRY_IS_ROW_PINNED,
TELEMETRY_GET_COLUMN_COUNT,
TELEMETRY_GET_COLUMN_INDEX,
TELEMETRY_GET_COLUMN_ID,
TELEMETRY_GET_GRID_VALUE,
TELEMETRY_IS_GRID_PROCESSOR_SET,
EMOJI_ADD,
EMOJI_REMOVE,
EMOJI_REMOVEALL,
EMOJI_SUBSTITUTE,
EMOJI_ENABLE_AUTO_CHATLINE,
DB_FIND,
DB_FIND_WITH_COUNT,
DB_FINDNEXT,
DB_GETFIELD,
DB_GETFIELDCOUNT,
DETAILCANMOD_GROUNDDECOR,
DETAILCANMOD_SPOTSHADOWS,
DETAILCANMOD_HARDSHADOWS,
DETAILCANMOD_SHADOWQUALITY,
DETAILCANMOD_WATERDETAIL,
DETAILCANMOD_ANTIALIASING,
DETAILCANMOD_ANTIALIASING_QUALITY,
DETAILCANMOD_PARTICLES,
DETAILCANMOD_BUILDAREA,
DETAILCANMOD_BLOOM,
DETAILCANMOD_GROUNDBLENDING,
DETAILCANMOD_TEXTURING,
DETAILCANMOD_MAXSCREENSIZE,
DETAILCANMOD_FOG,
DETAILCANMOD_ORTHOGRAPHIC,
DETAILCANMOD_TOOLKIT_DEFAULT,
DETAILCANMOD_SKYDETAIL,
DETAILCANMOD_ANIMDETAIL,
DETAILCANSET_GROUNDDECOR,
DETAILCANSET_SPOTSHADOWS,
DETAILCANSET_HARDSHADOWS,
DETAILCANSET_SHADOWQUALITY,
DETAILCANSET_WATERDETAIL,
DETAILCANSET_ANTIALIASING,
DETAILCANSET_ANTIALIASING_QUALITY,
DETAILCANSET_PARTICLES,
DETAILCANSET_BUILDAREA,
DETAILCANSET_BLOOM,
DETAILCANSET_GROUNDBLENDING,
DETAILCANSET_TEXTURING,
DETAILCANSET_MAXSCREENSIZE,
DETAILCANSET_FOG,
DETAILCANSET_ORTHOGRAPHIC,
DETAILCANSET_TOOLKIT_DEFAULT,
DETAILCANSET_SKYDETAIL,
DETAILCANSET_ANIMDETAIL,
DETAIL_SHADOWS,
DETAIL_LIGHTINGQUALITY,
DETAIL_ANTIALIASINGMODE,
DETAIL_AMBIENTOCCLUSION,
DETAIL_REFLECTIONS,
DETAIL_VSYNC,
DETAILGET_SHADOWS,
DETAILGET_LIGHTINGQUALITY,
DETAILGET_ANTIALIASINGMODE,
DETAILGET_AMBIENTOCCLUSION,
DETAILGET_REFLECTIONS,
DETAILGET_VSYNC,
DETAILCANMOD_SHADOWS,
DETAILCANMOD_LIGHTINGQUALITY,
DETAILCANMOD_ANTIALIASINGMODE,
DETAILCANMOD_AMBIENTOCCLUSION,
DETAILCANMOD_REFLECTIONS,
DETAILCANMOD_VSYNC,
DETAILCANSET_SHADOWS,
DETAILCANSET_LIGHTINGQUALITY,
DETAILCANSET_ANTIALIASINGMODE,
DETAILCANSET_AMBIENTOCCLUSION,
DETAILCANSET_REFLECTIONS,
DETAILCANSET_VSYNC,
AUTOSETUP_SETULTRA;
public String getFunction()
{
return "_" + name().toLowerCase();
}
}
|
onNpcClick("Man", options = arrayOf("Talk-to")) { e ->
e.player.startConversation {
npc(e.npc.id, HAPPY_TALKING, "Hello there, adventurer! What brings you to our town?")
options {
//Conditional options example
if (e.player.inventory.containsItem(1050, 1))
option("Ask about the town") {
npc(e.npc.id, HAPPY_TALKING, "This town is known for its ancient history and beautiful landscapes.")
player(HAPPY_TALKING, "That sounds fascinating!")
npc(e.npc.id, HAPPY_TALKING, "Feel free to explore and enjoy your stay!")
}
option("Ask about quests") {
npc(e.npc.id, HAPPY_TALKING, "Oh, there are many adventures to be had here!")
player(HAPPY_TALKING, "Any specific recommendations?")
npc(e.npc.id, HAPPY_TALKING, "You should visit the old wizard on the hill for a magical quest.")
}
option("Say goodbye") {
player(HAPPY_TALKING, "Thanks for your time. I must be going now.")
npc(e.npc.id, HAPPY_TALKING, "Safe travels, adventurer!")
}
}
}
}
|
val messages = arrayOf(
Pair(HAPPY_TALKING, "I'm fine!"),
Pair(CALM_TALK, "I think we need a new king. The one we've got isn't good."),
Pair(CALM_TALK, "Not too bad. But I'm quite worried about the goblin population these days."),
Pair(CONFUSED, "Who are you?.."),
Pair(HAPPY_TALKING, "Hello."),
Pair(NERVOUS, "I've heard there are many fearsome creatures that dwell underground..."),
Pair(WORRIED, "I'm a little worried. I've heard there are people killing citizens at random.")
)
onNpcClick("Man", "Woman", options = arrayOf("Talk-to")) { e ->
val (chathead, text) = messages.random()
e.player.startConversation {
player(HAPPY_TALKING, "Hello, how's it going?")
npc(e.npc.id, chathead, text)
}
}
|
package com.rs;
public final class Launcher {
public static void main(String[] args) throws Exception {
Logger.setupFormat();
Logger.setLevel(Level.FINE); //FINER for traces
JsonFileManager.setGSON(new GsonBuilder()
.registerTypeAdapter(Controller.class, new ControllerAdapter())
.registerTypeAdapter(Date.class, new DateAdapter())
.registerTypeAdapter(PacketEncoder.class, new PacketEncoderAdapter())
.registerTypeAdapter(Packet.class, new PacketAdapter())
.registerTypeAdapterFactory(new RecordTypeAdapterFactory())
.disableHtmlEscaping()
.setPrettyPrinting()
.create());
Settings.loadConfig();
if (!Settings.getConfig().isDebug())
Logger.setLevel(Level.WARNING);
long currentTime = System.currentTimeMillis();
Cache.init(Settings.getConfig().getCachePath());
MapXTEAs.loadKeys();
WorldDB DB = new WorldDB();
DB.init();
GameDecoder.loadPacketDecoders();
AsyncTaskExecutor.initExecutors();
PluginManager.loadPlugins();
PluginManager.executeStartupHooks();
try {
ServerChannelHandler.init(Settings.getConfig().getWorldInfo().port(), BaseWorldDecoder.class);
} catch (Throwable e) {
Logger.handle(Launcher.class, "main", e);
Logger.error(Launcher.class, "main", "Failed to initialize server channel handler. Shutting down...");
System.exit(1);
return;
}
WorldThread.init();
Logger.info(Launcher.class, "main", "Server launched in " + (System.currentTimeMillis() - currentTime) + " ms...");
Logger.info(Launcher.class, "main", "Server is listening at " + InetAddress.getLocalHost().getHostAddress() + ":" + Settings.getConfig().getWorldInfo().port() + "...");
Logger.info(Launcher.class, "main", "Player will be directed to "+Settings.getConfig().getWorldInfo()+"...");
Logger.info(Launcher.class, "main", "Registering world with lobby server...");
Logger.info(Launcher.class, "main", Settings.getConfig().getWorldInfo());
new WorldAPI().start();
LobbyCommunicator.post(Boolean.class, Settings.getConfig().getWorldInfo(), "addworld", success -> {
if (success)
Logger.info(Launcher.class, "main", "Registered world with lobby server...");
else
Logger.warn(Launcher.class, "main", "Failed to register world with lobby server... You can still login locally but social features will not work properly.");
});
addCleanMemoryTask();
// Runtime.getRuntime().addShutdownHook(new Thread() {
// @Override
// public void run() {
// try {
// for (Player player : World.getPlayers()) {
// if (player == null || !player.hasStarted())
// continue;
// try {
// player.getPackets().sendLogout(player, true);
// player.realFinish();
// } catch(Throwable e) {
//
// }
// }
// PartyRoom.save();
// Launcher.shutdown();
// } catch (Throwable e) {
// Logger.handle(this, e);
// }
// }
// });
}
private static void addCleanMemoryTask() {
AsyncTaskExecutor.schedule(() -> {
try {
cleanMemory(WorldUtil.getMemUsedPerc() > Settings.HIGH_MEM_USE_THRESHOLD);
} catch (Throwable e) {
Logger.handle(Launcher.class, "addCleanMemoryTask", e);
}
}, 0, Ticks.fromMinutes(10));
//}, 0, Ticks.fromSeconds(10));
}
public static void saveFilesSync() {
for (Player player : World.getPlayers()) {
if (player == null || !player.hasStarted() || player.hasFinished())
continue;
WorldDB.getPlayers().saveSync(player);
}
WorldPersistentData.save();
}
public static void saveFilesAsync() {
for (Player player : World.getPlayers()) {
if (player == null || !player.hasStarted() || player.hasFinished())
continue;
WorldDB.getPlayers().save(player);
}
WorldPersistentData.save();
}
public static void cleanMemory(boolean force) {
if (force) {
ItemDefinitions.clearItemsDefinitions();
NPCDefinitions.clearNPCDefinitions();
ObjectDefinitions.clearObjectDefinitions();
ChunkManager.clearUnusedMemory();
Logger.debug(Launcher.class, "cleanMemory", "Force cleaning cached data.");
}
for (Index index : Cache.STORE.getIndices())
index.resetCachedFiles();
System.gc(); System.gc();
}
public static void shutdown() {
try {
closeServices();
} finally {
System.exit(0);
}
}
public static void closeServices() {
ServerChannelHandler.shutdown();
AsyncTaskExecutor.shutdown();
}
private Launcher() {
}
public static void executeCommand(String cmd) {
executeCommand(null, cmd);
}
public static void executeCommand(Player player, String cmd) {
AsyncTaskExecutor.execute(() -> {
try {
String line;
ProcessBuilder builder = new ProcessBuilder(cmd.split(" "));
Process proc = builder.start();
BufferedReader in = new BufferedReader(new InputStreamReader(proc.getInputStream()));
while ((line = in.readLine()) != null) {
if (player != null)
player.getPackets().sendDevConsoleMessage(line);
Logger.debug(Launcher.class, "executeCommand", line);
}
proc.waitFor();
in.close();
} catch (IOException | InterruptedException e) {
if (player != null)
player.getPackets().sendDevConsoleMessage("Error: " + e.getMessage());
Logger.handle(Launcher.class, "executeCommand", e);
}
});
}
}
|
package com.rs;
public final class Settings {
private static Settings SETTINGS;
private static final Settings DEFAULTS = new Settings();
public static Settings getConfig() {
if (SETTINGS == null)
loadConfig();
return SETTINGS;
}
private String serverName;
private String ownerName;
private String cachePath;
private boolean debug = false;
private boolean enableJFR = false;
private final boolean allowHighMemUseOptimizations;
private String mongoUrl;
private int mongoPort;
private String mongoUser;
private String mongoPass;
private String mongoDbName;
private String lobbyIp;
private String lobbyApiKey;
private WorldInfo worldInfo;
private String loginMessage;
private Tile playerStartTile;
private Tile playerRespawnTile;
private int xpRate;
private double dropModifier;
private Item[] startItems;
private String staffWebhookUrl;
public Settings() {
serverName = "Darkan";
ownerName = "trent";
cachePath = "../cache/";
debug = false;
enableJFR = false;
allowHighMemUseOptimizations = false;
lobbyIp = "dev.darkan.org";
mongoUrl = "localhost";
mongoPort = 27017;
mongoUser = "";
mongoPass = "";
mongoDbName = "darkan-server";
lobbyApiKey = "TEST_API_KEY";
worldInfo = new WorldInfo(3, "127.0.0.1", 43595, "My Test World", 1, false, true, true, false, false);
loginMessage = "";
playerStartTile = Tile.of(2889, 3528, 0);
playerRespawnTile = Tile.of(2887, 3535, 0);
xpRate = 1;
dropModifier = 1.0;
startItems = new Item[] {
new Item(1351, 1),
new Item(590, 1),
new Item(303, 1),
new Item(315, 1),
new Item(1925, 1),
new Item(1931, 1),
new Item(2309, 1),
new Item(1265, 1),
new Item(1205, 1),
new Item(1277, 1),
new Item(1171, 1),
new Item(841, 1),
new Item(882, 25),
new Item(556, 25),
new Item(558, 15),
new Item(555, 6),
new Item(557, 4),
new Item(559, 2),
};
staffWebhookUrl = null;
}
public static final long WORLD_CYCLE_NS = 600000000L;
public static final long WORLD_CYCLE_MS = WORLD_CYCLE_NS / 1000000L;
public static final int AIR_GUITAR_MUSICS_COUNT = 150;
public static final int PLAYERS_LIMIT = 2000;
public static final int LOCAL_PLAYERS_LIMIT = 250;
public static final int NPCS_LIMIT = 64000;
public static final int LOCAL_NPCS_LIMIT = 250;
public static final double HIGH_MEM_USE_THRESHOLD = 85.0;
public static ArrayList<String> COMMIT_HISTORY = new ArrayList<>();
public static void loadConfig() {
Logger.info(Settings.class, "loadConfig", "Loading config...");
try {
File rootConfigFile = new File("./worldConfig.json");
File dataConfigFile = new File("./data/worldConfig.json");
if (rootConfigFile.exists())
SETTINGS = JsonFileManager.loadJsonFile(rootConfigFile, Settings.class);
else if (dataConfigFile.exists())
SETTINGS = JsonFileManager.loadJsonFile(dataConfigFile, Settings.class);
else
SETTINGS = new Settings();
for (Field f : SETTINGS.getClass().getDeclaredFields())
if (f.get(SETTINGS) == null)
f.set(SETTINGS, f.get(DEFAULTS));
JsonFileManager.saveJsonFile(SETTINGS, dataConfigFile);
if (rootConfigFile.exists())
rootConfigFile.delete();
} catch (JsonIOException | IOException | IllegalArgumentException | IllegalAccessException e1) {
e1.printStackTrace();
System.exit(5);
}
try {
String line;
ProcessBuilder builder = new ProcessBuilder("git", "log", "-n", "1");
Process proc = builder.start();
BufferedReader in = new BufferedReader(new InputStreamReader(proc.getInputStream()));
boolean markMsg = false;
while ((line = in.readLine()) != null) {
if (line.isEmpty())
continue;
line = line.replace("commit ", "Hash: ");
if (markMsg) {
line = "Message: " + line.trim();
markMsg = false;
}
if (line.contains("Date: "))
markMsg = true;
COMMIT_HISTORY.add(line);
}
proc.waitFor();
in.close();
Logger.info(Settings.class, "loadConfig", "Commit history loaded: " + COMMIT_HISTORY);
} catch (JsonIOException | IOException | InterruptedException e) {
Logger.handle(Settings.class, "loadConfig", e);
}
Globals.DEBUG = getConfig().debug;
Logger.info(Settings.class, "loadConfig", "Loaded lobby IP: " + getConfig().lobbyIp);
}
public static void saveConfig() throws IOException {
JsonFileManager.saveJsonFile(SETTINGS, new File("./worldConfig.json"));
}
public String getServerName() {
return serverName;
}
public String getOwnerName() {
return ownerName;
}
public boolean isDebug() {
return debug;
}
public boolean isEnableJFR() {
return enableJFR;
}
public boolean isAllowHighMemUseOptimizations() {
return allowHighMemUseOptimizations;
}
public String getLoginMessage() {
return loginMessage;
}
public void setLoginMessage(String loginMessage) {
this.loginMessage = loginMessage;
}
public Tile getPlayerStartTile() {
return Tile.of(playerStartTile != null ? playerStartTile : DEFAULTS.playerStartTile);
}
public Tile getPlayerRespawnTile() {
return Tile.of(playerRespawnTile != null ? playerRespawnTile : DEFAULTS.playerRespawnTile);
}
public int getXpRate() {
return xpRate;
}
public double getDropModifier() {
return dropModifier;
}
public String getCachePath() {
return cachePath != null ? cachePath : DEFAULTS.cachePath;
}
public static boolean isOwner(String string) {
return string.equalsIgnoreCase(SETTINGS.getOwnerName());
}
public Item[] getStartItems() {
return startItems != null ? startItems : DEFAULTS.startItems;
}
public WorldInfo getWorldInfo() {
return worldInfo != null ? worldInfo : DEFAULTS.worldInfo;
}
public String getLobbyIp() {
return lobbyIp;
}
public String getLobbyApiKey() {
return lobbyApiKey;
}
public String getMongoDBName() {
return mongoDbName;
}
public String getMongoDb() {
String db = "mongodb://";
if (mongoUser != null && !mongoUser.isEmpty())
db += mongoUser + ":" + new PercentEscaper("", false).escape(mongoPass) + "@";
db += mongoUrl;
if (mongoPort > 0)
db += ":" + mongoPort;
db += "/"+mongoDbName+"?retryWrites=true&w=majority";
return db;
}
public String getStaffWebhookUrl() {
return staffWebhookUrl;
}
public void setJFR(boolean b) {
enableJFR = b;
}
}
|
package com.rs.db;
public class WorldDB extends DBConnection {
private static final PlayerManager PLAYERS = new PlayerManager();
private static final HighscoresManager HIGHSCORES = new HighscoresManager();
private static final GEManager GE = new GEManager();
private static final LogManager LOGS = new LogManager();
public WorldDB() {
super(Settings.getConfig().getMongoDb(), Settings.getConfig().getMongoDBName());
Logger.info(WorldDB.class, "constructor()", "Connecting to MongoDB and initializing databases...");
addItemManager(PLAYERS);
addItemManager(HIGHSCORES);
addItemManager(GE);
addItemManager(LOGS);
}
public static PlayerManager getPlayers() {
return PLAYERS;
}
public static HighscoresManager getHighscores() {
return HIGHSCORES;
}
public static GEManager getGE() {
return GE;
}
public static LogManager getLogs() {
return LOGS;
}
}
|
package com.rs.db.collection;
public class GEManager extends DBItemManager {
public GEManager() {
super("grandexchange");
}
@Override
public void initCollection() {
getDocs().createIndex(Indexes.text("owner"));
getDocs().createIndex(Indexes.compoundIndex(Indexes.ascending("itemId"), Indexes.ascending("completedAmount")));
getDocs().createIndex(Indexes.compoundIndex(Indexes.ascending("itemId"), Indexes.ascending("state")));
getDocs().createIndex(Indexes.compoundIndex(Indexes.ascending("itemId"), Indexes.ascending("price")));
getDocs().createIndex(Indexes.compoundIndex(Indexes.ascending("itemId"), Indexes.ascending("selling")));
}
public void get(String username, Consumer<List<Offer>> func) {
execute(() -> func.accept(getSync(username)));
}
public void save(Offer offer) {
save(offer, null);
}
public void save(Offer offer, Runnable done) {
execute(() -> {
saveSync(offer);
if (done != null)
done.run();
});
}
public void saveSync(Offer offers) {
getDocs().findOneAndReplace(Filters.and(Filters.eq("owner", offers.getOwner()), Filters.eq("box", offers.getBox())), Document.parse(JsonFileManager.toJson(offers)), new FindOneAndReplaceOptions().upsert(true));
}
public List<Offer> getSync(String username) {
FindIterable<Document> offerDocs = getDocs().find(Filters.eq("owner", username));
if (offerDocs == null)
return null;
try {
List<Offer> offers = new ArrayList<>(6);
for (Document d : offerDocs) {
Offer offer = JsonFileManager.fromJSONString(JsonFileManager.toJson(d), Offer.class);
offers.add(offer);
}
return offers;
} catch (JsonIOException | IOException e) {
Logger.handle(GEManager.class, "getSync", e);
return null;
}
}
public void remove(String username, int box, Runnable done) {
execute(() -> {
removeSync(username, box);
if (done != null)
done.run();
});
}
public void removeSync(String username, int box) {
getDocs().findOneAndDelete(Filters.and(Filters.eq("owner", username), Filters.eq("box", box)));
}
public List<Offer> getBestOffersSync(Offer other) {
if (other.getState() == State.FINISHED)
return null;
List<Offer> result = new ArrayList<>();
FindIterable<Document> docs = getDocs().find(Filters.and(Filters.eq("state", State.STABLE.toString()), Filters.eq("itemId", other.getItemId()), Filters.eq("selling", !other.isSelling()), other.isSelling() ? Filters.gte("price", other.getPrice()) : Filters.lte("price", other.getPrice()))).sort(Sorts.ascending("price"));
for (Document doc : docs)
try {
Offer offer = JsonFileManager.fromJSONString(JsonFileManager.toJson(doc), Offer.class);
result.add(offer);
} catch (JsonIOException | IOException e) {
Logger.handleNoRecord(GEManager.class, "getBestOffersSync", "Error converting document: " + result, e);
}
return result;
}
public void getBestOffer(int itemId, boolean sell, Consumer<Offer> func) {
execute(() -> {
FindIterable<Document> docs = getDocs().find(Filters.and(Filters.eq("state", State.STABLE.toString()), Filters.eq("itemId", itemId), Filters.eq("selling", !sell))).sort(sell ? Sorts.ascending("price") : Sorts.descending("price"));
try {
func.accept(JsonFileManager.fromJSONString(JsonFileManager.toJson(docs.first()), Offer.class));
} catch (JsonIOException | IOException e) {
func.accept(null);
}
});
}
public void getAllOffersOfType(boolean selling, Consumer<List<Offer>> func) {
execute(() -> {
List<Offer> result = new ArrayList<>();
FindIterable<Document> docs = getDocs().find(Filters.and(Filters.eq("state", State.STABLE.toString()), Filters.eq("selling", selling)));
for (Document doc : docs)
try {
Offer offer = JsonFileManager.fromJSONString(JsonFileManager.toJson(doc), Offer.class);
result.add(offer);
} catch (JsonIOException | IOException e) {
Logger.handleNoRecord(GEManager.class, "getAllOffersOfType", "Error converting document: " + result, e);
}
func.accept(result);
});
}
}
|
package com.rs.db.collection;
public class HighscoresManager extends DBItemManager {
public HighscoresManager() {
super("highscores");
}
@Override
public void initCollection() {
getDocs().createIndex(Indexes.compoundIndex(Indexes.text("displayName"), Indexes.text("username")));
getDocs().createIndex(Indexes.descending("totalLevel", "totalXp"));
}
public void save(Player player) {
save(player, null);
}
public void save(Player player, Runnable done) {
execute(() -> {
saveSync(player);
if (done != null)
done.run();
});
}
public void saveSync(Player player) {
if (player.hasRights(Rights.OWNER) || player.hasRights(Rights.DEVELOPER) || player.hasRights(Rights.ADMIN) || player.getSkills().getTotalXp() < 50000)
return;
try {
getDocs().findOneAndReplace(eq("username", player.getUsername()), Document.parse(JsonFileManager.toJson(new Highscore(player))), new FindOneAndReplaceOptions().upsert(true));
} catch (Exception e) {
Logger.handle(HighscoresManager.class, "saveSync", e);
}
}
public void getPlayerAtPosition(int rank, Consumer<Highscore> top) {
execute(() -> {
try {
top.accept(JsonFileManager.fromJSONString(getDocs().find().sort(Sorts.descending("totalLevel", "totalXp")).skip(rank).limit(1).first().toJson(), Highscore.class));
} catch(Throwable e) {
top.accept(null);
}
});
}
}
|
package com.rs.db.collection;
public class PlayerManager extends DBItemManager {
public PlayerManager() {
super("players");
}
@Override
public void initCollection() {
getDocs().createIndex(Indexes.text("username"));
}
public void getByUsername(String username, Consumer<Player> func) {
execute(() -> func.accept(getSyncUsername(username)));
}
public void save(Player player) {
save(player, null);
}
public void save(Player account, Runnable done) {
execute(() -> {
saveSync(account);
if (done != null)
done.run();
});
}
public void saveSync(Player account) {
try {
getDocs().findOneAndReplace(eq("username", account.getUsername()), Document.parse(JsonFileManager.toJson(account)), new FindOneAndReplaceOptions().upsert(true));
} catch(Throwable e) {
Logger.handle(PlayerManager.class, "saveSync", "Error saving player: " + account.getUsername(), e);
}
}
public Player getSyncUsername(String username) {
Player loggedIn = World.getPlayerByUsername(username);
if (loggedIn != null)
return loggedIn;
Document accDoc = getDocs().find(eq("username", username)).first();
if (accDoc == null)
return null;
try {
return JsonFileManager.fromJSONString(JsonFileManager.toJson(accDoc), Player.class);
} catch (JsonIOException | IOException e) {
Logger.handle(PlayerManager.class, "getSyncUsername", e);
return null;
}
}
public boolean usernameExists(String username) {
return getSyncUsername(username) == null;
}
}
|
package com.rs.db.collection.logs;
public class CommandLog {
private final String uuid;
private final String player;
private final String command;
public CommandLog(String player, String command) {
this.player = player;
this.command = command;
this.uuid = UUID.randomUUID().toString();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
CommandLog that = (CommandLog) o;
return Objects.equals(uuid, that.uuid) && Objects.equals(player, that.player) && Objects.equals(command, that.command);
}
@Override
public int hashCode() {
return Objects.hash(uuid, player, command);
}
}
|
package com.rs.db.collection.logs;
public class GELog {
private final String uuid;
private final String from;
private final String to;
private final String item;
private final int itemId;
private final int amount;
private final int price;
public GELog(Offer offer1, Offer offer2, int amount, int price) {
Offer sellOffer = offer1.getOfferType() == GE.OfferType.SELL ? offer1 : offer2;
Offer buyOffer = offer2.getOfferType() == GE.OfferType.BUY ? offer2 : offer1;
to = buyOffer.getOwner();
item = ItemDefinitions.getDefs(sellOffer.getItemId()).name;
itemId = sellOffer.getItemId();
this.amount = amount;
this.price = price;
this.uuid = UUID.randomUUID().toString();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
GELog geLog = (GELog) o;
return itemId == geLog.itemId && amount == geLog.amount && price == geLog.price && Objects.equals(uuid, geLog.uuid) && Objects.equals(from, geLog.from) && Objects.equals(to, geLog.to) && Objects.equals(item, geLog.item);
}
@Override
public int hashCode() {
return Objects.hash(from, to, item, itemId, amount, price, uuid);
}
}
|
package com.rs.db.collection.logs;
public class GraveLog {
private final String uuid;
private final String player;
private final Tile tile;
private final List<Item> items;
public GraveLog(String player, GraveStone grave) {
this.player = player;
this.tile = grave.getTile();
items = new ArrayList<>();
for (GroundItem item : grave.getItems())
if (item != null)
items.add(new Item(item));
this.uuid = UUID.randomUUID().toString();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
GraveLog graveLog = (GraveLog) o;
return Objects.equals(uuid, graveLog.uuid) && Objects.equals(player, graveLog.player) && Objects.equals(tile, graveLog.tile) && Objects.equals(items, graveLog.items);
}
@Override
public int hashCode() {
return Objects.hash(uuid, player, tile, items);
}
}
|
package com.rs.db.collection.logs;
public class LogEntry {
public enum LogType {
ERROR,
GE, PICKUP, GRAVE, COMMAND, REPORT, TRADE
}
private final Date date;
private final LogType type;
private final long hash;
private final Object data;
public LogEntry(LogType type, long hash, Object data) {
this.date = new Date();
this.type = type;
this.hash = hash;
this.data = data;
}
public Date getDate() {
return date;
}
public LogType getType() {
return type;
}
public long getHash() {
return hash;
}
public Object getData() {
return data;
}
}
|
package com.rs.db.collection.logs;
public class LogManager extends DBItemManager {
public LogManager() {
super("logs");
}
@Override
public void initCollection() {
getDocs().createIndex(Indexes.text("type"));
getDocs().createIndex(Indexes.descending("hash"));
getDocs().createIndex(Indexes.ascending("date"), new IndexOptions().expireAfter(180L, TimeUnit.DAYS));
}
public void save(LogEntry entry) {
save(entry, null);
}
public void save(LogEntry entry, Runnable done) {
execute(() -> {
saveSync(entry);
if (done != null)
done.run();
});
}
public void saveSync(LogEntry entry) {
try {
getDocs().findOneAndReplace(eq("hash", entry.getHash()), Document.parse(JsonFileManager.toJson(entry)), new FindOneAndReplaceOptions().upsert(true));
} catch(Throwable e) {
e.printStackTrace();
}
}
public void logGE(Offer offer, Offer other, int num, int price) {
GELog log = new GELog(offer, other, num, price);
save(new LogEntry(LogEntry.LogType.GE, log.hashCode(), log));
}
public void logTrade(Player player1, Trade p1Trade, Player p2, Trade p2Trade) {
List<Item> p1Items = new ArrayList<>();
List<Item> p2Items = new ArrayList<>();
for (Item item : p1Trade.getItems().array())
if (item != null)
p1Items.add(item);
for (Item item : p2Trade.getItems().array())
if (item != null)
p2Items.add(item);
if (p1Items.size() > 0 || p2Items.size() > 0) {
TradeLog log = new TradeLog(player1, p1Items, p2, p2Items);
save(new LogEntry(LogEntry.LogType.TRADE, log.hashCode(), log));
}
}
public void logPickup(Player player, GroundItem item) {
PickupLog log = new PickupLog(player, item);
save(new LogEntry(LogEntry.LogType.PICKUP, log.hashCode(), log));
}
public void logGrave(String player, GraveStone grave) {
GraveLog log = new GraveLog(player, grave);
save(new LogEntry(LogEntry.LogType.GRAVE, log.hashCode(), log));
}
public void logReport(Player reporter, Player reported, ReportsManager.Rule rule) {
if (reporter == null || reported == null)
return;
ReportLog log = new ReportLog(reporter, reported, rule);
save(new LogEntry(LogEntry.LogType.REPORT, log.hashCode(), log));
}
public void logCommand(String username, String commandStr) {
CommandLog log = new CommandLog(username, commandStr);
save(new LogEntry(LogEntry.LogType.COMMAND, log.hashCode(), log));
}
}
|
package com.rs.db.collection.logs;
public class PickupLog {
private final String uuid;
private final String player;
private final String itemName;
private final Item item;
private final Tile tile;
private final String owner;
public PickupLog(Player player, GroundItem item) {
this.player = player.getUsername();
this.tile = item.getTile();
this.item = new Item(item);
this.itemName = item.getName();
this.owner = item.getCreatorUsername();
this.uuid = UUID.randomUUID().toString();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
PickupLog pickupLog = (PickupLog) o;
return Objects.equals(uuid, pickupLog.uuid) && Objects.equals(player, pickupLog.player) && Objects.equals(itemName, pickupLog.itemName) && Objects.equals(item, pickupLog.item) && Objects.equals(tile, pickupLog.tile) && Objects.equals(owner, pickupLog.owner);
}
@Override
public int hashCode() {
return Objects.hash(uuid, player, itemName, item, tile, owner);
}
}
|
package com.rs.db.collection.logs;
public class ReportLog {
private Object relevantData;
public ReportLog(Player reporter, Player reported, Rule rule) {
String player = reported.getUsername();
String reporter1 = reporter.getUsername();
}
//TODO finish
//TODO create hashCode and equals
}
|
package com.rs.db.collection.logs;
public class TradeLog {
private final String uuid;
private final String player1;
private final List<Item> p1Items;
private final String player2;
private final List<Item> p2Items;
public TradeLog(Player p1, List<Item> p1Items, Player p2, List<Item> p2Items) {
this.player1 = p1.getUsername();
this.p1Items = p1Items;
this.player2 = p2.getUsername();
this.p2Items = p2Items;
this.uuid = UUID.randomUUID().toString();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
TradeLog tradeLog = (TradeLog) o;
return Objects.equals(uuid, tradeLog.uuid) && Objects.equals(player1, tradeLog.player1) && Objects.equals(p1Items, tradeLog.p1Items) && Objects.equals(player2, tradeLog.player2) && Objects.equals(p2Items, tradeLog.p2Items);
}
@Override
public int hashCode() {
int result = Objects.hash(uuid, player1, player2, p1Items, p2Items);
return result;
}
}
|
package com.rs.db.model;
public class Highscore {
private final String username;
private final String displayName;
private final boolean ironman;
private final int totalLevel;
private final long totalXp;
private final int[] xp;
public Highscore(Player player) {
if (player.getDisplayName() == null)
throw new RuntimeException("No display name found for player: " + player.getUsername());
username = player.getUsername();
displayName = player.getDisplayName();
ironman = player.isIronMan();
totalLevel = player.getSkills().getTotalLevel();
totalXp = player.getSkills().getTotalXp();
xp = player.getSkills().getXpInt();
}
public boolean isIronman() {
return ironman;
}
public int getTotalLevel() {
return totalLevel;
}
public long getTotalXp() {
return totalXp;
}
public int[] getXp() {
return xp;
}
public String getUsername() {
return username;
}
public String getDisplayName() {
return displayName;
}
}
|
package com.rs.engine;
@PluginEventHandler
public class Shop {
private static final int MAIN_STOCK_ITEMS_KEY = 0;
private static final int MAX_SHOP_ITEMS = 40;
private String name;
private ShopItem[] mainStock;
private int[] defaultQuantity;
private ShopItem[] generalStock;
private boolean buyOnly;
private int currency;
private final transient CopyOnWriteArrayList<Player> viewingPlayers;
public Shop(String name, int money, ShopItem[] shopItems, boolean isGeneralStore, boolean buyOnly) {
viewingPlayers = new CopyOnWriteArrayList<>();
this.name = name;
currency = money;
mainStock = shopItems;
defaultQuantity = new int[shopItems.length];
for (int i = 0; i < defaultQuantity.length; i++)
defaultQuantity[i] = shopItems[i].getItem().getAmount();
if (isGeneralStore && shopItems.length < MAX_SHOP_ITEMS)
generalStock = new ShopItem[MAX_SHOP_ITEMS - shopItems.length];
this.buyOnly = buyOnly;
for (ShopItem item : mainStock) {
if (item == null)
continue;
item.init();
}
}
public static ButtonClickHandler handleInterfaces = new ButtonClickHandler(new Object[] { 449, 1265, 1266, 621 }, e -> {
if (e.getInterfaceId() == 449) {
if (e.getComponentId() == 1) {
Shop shop = e.getPlayer().getTempAttribs().getO("Shop");
if (shop == null)
return;
shop.sendInventory(e.getPlayer());
} else if (e.getComponentId() == 21) {
Shop shop = e.getPlayer().getTempAttribs().getO("Shop");
if (shop == null)
return;
int slot = e.getPlayer().getTempAttribs().getI("ShopSelectedSlot");
if (slot == -1)
return;
if (e.getPacket() == ClientPacket.IF_OP1)
shop.buy(e.getPlayer(), slot, 1);
else if (e.getPacket() == ClientPacket.IF_OP2)
shop.buy(e.getPlayer(), slot, 5);
else if (e.getPacket() == ClientPacket.IF_OP3)
shop.buy(e.getPlayer(), slot, 10);
else if (e.getPacket() == ClientPacket.IF_OP4)
shop.buy(e.getPlayer(), slot, 50);
shop.sendCustomPrices(e.getPlayer());
}
} else if (e.getInterfaceId() == 1265) {
Shop shop = e.getPlayer().getTempAttribs().getO("Shop");
if (shop == null)
return;
int slot = e.getPlayer().getTempAttribs().getI("ShopSelectedSlot");
boolean isBuying = e.getPlayer().getTempAttribs().getB("shop_buying");
if (e.getComponentId() == 20) {
e.getPlayer().getTempAttribs().setI("ShopSelectedSlot", e.getSlotId());
if (e.getPacket() == ClientPacket.IF_OP1)
shop.sendInfo(e.getPlayer(), e.getSlotId(), isBuying);
else if (e.getPacket() == ClientPacket.IF_OP2)
shop.handleShop(e.getPlayer(), e.getSlotId(), 1);
else if (e.getPacket() == ClientPacket.IF_OP3)
shop.handleShop(e.getPlayer(), e.getSlotId(), 5);
else if (e.getPacket() == ClientPacket.IF_OP4)
shop.handleShop(e.getPlayer(), e.getSlotId(), 10);
else if (e.getPacket() == ClientPacket.IF_OP5)
shop.handleShop(e.getPlayer(), e.getSlotId(), 50);
else if (e.getPacket() == ClientPacket.IF_OP6)
shop.handleShop(e.getPlayer(), e.getSlotId(), 500);
else if (e.getPacket() == ClientPacket.IF_OP7)
e.getPlayer().sendOptionDialogue("Really buy out the shop? This could be absurdly expensive.", ops -> {
ops.add("Yes, I am sure.", () -> shop.handleShop(e.getPlayer(), e.getSlotId(), Integer.MAX_VALUE));
ops.add("Nevermind.");
});
else if (e.getPacket() == ClientPacket.IF_OP10)
shop.sendExamine(e.getPlayer(), e.getSlotId());
} else if (e.getComponentId() == 201) {
if (slot == -1)
return;
if (isBuying)
shop.buy(e.getPlayer(), slot, e.getPlayer().getTempAttribs().getI("shopAmt", 0));
else {
shop.sell(e.getPlayer(), slot, e.getPlayer().getTempAttribs().getI("shopAmt", 0));
e.getPlayer().getVars().setVar(2563, 0);
e.getPlayer().getVars().setVar(2565, 1); // this is to update the tab.
}
} else if (e.getComponentId() == 208) {
e.getPlayer().getTempAttribs().setI("shopAmt", Utils.clampI(e.getPlayer().getTempAttribs().getI("shopAmt", 0) + 5, 1, 5000));
e.getPlayer().getPackets().setIFText(1265, 67, String.valueOf(e.getPlayer().getTempAttribs().getI("shopAmt", 0)));
} else if (e.getComponentId() == 15) {
e.getPlayer().getTempAttribs().setI("shopAmt", Utils.clampI(e.getPlayer().getTempAttribs().getI("shopAmt", 0) + 1, 1, 5000));
e.getPlayer().getPackets().setIFText(1265, 67, String.valueOf(e.getPlayer().getTempAttribs().getI("shopAmt", 0)));
} else if (e.getComponentId() == 214) {
e.getPlayer().getTempAttribs().setI("shopAmt", Utils.clampI(e.getPlayer().getTempAttribs().getI("shopAmt", 0) - 1, 1, 5000));
e.getPlayer().getPackets().setIFText(1265, 67, String.valueOf(e.getPlayer().getTempAttribs().getI("shopAmt", 0)));
} else if (e.getComponentId() == 217) {
e.getPlayer().getTempAttribs().setI("shopAmt", Utils.clampI(e.getPlayer().getTempAttribs().getI("shopAmt", 0) - 5, 1, 5000));
e.getPlayer().getPackets().setIFText(1265, 67, String.valueOf(e.getPlayer().getTempAttribs().getI("shopAmt", 0)));
} else if (e.getComponentId() == 220) {
e.getPlayer().getTempAttribs().setI("shopAmt", 1);
e.getPlayer().getPackets().setIFText(1265, 67, String.valueOf(e.getPlayer().getTempAttribs().getI("shopAmt", 0)));
} else if (e.getComponentId() == 211) {
if ((slot == -1) || (shop.getMainStock() == null) || (slot > shop.getMainStock().length - 1) || (shop.getMainStock()[slot] == null))
return;
if (e.getPlayer().getInventory().getItems().array()[slot] == null)
return;
e.getPlayer().getTempAttribs().setI("shopAmt", Utils.clampI(isBuying ? shop.getMainStock()[slot].getItem().getAmount() : e.getPlayer().getInventory().getItems().array()[slot].getAmount(), 1, 5000));
e.getPlayer().getPackets().setIFText(1265, 67, String.valueOf(e.getPlayer().getTempAttribs().getI("shopAmt", 0)));
} else if (e.getComponentId() == 29) {
e.getPlayer().getVars().setVar(2561, 93);
e.getPlayer().getTempAttribs().removeB("shop_buying");
e.getPlayer().getTempAttribs().setI("shopAmt", 1);
} else if (e.getComponentId() == 28) {
e.getPlayer().getTempAttribs().setB("shop_buying", true);
e.getPlayer().getTempAttribs().setI("shopAmt", 1);
e.getPlayer().getPackets().setIFText(1265, 67, String.valueOf(e.getPlayer().getTempAttribs().getI("shopAmt", 0)));
}
shop.sendCustomPrices(e.getPlayer());
} else if (e.getInterfaceId() == 1266) {
if (e.getComponentId() == 0)
if (e.getPacket() == ClientPacket.IF_OP6)
e.getPlayer().getInventory().sendExamine(e.getSlotId());
else {
Shop shop = e.getPlayer().getTempAttribs().getO("Shop");
if (shop == null)
return;
e.getPlayer().getVars().setVar(2563, e.getSlotId());
if (e.getPacket() == ClientPacket.IF_OP1)
shop.sendValue(e.getPlayer(), e.getSlotId());
else if (e.getPacket() == ClientPacket.IF_OP2)
shop.sell(e.getPlayer(), e.getSlotId(), 1);
else if (e.getPacket() == ClientPacket.IF_OP3)
shop.sell(e.getPlayer(), e.getSlotId(), 5);
else if (e.getPacket() == ClientPacket.IF_OP4)
shop.sell(e.getPlayer(), e.getSlotId(), 10);
else if (e.getPacket() == ClientPacket.IF_OP5)
shop.sell(e.getPlayer(), e.getSlotId(), 50);
}
} else if (e.getInterfaceId() == 621)
if (e.getComponentId() == 0)
if (e.getPacket() == ClientPacket.IF_OP6)
e.getPlayer().getInventory().sendExamine(e.getSlotId());
else {
Shop shop = e.getPlayer().getTempAttribs().getO("Shop");
if (shop == null)
return;
if (e.getPacket() == ClientPacket.IF_OP1)
shop.sendValue(e.getPlayer(), e.getSlotId());
else if (e.getPacket() == ClientPacket.IF_OP2)
shop.sell(e.getPlayer(), e.getSlotId(), 1);
else if (e.getPacket() == ClientPacket.IF_OP3)
shop.sell(e.getPlayer(), e.getSlotId(), 5);
else if (e.getPacket() == ClientPacket.IF_OP4)
shop.sell(e.getPlayer(), e.getSlotId(), 10);
else if (e.getPacket() == ClientPacket.IF_OP5)
shop.sell(e.getPlayer(), e.getSlotId(), 50);
}
});
public boolean isGeneralStore() {
return generalStock != null;
}
public void addPlayer(final Player player) {
viewingPlayers.add(player);
player.getTempAttribs().setO("Shop", this);
player.setCloseInterfacesEvent(() -> {
viewingPlayers.remove(player);
player.getTempAttribs().removeO("Shop");
});
player.getVars().setVar(118, MAIN_STOCK_ITEMS_KEY);
player.getVars().setVar(1496, -1);
player.getVars().setVar(532, currency);
player.getVars().setVar(2561, -1);
player.getVars().setVar(2562, -1);
player.getVars().setVar(2563, -1);
//player.getVars().setVar(2565, 1); //changes to sell tab
player.getVars().syncVarsToClient();
sendStore(player);
player.getInterfaceManager().sendInterface(1265);
player.getPackets().sendVarc(1876, -1);
player.getPackets().setIFEvents(new IFEvents(1265, 20, 0, getStoreSize() * 6).enableRightClickOptions(0,1,2,3,4,5,9));
player.getPackets().setIFEvents(new IFEvents(1265, 26, 0, getStoreSize() * 6)
.enableUseOptions(UseFlag.ICOMPONENT)
.enableRightClickOptions(0,2,3)
.setDepth(4)
.enableDrag()
.enableDepthFlagIgnoring()
.enableUseTargetability());
player.getPackets().setIFText(1265, 85, name);
if (isGeneralStore())
player.getPackets().setIFHidden(1265, 52, false);
sendInventory(player);
player.getTempAttribs().setB("shop_buying", true);
WorldTasks.delay(1, () -> sendCustomPrices(player));
}
public void sendCustomPrices(Player player) {
if (!player.getTempAttribs().getB("shop_buying"))
return;
for (int i = 0;i < mainStock.length;i++) {
if (mainStock[i] == null)
continue;
//player.getPackets().setIFSprite(1265, 24, i, 592);
if (mainStock[i].getCustomPrice() > 0)
player.getPackets().setIFText(1265, 23, i, Utils.kmify(mainStock[i].getCustomPrice()));
}
}
public void sendInventory(Player player) {
player.getInterfaceManager().sendInventoryInterface(1266);
player.getPackets().sendItems(93, player.getInventory().getItems());
player.getPackets().setIFRightClickOps(1266, 0, 0, 27, 0, 1, 2, 3, 4, 5);
player.getPackets().sendInterSetItemsOptionsScript(1266, 0, 93, 4, 7, "Value", "Sell 1", "Sell 5", "Sell 10", "Sell 50", "Examine");
}
// cid 67
public void buy(Player player, int slotId, int quantity) {
if (slotId >= mainStock.length && player.isIronMan()) {
player.sendMessage("You can't buy something another player has sold as an ironman!");
return;
}
if (slotId >= getStoreSize())
return;
ShopItem item = slotId >= mainStock.length ? generalStock[slotId - mainStock.length] : mainStock[slotId];
if (item == null)
return;
if (item.getItem().getAmount() == 0) {
player.sendMessage("There is no stock of that item at the moment.");
return;
}
int price = getBuyPrice(item);
int amountCoins = currency == 995 ? player.getInventory().getCoinsAsInt() : player.getInventory().getItems().getNumberOf(currency);
int maxQuantity = amountCoins / price;
int buyQ = Math.min(item.getItem().getAmount(), quantity);
boolean enoughCoins = maxQuantity >= buyQ;
if (!enoughCoins) {
player.sendMessage("You don't have enough " + ItemDefinitions.getDefs(currency).name.toLowerCase() + ".");
buyQ = maxQuantity;
} else if (quantity > buyQ)
player.sendMessage("The shop has run out of stock.");
if (item.getItem().getDefinitions().isStackable()) {
if (player.getInventory().getFreeSlots() < 1) {
player.sendMessage("Not enough space in your inventory.");
return;
}
} else {
int freeSlots = player.getInventory().getFreeSlots();
if (buyQ > freeSlots) {
buyQ = freeSlots;
player.sendMessage("Not enough space in your inventory.");
}
}
if (buyQ != 0) {
int totalPrice = price * buyQ;
if (currency == 995)
player.getInventory().removeCoins(totalPrice);
else
player.getInventory().deleteItem(currency, totalPrice);
if (item.getItem().getId() == 36 && buyQ == 5)
player.getInventory().addItem(24170, 1);
else
player.getInventory().addItem(item.getItem().getId(), buyQ);
item.getItem().setAmount(item.getItem().getAmount() - buyQ);
if (item.getItem().getAmount() <= 0 && slotId >= mainStock.length)
generalStock[slotId - mainStock.length] = null;
refreshShop();
sendInventory(player);
}
}
public void restoreItems() {
boolean needRefresh = false;
for (ShopItem element : mainStock) {
if (element == null)
continue;
if (element.tickRestock())
needRefresh = true;
}
if (generalStock != null)
for (int i = 0; i < generalStock.length; i++) {
if (generalStock[i] == null)
continue;
if (generalStock[i].tickRestock())
needRefresh = true;
if (generalStock[i].getItem().getAmount() <= 0)
generalStock[i] = null;
}
if (needRefresh) {
refreshShop();
for (Player player : viewingPlayers)
WorldTasks.delay(0, () -> sendCustomPrices(player));
}
}
private boolean addItem(int itemId, int quantity) {
for (ShopItem item : mainStock)
if (item.getItem().getId() == itemId) {
item.getItem().setAmount(item.getItem().getAmount() + quantity);
refreshShop();
return true;
}
if (generalStock != null) {
for (ShopItem item : generalStock) {
if (item == null)
continue;
if (item.getItem().getId() == itemId) {
item.getItem().setAmount(item.getItem().getAmount() + quantity);
refreshShop();
return true;
}
}
for (int i = 0; i < generalStock.length; i++)
if (generalStock[i] == null) {
generalStock[i] = new ShopItem(itemId, quantity);
generalStock[i].setCap(-1);
refreshShop();
return true;
}
}
return false;
}
public void sell(Player player, int slotId, int quantity) {
if (buyOnly) {
player.sendMessage("You cannot sell items to this shop.");
return;
}
if (player.getInventory().getItemsContainerSize() < slotId)
return;
Item item = player.getInventory().getItem(slotId);
if (item == null)
return;
int originalId = item.getId();
if (item.getDefinitions().isNoted())
item = new Item(item.getDefinitions().getCertId(), item.getAmount());
if (item.getDefinitions().isDestroyItem() || !ItemConstants.isTradeable(item) || item.getId() == currency) {
player.sendMessage("You can't sell this item.");
return;
}
int dq = getDefaultQuantity(item.getId());
if (dq == -1 && generalStock == null) {
player.sendMessage("You can't sell this item to this shop.");
return;
}
int numberOff = player.getInventory().getItems().getNumberOf(originalId);
if (quantity > numberOff)
quantity = numberOff;
if (!addItem(item.getId(), quantity)) {
player.sendMessage("Shop is currently full.");
return;
}
if ((player.getInventory().getNumberOf(currency) + (getSellPrice(item)*quantity)) < 0 || (player.getInventory().getNumberOf(currency)+(getSellPrice(item)*quantity)) > Integer.MAX_VALUE)
player.sendMessage("Looks like we need an eco reset..");
else {
player.getInventory().deleteItem(originalId, quantity);
if (currency == 995)
player.getInventory().addCoins(getSellPrice(item) * quantity);
else
player.getInventory().addItem(currency, getSellPrice(item) * quantity);
}
}
public void sendValue(Player player, int slotId) {
if (player.getInventory().getItemsContainerSize() < slotId)
return;
Item item = player.getInventory().getItem(slotId);
if (item == null)
return;
if (item.getDefinitions().isNoted())
item = new Item(item.getDefinitions().getCertId(), item.getAmount());
if (item.getDefinitions().isNoted() || !ItemConstants.isTradeable(item) || item.getId() == currency) {
player.sendMessage("You can't sell this item.");
return;
}
int dq = getDefaultQuantity(item.getId());
if (dq == -1 && generalStock == null) {
player.sendMessage("You can't sell this item to this shop.");
return;
}
player.sendMessage(item.getDefinitions().getName() + ": shop will buy for: " + getSellPrice(item) + " " + ItemDefinitions.getDefs(currency).getName().toLowerCase() + ". Right-click the item to sell.");
}
public int getDefaultQuantity(int itemId) {
for (int i = 0; i < mainStock.length; i++)
if (mainStock[i].getItem().getId() == itemId)
return defaultQuantity[i];
return -1;
}
public void sendInfo(Player player, int slotId, boolean isBuying) {
if (slotId >= getStoreSize())
return;
if (isBuying) {
ShopItem item = slotId >= mainStock.length ? generalStock[slotId - mainStock.length] : mainStock[slotId];
if (item == null)
return;
int price = getBuyPrice(item);
player.sendMessage(item.getItem().getDefinitions().getName() + ": shop will " + (isBuying ? "sell" : "buy") + " for " + price + " " + ItemDefinitions.getDefs(currency).getName().toLowerCase() + ".");
} else {
Item[] stock = player.getInventory().getItems().array();
if (slotId >= stock.length)
return;
Item item = stock[slotId];
if (item == null)
return;
int price = getSellPrice(item);
player.sendMessage(item.getDefinitions().getName() + ": shop will " + (isBuying ? "sell" : "buy") + " for " + price + " " + ItemDefinitions.getDefs(currency).getName().toLowerCase() + ".");
}
}
public int getSellPrice(Item item) {
int price = item.getDefinitions().getSellPrice();
if (price == 0)
price = 1;
if (currency == 6529) {
EnumDefinitions defs = EnumDefinitions.getEnum(732);
if (defs.getIntValue(item.getId()) != -1)
return defs.getIntValue(item.getId());
} else if (currency == 995) {
EnumDefinitions defs = EnumDefinitions.getEnum(1441);
if (defs.getIntValue(item.getId()) != -1)
return defs.getIntValue(item.getId());
}
return price;
}
public int getBuyPrice(ShopItem item) {
if (item.getCustomPrice() > 0)
return item.getCustomPrice();
int price = item.getItem().getDefinitions().getValue();
if (price == 0)
price = 1;
if (currency == 6529) {
EnumDefinitions defs = EnumDefinitions.getEnum(731);
if (defs.getIntValue(item.getItem().getId()) != -1)
return defs.getIntValue(item.getItem().getId());
return (int) (price * 3.0 / 2.0);
}
if (currency == 995) {
EnumDefinitions defs = EnumDefinitions.getEnum(733);
if (defs.getIntValue(item.getItem().getId()) != -1)
return defs.getIntValue(item.getItem().getId());
}
return price;
}
public void sendExamine(Player player, int slotId) {
if (slotId >= getStoreSize())
return;
ShopItem item = slotId >= mainStock.length ? generalStock[slotId - mainStock.length] : mainStock[slotId];
if (item == null)
return;
player.sendMessage(ItemConfig.get(item.getItem().getId()).getExamine(item.getItem()));
}
public void refreshShop() {
for (Player player : viewingPlayers) {
sendStore(player);
player.getPackets().setIFEvents(new IFEvents(620, 25, 0, getStoreSize() * 6).enableRightClickOptions(0,1,2,3,4,5,9));
sendCustomPrices(player);
}
}
public int getStoreSize() {
return mainStock.length + (generalStock != null ? generalStock.length : 0);
}
public void sendStore(Player player) {
Item[] stock = new Item[mainStock.length + (generalStock != null ? generalStock.length : 0)];
for (int i = 0;i < stock.length;i++)
if (i >= mainStock.length) {
ShopItem item = generalStock[i - mainStock.length];
if (item == null)
continue;
stock[i] = item.getItem();
} else {
ShopItem item = mainStock[i];
if (item == null)
continue;
stock[i] = item.getItem();
}
player.getPackets().sendItems(MAIN_STOCK_ITEMS_KEY, stock);
}
// public void sendSellStore(Player player, Item[] inventory) {
// Item[] stock = new Item[inventory.length + (generalStock != null ? generalStock.length : 0)];
// System.arraycopy(inventory, 0, stock, 0, inventory.length);
// if (generalStock != null)
// System.arraycopy(generalStock, 0, stock, inventory.length, generalStock.length);
// player.getPackets().sendItems(MAIN_STOCK_ITEMS_KEY, stock);
// }
/**
* Checks if the player is buying an item or selling it.
*
* @param player
* The player
* @param slotId
* The slot id
* @param amount
* The amount
*/
public void handleShop(Player player, int slotId, int amount) {
if (player.getTempAttribs().getB("shop_buying"))
buy(player, slotId, amount);
else
sell(player, slotId, amount);
}
public ShopItem[] getMainStock() {
return mainStock;
}
public boolean isBuyOnly() {
return buyOnly;
}
}
|
package com.rs.engine.book;
@PluginEventHandler
public abstract class Book {
private static final int INTERFACE = 960;
private static final int[] LEFT_COMPONENTS = { 49, 56, 61, 62, 54, 63, 55, 51, 60, 58, 53, 50, 57, 59, 52 };
private static final int[] RIGHT_COMPONENTS = { 33, 39, 36, 44, 37, 46, 40, 42, 34, 35, 38, 43, 47, 45, 41 };
private Player player;
private int page;
private final String title;
private final BookPage[] pages;
public Book(String title, BookPage... pages) {
this.title = title;
this.pages = pages;
}
public Book(String title, String text) {
this.title = title;
this.pages = buildPages(text);
}
public static ButtonClickHandler handleInter = new ButtonClickHandler(INTERFACE, e -> {
if (e.getPlayer().getTempAttribs().getO("currBook") == null)
return;
Book book = e.getPlayer().getTempAttribs().getO("currBook");
if (e.getComponentId() == 72)
book.prevPage();
if (e.getComponentId() == 73)
book.nextPage();
});
public void open(Player player) {
this.player = player;
this.player.getTempAttribs().setO("currBook", this);
this.player.setCloseInterfacesEvent(() -> this.player.getTempAttribs().removeO("currBook"));
player.getPackets().setIFText(INTERFACE, 69, title);
page = 0;
update();
}
public void update() {
player.getInterfaceManager().sendInterface(INTERFACE);
if (page == 0) {
player.getPackets().setIFHidden(INTERFACE, 72, true);
player.getPackets().setIFText(INTERFACE, 70, "");
} else {
player.getPackets().setIFHidden(INTERFACE, 72, false);
player.getPackets().setIFText(INTERFACE, 70, "Prev");
}
if (page >= pages.length-1) {
player.getPackets().setIFHidden(INTERFACE, 73, true);
player.getPackets().setIFText(INTERFACE, 71, "");
} else {
player.getPackets().setIFHidden(INTERFACE, 73, false);
player.getPackets().setIFText(INTERFACE, 71, "Next");
}
for (int line = 0;line < LEFT_COMPONENTS.length;line++) {
player.getPackets().setIFText(INTERFACE, LEFT_COMPONENTS[line], pages[page].getLeftLine(line) == null ? "" : pages[page].getLeftLine(line));
player.getPackets().setIFText(INTERFACE, RIGHT_COMPONENTS[line], pages[page].getRightLine(line) == null ? "" : pages[page].getRightLine(line));
}
}
private BookPage[] buildPages(String text) {
List<BookPage> pages = new ArrayList<>();
String[] lines = Utils.splitTextIntoLines(text, 497, IComponentDefinitions.getInterfaceComponent(INTERFACE, RIGHT_COMPONENTS[0]).baseWidth);
int i = 0;
while (i < lines.length) {
String[] leftPageLines = new String[LEFT_COMPONENTS.length];
String[] rightPageLines = new String[RIGHT_COMPONENTS.length];
for (int j = 0; j < LEFT_COMPONENTS.length; j++) {
if (i < lines.length) {
leftPageLines[j] = lines[i];
i++;
} else {
break;
}
}
for (int k = 0; k < RIGHT_COMPONENTS.length; k++) {
if (i < lines.length) {
rightPageLines[k] = lines[i];
i++;
} else {
break;
}
}
pages.add(new BookPage(leftPageLines, rightPageLines));
}
return pages.toArray(BookPage[]::new);
}
public void nextPage() {
if (page >= pages.length-1)
return;
page++;
update();
}
public void prevPage() {
if (page <= 0)
return;
page--;
update();
}
}
|
package com.rs.engine.book;
public class BookPage {
private final String[] left;
private final String[] right;
public BookPage(String[] left, String[] right) {
if (left.length > 15 || right.length > 15)
throw new RuntimeException("Cannot create book page with longer than 15 lines of text.");
this.left = left;
this.right = right;
}
public String getLeftLine(int line) {
return line >= left.length ? "" : left[line];
}
public String getRightLine(int line) {
return line >= right.length ? "" : right[line];
}
}
|
package com.rs.engine.command;
public class Command {
private final String usage;
private final String description;
private final CommandExecution execution;
public Command(String usage, String description, CommandExecution execution) {
this.description = description;
this.execution = execution;
this.usage = usage;
}
public void execute(Player player, String[] args) {
execution.run(player, args);
}
public String getDescription() {
return description;
}
public String getUsage() {
return usage;
}
}
|
package com.rs.engine.command;
public interface CommandExecution {
void run(Player p, String[] args);
}
|
package com.rs.engine.command;
public final class Commands {
private static final Map<Rights, Map<String , Command>> COMMANDS = new HashMap<>();
private static final Map<Rights, Set<Command>> UNIQUE_COMMANDS = new HashMap<>();
static {
for (Rights r : Rights.values()) {
COMMANDS.put(r, new HashMap<>());
UNIQUE_COMMANDS.put(r, new HashSet<>());
}
}
public static Set<Command> getCommands(Rights rights) {
return UNIQUE_COMMANDS.get(rights);
}
public static void add(Rights rights, String usage, String description, CommandExecution execution) {
String aliases = usage.contains(" ") ? usage.substring(0, usage.indexOf(" ")) : usage;
Command command = new Command(usage, description, execution);
UNIQUE_COMMANDS.get(rights).add(command);
if (aliases.contains(",")) {
String[] aliasesArr = aliases.split(",");
for (String alias : aliasesArr)
COMMANDS.get(rights).put(alias, command);
} else
COMMANDS.get(rights).put(aliases, command);
}
public static boolean executeCommand(Rights rights, Player player, String name, String[] args) {
Command command = COMMANDS.get(rights).get(name);
if (command == null)
return false;
try {
command.execute(player, args);
} catch (Throwable e) {
if (Settings.getConfig().isDebug())
e.printStackTrace();
player.sendMessage("Error handling command. Proper usage is ::" + command.getUsage());
}
return true;
}
public static boolean processCommand(Player player, String commandStr, boolean console, boolean clientCommand) {
if (commandStr.length() == 0)
return false;
String[] cmd = commandStr.split(" ");
if ((cmd.length == 0) || (cmd.length == 0))
return false;
String[] args = new String[cmd.length - 1];
System.arraycopy(cmd, 1, args, 0, cmd.length - 1);
for (int i = Rights.values().length-1;i >= 0;i--) {
if (player.getRights().ordinal() < Rights.values()[i].ordinal())
continue;
if (executeCommand(Rights.values()[i], player, cmd[0].toLowerCase(), args)) {
if (Rights.values()[i] != Rights.PLAYER)
WorldDB.getLogs().logCommand(player.getUsername(), commandStr);
return true;
}
}
return false;
}
@SuppressWarnings("unused")
private static boolean REFACTOR_ALL_THESE_INTO_NEW_SYSTEM(final Player p, String[] casedCmd, String[] args, boolean console, boolean clientCommand) {
switch (args[0]) {
case "cc":
p.getTreasureTrailsManager().openReward(Integer.valueOf(args[1]));
return true;
case "companim":
if (Integer.valueOf(args[1]) > Utils.getNPCDefinitionsSize())
return true;
NPCDefinitions defs = NPCDefinitions.getDefs(Integer.valueOf(args[1]));
if (defs == null)
return true;
p.getPackets().sendDevConsoleMessage(Integer.valueOf(args[1]) + ": " + defs.getCompatibleAnimations().toString());
p.sendMessage(Integer.valueOf(args[1]) + ": " + defs.getCompatibleAnimations().toString());
Logger.debug(Commands.class, "REFACTOR.compAnim", defs.getCompatibleAnimations().toString());
return true;
case "trenttitle":
String title = "<shad=000000><col=FF0000>T</col><col=FF6600>h</col><col=FFFF00>e</col> <col=00FF00>B</col><col=0000FF>o</col><col=6600FF>s</col><col=FF00FF>s";
p.setTitle(title);
p.setTitleColor(null);
p.setTitleShading(null);
return true;
case "dailies":
p.processDailyTasks();
return true;
case "resethouse":
p.sendOptionDialogue("Delete your house?", ops -> {
ops.add("Yes", () -> p.getHouse().reset());
ops.add("No");
});
return true;
case "resettask":
p.getSlayer().removeTask();
p.updateSlayerTask();
return true;
case "snow":
for (int x = 0; x < 5; x++)
for (int y = 0; y < 5; y++)
World.spawnObject(new GameObject(3701, ObjectType.SCENERY_INTERACT, 1, p.getX() + (x * 10), p.getY() + (y * 10), 3));
for (int x = 0; x < 5; x++)
for (int y = 0; y < 5; y++)
World.spawnObject(new GameObject(3701, ObjectType.SCENERY_INTERACT, 1, p.getX() - (x * 10), p.getY() - (y * 10), 3));
for (int x = 0; x < 5; x++)
for (int y = 0; y < 5; y++)
World.spawnObject(new GameObject(3701, ObjectType.SCENERY_INTERACT, 1, p.getX() + (x * 10), p.getY() - (y * 10), 3));
for (int x = 0; x < 5; x++)
for (int y = 0; y < 5; y++)
World.spawnObject(new GameObject(3701, ObjectType.SCENERY_INTERACT, 1, p.getX() - (x * 10), p.getY() + (y * 10), 3));
return true;
case "glowme":
p.setNextBodyGlow(new BodyGlow(500, Integer.valueOf(args[1]), Integer.valueOf(args[2]), Integer.valueOf(args[3]), Integer.valueOf(args[4])));
return true;
// case "getaccs":
// ArrayList<String> ips = Utils.getCharactersWithIP(args[1]);
// p.getPackets().sendRunScriptReverse(1207, new Object[] { ips.size() });
// p.getInterfaceManager().sendInterface(275);
// p.getPackets().setIFText(275, 1, "Characters with IP: " + args[1]);
// int numa = 10;
// for (String ip : ips) {
// if (numa > 288)
// break;
// if (ip == null)
// continue;
// p.getPackets().setIFText(275, numa, ip);
// numa++;
// }
// return true;
case "script":
p.getPackets().sendRunScript(Integer.valueOf(args[1]));
return true;
case "kinship":
int sniper = 1;
int berserker = 3;
int tactician = 4;
int tank = 5;
int artisan = 0;
int gatherer = 0;
int medic = 0;
int blitzer = 0;
int blaster = 0;
int blazer = 0;
int desperado = 0;
int keenEye = 0;
p.getInterfaceManager().sendInterface(993);
p.getVars().setVar(1776, (sniper << 28) + (berserker << 24) + (tactician << 20) + (tank << 16));
p.getVars().setVar(1851, (artisan << 28) + (gatherer << 24) + (medic << 20) + (blitzer << 16) + (blaster << 12) + (blazer << 8) + (desperado << 4) + keenEye);
return true;
case "loadouts":
StringBuilder loadouts = new StringBuilder();
for (String keys : p.getSavingAttributes().keySet())
if (keys.contains("loadoutinv"))
loadouts.append(keys.replace("loadoutinv", "")).append(", ");
p.sendMessage(loadouts.toString());
return true;
case "resetbrew":
p.getKeldagrimBrewery().reset();
p.getPhasmatysBrewery().reset();
return true;
case "ferment":
p.getKeldagrimBrewery().ferment();
p.getKeldagrimBrewery().updateVars();
p.getPhasmatysBrewery().ferment();
p.getPhasmatysBrewery().updateVars();
return true;
case "proj":
World.sendProjectile(Tile.of(p.getX() + 5, p.getY(), p.getPlane()), Tile.of(p.getX() - 5, p.getY(), p.getPlane()), Integer.valueOf(args[1]), 40, 40, 0, 0.2, 0, 0);
return true;
case "house":
p.getHouse().enterMyHouse();
return true;
case "hintgame":
for (Player players : World.getPlayers())
players.getHintIconsManager().addHintIcon(p.getX(), p.getY(), 0, 0, 2, 0, -1, true);
return true;
case "endhintgame":
for (Player players : World.getPlayers())
players.getHintIconsManager().removeAll();
return true;
case "dropitem":
World.addGroundItem(new Item(Integer.valueOf(args[1]), 1), Tile.of(p.getX(), p.getY(), p.getPlane()));
return true;
case "trolldropitem":
for (Player players : World.getPlayers())
players.getPackets().sendGroundItem(new GroundItem(new Item(Integer.valueOf(args[1]), 1), Tile.of(p.getX(), p.getY(), p.getPlane()), players.getUsername(), GroundItemType.NORMAL));
return true;
case "deathnpcs":
if (Settings.isOwner(p.getUsername().toLowerCase()))
for (NPC npc : World.getNPCs()) {
if (npc instanceof Familiar || npc instanceof Pet)
continue;
if (Utils.getDistance(npc.getTile(), p.getTile()) < 9)
npc.sendDeath(p);
}
return true;
case "cutscene":
p.getPackets().sendCutscene(Integer.parseInt(args[1]));
return true;
}
return false;
}
public static void sendYell(Player player, String message, boolean staffYell) {
if (player.getAccount().isMuted()) {
player.sendMessage("You are muted. The mute will be lifted at " + player.getAccount().getUnmuteDate());
return;
}
if (staffYell) {
World.sendWorldMessage("[<col=ff0000>Staff Yell</col>] " + (player.hasRights(Rights.MOD) ? "<img=1>" : "") + player.getDisplayName() + ": <col=ff0000>" + message + ".</col>", true);
return;
}
if (message.length() > 100)
message = message.substring(0, 100);
if (!player.hasRights(Rights.ADMIN)) {
String[] invalid = { "<euro", "<img", "<img=", "<col", "<col=", "<shad", "<shad=", "<str>", "<u>" };
for (String s : invalid)
if (message.contains(s)) {
player.sendMessage("You cannot add additional code to the message.");
return;
}
if (player.getRights() == Rights.MOD)
World.sendWorldMessage("[<img=0><col=0077FF>Moderator</col>] <img=0>" + player.getDisplayName() + ": <col=0077FF>" + message + "", false);
else
World.sendWorldMessage("[<col=218736>Yell</col>] " + player.getDisplayName() + ": <col=218736>" + message + "", false);
return;
}
if (Settings.isOwner(player.getUsername().toLowerCase())) {
World.sendWorldMessage("[<img=1><col=ff0000><shad=000000>Owner/Developer</shad></col>] <img=1>" + player.getDisplayName() + ": <col=ff0000><shad=000000>" + message + "", false);
return;
}
World.sendWorldMessage("[<img=1><col=ff0000>Admin</col>] <img=1>" + player.getDisplayName() + ": <col=ff0000>" + message + "", false);
}
}
|
package com.rs.engine.cutscene;
public abstract class Cutscene {
private Player player;
private int currIndex;
private final Map<String, Object> objects = new HashMap<>();
private final List<CutsceneAction> actions = new ArrayList<>();
private int delay;
private boolean hideMap;
private boolean dialoguePaused;
private boolean constructingRegion;
private Instance instance;
private Tile endTile;
public abstract void construct(Player player);
public final void stopCutscene() {
if (player.getX() != endTile.getX() || player.getY() != endTile.getY() || player.getPlane() != endTile.getPlane())
player.tele(endTile);
if (hideMap)
player.getPackets().setBlockMinimapState(0);
restoreDefaultAspectRatio();
player.getPackets().sendResetCamera();
player.setLargeSceneView(false);
player.resetReceivedHits();
player.getPoison().reset();
player.unlock();
deleteObjects();
if (instance != null)
instance.destroy();
player.getTempAttribs().removeB("CUTSCENE_INTERFACE_CLOSE_DISABLED");
}
public final void startCutscene() {
if (hideMap)
player.getPackets().setBlockMinimapState(2);
player.setLargeSceneView(true);
player.lock();
player.stopAll(true, false);
player.getTempAttribs().setB("CUTSCENE_INTERFACE_CLOSE_DISABLED", true);
}
public void constructArea(final Tile returnTile, final int baseChunkX, final int baseChunkY, final int widthChunks, final int heightChunks, final boolean copyNpcs) {
constructingRegion = true;
Instance old = instance;
instance = Instance.of(returnTile, widthChunks, heightChunks, copyNpcs);
instance.copyMapAllPlanes(baseChunkX, baseChunkY).thenAccept(e -> {
instance.teleportTo(player);
constructingRegion = false;
if (old != null)
old.destroy();
});
}
public Player getPlayer() {
return player;
}
public void setPlayer(Player player) {
this.player = player;
}
public final void logout() {
stopCutscene();
}
public final boolean process() {
if (dialoguePaused)
return true;
if (delay > 0) {
delay--;
return true;
}
while(true) {
if (constructingRegion)
return true;
if (currIndex == actions.size()) {
stopCutscene();
return false;
} else if (currIndex == 0)
startCutscene();
CutsceneAction action = actions.get(currIndex++);
action.process(player, objects);
int delay = action.getDelay();
if (delay == -1)
continue;
this.delay = delay;
return true;
}
}
public void deleteObjects() {
for (Object object : objects.values())
deleteObject(object);
}
public void deleteObject(Object object) {
if (object instanceof NPC n && !n.persistsBeyondCutscene())
n.finish();
}
public final void createObjectMap() {
endTile = Tile.of(player.getTile());
objects.put("cutscene", this);
}
public int getX(int x) {
Instance instance = this.instance;
if (instance == null)
instance = player.getInstancedArea();
return instance != null && instance.isCreated() ? instance.getLocalX(x) : x;
}
public int getY(int y) {
Instance instance = this.instance;
if (instance == null)
instance = player.getInstancedArea();
return instance != null && instance.isCreated() ? instance.getLocalY(y) : y;
}
public int getLocalX(int x) {
return x > 0xFF ? (x - MapUtils.decode(Structure.CHUNK, player.getSceneBaseChunkId())[0] * 8) : x;
}
public int getLocalY(int y) {
return y > 0xFF ? (y - MapUtils.decode(Structure.CHUNK, player.getSceneBaseChunkId())[1] * 8) : y;
}
public boolean isHideMap() {
return hideMap;
}
public void hideMinimap() {
hideMinimap(true);
}
public void hideMinimap(boolean hide) {
this.hideMap = hide;
}
public void setEndTile(Tile tile) {
this.endTile = tile;
}
public Tile getEndTile() {
return endTile;
}
public void camPos(int x, int y, int height, int delay) {
actions.add(new PosCameraAction(x, y, height, delay));
}
public void camLook(int x, int y, int height, int delay) {
actions.add(new LookCameraAction(x, y, height, delay));
}
public void camPos(int x, int y, int height, int speed1, int speed2, int delay) {
actions.add(new PosCameraAction(x, y, height, speed1, speed2, delay));
}
public void camLook(int x, int y, int height, int speed1, int speed2, int delay) {
actions.add(new LookCameraAction(x, y, height, speed1, speed2, delay));
}
public void camPos(int x, int y, int height) {
camPos(x, y, height, -1);
}
public void camLook(int x, int y, int height) {
camLook(x, y, height, -1);
}
public void camPos(int x, int y, int height, int speed1, int speed2) {
camPos(x, y, height, speed1, speed2, -1);
}
public void camLook(int x, int y, int height, int speed1, int speed2) {
camLook(x, y, height, speed1, speed2, -1);
}
public void camShake(int slotId, int v1, int v2, int v3, int v4, int delay) {
action(delay, () -> player.getPackets().sendCameraShake(slotId, v1, v2, v3, v4));
}
public void camShake(int slotId, int v1, int v2, int v3, int v4) {
camShake(slotId, v1, v2, v3, v4, -1);
}
public void camShakeReset(int delay) {
action(delay, () -> player.getPackets().sendStopCameraShake());
}
public void camShakeReset() {
camShakeReset(-1);
}
public void camPosReset(int delay) {
action(delay, () -> player.getPackets().sendResetCamera());
}
public void camPosResetSoft(int delay) {
action(delay, () -> player.getPackets().sendResetCameraSoft());
}
public void camPosReset() {
camPosReset(-1);
}
public void camPosResetSoft() {
camPosResetSoft(-1);
}
public void dialogue(Dialogue dialogue, int delay) {
actions.add(new DialogueAction(dialogue, delay, false));
}
public void dialogue(Dialogue dialogue) {
dialogue(dialogue, -1);
}
public void dialogue(Dialogue dialogue, boolean pause) {
if (pause)
dialogue.addNext(() -> dialoguePaused = false);
actions.add(new DialogueAction(dialogue, pause ? 1 : -1, pause));
}
public void dynamicRegion(Tile returnTile, int baseX, int baseY, int widthChunks, int heightChunks, boolean copyNpcs) {
actions.add(new ConstructMapAction(returnTile, baseX, baseY, widthChunks, heightChunks, copyNpcs));
}
public void dynamicRegion(Tile returnTile, int baseX, int baseY, int widthChunks, int heightChunks) {
dynamicRegion(returnTile, baseX, baseY, widthChunks, heightChunks, false);
}
public void fadeIn(int delay) {
action(delay, () -> player.getInterfaceManager().fadeIn());
}
public void fadeOut(int delay) {
action(delay, () -> player.getInterfaceManager().fadeOut());
}
public void fadeOutQuickly(int delay) {
action(delay, () -> player.getInterfaceManager().removeInterface(115));
}
public void fadeInBG(int delay) {
action(delay, () -> player.getInterfaceManager().fadeInBG());
}
public void fadeOutBG(int delay) {
action(delay, () -> player.getInterfaceManager().fadeOutBG());
}
public void music(int id, int delay) {
action(delay, () -> player.musicTrack(id, 5));
}
public void music(int id) {
music(id, -1);
}
public void musicEffect(int id, int delay) {
actions.add(new PlayerMusicEffectAction(id, delay));
}
public void musicEffect(int id) {
musicEffect(id, -1);
}
public NPC getNPC(String key) {
if (key == null)
return null;
if (objects.get(key) != null)
return (NPC) objects.get(key);
return null;
}
public void npcCreate(String key, int npcId, int x, int y, int z, int delay, Consumer<NPC> configureNpc) {
actions.add(new CreateNPCAction(key, npcId, x, y, z, delay, configureNpc));
}
public void npcCreate(String key, int npcId, int x, int y, int z, int delay) {
npcCreate(key, npcId, x, y, z, delay, null);
}
public void npcCreate(String key, int npcId, int x, int y, int z, Consumer<NPC> configureNpc) {
npcCreate(key, npcId, x, y, z, -1, configureNpc);
}
public void npcCreate(String key, int npcId, int x, int y, int z) {
npcCreate(key, npcId, x, y, z, -1);
}
public void npcCreate(String key, int npcId, Tile tile, Consumer<NPC> configureNpc) {
npcCreate(key, npcId, tile.getX(), tile.getY(), tile.getPlane(), -1, configureNpc);
}
public void npcCreate(String key, int npcId, Tile tile) {
npcCreate(key, npcId, tile.getX(), tile.getY(), tile.getPlane(), -1);
}
public void npcCreate(String key, int npcId, Tile tile, int delay, Consumer<NPC> configureNpc) {
npcCreate(key, npcId, tile.getX(), tile.getY(), tile.getPlane(), delay, configureNpc);
}
public void npcCreate(String key, int npcId, Tile tile, int delay) {
npcCreate(key, npcId, tile.getX(), tile.getY(), tile.getPlane(), delay);
}
public void npcDestroy(String key, int delay) {
actions.add(new DestroyCachedObjectAction(key, delay));
}
public void npcDestroy(String key) {
npcDestroy(key, -1);
}
public void npcFaceTile(String key, int x, int y, int delay) {
actions.add(new NPCFaceTileAction(key, x, y, delay));
}
public void npcFaceTile(String key, int x, int y) {
npcFaceTile(key, x, y, -1);
}
public void npcFaceTile(String key, Tile tile) {
npcFaceTile(key, tile, -1);
}
public void npcFaceTile(String key, Tile tile, int delay) {
actions.add(new NPCFaceTileAction(key, tile.getX(), tile.getY(), delay));
}
public void npcSpotAnim(String key, SpotAnim anim, int delay) {
actions.add(new NPCSpotAnimAction(key, anim, delay));
}
public void npcSpotAnim(String key, SpotAnim anim) {
npcSpotAnim(key, anim, -1);
}
public void npcSpotAnim(String key, int anim) {
npcSpotAnim(key, new SpotAnim(anim), -1);
}
public void npcSpotAnim(String key, int anim, int delay) {
actions.add(new NPCSpotAnimAction(key, new SpotAnim(anim), delay));
}
public void npcAnim(String key, Animation anim, int delay) {
actions.add(new NPCAnimationAction(key, anim, delay));
}
public void npcSync(String key, int anim, int spotAnim, int delay) {
actions.add(new NPCAnimationAction(key, new Animation(anim), -1));
actions.add(new NPCSpotAnimAction(key, new SpotAnim(spotAnim), delay));
}
public void npcSync(String key, int anim, int spotAnim) {
npcSync(key, anim, spotAnim, -1);
}
public void npcAnim(String key, Animation anim) {
npcAnim(key, anim, -1);
}
public void npcAnim(String key, int id) {
npcAnim(key, new Animation(id));
}
public void npcAnim(String key, int id, int delay) {
npcAnim(key, new Animation(id), delay);
}
public void npcTransform(String key, int id, int delay) {
actions.add(new NPCTransformAction(key, id, delay));
}
public void npcTransform(String key, int id) { npcTransform(key, id, 0); }
public void npcTalk(String key, String message, int delay) {
actions.add(new NPCForceTalkAction(key, message, delay));
}
public void npcTalk(String key, String message) {
npcTalk(key, message, -1);
}
public void npcMove(String key, int x, int y, int z, MoveType type, int delay) {
actions.add(new MoveNPCAction(key, x, y, z, type, delay));
}
public void npcMove(String key, int x, int y, int z, MoveType type) {
npcMove(key, x, y, z, type, -1);
}
public void npcMove(String key, int x, int y, MoveType type, int delay) {
npcMove(key, x, y, player.getPlane(), type, delay);
}
public void npcMove(String key, int x, int y, MoveType type) {
npcMove(key, x, y, player.getPlane(), type, -1);
}
public void npcMove(String key, Tile tile, MoveType type) {
npcMove(key, tile.getX(), tile.getY(), player.getPlane(), type, -1);
}
public void npcMove(String key, Tile tile, MoveType type, int delay) {
npcMove(key, tile.getX(), tile.getY(), player.getPlane(), type, delay);
}
public void npcWalk(String key, int x, int y, int delay) {
npcMove(key, x, y, player.getPlane(), MoveType.WALK, delay);
}
public void npcWalk(String key, int x, int y) {
npcMove(key, x, y, player.getPlane(), MoveType.WALK, -1);
}
public void playerMove(int x, int y, int z, MoveType type, int delay) {
actions.add(new MovePlayerAction(x, y, z, type, delay));
}
public void playerMove(int x, int y, int z, MoveType type) {
playerMove(x, y, z, type, -1);
}
public void playerMove(int x, int y, MoveType type, int delay) {
playerMove(x, y, player.getPlane(), type, delay);
}
public void playerMove(int x, int y, MoveType type) {
playerMove(x, y, player.getPlane(), type, -1);
}
public void playerMove(Tile tile, MoveType type) {
playerMove(tile.getX(), tile.getY(), tile.getPlane(), type, -1);
}
public void playerMove(Tile tile, MoveType type, int delay) {
playerMove(tile.getX(), tile.getY(), tile.getPlane(), type, delay);
}
public void playerFaceTile(int x, int y, int delay) {
actions.add(new PlayerFaceTileAction(x, y, delay));
}
public void playerFaceTile(int x, int y) {
playerFaceTile(x, y, -1);
}
public void playerAnim(Animation anim, int delay) {
actions.add(new PlayerAnimationAction(anim, delay));
}
public void playerAnim(Animation anim) {
playerAnim(anim, -1);
}
public void playerSpotAnim(SpotAnim anim, int delay) {
actions.add(new PlayerGraphicAction(anim, delay));
}
public void playerSpotAnim(SpotAnim anim) {
playerSpotAnim(anim, -1);
}
public void playerTalk(String message, int delay) {
actions.add(new PlayerForceTalkAction(message, delay));
}
public void playerTalk(String message) {
playerTalk(message, -1);
}
public void playerFaceEntity(String key, int delay) {
actions.add(new PlayerFaceEntityAction(key, delay));
}
public void playerFaceEntity(String key) {
playerFaceEntity(key, -1);
}
public void action(int delay, Runnable runnable) {
actions.add(new CutsceneCodeAction(runnable, delay));
}
public void action(Runnable runnable) {
action(-1, runnable);
}
public void delay(int delay) {
actions.add(new DelayAction(delay));
}
public void setDialoguePause(boolean paused) {
this.dialoguePaused = paused;
}
public void projectile(int delay, Tile from, Tile to, int graphicId, int startHeight, int endHeight, int startTime, double speed, int angle, int slope, Consumer<WorldProjectile> task) {
action(delay, () -> World.sendProjectile(Tile.of(getX(from.getX()), getY(from.getY()), from.getPlane()), Tile.of(getX(to.getX()), getY(to.getY()), to.getPlane()), graphicId, startHeight, endHeight, startTime, speed, angle, task));
}
public void projectile(int delay, Tile from, Tile to, int graphicId, int startHeight, int endHeight, int startTime, double speed, int angle, int slope) {
action(delay, () -> World.sendProjectile(Tile.of(getX(from.getX()), getY(from.getY()), from.getPlane()), Tile.of(getX(to.getX()), getY(to.getY()), to.getPlane()), graphicId, startHeight, endHeight, startTime, speed, angle, slope));
}
public void projectile(Tile from, Tile to, int graphicId, int startHeight, int endHeight, int startTime, double speed, int angle, int slope, Consumer<WorldProjectile> task) {
projectile(-1, from, to, graphicId, startHeight, endHeight, startTime, speed, angle, slope, task);
}
public void projectile(Tile from, Tile to, int graphicId, int startHeight, int endHeight, int startTime, double speed, int angle, int slope) {
projectile(-1, from, to, graphicId, startHeight, endHeight, startTime, speed, angle, slope);
}
public void npcFaceNPC(String key, String targetKey, int delay) {
action(delay, () -> getNPC(key).setNextFaceEntity(getNPC(targetKey)));
}
public void npcFaceNPC(String key, String targetKey) {
npcFaceNPC(key, targetKey, -1);
}
public void playerFaceDir(Direction dir, int delay) {
action(delay, () -> player.setNextFaceTile(player.transform(dir.dx, dir.dy)));
}
public void playerFaceDir(Direction dir) {
playerFaceDir(dir, -1);
}
public void npcFaceDir(String key, Direction dir, int delay) {
action(delay, () -> getNPC(key).setNextFaceTile(getNPC(key).transform(dir.dx, dir.dy)));
}
public void npcFaceDir(String key, Direction dir) {
npcFaceDir(key, dir, -1);
}
public void spawnObj(int id, int rotation, int x, int y, int z) {
action(() -> World.spawnObject(new GameObject(id, ObjectDefinitions.getDefs(id).types[0], rotation, Tile.of(getX(x), getY(y), z))));
}
public void lowerAspectRatio() {
player.getVars().setVar(1241, 1);
}
public void restoreDefaultAspectRatio() {
player.getVars().setVar(1241, 3);
}
public Instance getInstance() {
return instance;
}
public void returnPlayerFromInstance() {
action(() -> {
if (instance != null)
player.tele(getInstance().getReturnTo());
});
}
}
|
package com.rs.engine.cutscene
@DslMarker
annotation class CutsceneDsl
@CutsceneDsl
open class CutsceneBuilder {
private var cutscene = object: Cutscene() {
override fun construct(player: Player?) { }
}
internal open fun build(): Cutscene = cutscene
}
fun Player.playCutscene(block: CutsceneBuilder.() -> Unit) {
playCutscene(CutsceneBuilder().apply(block).build())
}
|
package com.rs.engine.cutscene;
public class ExampleCutscene extends Cutscene {
@Override
public void construct(Player player) {
fadeIn(5);
dynamicRegion(player.getTile(), 178, 554, 4, 4);
playerMove(15, 20, 0, MoveType.TELE);
spawnObj(67500, 0, 14, 23, 0);
npcCreate("meme", 50, 14, 20, 0, 0);
fadeOut(5);
action(5, () -> getNPC("meme").transformIntoNPC(13447));
delay(20);
}
}
|
package com.rs.engine.cutscene.actions;
public class ConstructMapAction extends CutsceneAction {
private final Tile returnTile;
private final int baseChunkX;
private final int baseChunkY;
private final int widthChunks;
private final int heightChunks;
private final boolean copyNpcs;
public ConstructMapAction(Tile returnTile, int baseChunkX, int baseChunkY, int widthChunks, int heightChunks, boolean copyNpcs) {
super(null, 1);
this.returnTile = returnTile;
this.baseChunkX = baseChunkX;
this.baseChunkY = baseChunkY;
this.widthChunks = widthChunks;
this.heightChunks = heightChunks;
this.copyNpcs = copyNpcs;
}
@Override
public void process(Player player, Map<String, Object> objects) {
Cutscene scene = (Cutscene) objects.get("cutscene");
scene.constructArea(returnTile, baseChunkX, baseChunkY, widthChunks, heightChunks, copyNpcs);
}
}
|
package com.rs.engine.cutscene.actions;
public class CreateNPCAction extends CutsceneAction {
private final int id;
private final int x;
private final int y;
private final int plane;
private final Consumer<NPC> configureNpc;
public CreateNPCAction(String key, int id, int x, int y, int plane, int actionDelay, Consumer<NPC> configureNpc) {
super(key, actionDelay);
this.id = id;
this.x = x;
this.y = y;
this.plane = plane;
this.configureNpc = configureNpc;
}
@Override
public void process(Player player, Map<String, Object> objects) {
Cutscene scene = (Cutscene) objects.get("cutscene");
if (objects.get(getObjectKey()) != null)
scene.deleteObject(objects.get(getObjectKey()));
NPC npc = World.spawnNPC(id, Tile.of(scene.getX(x), scene.getY(y), plane), -1, true, true);
objects.put(getObjectKey(), npc);
npc.setRandomWalk(false);
if (configureNpc != null)
configureNpc.accept(npc);
}
}
|
package com.rs.engine.cutscene.actions;
public abstract class CutsceneAction {
private final String objectKey;
private final int delay;
public CutsceneAction(String objectKey, int delay) {
this.objectKey = objectKey;
this.delay = delay;
}
public abstract void process(Player player, Map<String, Object> objects);
public String getObjectKey() {
return objectKey;
}
public int getDelay() {
return delay;
}
}
|
package com.rs.engine.cutscene.actions;
public class CutsceneCodeAction extends CutsceneAction {
private final Runnable runnable;
public CutsceneCodeAction(Runnable runnable, int actionDelay) {
super(null, actionDelay);
this.runnable = runnable;
}
@Override
public void process(Player player, Map<String, Object> objects) {
runnable.run();
}
}
|
package com.rs.engine.cutscene.actions;
public class DelayAction extends CutsceneAction {
public DelayAction(int delay) {
super(null, delay);
}
@Override
public void process(Player player, Map<String, Object> objects) {
}
}
|
package com.rs.engine.cutscene.actions;
public class DestroyCachedObjectAction extends CutsceneAction {
public DestroyCachedObjectAction(String objectKey, int actionDelay) {
super(objectKey, actionDelay);
}
@Override
public void process(Player player, Map<String, Object> objects) {
Cutscene scene = (Cutscene) objects.get("cutscene");
scene.deleteObject(objects.get(getObjectKey()));
}
}
|
package com.rs.engine.cutscene.actions;
public class DialogueAction extends CutsceneAction {
private final Dialogue dialogue;
private final boolean pause;
public DialogueAction(Dialogue dialogue, int delay, boolean pause) {
super(null, delay);
this.dialogue = dialogue;
this.pause = pause;
}
@Override
public void process(Player player, Map<String, Object> objects) {
if (pause)
((Cutscene) objects.get("cutscene")).setDialoguePause(true);
player.startConversation(dialogue);
}
}
|
package com.rs.engine.cutscene.actions;
public final class InterfaceAction extends CutsceneAction {
private final int interfaceId;
private final int delay;
public InterfaceAction(int interfaceId, int actionDelay) {
super(null, actionDelay);
this.interfaceId = interfaceId;
delay = actionDelay;
}
@Override
public void process(final Player player, Map<String, Object> objects) {
player.getInterfaceManager().sendInterface(interfaceId);
WorldTasks.schedule(delay, () -> player.getInterfaceManager().removeCentralInterface());
}
}
|
package com.rs.engine.cutscene.actions;
public class LookCameraAction extends CutsceneAction {
private final int viewLocalX;
private final int viewLocalY;
private final int viewZ;
private final int speedToExactDestination;
private final int speedOnRoutePath;
public LookCameraAction(int viewLocalX, int viewLocalY, int viewZ, int speedToExactDestination, int speedOnRoutePath, int actionDelay) {
super(null, actionDelay);
this.viewLocalX = viewLocalX;
this.viewLocalY = viewLocalY;
this.viewZ = viewZ;
this.speedToExactDestination = speedToExactDestination;
this.speedOnRoutePath = speedOnRoutePath;
}
public LookCameraAction(int viewLocalX, int viewLocalY, int viewZ, int actionDelay) {
this(viewLocalX, viewLocalY, viewZ, -1, -1, actionDelay);
}
@Override
public void process(Player player, Map<String, Object> objects) {
Cutscene scene = (Cutscene) objects.get("cutscene");
player.getPackets().sendCameraLook(Tile.of(scene.getX(viewLocalX), scene.getY(viewLocalY), 0), viewZ, speedToExactDestination, speedOnRoutePath);
}
}
|
package com.rs.engine.cutscene.actions;
public class MoveNPCAction extends CutsceneAction {
private final int x;
private final int y;
private final int plane;
private final MoveType movementType;
public MoveNPCAction(String key, int x, int y, boolean run, int actionDelay) {
this(key, x, y, 0, run ? MoveType.RUN : MoveType.WALK, actionDelay);
}
public MoveNPCAction(String key, int x, int y, int plane, MoveType movementType, int actionDelay) {
super(key, actionDelay);
this.x = x;
this.y = y;
this.plane = plane;
this.movementType = movementType;
}
@Override
public void process(Player player, Map<String, Object> objects) {
NPC npc = (NPC) objects.get(getObjectKey());
Cutscene scene = (Cutscene) objects.get("cutscene");
if (movementType == MoveType.TELE) {
npc.tele(Tile.of(scene.getX(x), scene.getY(y), plane));
return;
}
npc.setRun(movementType == MoveType.RUN);
npc.addWalkSteps(scene.getX(x), scene.getY(y), 25, false);
}
}
|
package com.rs.engine.cutscene.actions;
public class MovePlayerAction extends CutsceneAction {
private final int x;
private final int y;
private final int plane;
private final MoveType movementType;
public MovePlayerAction(int x, int y, int plane, MoveType movementType, int actionDelay) {
super(null, actionDelay);
this.x = x;
this.y = y;
this.plane = plane;
this.movementType = movementType;
}
@Override
public void process(Player player, Map<String, Object> objects) {
Cutscene scene = (Cutscene) objects.get("cutscene");
if (movementType == MoveType.TELE) {
player.tele(Tile.of(scene.getX(x), scene.getY(y), plane));
return;
}
player.setRun(movementType == MoveType.RUN);
player.addWalkSteps(scene.getX(x), scene.getY(y), 25, false);
}
}
|
package com.rs.engine.cutscene.actions;
public class NPCAnimationAction extends CutsceneAction {
private final Animation anim;
public NPCAnimationAction(String key, Animation anim, int actionDelay) {
super(key, actionDelay);
this.anim = anim;
}
@Override
public void process(Player player, Map<String, Object> objects) {
NPC npc = (NPC) objects.get(getObjectKey());
npc.setNextAnimation(anim);
}
}
|
package com.rs.engine.cutscene.actions;
public class NPCFaceTileAction extends CutsceneAction {
private final int x;
private final int y;
public NPCFaceTileAction(String key, int x, int y, int actionDelay) {
super(key, actionDelay);
this.x = x;
this.y = y;
}
@Override
public void process(Player player, Map<String, Object> objects) {
Cutscene scene = (Cutscene) objects.get("cutscene");;
NPC npc = (NPC) objects.get(getObjectKey());
npc.setNextFaceTile(Tile.of(scene.getX(x), scene.getY(y), npc.getPlane()));
}
}
|
package com.rs.engine.cutscene.actions;
public class NPCForceTalkAction extends CutsceneAction {
private final String text;
public NPCForceTalkAction(String key, String text, int actionDelay) {
super(key, actionDelay);
this.text = text;
}
@Override
public void process(Player player, Map<String, Object> objects) {
NPC npc = (NPC) objects.get(getObjectKey());
npc.setNextForceTalk(new ForceTalk(text));
}
}
|
package com.rs.engine.cutscene.actions;
public class NPCSpotAnimAction extends CutsceneAction {
private final SpotAnim gfx;
public NPCSpotAnimAction(String key, SpotAnim gfx, int actionDelay) {
super(key, actionDelay);
this.gfx = gfx;
}
@Override
public void process(Player player, Map<String, Object> objects) {
NPC npc = (NPC) objects.get(getObjectKey());
npc.setNextSpotAnim(gfx);
}
}
|
package com.rs.engine.cutscene.actions;
public class NPCTransformAction extends CutsceneAction {
private final int id;
public NPCTransformAction(String key, int id, int actionDelay) {
super(key, actionDelay);
this.id = id;
}
@Override
public void process(Player player, Map<String, Object> objects) {
NPC npc = (NPC) objects.get(getObjectKey());
npc.transformIntoNPC(id);
}
}
|
package com.rs.engine.cutscene.actions;
public class PlayerAnimationAction extends CutsceneAction {
private final Animation anim;
public PlayerAnimationAction(Animation anim, int actionDelay) {
super(null, actionDelay);
this.anim = anim;
}
@Override
public void process(Player player, Map<String, Object> objects) {
player.setNextAnimation(anim);
}
}
|
package com.rs.engine.cutscene.actions;
public class PlayerFaceEntityAction extends CutsceneAction {
public PlayerFaceEntityAction(String key, int actionDelay) {
super(key, actionDelay);
}
@Override
public void process(Player player, Map<String, Object> objects) {
NPC npc = (NPC) objects.get(getObjectKey());
player.faceEntity(npc);
}
}
|
package com.rs.engine.cutscene.actions;
public class PlayerFaceTileAction extends CutsceneAction {
private final int x;
private final int y;
public PlayerFaceTileAction(int x, int y, int actionDelay) {
super(null, actionDelay);
this.x = x;
this.y = y;
}
@Override
public void process(Player player, Map<String, Object> objects) {
Cutscene scene = (Cutscene) objects.get("cutscene");
player.setNextFaceTile(Tile.of(scene.getX(x), scene.getY(y), player.getPlane()));
}
}
|
package com.rs.engine.cutscene.actions;
public class PlayerForceTalkAction extends CutsceneAction {
private final String text;
public PlayerForceTalkAction(String text, int actionDelay) {
super(null, actionDelay);
this.text = text;
}
@Override
public void process(Player player, Map<String, Object> objects) {
player.setNextForceTalk(new ForceTalk(text));
}
}
|
package com.rs.engine.cutscene.actions;
public class PlayerGraphicAction extends CutsceneAction {
private final SpotAnim gfx;
public PlayerGraphicAction(SpotAnim gfx, int actionDelay) {
super(null, actionDelay);
this.gfx = gfx;
}
@Override
public void process(Player player, Map<String, Object> objects) {
player.setNextSpotAnim(gfx);
}
}
|
package com.rs.engine.cutscene.actions;
public class PlayerMusicEffectAction extends CutsceneAction {
private final int id;
public PlayerMusicEffectAction(int id, int actionDelay) {
super(null, actionDelay);
this.id = id;
}
@Override
public void process(Player player, Map<String, Object> objects) {
player.jingle(id);
}
}
|
package com.rs.engine.cutscene.actions;
public class PlayerTransformAction extends CutsceneAction {
private final int npcId;
public PlayerTransformAction(int npcId, int actionDelay) {
super(null, actionDelay);
this.npcId = npcId;
}
@Override
public void process(Player player, Map<String, Object> objects) {
player.getAppearance().transformIntoNPC(npcId);
}
}
|
package com.rs.engine.cutscene.actions;
public class PlayMusicAction extends CutsceneAction {
private final int id;
private final int delay;
private final int volume;
public PlayMusicAction(int id, int delay, int volume, int actionDelay) {
super(null, actionDelay);
this.id = id;
this.delay = delay;
this.volume = volume;
}
public PlayMusicAction(int id, int delay, int actionDelay) {
super(null, actionDelay);
this.id = id;
this.delay = delay;
this.volume = 255;
}
public PlayMusicAction(int id, int actionDelay) {
super(null, actionDelay);
this.id = id;
this.delay = 5;
this.volume = 255;
}
@Override
public void process(Player player, Map<String, Object> objects) {
player.musicTrack(id, delay, volume);
}
}
|
package com.rs.engine.cutscene.actions;
public class PosCameraAction extends CutsceneAction {
private final int moveLocalX;
private final int moveLocalY;
private final int moveZ;
private final int speed;
private final int speed2;
public PosCameraAction(int moveLocalX, int moveLocalY, int moveZ, int speed, int speed2, int actionDelay) {
super(null, actionDelay);
this.moveLocalX = moveLocalX;
this.moveLocalY = moveLocalY;
this.moveZ = moveZ;
this.speed = speed;
this.speed2 = speed2;
}
public PosCameraAction(int moveLocalX, int moveLocalY, int moveZ, int actionDelay) {
this(moveLocalX, moveLocalY, moveZ, -1, -1, actionDelay);
}
@Override
public void process(Player player, Map<String, Object> objects) {
Cutscene scene = (Cutscene) objects.get("cutscene");
player.getPackets().sendCameraPos(Tile.of(scene.getX(moveLocalX), scene.getY(moveLocalY), 0), moveZ, speed, speed2);
}
}
|
package com.rs.engine.dialogue;
public class Conversation {
public static String DEFAULT_OPTIONS_TITLE = "Choose an option";
private final HashMap<String, Dialogue> markedStages;
private Dialogue firstDialogue;
protected Player player;
protected Dialogue current;
protected int npcId;
private boolean created = false;
public Conversation(Dialogue current) {
this(null, current);
}
public Conversation(Player player) {
this(player, null);
}
public Conversation(Player player, Dialogue current) {
this.player = player;
this.current = current;
this.firstDialogue = current;
this.markedStages = new HashMap<>();
}
public Conversation(Statement statement) {
this(null, new Dialogue(statement));
}
public Dialogue create(String stageName, Dialogue dialogue) {
markedStages.put(stageName, dialogue);
return dialogue;
}
public Dialogue createStage(String stageName, Statement statement) {
Dialogue dialogue = new Dialogue(statement);
markedStages.put(stageName, dialogue);
return dialogue;
}
public void create(String stageName) {
created = true;
setFirst(getStage(stageName).getHead());
}
public boolean create() {
try {
created = true;
if (current != null) {
setFirst(firstDialogue);
return true;
}
return false;
} catch(Exception e) {
throw new RuntimeException("Error creating dialogue: " + getClass().getSimpleName() + " - " + e.getMessage());
}
}
public Dialogue getCurrent() {
return current;
}
public Dialogue getStart() {
try {
return current.getHead();
} catch(Exception e) {
throw new RuntimeException("Error creating dialogue: " + getClass().getSimpleName() + " - " + e.getMessage());
}
}
public void setFirst(Dialogue dialogue) {
current = dialogue;
}
public Dialogue getStage(String stageName) {
return markedStages.get(stageName);
}
public Dialogue addNext(String stageName, Dialogue dialogue) {
if (firstDialogue == null)
firstDialogue = dialogue;
if (markedStages == null)
throw new RuntimeException("Do not call builder functions outside the constructor.");
if (stageName != null)
markedStages.put(stageName, dialogue);
if (current == null)
current = dialogue;
else
current = current.addNext(dialogue);
return current;
}
public Dialogue addNext(Dialogue dialogue) {
return addNext(null, dialogue);
}
public Dialogue addNext(Runnable event) {
return addNext(new Dialogue(event));
}
public Dialogue addNext(String stageName, Statement statement) {
if (markedStages == null)
throw new RuntimeException("Do not call builder functions outside the constructor.");
Dialogue dialogue = new Dialogue(statement);
if (firstDialogue == null)
firstDialogue = dialogue;
if (stageName != null)
markedStages.put(stageName, dialogue);
if (current == null)
current = dialogue;
else
current = current.addNext(dialogue);
return current;
}
public Dialogue addNext(Statement statement) {
return addNext(null, statement);
}
public Dialogue addPlayer(HeadE expression, String text) {
return addNext(new PlayerStatement(expression, text));
}
public Dialogue addPlayer(HeadE expression, String text, Runnable extraFunctionality) {
return addNext(new Dialogue(new PlayerStatement(expression, text), extraFunctionality));
}
public Dialogue addOption(String title, String... options) {
return addNext(new OptionStatement(title, options));
}
public Dialogue addOptions(Options options) {
return addOptions(null, options);
}
public Dialogue addNext(Statement statement, Dialogue... options) {
return addNext(null, statement, options);
}
public Dialogue addOptions(Consumer<Options> create) {
Options options = new Options() {
@Override
public void create() {
create.accept(this);
}
};
return addOptions(null, options);
}
public Dialogue addOptions(String title, Consumer<Options> create) {
Options options = new Options() {
@Override
public void create() {
create.accept(this);
}
};
return addOptions(title, options);
}
public Dialogue addOptions(Conversation conversation, String stageName, Consumer<Options> create) {
Options options = new Options(stageName, conversation) {
@Override
public void create() {
create.accept(this);
}
};
return addOptions(DEFAULT_OPTIONS_TITLE, options);
}
public Dialogue addOptions(String stageName, String title, Consumer<Options> create) {
Options options = new Options(stageName, this) {
@Override
public void create() {
create.accept(this);
}
};
return addOptions(title, options);
}
public Dialogue addNext(String name, Statement statement, Dialogue... options) {
Dialogue option = addNext(name, statement);
for (Dialogue option2 : options)
option.addNext(option2);
return option;
}
public Dialogue addNext(Statement statement, Runnable... events) {
return addNext(null, statement, events);
}
public Dialogue addNext(String name, Statement statement, Runnable... events) {
Dialogue option = addNext(name, statement);
for (Runnable event : events)
option.addNext(event);
return option;
}
public Dialogue addNext(String markedStage) {
return addNext(markedStages.get(markedStage));
}
public Dialogue addOptions(String title, Options options) {
if (options.getOptions().size() <= 1) {
for (String opName : options.getOptions().keySet()) {
Option op = options.getOptions().get(opName);
if (op.show() && op.getDialogue() != null) {
Dialogue next = addNext(op.getDialogue());
if (options.getConv() != null)
options.getConv().addStage(options.getStageName(), next);
return next;
}
}
return null;
}
if (options.getOptions().size() <= 5) {
List<String> ops = new ArrayList<>();
for (String opName : options.getOptions().keySet()) {
Option o = options.getOptions().get(opName);
if (o.show())
ops.add(opName);
}
Dialogue op = new Dialogue(new OptionStatement(title, ops.stream().toArray(String[] ::new)));
for (String opName : options.getOptions().keySet()) {
Option o = options.getOptions().get(opName);
if (o.show() && o.getDialogue() != null)
op.addNext(o.getDialogue());
}
if (options.getConv() != null)
options.getConv().addStage(options.getStageName(), op);
return addNext(op);
}
String[] ops = new String[options.getOptions().keySet().size()];
options.getOptions().keySet().toArray(ops);
String[] baseOptions = new String[5];
System.arraycopy(ops, 0, baseOptions, 0, 4);
baseOptions[4] = "More options...";
Dialogue baseOption = new Dialogue(new OptionStatement(title, baseOptions));
Dialogue currPage = baseOption;
for (int i = 0;i < ops.length;i++) {
Option op = options.getOptions().get(ops[i]);
if (op.show() && op.getDialogue() != null) {
currPage.addNext(op.getDialogue());
if (i >= 3 && ((i+1) % 4) == 0) {
String[] nextOps = new String[Utils.clampI(ops.length-i, 0, 5)];
for (int j = 1;j < 5;j++) {
if (i+j >= ops.length)
continue;
nextOps[j-1] = ops[i+j];
}
nextOps[nextOps.length-1] = "More options...";
Dialogue nextPage = new Dialogue(new OptionStatement(title, nextOps));
currPage.addNext(nextPage);
currPage = nextPage;
}
}
}
currPage.addNext(baseOption);
if (options.getConv() != null)
options.getConv().addStage(options.getStageName(), baseOption);
return addNext(baseOption);
}
public Dialogue addItem(int itemId, String text) {
return addNext(new ItemStatement(itemId, text));
}
public Dialogue addItem(int itemId, String text, Runnable extraFunctionality) {
return addNext(new Dialogue(new ItemStatement(itemId, text), extraFunctionality));
}
public Dialogue addNPC(int npcId, HeadE expression, String text) {
this.npcId = npcId;
return addNext(new NPCStatement(npcId, expression, text));
}
public Dialogue addNPC(int npcId, HeadE expression, String text, Runnable extraFunctionality) {
this.npcId = npcId;
return addNext(new Dialogue(new NPCStatement(npcId, expression, text), extraFunctionality));
}
public Dialogue addNPC(HeadE expression, String text) {
return addNext(new NPCStatement(npcId, expression, text));
}
public Dialogue addNPC(HeadE expression, String text, Runnable extraFunctionality) {
return addNext(new Dialogue(new NPCStatement(npcId, expression, text), extraFunctionality));
}
public Dialogue addNPC(NPC npc, HeadE expression, String text) {
return addNext(new NPCStatement(npc.getCustomName(), npc.getId(), expression, text));
}
public Dialogue addNPC(NPC npc, HeadE expression, String text, Runnable extraFunctionality) {
return addNext(new Dialogue(new NPCStatement(npc.getCustomName(), npc.getId(), expression, text), extraFunctionality));
}
public Dialogue addQuestStart(Quest quest) {
return addNext(new QuestStartStatement(quest));
}
public Dialogue addSimple(String... text) {
return addNext(new SimpleStatement(text));
}
public Dialogue addSimple(String text, Runnable extraFunctionality) {
return addNext(new Dialogue(new SimpleStatement(text), extraFunctionality));
}
public void start() {
if (current == null)
return;
current.run(player);
}
public void process(int interfaceId, int componentId) {
process(current.getStatement() != null ? current.getStatement().getOptionId(componentId) : 0);
}
public void process(int opIndex) {
if (current != null) {
current.close(player);
if (current.getVoiceEffect() > -1)
player.getPackets().resetSounds();
}
current = current.getNext(opIndex);
if (current == null) {
player.endConversation();
return;
}
if (current instanceof StageSelectDialogue d) {
if (d.getFunc() != null)
d.getFunc().run();
if (d.getStages() != null)
current = d.getStages().get(d.getStageName());
else
current = d.getDirectNextReference();
}
if (player.getInterfaceManager().containsChatBoxInter())
player.getInterfaceManager().closeChatBoxInterface();
current.run(player);
}
public void setPlayer(Player player) {
this.player = player;
}
public void addStage(String stageName, Dialogue dialogue) {
markedStages.put(stageName, dialogue);
}
@Override
public String toString() {
Set<Dialogue> visited = new HashSet<>();
StringBuilder str = new StringBuilder();
Dialogue head = current;
Dialogue curr = current;
while(curr != null) {
visited.add(curr);
str.append(curr).append("\n");
curr = curr.getNext(0);
if (visited.contains(curr))
break;
}
curr = head;
str.append(created);
return str.toString();
}
public boolean isCreated() {
return created;
}
public HashMap<String, Dialogue> getStages() {
return markedStages;
}
}
|
package com.rs.engine.dialogue;
public class Dialogue {
private Dialogue prev;
private ArrayList<Dialogue> next = new ArrayList<>();
private Runnable event;
private Statement statement;
private int voiceEffectId = -1;
private boolean started = true;
public Dialogue(Statement statement, Runnable extraFunctionality) {
this.statement = statement;
event = extraFunctionality;
}
public Dialogue(Statement statement) {
this(statement, () -> { });
}
public Dialogue(Runnable event) {
this(null, event);
}
public Dialogue() {
this(null, () -> { });
started = false;
}
public Dialogue(Dialogue dialogue) {
prev = dialogue.prev;
next = dialogue.next;
event = dialogue.event;
statement = dialogue.statement;
started = dialogue.started;
}
public void clearChildren() {
started = false;
event = null;
statement = null;
next.clear();
}
public Dialogue setFunc(Runnable consumer) {
event = consumer;
return this;
}
public Runnable getFunc() {
return event;
}
public Dialogue addGotoStage(String stageName, Map<String, Dialogue> stages) {
return addNext(new StageSelectDialogue(stageName, stages));
}
public Dialogue addGotoStage(String stageName, Conversation conversation) {
return addNext(new StageSelectDialogue(stageName, conversation.getStages()));
}
public Dialogue addGotoStage(Dialogue directNextReference) {
return addNext(new StageSelectDialogue(directNextReference));
}
public Dialogue addStatementWithOptions(Statement statement, Dialogue... options) {
Dialogue option = addNext(statement);
for (Dialogue option2 : options)
option.addNext(option2);
return option;
}
public Dialogue addStatementWithActions(Statement statement, Runnable... events) {
Dialogue option = addNext(statement);
for (Runnable event2 : events)
option.addNext(event2);
return option;
}
public Dialogue addPlayer(HeadE expression, String text) {
return addNext(new PlayerStatement(expression, text));
}
public Dialogue addPlayer(HeadE expression, String text, Runnable extraFunctionality) {
return addNext(new Dialogue(new PlayerStatement(expression, text), extraFunctionality));
}
public Dialogue addOption(String title, String... options) {
return addNext(new OptionStatement(title, options));
}
public Dialogue addNPC(int npcId, HeadE expression, String text) {
return addNext(new NPCStatement(npcId, expression, text));
}
public Dialogue addNPC(int npcId, HeadE expression, String text, Runnable extraFunctionality) {
return addNext(new Dialogue(new NPCStatement(npcId, expression, text), extraFunctionality));
}
public Dialogue addNPC(NPC npc, HeadE expression, String text) {
return addNext(new NPCStatement(npc.getCustomName(), npc.getId(), expression, text));
}
public Dialogue addNPC(NPC npc, HeadE expression, String text, Runnable extraFunctionality) {
return addNext(new Dialogue(new NPCStatement(npc.getCustomName(), npc.getId(), expression, text), extraFunctionality));
}
public Dialogue addItem(int itemId, String text) {
return addNext(new ItemStatement(itemId, text));
}
public Dialogue addItem(int itemId, String text, Runnable extraFunctionality) {
return addNext(new Dialogue(new ItemStatement(itemId, text), extraFunctionality));
}
public Dialogue addSimple(String... text) {
return addNext(new SimpleStatement(text));
}
public Dialogue addSimple(String text, Runnable extraFunctionality) {
return addNext(new Dialogue(new SimpleStatement(text), extraFunctionality));
}
public Dialogue addItemToInv(Player player, Item item, String text) {
return addNext(new ItemStatement(item.getId(), text)).setFunc(() -> player.getInventory().addItem(item));
}
public Dialogue addQuestStart(Quest quest) {
return addNext(new QuestStartStatement(quest));
}
public Dialogue addMakeX(int[] itemIds, int maxAmt) {
return addNext(new MakeXStatement(itemIds, maxAmt));
}
public Dialogue addMakeX(int itemId, int maxAmt) {
return addMakeX(new int[] { itemId }, maxAmt);
}
public Dialogue addMakeX(int[] itemIds) {
return addMakeX(itemIds, 60);
}
public Dialogue addMakeX(int itemId) {
return addMakeX(new int[] { itemId }, 60);
}
public Dialogue addOptions(Consumer<Options> create) {
Options options = new Options() {
@Override
public void create() {
create.accept(this);
}
};
return addOptions(null, options);
}
public Dialogue addOptions(Options options) {
return addOptions(null, options);
}
public Dialogue addOptions(String title, Consumer<Options> create) {
Options options = new Options() {
@Override
public void create() {
create.accept(this);
}
};
return addOptions(title, options);
}
public Dialogue addOptions(Conversation conversation, String stageName, Consumer<Options> create) {
Options options = new Options(stageName, conversation) {
@Override
public void create() {
create.accept(this);
}
};
return addOptions(Conversation.DEFAULT_OPTIONS_TITLE, options);
}
public Dialogue addOptions(String stageName, Conversation conv, String title, Consumer<Options> create) {
Options options = new Options(stageName, conv) {
@Override
public void create() {
create.accept(this);
}
};
return addOptions(title, options);
}
public Dialogue addOptions(String title, Options options) {
if (options.getOptions().size() <= 1) {
for (String opName : options.getOptions().keySet()) {
Option op = options.getOptions().get(opName);
if (op.show() && op.getDialogue() != null)
return addNext(op.getDialogue());
}
if (options.getConv() != null)
options.getConv().addStage(options.getStageName(), getNext(0));
} else if (options.getOptions().size() <= 5) {
List<String> ops = new ArrayList<>();
for (String opName : options.getOptions().keySet()) {
Option o = options.getOptions().get(opName);
if (o.show())
ops.add(opName);
}
Dialogue op = new Dialogue(new OptionStatement(title, ops.stream().toArray(String[] ::new)));
for (String opName : options.getOptions().keySet()) {
Option o = options.getOptions().get(opName);
if (o.show() && o.getDialogue() != null)
op.addNext(o.getDialogue());
}
if (options.getConv() != null)
options.getConv().addStage(options.getStageName(), op);
return addNext(op);
} else {
String[] ops = new String[options.getOptions().keySet().size()];
options.getOptions().keySet().toArray(ops);
String[] baseOptions = new String[5];
System.arraycopy(ops, 0, baseOptions, 0, 4);
baseOptions[4] = "More options...";
Dialogue baseOption = new Dialogue(new OptionStatement(title, baseOptions));
Dialogue currPage = baseOption;
for (int i = 0;i < ops.length;i++) {
Option op = options.getOptions().get(ops[i]);
if (op.show() && op.getDialogue() != null) {
currPage.addNext(op.getDialogue());
if (i >= 3 && ((i+1) % 4) == 0) {
String[] nextOps = new String[Utils.clampI(ops.length-i, 0, 5)];
for (int j = 1;j < 5;j++) {
if (i+j >= ops.length)
continue;
nextOps[j-1] = ops[i+j];
}
nextOps[nextOps.length-1] = "More options...";
Dialogue nextPage = new Dialogue(new OptionStatement(title, nextOps));
currPage.addNext(nextPage);
currPage = nextPage;
}
}
}
currPage.addNext(baseOption);
if (options.getConv() != null)
options.getConv().addStage(options.getStageName(), baseOption);
return addNext(baseOption);
}
return this;
}
public Dialogue addNext(Statement statement) {
if (!started) {
this.statement = statement;
started = true;
return this;
}
Dialogue nextD = new Dialogue(statement);
if (nextD.getPrev() == null)
nextD.setPrev(this);
next.add(nextD);
return nextD;
}
public Dialogue addNextIf(BooleanSupplier condition, Dialogue dialogue) {
if (condition.getAsBoolean()) {
addNext(dialogue.getHead());
return dialogue;
}
return this;
}
public Dialogue addNextIf(BooleanSupplier condition, Runnable event) {
if (condition.getAsBoolean())
return addNext(event);
return this;
}
public Dialogue addNext(Dialogue dialogue) {
if (!started) {
if (dialogue instanceof StageSelectDialogue)
return dialogue;
statement = dialogue.statement;
event = dialogue.event;
next = dialogue.next;
started = true;
return this;
}
if (dialogue.getPrev() == null)
dialogue.setPrev(this);
else {
Dialogue copy = new Dialogue(this);
dialogue.setPrev(copy);
}
next.add(dialogue);
return dialogue;
}
public Dialogue addNext(Runnable event) {
Dialogue dialogue = new Dialogue();
dialogue.statement = null;
dialogue.event = event;
return addNext(dialogue);
}
public Dialogue addNPC(int npcId, HeadE expression, String text, String nameOverride) {
return addNext(new Dialogue(new NPCStatement(nameOverride, npcId, expression, text)));
}
public Dialogue addNPC(int npcId, HeadE expression, String text, String nameOverride, Runnable extraFunctionality) {
return addNext(new Dialogue(new NPCStatement(nameOverride, npcId, expression, text), extraFunctionality));
}
public Dialogue addStop() {
return addNext(new Dialogue());
}
public Dialogue finish() {
return getHead();
}
public Dialogue getHead() {
if (prev == null)
return this;
Set<Dialogue> visited = new HashSet<>();
Dialogue curr = this;
while(curr.getPrev() != null) {
if (visited.contains(curr))
break;
visited.add(curr);
curr = curr.getPrev();
}
return curr;
}
public Dialogue getNext(int choice) {
if (next.size() > 0 && choice < next.size())
return next.get(choice);
return null;
}
public void run(Player player) {
if (event != null)
event.run();
if (statement != null)
statement.send(player);
if (voiceEffectId != -1)
player.voiceEffect(voiceEffectId, false);
}
public Dialogue getPrev() {
return prev;
}
public void setPrev(Dialogue prev) {
this.prev = prev;
}
public Statement getStatement() {
return statement;
}
@Override
public String toString() {
StringBuilder str = new StringBuilder("[Dialogue] { stmt: " + statement + " next: [ ");
for (Dialogue d : next) {
if (d == null)
continue;
str.append(d.getClass().getSimpleName()).append("(").append(d.getStatement()).append(")\n\t");
}
str.append(" ] }");
return str.toString();
}
public Dialogue cutPrev() {
Dialogue isolated = new Dialogue();
isolated.addNext(this);
isolated.prev = null;
return isolated;
}
public Dialogue setStage(String stageName, Conversation conversation) {
Dialogue copy = new Dialogue(this);
copy.prev = null;
conversation.addStage(stageName, copy);
return this;
}
public void close(Player player) {
if (statement != null)
statement.close(player);
}
public int getVoiceEffect() {
return voiceEffectId;
}
public Dialogue voiceEffect(int voiceId) {
this.voiceEffectId = voiceId;
return this;
}
}
|
package com.rs.engine.dialogue
@DslMarker
annotation class DialogueDsl
@DialogueDsl
open class DialogueBuilder(val stages: MutableMap<String, Dialogue> = mutableMapOf()) {
private var dialogue = Dialogue()
private var pendingLabel: String? = null
val start = dialogue
fun player(expression: HeadE, text: String, extraFunctionality: Runnable? = null) {
dialogue = dialogue.addPlayer(expression, text, extraFunctionality)
applyPendingLabel()
}
fun npc(id: Int, expression: HeadE, text: String, extraFunctionality: Runnable? = null) {
dialogue = dialogue.addNPC(id, expression, text, extraFunctionality)
applyPendingLabel()
}
fun item(itemId: Int, text: String, extraFunctionality: Runnable? = null) {
dialogue = dialogue.addItem(itemId, text, extraFunctionality)
applyPendingLabel()
}
fun simple(vararg text: String, extraFunctionality: Runnable? = null) {
dialogue = if (extraFunctionality != null) {
dialogue.addSimple(text.first(), extraFunctionality)
} else {
dialogue.addSimple(*text)
}
applyPendingLabel()
}
fun exec(extraFunctionality: Runnable) {
dialogue = dialogue.addNext(extraFunctionality)
applyPendingLabel()
}
fun addItemToInv(player: Player, item: Item, text: String) {
dialogue = dialogue.addItemToInv(player, item, text)
applyPendingLabel()
}
fun questStart(quest: Quest) {
dialogue = dialogue.addQuestStart(quest)
applyPendingLabel()
}
fun options(title: String? = null, setup: OptionsBuilder.() -> Unit) {
dialogue = dialogue.addOptions(title) { options ->
OptionsBuilder(stages).apply(setup).applyToOptions(options)
}
applyPendingLabel()
}
fun makeX(itemId: Int, maxAmt: Int = 60) {
dialogue = dialogue.addMakeX(itemId, maxAmt)
applyPendingLabel()
}
fun makeX(itemIds: IntArray, maxAmt: Int = 60) {
dialogue = dialogue.addMakeX(itemIds, maxAmt)
applyPendingLabel()
}
fun label(stageName: String) {
pendingLabel = stageName
}
fun goto(stageName: String, conversation: Conversation? = null) {
dialogue = if (conversation != null)
dialogue.addGotoStage(stageName, conversation)
else
dialogue.addGotoStage(stageName, stages)
}
fun statementWithOptions(statement: Statement, vararg options: DialogueBuilder.() -> Unit) {
val optionDialogues = options.map { DialogueBuilder(stages).apply(it).build() }
dialogue = dialogue.addStatementWithOptions(statement, *optionDialogues.toTypedArray())
applyPendingLabel()
}
fun statementWithActions(statement: Statement, vararg events: Runnable) {
dialogue = dialogue.addStatementWithActions(statement, *events)
applyPendingLabel()
}
fun item(itemId: Int, text: String) {
dialogue = dialogue.addItem(itemId, text)
applyPendingLabel()
}
fun simple(text: String) {
dialogue = dialogue.addSimple(text)
applyPendingLabel()
}
fun npc(npc: NPC, expression: HeadE, text: String, extraFunctionality: Runnable? = null) {
dialogue = dialogue.addNPC(npc, expression, text, extraFunctionality)
applyPendingLabel()
}
fun makeX(itemId: Int) {
dialogue = dialogue.addMakeX(itemId)
applyPendingLabel()
}
fun makeX(itemIds: IntArray) {
dialogue = dialogue.addMakeX(itemIds)
applyPendingLabel()
}
fun nextIf(condition: BooleanSupplier, dialogueSetup: DialogueBuilder.() -> Unit) {
val nextDialogue = DialogueBuilder(stages).apply(dialogueSetup).build()
dialogue = dialogue.addNextIf(condition, nextDialogue)
applyPendingLabel()
}
fun stop() {
dialogue = dialogue.addStop()
}
fun setStage(stageName: String, conversation: Conversation) {
dialogue = dialogue.setStage(stageName, conversation)
}
fun voiceEffect(voiceId: Int) {
dialogue = dialogue.voiceEffect(voiceId)
}
private fun applyPendingLabel() {
if (pendingLabel != null) {
stages[pendingLabel!!] = dialogue
pendingLabel = null
}
}
internal open fun build(): Dialogue = start
}
@DialogueDsl
class OptionsBuilder(val stages: MutableMap<String, Dialogue>) {
private sealed class OptionOperation {
data class BuilderOp(val name: String, val setup: OptionBuilder.() -> Unit) : OptionOperation()
data class ExecOp(val name: String, val exec: Runnable) : OptionOperation()
}
private val operations = mutableListOf<OptionOperation>()
fun op(name: String, setup: OptionBuilder.() -> Unit = {}) {
operations.add(OptionOperation.BuilderOp(name, setup))
}
fun opExec(name: String, exec: Runnable) {
operations.add(OptionOperation.ExecOp(name, exec))
}
fun applyToOptions(options: Options) {
operations.forEach { operation ->
when (operation) {
is OptionOperation.BuilderOp -> {
val builder = OptionBuilder(stages).apply(operation.setup)
options.add(operation.name, builder.build())
}
is OptionOperation.ExecOp -> {
options.add(operation.name, operation.exec)
}
}
}
}
}
@DialogueDsl
class OptionBuilder(stages: MutableMap<String, Dialogue>) : DialogueBuilder(stages)
fun dialogue(block: DialogueBuilder.() -> Unit): Dialogue {
val builder = DialogueBuilder()
builder.block()
return builder.build()
}
fun Player.startConversation(block: DialogueBuilder.() -> Unit) {
startConversation(DialogueBuilder().apply(block).build())
}
|
package com.rs.engine.dialogue;
public enum HeadE {
NONE(-1),
AMAZED_MILD(9742),
AMAZED(9746),
MORTIFIED_JAW_DROP(9750),
MORTIFIED(9753),
SAD_MILD_LOOK_DOWN(9757),
SAD_MILD(9760),
SAD_SNIFFLE(9761),
SAD(9764),
SAD_CRYING(9765),
SAD_EXTREME(9768),
UPSET(9770),
UPSET_SNIFFLE(9772),
SCARED(9773),
WORRIED(9775),
TERRIFIED(9777),
FRUSTRATED(9781),
VERY_FRUSTRATED(9785),
ANGRY(9789),
BUMPY_RIDE(9793),
SLEEPING(9802),
NOTHING_LISTENING(9804),
CALM(9806),
NO_EXPRESSION(9809),
CALM_TALK(9810),
CONFUSED(9811),
SHAKING_HEAD(9814),
SKEPTICAL_HEAD_SHAKE(9827),
SKEPTICAL(9830),
ROLL_EYES(9831),
SKEPTICAL_THINKING(9834),
DRUNK(9835),
NERVOUS(9836),
SECRETIVE(9838),
CHUCKLE(9840),
LAUGH(9841),
EVIL_LAUGH(9842),
CHEERFUL(9843),
TALKING_ALOT(9845),
CHEERFUL_EXPOSITION(9847),
HAPPY_TALKING(9850),
FOGGY_STORYTELLING(9851),
FOGGY_STORYTELLING_2(9852),
EYES_CLOSED_NERVOUS(9877),
DIZZY(9878),
DRUNK_ANGRY(12648),
LOSING_IT_LAUGHING(12649),
SAD_VERY_SNIFFLE(12650),
T_CALM_TALK(12936),
T_ANGRY(12940),
T_VERY_SAD(12944),
T_SAD(12948),
T_HAPPY_TALK(12952),
T_CONFUSED(12957),
T_CONFUSED_DENIAL(12961),
T_LAUGH(12964),
T_SCARED(12968),
T_ANGRY_NO(12973),
T_SURPRISED(12977),
CAT_CALM_TALK(9178),
CAT_CHEERFUL(9179),
CAT_EXPLAIN(9180),
CAT_SHOOK(9181),
CAT_SHOUTING(9185),
CAT_SLOW_TALK(9187),
CAT_CALM_TALK2(9189),
CAT_SURPRISED(9190),
CAT_HAPPY(9192),
CAT_PURRING(9202),
CAT_DISAPPOINTED(9225),
CAT_CRAZY(10522),
CAT_DISAPPOINTED2(11536),
CAT_LAUGH(1518),
CAT_SAD(6552),
CAT_INTELLIGENT_CALM(6553),
OLD_CHAT(590),
CHILD_FRUSTRATED(7168),
CHILD_DOWN(7169),
CHILD_RECALLING(7170),
CHILD_EVIL_LAUGH(7171),
CHILD_HAPPY_TALK(7172),
CHILD_CALM_TALK(7173),
CHILD_LAUGH(7175),
CHILD_THINKING(7176),
CHILD_SAD(7177),
CHILD_SCARED(7178),
CHILD_SECRETIVE(7179),
CHILD_AWE(7180),
CHILD_ANGRY(8814),
CHILD_ANGRY_HEADSHAKE(8815),
CHILD_UNSURE(8824),
CHILD_CRYING(9683),
CHILD_GRETA_THUNBERG(9684),
CHILD_TANTRUM(7181),
PENG_TALK(5661),
PENG_EXPLAIN(5662),
PENG_HAPPY(5663),
PENG_SAD(5665),
SPIDER_NONE(11605),
SPIDER_EXCLAIM(11606),
SPIDER_CALM(11607),
SPIDER_SAD(11607),
//Kalphites 6243-6246 possibly
//More bug faces 7630-7639
//8380-8387
//8475-8478
;
private final int emoteId;
private HeadE(int emoteId) {
this.emoteId = emoteId;
}
public int getEmoteId() {
return emoteId;
}
}
|
package com.rs.engine.dialogue;
public class Option {
private final Dialogue dialogue;
private final Supplier<Boolean> constraint;
public Option(Supplier<Boolean> constraint, Dialogue dialogue) {
this.constraint = constraint;
this.dialogue = dialogue;
}
public Option(Dialogue dialogue) {
this(null, dialogue);
}
public Dialogue getDialogue() {
return dialogue;
}
public Supplier<Boolean> getConstraint() {
return constraint;
}
public boolean show() {
return constraint == null ? true : constraint.get();
}
}
|
package com.rs.engine.dialogue;
public abstract class Options {
private final Map<String, Option> options = new LinkedHashMap<>(); //LinkedHashMap O(1) but allows ordered keys
private String stageName;
private Conversation conv;
public Options() {
create();
}
public Options(String stageName, Conversation conv) {
this.conv = conv;
this.stageName = stageName;
create();
}
public abstract void create();
public void option(String name, Dialogue dialogue) {
options.put(name, new Option(dialogue.getHead()));
}
public void option(String name, Runnable consumer) {
options.put(name, new Option(new Dialogue(null, consumer)));
}
public void option(Supplier<Boolean> constraint, String name, Dialogue dialogue) {
options.put(name, new Option(constraint, dialogue.getHead()));
}
public void option(String name) {
options.put(name, new Option(null));
}
public void add(String name, Dialogue dialogue) {
options.put(name, new Option(dialogue.getHead()));
}
public void add(String name, Runnable consumer) {
options.put(name, new Option(new Dialogue(null, consumer)));
}
public void add(Supplier<Boolean> constraint, String name, Dialogue dialogue) {
options.put(name, new Option(constraint, dialogue.getHead()));
}
public Dialogue add(String name) {
Dialogue dial = new Dialogue();
options.put(name, new Option(dial));
return dial;
}
public void empty(String name) {
options.put(name, new Option(null));
}
public Map<String, Option> getOptions() {
return options;
}
public String getStageName() {
return stageName;
}
public Conversation getConv() {
return conv;
}
}
|
package com.rs.engine.dialogue.impl;
public class MakeXActionD extends Dialogue {
private final List<MakeXItem> options = new ArrayList<>();
public MakeXActionD addOption(MakeXItem option) {
clearChildren();
options.add(option);
MakeXItem[] opArr = new MakeXItem[options.size()];
options.toArray(opArr);
addStatementWithOptions(new MakeXStatement(opArr, 28), opArr);
return this;
}
public boolean isEmpty() {
return options.isEmpty();
}
}
|
package com.rs.engine.dialogue.impl;
public class MakeXItem extends Dialogue {
private final int itemId;
public MakeXItem(Player player, Item[] materials, Item[] products, double xp, int anim, int req, int skill, int delay) {
itemId = products[0].getId();
setFunc(() -> {
int quantity = MakeXStatement.getQuantity(player);
for (Item mat : materials) {
int newQ = player.getInventory().getNumberOf(mat.getId()) / mat.getAmount();
if (newQ < quantity)
quantity = newQ;
}
player.getActionManager().setAction(new CreateAction(new Item[][] { materials }, new Item[][] { products }, new double [] { xp }, new int[] { anim }, new int[] { req }, skill, delay, 0).setQuantity(quantity));
});
}
public MakeXItem(Player player, Item material, Item product, double xp, int anim, int req, int skill, int delay) {
this(player, new Item[] { material }, new Item[] { product }, xp, anim, req, skill, delay);
}
public int getItemId() {
return itemId;
}
}
|
package com.rs.engine.dialogue.statements;
public class DestroyItemStatement implements Statement {
private final Item item;
private final String message;
public DestroyItemStatement(Item item, String message) {
this.item = item;
this.message = message;
}
@Override
public void send(Player player) {
player.getInterfaceManager().sendChatBoxInterface(1183);
player.getPackets().setIFText(1183, 7, item.getName());
if (message != null)
player.getPackets().setIFText(1183, 12, message);
player.getPackets().setIFItem(1183, 13, item.getId(), 1);
}
@Override
public int getOptionId(int componentId) {
return componentId == 9 ? 0 : 1;
}
@Override
public void close(Player player) {
}
}
|
package com.rs.engine.dialogue.statements;
public class ItemStatement implements Statement {
private final int itemId;
private int zoom = 500;
private final String[] text;
public ItemStatement(int itemId, String... text) {
this.itemId = itemId;
this.text = text;
}
public ItemStatement(int itemId, int zoom, String... text) {
this.itemId = itemId;
this.text = text;
this.zoom = zoom;
}
@Override
public void send(Player player) {
StringBuilder text = new StringBuilder();
for (String s : this.text)
text.append(s).append("<br>");
player.getInterfaceManager().sendChatBoxInterface(1189);
player.getPackets().sendRunScript(3449, itemId, zoom);
player.getPackets().setIFText(1189, 4, text.toString());
}
@Override
public int getOptionId(int componentId) {
return 0;
}
@Override
public void close(Player player) {
}
}
|
package com.rs.engine.dialogue.statements;
public class LampXPSelectStatement implements Statement {
private final Lamp lamp;
public LampXPSelectStatement(Lamp lamp) {
this.lamp = lamp;
}
@Override
public void send(Player player) {
if (lamp.getId() == 12628)
lamp.setXp(500);
player.getTempAttribs().setO("lampInstance", lamp);
player.getVars().setVar(738, 1); //has house
player.getVars().setVarBit(2187, 1);
player.getInterfaceManager().sendInterface(1263);
player.getPackets().sendVarcString(358, "What skill would you like XP in?");
sendSelectedSkill(player);
player.getPackets().sendVarc(1797, 0);
player.getPackets().sendVarc(1798, lamp.getReq()); //level required to use lamp
player.getPackets().sendVarc(1799, getVarCValueForLamp(lamp.getId()));
for (int i = 13; i < 38; i++)
player.getPackets().setIFRightClickOps(1263, i, -1, 0, 0);
player.getPackets().setIFEvents(new IFEvents(1263, 39, 1, 26).enableContinueButton());
}
@Override
public int getOptionId(int componentId) {
return switch(componentId) {
case 39 -> 0;
default -> 1;
};
}
private static void sendSelectedSkill(Player player) {
if (player.getTempAttribs().getO("lampInstance") == null)
return;
Lamp lamp = player.getTempAttribs().getO("lampInstance");
EnumDefinitions map = EnumDefinitions.getEnum(681);
if (lamp.getSelectedSkill() == map.getDefaultIntValue()) {
player.getPackets().sendVarc(1796, map.getDefaultIntValue());
return;
}
long key = map.getKeyForValue(lamp.getSelectedSkill());
player.getPackets().sendVarc(1796, (int) key);
}
private int getVarCValueForLamp(int id) {
return switch (id) {
case 4447 ->//Shield of Arrav
23713;
default -> id;
};
}
@Override
public void close(Player player) {
player.closeInterfaces();
}
}
|
package com.rs.engine.dialogue.statements;
public class LegacyItemStatement implements Statement {
private final int[] itemIds;
private final String title;
private final String[] text;
public LegacyItemStatement(int item, String title, String... text) {
itemIds = new int[] { item };
this.title = title;
this.text = text;
}
public LegacyItemStatement(int item1, int item2, String title, String... text) {
itemIds = new int[] { item1, item2 };
this.title = title;
this.text = text;
}
@Override
public void send(Player player) {
int interfaceId = itemIds.length > 1 ? 131 : 519;
StringBuilder text = new StringBuilder();
text.append(title).append("<br>");
for (String s : this.text)
text.append(s).append("<br>");
player.getInterfaceManager().sendChatBoxInterface(interfaceId);
player.getPackets().setIFText(interfaceId, 1, text.toString());
player.getPackets().setIFItem(interfaceId, 0, itemIds[0], 1);
if (itemIds.length > 1)
player.getPackets().setIFItem(interfaceId, 2, itemIds[1], 1);
}
@Override
public int getOptionId(int componentId) {
return 0;
}
@Override
public void close(Player player) {
}
}
|
package com.rs.engine.dialogue.statements;
@PluginEventHandler
public class MakeXStatement implements Statement {
public enum MakeXType {
MAKE,
MAKE_SET,
COOK,
ROAST,
OFFER,
SELL,
BAKE,
CUT,
DEPOSIT,
MAKE_INTERVAL,
TELEPORT,
SELECT,
MAKE_SET_INTERVAL,
TAKE,
RETURN,
HEAT,
ADD
}
private final MakeXType type;
private int maxQuantity = -50;
private final String question;
private final int[] items;
private final String[] options;
public MakeXStatement(MakeXType type, int maxQuantity, String question, int[] items, String[] options) {
this.type = type;
this.maxQuantity = maxQuantity;
this.question = question;
this.items = items;
this.options = options;
}
public MakeXStatement(MakeXItem[] items, int maxQuantity) {
this(MakeXType.MAKE, maxQuantity, "How many would you like to make?", Arrays.stream(items).mapToInt(MakeXItem::getItemId).toArray(), null);
}
public MakeXStatement(MakeXType type, String question, int[] items, int maxQuantity) {
this(type, maxQuantity, question, items, null);
}
public MakeXStatement(MakeXType type, int[] items, int maxQuantity) {
this(type, maxQuantity, "How many would you like to make?", items, null);
}
public MakeXStatement(MakeXType type, int[] items, String[] options) {
this(type, -50, "Select an item.", items, options);
}
public MakeXStatement(MakeXType type, int[] items) {
this(type, -50, "Select an item.", items, null);
}
public MakeXStatement(String question, int[] items, int maxQuantity) {
this(MakeXType.MAKE, maxQuantity, question, items, null);
}
public MakeXStatement(int[] items, int maxQuantity) {
this(MakeXType.MAKE, maxQuantity, "How many would you like to make?", items, null);
}
public MakeXStatement(int[] items, String[] options) {
this(MakeXType.SELECT, -50, "Select an item.", items, options);
}
public MakeXStatement(int[] items) {
this(MakeXType.SELECT, -50, "Select an item.", items, null);
}
@Override
public void send(Player player) {
player.getPackets().setIFRightClickOps(916, 8, -1, 0, 0);
player.getPackets().setIFText(916, 6, question);
player.getPackets().sendVarc(754, type.ordinal());
for (int i = 0; i < 10; i++) {
if (i >= items.length) {
player.getPackets().sendVarc(i >= 6 ? (1139 + i - 6) : 755 + i, -1);
continue;
}
player.getPackets().sendVarc(i >= 6 ? (1139 + i - 6) : 755 + i, items[i]);
player.getPackets().sendVarcString(i >= 6 ? (280 + i - 6) : 132 + i, options != null ? options[i] : ItemDefinitions.getDefs(items[i]).getName());
}
setMaxQuantity(player, maxQuantity);
setQuantity(player, maxQuantity);
player.getInterfaceManager().sendChatBoxInterface(905);
player.getInterfaceManager().sendSubSpecific(true, 905, 4, 916);
}
public static ButtonClickHandler handleSetQuantityButtons = new ButtonClickHandler(916, e -> {
if (e.getComponentId() == 10)
setQuantity(e.getPlayer(), 1, true);
else if (e.getComponentId() == 11)
setQuantity(e.getPlayer(), 5, true);
else if (e.getComponentId() == 12)
setQuantity(e.getPlayer(), 10, true);
else if (e.getComponentId() == 8)
setQuantity(e.getPlayer(), getMaxQuantity(e.getPlayer()), true);
else if (e.getComponentId() == 24)
setQuantity(e.getPlayer(), getQuantity(e.getPlayer()) + 1, true);
else if (e.getComponentId() == 25)
setQuantity(e.getPlayer(), getQuantity(e.getPlayer()) - 1, true);
});
@Override
public int getOptionId(int componentId) {
if (componentId < 14)
return 0;
if (componentId == 26)
return 7;
if (componentId >= 21)
return componentId - 13;
return componentId - 14;
}
public static void setMaxQuantity(Player player, int maxQuantity) {
player.getVars().setVarBit(8094, maxQuantity);
}
public static void setQuantity(Player player, int quantity) {
setQuantity(player, quantity, true);
}
public static void setQuantity(Player player, int quantity, boolean refresh) {
int maxQuantity = getMaxQuantity(player);
if (quantity > maxQuantity)
quantity = maxQuantity;
else if (quantity < 0)
quantity = 0;
if (refresh)
player.getVars().setVarBit(8095, quantity);
}
public static int getMaxQuantity(Player player) {
return player.getVars().getVarBit(8094);
}
public static int getQuantity(Player player) {
if (player.getVars().getVarBit(8094) <= 0)
return 60;
return player.getVars().getVarBit(8095);
}
@Override
public void close(Player player) {
}
}
|
package com.rs.engine.dialogue.statements;
public class NPCStatement implements Statement {
private final String nameOverride;
private final int npcId;
private final HeadE emote;
private final String[] texts;
public NPCStatement(String nameOverride, int npcId, HeadE emote, String... texts) {
this.nameOverride = nameOverride;
this.npcId = npcId;
this.emote = emote;
this.texts = texts;
}
public NPCStatement(int npcId, HeadE emote, String... texts) {
this(null, npcId, emote, texts);
}
@Override
public void send(Player player) {
StringBuilder builder = new StringBuilder();
for (String text2 : texts)
builder.append(" ").append(text2);
String text = builder.toString();
player.getInterfaceManager().sendChatBoxInterface(1184);
player.getPackets().setIFText(1184, 17, nameOverride != null ? nameOverride : NPCDefinitions.getDefs(npcId, player.getVars()).getName());
player.getPackets().setIFText(1184, 13, text);
player.getPackets().setIFNPCHead(1184, 11, npcId);
if (emote != null && emote.getEmoteId() != -1)
player.getPackets().setIFAnimation(emote.getEmoteId(), 1184, 11);
}
@Override
public int getOptionId(int componentId) {
return 0;
}
@Override
public void close(Player player) {
}
}
|
package com.rs.engine.dialogue.statements;
public class OptionStatement implements Statement {
private final String title;
private final String[] options;
public OptionStatement(String title, String... options) {
this.title = title;
if (options.length > 5)
throw new InvalidParameterException("The max options length is 5.");
this.options = options;
}
@Override
public void send(Player player) {
String[] optionArray = new String[5];
for (int i = 0; i < 5; i++)
optionArray[i] = "";
int ptr = 0;
for (String s : options)
if (s != null)
optionArray[ptr++] = s;
player.getInterfaceManager().sendChatBoxInterface(1188);
player.getPackets().setIFText(1188, 20, title != null ? title : "Select an Option");
player.getPackets().sendRunScriptReverse(5589, optionArray[4], optionArray[3], optionArray[2], optionArray[1], optionArray[0], options.length);
}
@Override
public int getOptionId(int componentId) {
return componentId == 11 ? 0 : componentId-12;
}
@Override
public void close(Player player) {
}
}
|
package com.rs.engine.dialogue.statements;
public class PlayerStatement implements Statement {
private final HeadE emote;
private final String[] texts;
public PlayerStatement(HeadE emote, String... texts) {
this.emote = emote;
this.texts = texts;
}
@Override
public void send(Player player) {
StringBuilder builder = new StringBuilder();
for (String text2 : texts)
builder.append(" ").append(text2);
String text = builder.toString();
player.getInterfaceManager().sendChatBoxInterface(1191);
player.getPackets().setIFText(1191, 8, player.getDisplayName());
player.getPackets().setIFText(1191, 17, text);
player.getPackets().setIFPlayerHead(1191, 15);
if (emote != null && emote.getEmoteId() != -1)
player.getPackets().setIFAnimation(emote.getEmoteId(), 1191, 15);
}
@Override
public int getOptionId(int componentId) {
return 0;
}
@Override
public void close(Player player) {
}
}
|
package com.rs.engine.dialogue.statements;
public class QuestStartStatement implements Statement {
private final Quest quest;
public QuestStartStatement(Quest quest) {
this.quest = quest;
}
@Override
public void send(Player player) {
quest.openQuestInfo(player, true);
}
@Override
public int getOptionId(int componentId) {
return switch(componentId) {
case 46 -> 0;
default -> 1;
};
}
@Override
public void close(Player player) {
if (player.getInterfaceManager().containsScreenInter())
player.getInterfaceManager().removeCentralInterface();
}
}
|
package com.rs.engine.dialogue.statements;
public class SimpleStatement implements Statement {
private final String[] texts;
public SimpleStatement(String... texts) {
this.texts = texts;
}
@Override
public void send(Player player) {
StringBuilder builder = new StringBuilder();
for (int line = 0; line < texts.length; line++)
builder.append(line == 0 ? "<p=" + 1 + ">" : "<br>").append(texts[line]);
String text = builder.toString();
player.getInterfaceManager().sendChatBoxInterface(1186);
player.getPackets().setIFText(1186, 1, text);
}
@Override
public int getOptionId(int componentId) {
return 0;
}
@Override
public void close(Player player) {
}
}
|
package com.rs.engine.dialogue.statements;
public interface Statement {
void send(Player player);
int getOptionId(int componentId);
void close(Player player);
}
|
package com.rs.engine.miniquest;
public enum Miniquest {
ENTER_THE_ABYSS("Enter the Abyss", new Quest[]{Quest.RUNE_MYSTERIES}, null, null, null),
KNIGHTS_WAVE_TRAINING_GROUNDS("Knights Waves Training Grounds", new Quest[]{Quest.KINGS_RANSOM}, null, null, null),
TROLL_WARZONE("Troll Warzone Tutorial", null, null, null, null),
WITCHES_POTION("Witch's Potion", null, null, null, null),
HUNT_FOR_SUROK("The Hunt for Surok", new Quest[]{Quest.WHAT_LIES_BELOW}, null, Map.of(Skills.MINING, 42, Skills.PRAYER, 43), null),
FROM_TINY_ACORNS("From Tiny Acorns", new Quest[] { Quest.BUYERS_AND_CELLARS }, null, Map.of(Skills.THIEVING, 24), null),
LOST_HER_MARBLES("Lost Her Marbles", null, new Miniquest[] { Miniquest.FROM_TINY_ACORNS }, Map.of(Skills.THIEVING, 41), null),
A_GUILD_OF_OUR_OWN("A Guild of Our Own", null, new Miniquest[] { Miniquest.LOST_HER_MARBLES }, Map.of(Skills.THIEVING, 62, Skills.HERBLORE, 46, Skills.AGILITY, 40), null),
BAR_CRAWL("Alfred Grimhand's Barcrawl", null, null, null, null)
;
static {
initializeHandlers();
}
public static void initializeHandlers() {
try {
List<Class<?>> classes = Utils.getClassesWithAnnotation("com.rs", MiniquestHandler.class);
for (Class<?> clazz : classes) {
MiniquestHandler handler = clazz.getAnnotation(MiniquestHandler.class);
if (handler == null || clazz.getSuperclass() != MiniquestOutline.class)
continue;
handler.miniquest().handler = (MiniquestOutline) clazz.getConstructor().newInstance();
}
} catch (ClassNotFoundException | IOException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException e) {
e.printStackTrace();
}
}
private final String name;
private final Quest[] questPreReqs;
private final Miniquest[] miniquestPreReqs;
private final Map<Integer, Integer> skillReqs;
private MiniquestOutline handler;
Miniquest(String name, Quest[] questPreReqs, Miniquest[] miniquestPreReqs, Map<Integer, Integer> skillReqs, Function<Player, Boolean> canStart) {
this.name = name;
this.questPreReqs = questPreReqs;
this.miniquestPreReqs = miniquestPreReqs;
this.skillReqs = skillReqs;
}
public boolean isImplemented() {
return handler != null;
}
public MiniquestOutline getHandler() {
return handler;
}
public boolean meetsReqs(Player player) {
return meetsReqs(player, null, false);
}
public boolean meetsReqs(Player player, String actionStr, boolean outputReqs) {
boolean meetsRequirements = true;
if (questPreReqs != null) {
for (Quest preReq : questPreReqs) {
if (!player.isQuestComplete(preReq, actionStr)) {
if (outputReqs)
player.sendMessage("You need to complete " + preReq.getDefs().name + " first.");
meetsRequirements = false;
}
}
}
if (miniquestPreReqs != null) {
for (Miniquest preReq : miniquestPreReqs) {
if (!player.isMiniquestComplete(preReq, actionStr, outputReqs)) {
if (outputReqs)
player.sendMessage("You need to complete " + preReq.getName() + " first.");
meetsRequirements = false;
}
}
}
if (skillReqs != null) {
for (int skillId : skillReqs.keySet()) {
if (player.getSkills().getLevelForXp(skillId) < skillReqs.get(skillId)) {
if (actionStr != null)
player.sendMessage("You need a " + Skills.SKILL_NAME[skillId] + " level of " + skillReqs.get(skillId) + ".");
meetsRequirements = false;
}
}
}
if (!meetsRequirements && actionStr != null)
if (outputReqs)
player.sendMessage("You must meet the requirements for the miniquest: " + getName() + " " + actionStr);
return meetsRequirements;
}
public String getName() {
return name;
}
}
|
package com.rs.engine.miniquest;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface MiniquestHandler {
Miniquest miniquest();
String startText();
String itemsText();
String combatText();
String rewardsText();
int completedStage();
}
|
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 3