├── .gitignore
├── src
    └── main
    │   ├── resources
    │       └── org
    │       │   └── runestar
    │       │       └── cs2
    │       │           ├── boolean-names.tsv
    │       │           ├── setsize-names.tsv
    │       │           ├── windowmode-names.tsv
    │       │           ├── inv-names.tsv
    │       │           ├── settextalignh-names.tsv
    │       │           ├── settextalignv-names.tsv
    │       │           ├── clienttype-names.tsv
    │       │           ├── iftype-names.tsv
    │       │           ├── chatfilter-names.tsv
    │       │           ├── setposh-names.tsv
    │       │           ├── setposv-names.tsv
    │       │           ├── stat-names.tsv
    │       │           ├── fontmetrics-names.tsv
    │       │           ├── param-names.tsv
    │       │           ├── chattype-names.tsv
    │       │           ├── maparea-names.tsv
    │       │           ├── key-names.tsv
    │       │           ├── interface-names.tsv
    │       │           ├── struct-names.tsv
    │       │           └── param-types.tsv
    │   └── java
    │       └── org
    │           └── runestar
    │               └── cs2
    │                   ├── bin
    │                       ├── StackType.kt
    │                       ├── ClientScriptDesc.kt
    │                       ├── Trigger.kt
    │                       ├── Value.kt
    │                       ├── ScriptName.kt
    │                       ├── Type.kt
    │                       ├── Script.kt
    │                       └── Opcodes.kt
    │                   ├── ir
    │                       ├── FunctionSet.kt
    │                       ├── CallGraph.kt
    │                       ├── Function.kt
    │                       ├── EventProperty.kt
    │                       ├── Element.kt
    │                       ├── Instruction.kt
    │                       ├── Variable.kt
    │                       ├── Typing.kt
    │                       ├── Expression.kt
    │                       ├── Typings.kt
    │                       ├── Prototype.kt
    │                       └── Interpreter.kt
    │                   ├── cg
    │                       ├── Generator.kt
    │                       ├── Ints.kt
    │                       └── StrictGenerator.kt
    │                   ├── cfa
    │                       ├── FlowGraph.kt
    │                       ├── Construct.kt
    │                       ├── Block.kt
    │                       └── Reconstruct.kt
    │                   ├── util
    │                       ├── Chain.kt
    │                       ├── ListStack.kt
    │                       ├── Extensions.kt
    │                       ├── DirectedGraph.kt
    │                       ├── LinkedGraph.kt
    │                       ├── PartitionedChain.kt
    │                       ├── Loader.kt
    │                       ├── DominatorTree.kt
    │                       └── HashChain.kt
    │                   ├── Decompiler.kt
    │                   ├── dfa
    │                       ├── DeleteNops.kt
    │                       ├── ReorderArgs.kt
    │                       ├── Phase.kt
    │                       ├── RemoveDeadCode.kt
    │                       ├── CombineSameLineOperations.kt
    │                       ├── FindArrayArgs.kt
    │                       ├── AddShortCircuitOperators.kt
    │                       ├── CalcIdentifiers.kt
    │                       ├── InlineStackDefinitions.kt
    │                       └── CalcTypes.kt
    │                   ├── Example.kt
    │                   └── Resources.kt
├── NOTICE
├── pom.xml
├── README.md
└── LICENSE


/.gitignore:
--------------------------------------------------------------------------------
1 | .idea/
2 | target
3 | *.iml
4 | input/
5 | scripts/


--------------------------------------------------------------------------------
/src/main/resources/org/runestar/cs2/boolean-names.tsv:
--------------------------------------------------------------------------------
1 | 0	false
2 | 1	true


--------------------------------------------------------------------------------
/src/main/resources/org/runestar/cs2/setsize-names.tsv:
--------------------------------------------------------------------------------
1 | 0	abs
2 | 1	minus
3 | 2	2


--------------------------------------------------------------------------------
/src/main/resources/org/runestar/cs2/windowmode-names.tsv:
--------------------------------------------------------------------------------
1 | 1	fixed
2 | 2	resizable


--------------------------------------------------------------------------------
/src/main/resources/org/runestar/cs2/inv-names.tsv:
--------------------------------------------------------------------------------
1 | 93	inv
2 | 94	worn
3 | 95	bank
4 | 


--------------------------------------------------------------------------------
/src/main/resources/org/runestar/cs2/settextalignh-names.tsv:
--------------------------------------------------------------------------------
1 | 0	left
2 | 1	centre
3 | 2	right


--------------------------------------------------------------------------------
/src/main/resources/org/runestar/cs2/settextalignv-names.tsv:
--------------------------------------------------------------------------------
1 | 0	top
2 | 1	centre
3 | 2	bottom


--------------------------------------------------------------------------------
/src/main/resources/org/runestar/cs2/clienttype-names.tsv:
--------------------------------------------------------------------------------
1 | 1	desktop
2 | 2	android
3 | 3	ios
4 | 4	enhanced
5 | 


--------------------------------------------------------------------------------
/src/main/resources/org/runestar/cs2/iftype-names.tsv:
--------------------------------------------------------------------------------
1 | 3	rectangle
2 | 4	text
3 | 5	graphic
4 | 6	model
5 | 9	line


--------------------------------------------------------------------------------
/src/main/resources/org/runestar/cs2/chatfilter-names.tsv:
--------------------------------------------------------------------------------
1 | 0	on
2 | 1	friends
3 | 2	off
4 | 3	hide
5 | 4	autochat
6 | 


--------------------------------------------------------------------------------
/src/main/resources/org/runestar/cs2/setposh-names.tsv:
--------------------------------------------------------------------------------
1 | 0	abs_left
2 | 1	abs_centre
3 | 2	abs_right
4 | 3	3
5 | 4	4
6 | 5	5


--------------------------------------------------------------------------------
/src/main/resources/org/runestar/cs2/setposv-names.tsv:
--------------------------------------------------------------------------------
1 | 0	abs_top
2 | 1	abs_centre
3 | 2	abs_bottom
4 | 3	3
5 | 4	4
6 | 5	5


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/bin/StackType.kt:
--------------------------------------------------------------------------------
1 | package org.runestar.cs2.bin
2 | 
3 | enum class StackType(val defaultType: Type) {
4 |     INT(Type.INT),
5 |     STRING(Type.STRING),
6 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/ir/FunctionSet.kt:
--------------------------------------------------------------------------------
1 | package org.runestar.cs2.ir
2 | 
3 | class FunctionSet(
4 |         val functions: Map<Int, Function>,
5 |         val typings: Typings,
6 |         val callGraph: CallGraph,
7 | )


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/cg/Generator.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.cg
 2 | 
 3 | import org.runestar.cs2.cfa.Construct
 4 | import org.runestar.cs2.ir.Function
 5 | import org.runestar.cs2.ir.FunctionSet
 6 | 
 7 | interface Generator {
 8 | 
 9 |     fun write(f: Function, fs: FunctionSet, root: Construct)
10 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/cfa/FlowGraph.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.cfa
 2 | 
 3 | import org.runestar.cs2.ir.Function
 4 | import org.runestar.cs2.util.dominatorTree
 5 | 
 6 | class FlowGraph(val f: Function) {
 7 | 
 8 |     val blocks = partitionBlocks(f)
 9 | 
10 |     val graph = graphBlocks(blocks)
11 | 
12 |     val dtree = dominatorTree(graph)
13 | }


--------------------------------------------------------------------------------
/src/main/resources/org/runestar/cs2/stat-names.tsv:
--------------------------------------------------------------------------------
 1 | 0	attack
 2 | 1	defence
 3 | 2	strength
 4 | 3	hitpoints
 5 | 4	ranged
 6 | 5	prayer
 7 | 6	magic
 8 | 7	cooking
 9 | 8	woodcutting
10 | 9	fletching
11 | 10	fishing
12 | 11	firemaking
13 | 12	crafting
14 | 13	smithing
15 | 14	mining
16 | 15	herblore
17 | 16	agility
18 | 17	thieving
19 | 18	slayer
20 | 19	farming
21 | 20	runecraft
22 | 21	hunter
23 | 22	construction
24 | 


--------------------------------------------------------------------------------
/src/main/resources/org/runestar/cs2/fontmetrics-names.tsv:
--------------------------------------------------------------------------------
 1 | 494	p11_full
 2 | 495	p12_full
 3 | 496	b12_full
 4 | 497	q8_full
 5 | 645	quill_oblique_large
 6 | 646	quill_caps_large
 7 | 647	lunar_alphabet
 8 | 648	lunar_alphabet_lrg
 9 | 764	barbassault_font
10 | 819	surok_font
11 | 1442	verdana_11pt_regular
12 | 1443	verdana_11pt_bold
13 | 1445	verdana_13pt_regular
14 | 1446	verdana_13pt_bold
15 | 1447	verdana_15pt_regular
16 | 


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/ir/CallGraph.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.ir
 2 | 
 3 | import org.runestar.cs2.bin.Trigger
 4 | import org.runestar.cs2.util.LinkedGraph
 5 | 
 6 | class CallGraph {
 7 | 
 8 | //    val graph = LinkedGraph<Int>()
 9 | 
10 |     val triggers = HashMap<Int, Trigger>()
11 | 
12 |     fun call(from: Int, to: Int, trigger: Trigger) {
13 |         triggers[to] = trigger
14 | //        graph.addSuccessor(from, to)
15 |     }
16 | }


--------------------------------------------------------------------------------
/src/main/resources/org/runestar/cs2/param-names.tsv:
--------------------------------------------------------------------------------
 1 | 336	spell_spellbook
 2 | 365	magic_runetype_1
 3 | 366	magic_runecount_1
 4 | 367	magic_runetype_2
 5 | 368	magic_runecount_2
 6 | 369	magic_runetype_3
 7 | 370	magic_runecount_3
 8 | 596	spell_button
 9 | 597	spell_graphic1_on
10 | 598	spell_graphic1_off
11 | 599	spell_graphic2_on
12 | 600	spell_graphic2_off
13 | 601	spell_name
14 | 602	spell_desc
15 | 603	spell_membersonly
16 | 604	spell_levelreq
17 | 605	spell_type
18 | 606	magic_runetype_4
19 | 607	magic_runecount_4


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/util/Chain.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.util
 2 | 
 3 | interface Chain<E : Any> : MutableIterable<E> {
 4 | 
 5 |     val first: E
 6 | 
 7 |     val last: E
 8 | 
 9 |     fun addFirst(e: E)
10 | 
11 |     fun addLast(e: E)
12 | 
13 |     fun next(e: E): E?
14 | 
15 |     fun previous(e: E): E?
16 | 
17 |     fun insertAfter(e: E, point: E)
18 | 
19 |     fun insertBefore(e: E, point: E)
20 | 
21 |     fun remove(e: E)
22 | 
23 |     override fun iterator(): MutableIterator<E> = iterator(first, last)
24 | 
25 |     fun iterator(from: E, to: E): MutableIterator<E>
26 | }


--------------------------------------------------------------------------------
/src/main/resources/org/runestar/cs2/chattype-names.tsv:
--------------------------------------------------------------------------------
 1 | 0	gamemessage
 2 | 1	modchat
 3 | 2	publicchat
 4 | 3	privatechat
 5 | 4	engine
 6 | 5	loginlogoutnotification
 7 | 6	privatechatout
 8 | 7	modprivatechat
 9 | 9	friendschat
10 | 11	friendschatnotification
11 | 14	broadcast
12 | 26	snapshotfeedback
13 | 27	obj_examine
14 | 28	npc_examine
15 | 29	loc_examine
16 | 30	friendnotification
17 | 31	ignorenotification
18 | 90	autotyper
19 | 91	modautotyper
20 | 99	console
21 | 101	tradereq
22 | 102	trade
23 | 103	chalreq_trade
24 | 104	chalreq_friendschat
25 | 105	spam
26 | 106	playerrelated
27 | 107	10sectimeout
28 | 


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/util/ListStack.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.util
 2 | 
 3 | data class ListStack<T : Any>(val delegate: MutableList<T>) {
 4 | 
 5 |     val size: Int get() = delegate.size
 6 | 
 7 |     fun isEmpty(): Boolean = delegate.isEmpty()
 8 | 
 9 |     fun push(element: T) { delegate.add(element) }
10 | 
11 |     fun peek(): T = delegate[delegate.lastIndex]
12 | 
13 |     fun pop(): T = delegate.removeAt(delegate.lastIndex)
14 | 
15 |     fun popAll(): List<T> = delegate.toList().also { delegate.clear() }
16 | 
17 |     fun pop(count: Int): List<T> = MutableList(count) { pop() }.also { it.reverse() }
18 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/ir/Function.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.ir
 2 | 
 3 | import org.runestar.cs2.bin.StackType
 4 | import org.runestar.cs2.util.Chain
 5 | 
 6 | class Function(
 7 |         val id: Int,
 8 |         var arguments: List<Variable.Local>,
 9 |         val instructions: Chain<Instruction>,
10 |         val returnTypes: List<StackType>
11 | ) {
12 | 
13 |     override fun toString() = buildString {
14 |         append("id=").appendLine(id)
15 |         append("arguments=").appendLine(arguments)
16 |         append("returnTypes=").appendLine(returnTypes)
17 |         instructions.forEach { appendLine(it) }
18 |     }
19 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/Decompiler.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2
 2 | 
 3 | import org.runestar.cs2.bin.Script
 4 | import org.runestar.cs2.cfa.reconstruct
 5 | import org.runestar.cs2.cg.Generator
 6 | import org.runestar.cs2.dfa.Phase
 7 | import org.runestar.cs2.ir.Command
 8 | import org.runestar.cs2.ir.interpret
 9 | import org.runestar.cs2.util.Loader
10 | 
11 | fun decompile(
12 |         scripts: Loader.Keyed<Script>,
13 |         generator: Generator,
14 | ) {
15 |     val fs = interpret(scripts, Command.LOADER, PARAM_TYPES)
16 |     Phase.DEFAULT.transform(fs)
17 |     fs.functions.values.forEach { generator.write(it, fs, reconstruct(it)) }
18 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/bin/ClientScriptDesc.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.bin
 2 | 
 3 | import org.runestar.cs2.util.CP1252
 4 | 
 5 | data class ClientScriptDesc(
 6 |         val argumentTypes: List<Type>,
 7 |         val triggers: Boolean,
 8 | )
 9 | 
10 | fun ClientScriptDesc(desc: String): ClientScriptDesc {
11 |     val bytes = desc.toByteArray(CP1252)
12 |     val triggers = bytes.isNotEmpty() && desc.last() == 'Y'
13 |     val argTypes = ArrayList<Type>(bytes.size)
14 |     for (i in bytes.indices) {
15 |         if (!triggers || i != bytes.lastIndex) {
16 |             argTypes.add(Type.of(bytes[i]))
17 |         }
18 |     }
19 |     return ClientScriptDesc(argTypes, triggers)
20 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/bin/Trigger.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.bin
 2 | 
 3 | enum class Trigger(val id: Int) {
 4 | 
 5 |     opworldmapelement1(10),
 6 |     opworldmapelement2(11),
 7 |     opworldmapelement3(12),
 8 |     opworldmapelement4(13),
 9 |     opworldmapelement5(14),
10 |     worldmapelementmouseover(15),
11 |     worldmapelementmouseleave(16),
12 |     worldmapelementmouserepeat(17),
13 |     trigger_47(47),
14 |     trigger_48(48),
15 |     trigger_49(49),
16 |     proc(73),
17 |     clientscript(76),
18 |     ;
19 | 
20 |     companion object {
21 | 
22 |         private val VALUES = values().associateBy { it.id }
23 | 
24 |         fun of(id: Int): Trigger = VALUES.getValue(id)
25 |     }
26 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/util/Extensions.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.util
 2 | 
 3 | import java.lang.invoke.MethodHandles
 4 | import java.nio.charset.Charset
 5 | import java.nio.file.Path
 6 | 
 7 | fun Short.toUnsignedInt(): Int = java.lang.Short.toUnsignedInt(this)
 8 | 
 9 | fun Byte.toUnsignedInt(): Int = java.lang.Byte.toUnsignedInt(this)
10 | 
11 | val CP1252 = charset("windows-1252")
12 | 
13 | fun Char.toByte(charset: Charset): Byte = toString().toByteArray(charset).single()
14 | 
15 | fun counter(): () -> Int {
16 |     var i = 0
17 |     return { i++ }
18 | }
19 | 
20 | inline val thisClass: Class<*> get() = MethodHandles.lookup().lookupClass()
21 | 
22 | fun Path.list(): List<String> = checkNotNull(toFile().list()).asList()


--------------------------------------------------------------------------------
/NOTICE:
--------------------------------------------------------------------------------
 1 | Copyright (C) 2018-2021, Hunter WB <hunterwb.com>
 2 | 
 3 | This program is free software: you can redistribute it and/or modify
 4 | it under the terms of the GNU Affero General Public License as published by
 5 | the Free Software Foundation, either version 3 of the License, or
 6 | (at your option) any later version.
 7 | 
 8 | This program is distributed in the hope that it will be useful,
 9 | but WITHOUT ANY WARRANTY; without even the implied warranty of
10 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 | GNU Affero General Public License for more details.
12 | 
13 | You should have received a copy of the GNU Affero General Public License
14 | along with this program.  If not, see <https://www.gnu.org/licenses/>.
15 | 


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/dfa/DeleteNops.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.dfa
 2 | 
 3 | import org.runestar.cs2.ir.Element
 4 | import org.runestar.cs2.ir.Function
 5 | import org.runestar.cs2.ir.FunctionSet
 6 | import org.runestar.cs2.ir.Instruction
 7 | import org.runestar.cs2.ir.asList
 8 | 
 9 | object DeleteNops : Phase.Individual() {
10 | 
11 |     override fun transform(f: Function, fs: FunctionSet) {
12 |         val itr = f.instructions.iterator()
13 |         for (insn in itr) {
14 |             if (insn !is Instruction.Assignment) continue
15 |             if (insn.definitions.asList.isNotEmpty()) continue
16 |             if (insn.expression.asList.all { it is Element }) {
17 |                 itr.remove()
18 |             }
19 |         }
20 |     }
21 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/dfa/ReorderArgs.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.dfa
 2 | 
 3 | import org.runestar.cs2.ir.Function
 4 | import org.runestar.cs2.ir.FunctionSet
 5 | 
 6 | object ReorderArgs : Phase.Individual() {
 7 | 
 8 |     override fun transform(f: Function, fs: FunctionSet) {
 9 |         if (f.arguments.size <= 1) return
10 |         val oldStackTypes = f.arguments.map { it.stackType }
11 |         val typing = fs.typings.args(f.id, oldStackTypes)
12 |         val newStackTypes = typing.map { it.stackType }
13 |         if (oldStackTypes == newStackTypes) return
14 |         val oldArgs = f.arguments.toMutableList()
15 |         val newArgs = newStackTypes.map { st -> oldArgs.removeAt(oldArgs.indexOfFirst { it.stackType == st }) }
16 |         f.arguments = newArgs
17 |     }
18 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/bin/Value.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.bin
 2 | 
 3 | sealed class Value {
 4 | 
 5 |     abstract val stackType: StackType
 6 | 
 7 |     data class Int(val int: kotlin.Int) : Value() {
 8 | 
 9 |         override val stackType get() = StackType.INT
10 | 
11 |         override fun toString() = int.toString()
12 |     }
13 | 
14 |     data class String(val string: kotlin.String) : Value() {
15 | 
16 |         override val stackType get() = StackType.STRING
17 | 
18 |         override fun toString() = string
19 |     }
20 | }
21 | 
22 | fun Value(int: Int) = Value.Int(int)
23 | 
24 | fun Value(string: String) = Value.String(string)
25 | 
26 | val Value.int get() = (this as Value.Int).int
27 | 
28 | val Value.string get() = (this as Value.String).string
29 | 
30 | val Value.boolean get() = when (int) {
31 |     0 -> false
32 |     1 -> true
33 |     else -> error(this)
34 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/util/DirectedGraph.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.util
 2 | 
 3 | interface DirectedGraph<N : Any> : Iterable<N> {
 4 | 
 5 |     val head: N
 6 | 
 7 |     fun immediatePredecessors(n: N): List<N>
 8 | 
 9 |     fun immediateSuccessors(n: N): List<N>
10 | }
11 | 
12 | fun <N : Any> DirectedGraph<N>.postOrder(
13 |         n: N = head,
14 |         seen: MutableSet<N> = HashSet(),
15 |         consumer: (N) -> Unit
16 | ) {
17 |     if (!seen.add(n)) return
18 |     for (s in immediateSuccessors(n)) {
19 |         postOrder(s, seen, consumer)
20 |     }
21 |     consumer(n)
22 | }
23 | 
24 | fun <N : Any> DirectedGraph<N>.isSuccessorAcyclic(
25 |         n: N,
26 |         successor: N
27 | ): Boolean {
28 |     for (s in immediateSuccessors(n)) {
29 |         if (s == successor) return true
30 |         if (isSuccessorAcyclic(s, successor)) return true
31 |     }
32 |     return false
33 | }


--------------------------------------------------------------------------------
/src/main/resources/org/runestar/cs2/maparea-names.tsv:
--------------------------------------------------------------------------------
 1 | 0	main
 2 | 1	ancient_cavern
 3 | 2	ardougne_underground
 4 | 3	asgarnia_ice_dungeon
 5 | 4	braindeath_island
 6 | 5	dorgeshkaan
 7 | 6	dwarven_mines
 8 | 7	godwars
 9 | 8	kalphite
10 | 9	karamja_underground
11 | 10	keldagrim
12 | 11	miscellania_underground
13 | 12	misthalin_underground
14 | 13	mole
15 | 14	morytania_underground
16 | 15	mosleharmless_cave
17 | 16	ourania
18 | 17	slayer_cave
19 | 18	sos
20 | 19	stronghold_underground
21 | 20	taverley_underground
22 | 21	tolna
23 | 22	troll_stronghold
24 | 23	tzhaar_area
25 | 24	undead_dungeon
26 | 25	waterbirth
27 | 26	wilderness_dungeons
28 | 27	yanille_underground
29 | 28	zanaris
30 | 29	prifddinas
31 | 30	fossil_underground
32 | 31	feldip_underground
33 | 32	kourend_underground
34 | 33	kebos_underground
35 | 34	prifddinas_underground
36 | 35	grand_library
37 | 36	br_default
38 | 37	tutorial_2
39 | 38	br_dark_varrock
40 | 


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/ir/EventProperty.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.ir
 2 | 
 3 | import org.runestar.cs2.bin.Value
 4 | 
 5 | enum class EventProperty(val magic: Value, val prototype: Prototype) : Element {
 6 | 
 7 |     opbase(Value("event_opbase"), OPBASE),
 8 |     mousex(Value(Int.MIN_VALUE + 1), MOUSEX),
 9 |     mousey(Value(Int.MIN_VALUE + 2), MOUSEY),
10 |     com(Value(Int.MIN_VALUE + 3), COMPONENT),
11 |     opindex(Value(Int.MIN_VALUE + 4), OPINDEX),
12 |     comsubid(Value(Int.MIN_VALUE + 5), COMSUBID),
13 |     drop(Value(Int.MIN_VALUE + 6), DROP),
14 |     dropsubid(Value(Int.MIN_VALUE + 7), DROPSUBID),
15 |     key(Value(Int.MIN_VALUE + 8), KEY),
16 |     keychar(Value(Int.MIN_VALUE + 9), KEYCHAR),
17 |     ;
18 | 
19 |     override val stackType get() = prototype.stackType
20 | 
21 |     val literal = "event_$name"
22 | 
23 |     override fun toString() = literal
24 | 
25 |     companion object {
26 | 
27 |         private val VALUES = values().associateBy { it.magic }
28 | 
29 |         fun of(magic: Value): EventProperty? = VALUES[magic]
30 |     }
31 | }


--------------------------------------------------------------------------------
/src/main/resources/org/runestar/cs2/key-names.tsv:
--------------------------------------------------------------------------------
 1 | 1	f1
 2 | 2	f2
 3 | 3	f3
 4 | 4	f4
 5 | 5	f5
 6 | 6	f6
 7 | 7	f7
 8 | 8	f8
 9 | 9	f9
10 | 10	f10
11 | 11	f11
12 | 12	f12
13 | 13	escape
14 | 16	1
15 | 17	2
16 | 18	3
17 | 19	4
18 | 20	5
19 | 21	6
20 | 22	7
21 | 23	8
22 | 24	9
23 | 25	0
24 | 26	minus
25 | 27	equals
26 | 28	console
27 | 32	q
28 | 33	w
29 | 34	e
30 | 35	r
31 | 36	t
32 | 37	y
33 | 38	u
34 | 39	i
35 | 40	o
36 | 41	p
37 | 42	left_bracket
38 | 43	right_bracket
39 | 48	a
40 | 49	s
41 | 50	d
42 | 51	f
43 | 52	g
44 | 53	h
45 | 54	j
46 | 55	k
47 | 56	l
48 | 57	semicolon
49 | 58	apostrophe
50 | 59	win_left
51 | 64	z
52 | 65	x
53 | 66	c
54 | 67	v
55 | 68	b
56 | 69	n
57 | 70	m
58 | 71	comma
59 | 72	period
60 | 73	slash
61 | 74	backslash
62 | 80	tab
63 | 81	shift_left
64 | 82	control_left
65 | 83	space
66 | 84	return
67 | 85	backspace
68 | 86	alt_left
69 | 87	numpad_add
70 | 88	numpad_subtract
71 | 89	numpad_multiply
72 | 90	numpad_divide
73 | 91	clear
74 | 96	left
75 | 97	right
76 | 98	up
77 | 99	down
78 | 100	insert
79 | 101	del
80 | 102	home
81 | 103	end
82 | 104	page_up
83 | 105	page_down
84 | 


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/dfa/Phase.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.dfa
 2 | 
 3 | import org.runestar.cs2.ir.Function
 4 | import org.runestar.cs2.ir.FunctionSet
 5 | 
 6 | interface Phase {
 7 | 
 8 |     fun transform(fs: FunctionSet)
 9 | 
10 |     abstract class Individual : Phase {
11 | 
12 |         final override fun transform(fs: FunctionSet) = fs.functions.values.forEach { transform(it, fs) }
13 | 
14 |         abstract fun transform(f: Function, fs: FunctionSet)
15 |     }
16 | 
17 |     class Composite(private vararg val ps: Phase) : Phase {
18 | 
19 |         override fun transform(fs: FunctionSet) = ps.forEach { it.transform(fs) }
20 |     }
21 | 
22 |     companion object {
23 | 
24 |         val DEFAULT = Composite(
25 |                 RemoveDeadCode,
26 |                 DeleteNops,
27 |                 ReorderArgs,
28 |                 FindArrayArgs,
29 |                 CombineSameLineOperations,
30 |                 InlineStackDefinitions,
31 |                 CalcTypes,
32 |                 CalcIdentifiers,
33 |                 AddShortCircuitOperators,
34 |         )
35 |     }
36 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/util/LinkedGraph.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.util
 2 | 
 3 | class LinkedGraph<N : Any> : DirectedGraph<N> {
 4 | 
 5 |     private val map = HashMap<N, Node<N>>()
 6 | 
 7 |     override lateinit var head: N
 8 | 
 9 |     override fun immediatePredecessors(n: N): List<N> = get(n).predecessors
10 | 
11 |     override fun immediateSuccessors(n: N): List<N> = get(n).successors
12 | 
13 |     override fun iterator(): Iterator<N> = map.keys.iterator()
14 | 
15 |     private fun get(n: N): Node<N> = map.getOrPut(n) { Node() }
16 | 
17 |     fun addSuccessor(n: N, successor: N) {
18 |         get(n).successors.add(successor)
19 |         get(successor).predecessors.add(n)
20 |     }
21 | 
22 |     override fun toString() = buildString {
23 |         for (n in this@LinkedGraph) {
24 |             append(n).append(", s=").append(immediateSuccessors(n)).append(", p=").append(immediatePredecessors(n)).appendLine()
25 |         }
26 |     }
27 | 
28 |     private class Node<N : Any>(
29 |             val predecessors: MutableList<N> = ArrayList(),
30 |             val successors: MutableList<N> = ArrayList()
31 |     )
32 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/cfa/Construct.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.cfa
 2 | 
 3 | import org.runestar.cs2.ir.Expression
 4 | import org.runestar.cs2.ir.Instruction
 5 | import java.util.ArrayList
 6 | 
 7 | interface Construct {
 8 | 
 9 |     var next: Construct?
10 | 
11 |     class Seq(val instructions: MutableList<Instruction> = ArrayList()) : Construct {
12 | 
13 |         override var next: Construct? = null
14 |     }
15 | 
16 |     class Branch(var condition: Expression.Operation, var body: Construct)
17 | 
18 |     class If(val branches: MutableList<Branch> = ArrayList()) : Construct {
19 | 
20 |         var elze: Construct? = null
21 | 
22 |         override var next: Construct? = null
23 |     }
24 | 
25 |     class While(val condition: Expression.Operation): Construct {
26 | 
27 |         lateinit var body: Construct
28 | 
29 |         override var next: Construct? = null
30 |     }
31 | 
32 |     class Switch(
33 |             val expression: Expression,
34 |             val cases: Map<Set<Int>, Construct>
35 |     ) : Construct {
36 | 
37 |         var default: Construct? = null
38 | 
39 |         override var next: Construct? = null
40 |     }
41 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/ir/Element.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.ir
 2 | 
 3 | import org.runestar.cs2.bin.StackType
 4 | import org.runestar.cs2.bin.Value
 5 | import org.runestar.cs2.ir.Variable as Var
 6 | 
 7 | interface Element : Expression {
 8 | 
 9 |     val stackType: StackType
10 | 
11 |     override val stackTypes: List<StackType> get() = listOf(stackType)
12 | 
13 |     class Constant(val value: Value) : Element {
14 | 
15 |         override val stackType get() = value.stackType
16 | 
17 |         override fun toString() = value.toString()
18 |     }
19 | 
20 |     interface Variable : Element {
21 | 
22 |         val variable: Var
23 | 
24 |         override val stackType get() = variable.stackType
25 |     }
26 | 
27 |     class Access(
28 |             override val variable: Var,
29 |             val value: Value? = null,
30 |     ) : Variable {
31 | 
32 |         init {
33 |             if (value != null) require(variable.stackType == value.stackType)
34 |         }
35 | 
36 |         override fun toString() = "$$variable"
37 |     }
38 | 
39 |     class Pointer(override val variable: Var) : Variable {
40 | 
41 |         override fun toString() = variable.toString()
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/bin/ScriptName.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.bin
 2 | 
 3 | import kotlin.math.abs
 4 | 
 5 | data class ScriptName(val trigger: Trigger, val name: String) {
 6 | 
 7 |     override fun toString() = "[$trigger,$name]"
 8 | }
 9 | 
10 | fun ScriptName(cacheName: String): ScriptName {
11 |     val n = cacheName.toIntOrNull()
12 |     return if (n == null) {
13 |         val comma = cacheName.indexOf(',')
14 |         require(cacheName.startsWith('[') && cacheName.endsWith(']') && comma != -1)
15 |         ScriptName(Trigger.valueOf(cacheName.substring(1, comma)), cacheName.substring(comma + 1, cacheName.length - 1))
16 |     } else {
17 |         var t = n + 512
18 |         if (t in 10..50) {
19 |             // global trigger
20 |             ScriptName(Trigger.of(t), "_")
21 |         } else {
22 |             val c = abs((n shl 8) - 3)
23 |             t = (c shr 8) + n + 768
24 |             if (t in 0..255) {
25 |                 // category trigger
26 |                 ScriptName(Trigger.of(n + 512), "_category_$c")
27 |             } else {
28 |                 // type trigger
29 |                 ScriptName(Trigger.of(n and 0xFF), (n shr 8).toString())
30 |             }
31 |         }
32 |     }
33 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/dfa/RemoveDeadCode.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.dfa
 2 | 
 3 | import org.runestar.cs2.ir.Element
 4 | import org.runestar.cs2.ir.Function
 5 | import org.runestar.cs2.ir.FunctionSet
 6 | import org.runestar.cs2.ir.Instruction
 7 | import org.runestar.cs2.ir.Variable
 8 | import org.runestar.cs2.ir.remove
 9 | 
10 | object RemoveDeadCode : Phase.Individual() {
11 | 
12 |     override fun transform(f: Function, fs: FunctionSet) {
13 |         var insn: Instruction? = f.instructions.first
14 |         while (insn != null) {
15 |             if (insn is Instruction.Return) {
16 |                 insn = f.instructions.next(insn)
17 |                 while (insn != null && insn !is Instruction.Label) {
18 |                     if (insn is Instruction.Assignment) {
19 |                         val def = insn.definitions as Element.Access
20 |                         val v = def.variable as Variable.Stack
21 |                         fs.typings.remove(v)
22 |                         val c = insn.expression as Element.Constant
23 |                         fs.typings.remove(c)
24 |                     }
25 |                     val next = f.instructions.next(insn)
26 |                     f.instructions.remove(insn)
27 |                     insn = next
28 |                 }
29 |             } else {
30 |                 insn = f.instructions.next(insn)
31 |             }
32 |         }
33 |     }
34 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/util/PartitionedChain.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.util
 2 | 
 3 | class PartitionedChain<E : Any>(
 4 |         private val delegate: Chain<E>,
 5 |         heads: List<E>
 6 | ) : Iterable<PartitionedChain<E>.Block> {
 7 | 
 8 |     private val blocks = HashChain<Block>()
 9 | 
10 |     private val map = HashMap<E, Block>()
11 | 
12 |     init {
13 |         for (i in heads.indices) {
14 |             val head: E = heads[i]
15 |             val tail: E = if (i != heads.lastIndex) {
16 |                 delegate.previous(heads[i + 1])!!
17 |             } else {
18 |                 delegate.last
19 |             }
20 |             blocks.addLast(Block(i, head, tail))
21 |         }
22 |         for (b in blocks) {
23 |             for (e in b) {
24 |                 map[e] = b
25 |             }
26 |         }
27 |     }
28 | 
29 |     override fun iterator(): Iterator<Block> = blocks.iterator()
30 | 
31 |     fun block(e: E): Block = map.getValue(e)
32 | 
33 |     val head: Block get() = blocks.first
34 | 
35 |     fun next(b: Block): Block = blocks.next(b)!!
36 | 
37 |     fun previous(b: Block): Block = blocks.previous(b)!!
38 | 
39 |     inner class Block(
40 |             val index: Int,
41 |             var head: E,
42 |             var tail: E
43 |     ) : Iterable<E> {
44 | 
45 |         override fun iterator() = delegate.iterator(head, tail)
46 | 
47 |         override fun toString() = index.toString()
48 |     }
49 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/Example.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2
 2 | 
 3 | import org.runestar.cs2.bin.Script
 4 | import org.runestar.cs2.cg.StrictGenerator
 5 | import org.runestar.cs2.util.Loader
 6 | import org.runestar.cs2.util.caching
 7 | import org.runestar.cs2.util.list
 8 | import org.runestar.cs2.util.withIds
 9 | import java.nio.file.Files
10 | import java.nio.file.Path
11 | import java.util.TreeSet
12 | 
13 | fun main() {
14 |     val readme = StringBuilder()
15 |     readme.append("[![Discord](https://img.shields.io/discord/384870460640329728.svg?logo=discord)](https://discord.gg/G2kxrnU)\n\n")
16 | 
17 |     val loadDir = Path.of("input")
18 |     val saveDir = Path.of("scripts", "scripts")
19 |     Files.createDirectories(saveDir)
20 | 
21 |     val generator = StrictGenerator { scriptId, scriptName, script ->
22 |         Files.writeString(saveDir.resolve("$scriptName.cs2"), script)
23 |         if (SCRIPT_NAMES.load(scriptId) != null) {
24 |             readme.append("[**$scriptId**](scripts/$scriptName.cs2) `$scriptName`  \n")
25 |         } else {
26 |             readme.append("[**$scriptId**](scripts/$scriptName.cs2)  \n")
27 |         }
28 |     }
29 | 
30 |     val scriptLoader = Loader { Script(Files.readAllBytes(loadDir.resolve(it.toString()))) }.caching()
31 |     val scriptIds = loadDir.list().mapTo(TreeSet()) { it.toInt() }
32 | 
33 |     decompile(scriptLoader.withIds(scriptIds), generator)
34 | 
35 |     Files.writeString(Path.of("scripts", "README.md"), readme)
36 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/util/Loader.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.util
 2 | 
 3 | fun interface Loader<T : Any> {
 4 | 
 5 |     fun load(id: Int): T?
 6 | 
 7 |     interface Keyed<T : Any> : Loader<T> {
 8 | 
 9 |         val ids: Set<Int>
10 |     }
11 | 
12 |     data class Map<T : Any>(val map: kotlin.collections.Map<Int, T>) : Keyed<T> {
13 | 
14 |         override fun load(id: Int): T? = map[id]
15 | 
16 |         override val ids: Set<Int> get() = map.keys
17 |     }
18 | 
19 |     data class Constant<T : Any>(val t: T): Loader<T> {
20 | 
21 |         override fun load(id: Int) = t
22 |     }
23 | }
24 | 
25 | fun <T : Any> Loader<T>.caching(): Loader<T> = object : Loader<T> {
26 | 
27 |     private val cache = HashMap<Int, T?>()
28 | 
29 |     override fun load(id: Int): T? = cache[id] ?: if (id in cache) null else this@caching.load(id).also { cache[id] = it }
30 | }
31 | 
32 | fun <T : Any> Loader<T>.withIds(ids: Set<Int>): Loader.Keyed<T> = object : Loader.Keyed<T>, Loader<T> by this {
33 | 
34 |     override val ids get() = ids
35 | }
36 | 
37 | fun <T : Any> Loader<T>.loadNotNull(id: Int): T = checkNotNull(load(id)) { "Value for id $id was null" }
38 | 
39 | fun <T : Any> Loader<T>.orElse(other: Loader<T>): Loader<T> = Loader { load(it) ?: other.load(it) }
40 | 
41 | fun <T : Any, E : Any> Loader<T>.map(transform: (T) -> E): Loader<E> = Loader { load(it)?.let(transform) }
42 | 
43 | fun <T : Any, E : Any> Loader<T>.mapIndexed(transform: (Int, T) -> E): Loader<E> = Loader { id -> load(id)?.let { transform(id, it) } }
44 | 
45 | fun <T : Any> Loader(t: T) = Loader.Constant(t)
46 | 
47 | fun <T : Any> Loader(map: Map<Int, T>) = Loader.Map(map)


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/dfa/CombineSameLineOperations.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.dfa
 2 | 
 3 | import org.runestar.cs2.ir.Element
 4 | import org.runestar.cs2.ir.Expression
 5 | import org.runestar.cs2.ir.Function
 6 | import org.runestar.cs2.ir.FunctionSet
 7 | import org.runestar.cs2.ir.Instruction
 8 | import org.runestar.cs2.ir.Variable
 9 | import org.runestar.cs2.ir.plus
10 | 
11 | object CombineSameLineOperations : Phase.Individual() {
12 | 
13 |     override fun transform(f: Function, fs: FunctionSet) {
14 |         val itr = f.instructions.iterator()
15 |         for (start in itr) {
16 |             if (!isStackAssign(start)) continue
17 |             var end = start
18 |             while (isStackAssign(end)) end = itr.next()
19 |             if (start != end && f.instructions.next(start) != end) {
20 |                 val newInsn = Instruction.Assignment(Expression(), Expression())
21 |                 f.instructions.insertBefore(newInsn, start)
22 |                 var n = start
23 |                 while (n != end) {
24 |                     f.instructions.remove(n)
25 |                     n as Instruction.Assignment
26 |                     newInsn.expression = n.expression + newInsn.expression
27 |                     newInsn.definitions = n.definitions + newInsn.definitions
28 |                     n = f.instructions.next(n)!!
29 |                 }
30 |             }
31 |         }
32 |     }
33 | 
34 |     private fun isStackAssign(insn: Instruction): Boolean {
35 |         if (insn !is Instruction.Assignment) return false
36 |         val expr = insn.expression
37 |         return expr is Element.Access && expr.variable is Variable.Stack
38 |     }
39 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/ir/Instruction.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.ir
 2 | 
 3 | interface Instruction {
 4 | 
 5 |     interface Evaluation : Instruction {
 6 | 
 7 |         var expression: Expression
 8 |     }
 9 | 
10 |     class Assignment(
11 |             var definitions: Expression,
12 |             override var expression: Expression,
13 |     ) : Evaluation {
14 | 
15 |         constructor(expression: Expression) : this(Expression(), expression)
16 | 
17 |         init {
18 |             check(definitions.stackTypes.size == expression.stackTypes.size || definitions.stackTypes.isEmpty())
19 |         }
20 | 
21 |         override fun toString() = "$definitions = $expression"
22 |     }
23 | 
24 |     class Return(override var expression: Expression) : Evaluation {
25 | 
26 |         override fun toString() = "return $expression"
27 |     }
28 | 
29 |     class Branch(
30 |             override var expression: Expression,
31 |             var pass: Label,
32 |     ) : Evaluation {
33 | 
34 |         override fun toString() = "if $expression goto $pass"
35 |     }
36 | 
37 |     class Switch(
38 |             override var expression: Expression,
39 |             val cases: Map<Int, Label>,
40 |     ) : Evaluation {
41 | 
42 |         override fun toString() = buildString {
43 |             append("switch ").append(expression).append(" ")
44 |             cases.entries.joinTo(this, ",") { "${it.key}:${it.value}" }
45 |         }
46 |     }
47 | 
48 |     data class Label(var id: Int) : Instruction {
49 | 
50 |         override fun toString() = "@$id"
51 |     }
52 | 
53 |     class Goto(var label: Label) : Instruction {
54 | 
55 |         override fun toString() = "goto $label"
56 |     }
57 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/ir/Variable.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.ir
 2 | 
 3 | import org.runestar.cs2.bin.StackType
 4 | 
 5 | interface Variable {
 6 | 
 7 |     val id: Int
 8 | 
 9 |     val stackType: StackType
10 | 
11 |     interface OfInt : Variable {
12 | 
13 |         override val stackType get() = StackType.INT
14 |     }
15 | 
16 |     interface OfString : Variable {
17 | 
18 |         override val stackType get() = StackType.STRING
19 |     }
20 | 
21 |     interface Global : Variable
22 | 
23 |     interface Local : Variable {
24 | 
25 |         val script: Int
26 |     }
27 | 
28 |     interface Stack : Local
29 | 
30 |     abstract class Base : Variable {
31 | 
32 |         final override fun toString() = javaClass.simpleName + id.toString()
33 |     }
34 | 
35 |     data class varp(override val id: Int) : Base(), Global, OfInt
36 | 
37 |     data class varbit(override val id: Int) : Base(), Global, OfInt
38 | 
39 |     data class varcint(override val id: Int) : Base(), Global, OfInt
40 | 
41 |     data class varcstring(override val id: Int) : Base(), Global, OfString
42 | 
43 |     data class stackint(override val script: Int, override val id: Int) : Base(), Stack, OfInt
44 | 
45 |     data class stackstring(override val script: Int, override val id: Int) : Base(), Stack, OfString
46 | 
47 |     data class int(override val script: Int, override val id: Int) : Base(), Local, OfInt
48 | 
49 |     data class string(override val script: Int, override val id: Int) : Base(), Local, OfString
50 | 
51 |     data class array(override val script: Int, override val id: Int) : Base(), Local, OfInt
52 | 
53 |     data class varclansetting(override val id: Int) : Base(), Global, OfInt
54 | 
55 |     data class varclan(override val id: Int) : Base(), Global, OfInt
56 | }


--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <project xmlns="http://maven.apache.org/POM/4.0.0"
 3 |          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4 |          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 5 |     <modelVersion>4.0.0</modelVersion>
 6 | 
 7 |     <groupId>org.runestar.cs2</groupId>
 8 |     <artifactId>cs2</artifactId>
 9 |     <version>0.1.0-SNAPSHOT</version>
10 | 
11 |     <properties>
12 |         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
13 |         <version.kotlin>1.4.10</version.kotlin>
14 |         <version.java>11</version.java>
15 |     </properties>
16 | 
17 |     <dependencies>
18 |         <dependency>
19 |             <groupId>org.jetbrains.kotlin</groupId>
20 |             <artifactId>kotlin-stdlib</artifactId>
21 |             <version>${version.kotlin}</version>
22 |         </dependency>
23 |     </dependencies>
24 | 
25 |     <build>
26 |         <plugins>
27 |             <plugin>
28 |                 <groupId>org.jetbrains.kotlin</groupId>
29 |                 <artifactId>kotlin-maven-plugin</artifactId>
30 |                 <version>${version.kotlin}</version>
31 |                 <executions>
32 |                     <execution>
33 |                         <id>compile</id>
34 |                         <phase>process-sources</phase>
35 |                         <goals>
36 |                             <goal>compile</goal>
37 |                         </goals>
38 |                     </execution>
39 |                 </executions>
40 |                 <configuration>
41 |                     <jvmTarget>${version.java}</jvmTarget>
42 |                 </configuration>
43 |             </plugin>
44 |         </plugins>
45 |     </build>
46 | </project>


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/cfa/Block.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.cfa
 2 | 
 3 | import org.runestar.cs2.ir.Function
 4 | import org.runestar.cs2.ir.Instruction
 5 | import org.runestar.cs2.util.DirectedGraph
 6 | import org.runestar.cs2.util.LinkedGraph
 7 | import org.runestar.cs2.util.PartitionedChain
 8 | 
 9 | typealias BasicBlock = PartitionedChain<Instruction>.Block
10 | 
11 | fun partitionBlocks(f: Function): PartitionedChain<Instruction> {
12 |     val blockHeads = ArrayList<Instruction>()
13 |     blockHeads.add(f.instructions.first)
14 |     for (insn in f.instructions) {
15 |         when (insn) {
16 |             is Instruction.Label -> if (blockHeads.last() != insn) blockHeads.add(insn)
17 |             is Instruction.Branch, is Instruction.Switch -> blockHeads.add(f.instructions.next(insn)!!)
18 |         }
19 |     }
20 |     return PartitionedChain(f.instructions, blockHeads)
21 | }
22 | 
23 | fun graphBlocks(blockList: PartitionedChain<Instruction>): DirectedGraph<BasicBlock> {
24 |     val graph = LinkedGraph<BasicBlock>()
25 |     for (block in blockList) {
26 |         when (val tail = block.tail) {
27 |             is Instruction.Goto -> graph.addSuccessor(block, blockList.block(tail.label))
28 |             is Instruction.Switch -> {
29 |                 graph.addSuccessor(block, blockList.next(block))
30 |                 tail.cases.values.forEach { label -> graph.addSuccessor(block, blockList.block(label)) }
31 |             }
32 |             is Instruction.Branch -> {
33 |                 graph.addSuccessor(block, blockList.block(tail.pass))
34 |                 graph.addSuccessor(block, blockList.next(block))
35 |             }
36 |             is Instruction.Return -> {}
37 |             is Instruction.Assignment, is Instruction.Label -> graph.addSuccessor(block, blockList.next(block))
38 |         }
39 |     }
40 |     graph.head = blockList.head
41 |     return graph
42 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/util/DominatorTree.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.util
 2 | 
 3 | fun <N : Any> dominatorTree(graph: DirectedGraph<N>): DirectedGraph<N> {
 4 |     // A Simple, Fast Dominance Algorithm. Cooper, Harvey, Kennedy. 2001
 5 |     val postOrderList = ArrayList<N>()
 6 |     val postOrderMap = HashMap<N, Int>()
 7 |     graph.postOrder {
 8 |         postOrderMap[it] = postOrderList.size
 9 |         postOrderList.add(it)
10 |     }
11 | 
12 |     val idoms = HashMap<N, N>()
13 | 
14 |     fun intersect(n1: N, n2: N): N {
15 |         var f1 = n1
16 |         var f2 = n2
17 |         while (f1 != f2) {
18 |             val f2v = postOrderMap.getValue(f2)
19 |             while (postOrderMap.getValue(f1) < f2v) {
20 |                 f1 = idoms.getValue(f1)
21 |             }
22 |             val f1v = postOrderMap.getValue(f1)
23 |             while (postOrderMap.getValue(f2) < f1v) {
24 |                 f2 = idoms.getValue(f2)
25 |             }
26 |         }
27 |         return f1
28 |     }
29 | 
30 | //    idoms[graph.head] = graph.head
31 |     var changed: Boolean
32 |     do {
33 |         changed = false
34 |         for (i in (postOrderList.lastIndex - 1) downTo 0) {
35 |             val n = postOrderList[i]
36 |             val predecessors = graph.immediatePredecessors(n)
37 |             var newIdom = predecessors[0]
38 |             for (pi in 1..predecessors.lastIndex) {
39 |                 val p = predecessors[pi]
40 |                 if (p in idoms) {
41 |                     newIdom = intersect(p, newIdom)
42 |                 }
43 |             }
44 |             changed = idoms.put(n, newIdom) != newIdom
45 |         }
46 |     } while (changed)
47 | 
48 |     val dominatorTree = LinkedGraph<N>()
49 |     for ((n, idom) in idoms) {
50 |         dominatorTree.addSuccessor(idom, n)
51 |     }
52 |     dominatorTree.head = graph.head
53 |     return dominatorTree
54 | }
55 | 
56 | 


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/bin/Type.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.bin
 2 | 
 3 | import org.runestar.cs2.util.CP1252
 4 | import org.runestar.cs2.util.toByte
 5 | 
 6 | enum class Type(desc: Char = 0.toChar()) {
 7 | 
 8 |     AREA('R'),
 9 |     BOOLEAN('1'),
10 |     CATEGORY('y'),
11 |     CHAR('z'),
12 |     COMPONENT('I'),
13 |     COORD('c'),
14 |     ENUM('g'),
15 |     FONTMETRICS('f'),
16 |     GRAPHIC('d'),
17 |     INT('i'),
18 |     INTERFACE('a'),
19 |     INV('v'),
20 |     LOC('l'),
21 |     MAPAREA('`'),
22 |     MAPELEMENT('µ'),
23 |     MODEL('m'),
24 |     NAMEDOBJ('O'),
25 |     NPC('n'),
26 |     OBJ('o'),
27 |     PARAM,
28 |     SEQ('A'),
29 |     SPOTANIM('t'),
30 |     STAT('S'),
31 |     STRING('s'),
32 |     STRUCT('J'),
33 |     SYNTH('P'),
34 |     NEWVAR('-'),
35 |     NPC_UID('u'),
36 |     PLAYER_UID('p'),
37 |     TYPE,
38 |     ;
39 | 
40 |     val desc = desc.toByte(CP1252)
41 | 
42 |     val stackType get() = if (this == STRING) StackType.STRING else StackType.INT
43 | 
44 |     val literal = name.toLowerCase()
45 | 
46 |     override fun toString() = literal
47 | 
48 |     companion object {
49 | 
50 |         private val VALUES = values().filter { it.desc != 0.toByte() }.associateBy { it.desc }
51 | 
52 |         fun of(desc: Byte): Type = VALUES.getValue(desc)
53 | 
54 |         fun ofAuto(desc: Byte): Type = if (desc == 0.toByte()) INT else of(desc)
55 | 
56 |         fun union(types: Set<Type>): Type? {
57 |             when (types.size) {
58 |                 0 -> return null
59 |                 1 -> return types.iterator().next()
60 |                 2 -> {
61 |                     if (OBJ in types && NAMEDOBJ in types) return OBJ
62 |                     if (FONTMETRICS in types && GRAPHIC in types) return FONTMETRICS
63 |                 }
64 |             }
65 |             error(types)
66 |         }
67 | 
68 |         fun intersection(types: Set<Type>): Type? {
69 |             when (types.size) {
70 |                 0 -> return null
71 |                 1 -> return types.iterator().next()
72 |                 2 -> {
73 |                     if (OBJ in types && NAMEDOBJ in types) return NAMEDOBJ
74 |                     if (FONTMETRICS in types && GRAPHIC in types) return GRAPHIC
75 |                 }
76 |             }
77 |             error(types)
78 |         }
79 |     }
80 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/Resources.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2
 2 | 
 3 | import org.runestar.cs2.bin.ScriptName
 4 | import org.runestar.cs2.bin.Type
 5 | import org.runestar.cs2.util.Loader
 6 | import org.runestar.cs2.util.thisClass
 7 | 
 8 | private fun <T : Any> readLoader(fileName: String, valueMapper: (String) -> T): Loader.Map<T> {
 9 |     val map = HashMap<Int, T>()
10 |     thisClass.getResourceAsStream(fileName).bufferedReader().use {
11 |         while (true) {
12 |             val line = it.readLine() ?: break
13 |             val tab = line.indexOf('\t')
14 |             val id = line.substring(0, tab).toInt()
15 |             val v = valueMapper(line.substring(tab + 1))
16 |             check(map.put(id, v) == null)
17 |         }
18 |     }
19 |     return Loader(map)
20 | }
21 | 
22 | private fun readNames(fileName: String): Loader.Map<String> = readLoader(fileName) { it }
23 | 
24 | val PARAM_TYPES = readLoader("param-types.tsv") { Type.ofAuto(it.toByte()) }
25 | 
26 | val SCRIPT_NAMES = readLoader("script-names.tsv") { ScriptName(it) }
27 | 
28 | val BOOLEAN_NAMES = readNames("boolean-names.tsv")
29 | val FONTMETRICS_NAMES = readNames("fontmetrics-names.tsv")
30 | val GRAPHIC_NAMES = readNames("graphic-names.tsv")
31 | val INTERFACE_NAMES = readNames("interface-names.tsv")
32 | val INV_NAMES = readNames("inv-names.tsv")
33 | val LOC_NAMES = readNames("loc-names.tsv")
34 | val MAPAREA_NAMES = readNames("maparea-names.tsv")
35 | val MODEL_NAMES = readNames("model-names.tsv")
36 | val NPC_NAMES = readNames("npc-names.tsv")
37 | val OBJ_NAMES = readNames("obj-names.tsv")
38 | val PARAM_NAMES = readNames("param-names.tsv")
39 | val SEQ_NAMES = readNames("seq-names.tsv")
40 | val STAT_NAMES = readNames("stat-names.tsv")
41 | val STRUCT_NAMES = readNames("struct-names.tsv")
42 | val SYNTH_NAMES = readNames("synth-names.tsv")
43 | 
44 | val CHATFILTER_NAMES = readNames("chatfilter-names.tsv")
45 | val CHATTYPE_NAMES = readNames("chattype-names.tsv")
46 | val CLIENTTYPE_NAMES = readNames("clienttype-names.tsv")
47 | val IFTYPE_NAMES = readNames("iftype-names.tsv")
48 | val KEY_NAMES = readNames("key-names.tsv")
49 | val SETPOSH_NAMES = readNames("setposh-names.tsv")
50 | val SETPOSV_NAMES = readNames("setposv-names.tsv")
51 | val SETSIZE_NAMES = readNames("setsize-names.tsv")
52 | val SETTEXTALIGNH_NAMES = readNames("settextalignh-names.tsv")
53 | val SETTEXTALIGNV_NAMES = readNames("settextalignv-names.tsv")
54 | val WINDOWMODE_NAMES = readNames("windowmode-names.tsv")


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/dfa/FindArrayArgs.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.dfa
 2 | 
 3 | import org.runestar.cs2.bin.*
 4 | import org.runestar.cs2.bin.StackType
 5 | import org.runestar.cs2.ir.Element
 6 | import org.runestar.cs2.ir.Expression
 7 | import org.runestar.cs2.ir.Function
 8 | import org.runestar.cs2.ir.FunctionSet
 9 | import org.runestar.cs2.ir.Instruction
10 | import org.runestar.cs2.ir.Variable
11 | import org.runestar.cs2.ir.asList
12 | import org.runestar.cs2.ir.assign
13 | 
14 | object FindArrayArgs : Phase.Individual() {
15 | 
16 |     override fun transform(f: Function, fs: FunctionSet) {
17 |         if (f.arguments.none { it.stackType == StackType.INT }) return
18 |         for (insn in f.instructions) {
19 |             if (insn !is Instruction.Assignment) continue
20 |             val e = insn.expression
21 |             if (e !is Expression.Operation) continue
22 |             val args = e.arguments.asList
23 |             when (e.opcode) {
24 |                 DEFINE_ARRAY -> {
25 |                     if ((args[0] as Element.Access).variable.id == 0) return
26 |                 }
27 |                 PUSH_ARRAY_INT -> {
28 |                     if ((args[0] as Element.Access).variable.id == 0) {
29 | 
30 |                         val oldVar = f.arguments[0]
31 |                         val newVar = Variable.array(f.id, 0)
32 |                         val newVars = f.arguments.toMutableList()
33 |                         newVars[0] = newVar
34 |                         f.arguments = newVars
35 | 
36 |                         val t = fs.typings.of(newVar)
37 |                         val ts = fs.typings.args(f.id, f.arguments.map { it.stackType }).toMutableList()
38 |                         ts[0] = t
39 |                         fs.typings.remove(oldVar)
40 |                         fs.typings.args[f.id] = ts
41 |                         transformCalls(f.id, fs)
42 |                         return
43 |                     }
44 |                 }
45 |             }
46 |         }
47 |     }
48 | 
49 |     private fun transformCalls(scriptId: Int, fs: FunctionSet) {
50 |         for (f in fs.functions.values) {
51 |             for (insn in f.instructions) {
52 |                 if (insn !is Instruction.Assignment) continue
53 |                 val e = insn.expression
54 |                 if (e !is Expression.Proc) continue
55 |                 if (e.scriptId != scriptId) continue
56 | 
57 |                 // todo
58 |                 val oldArgs = e.arguments.asList
59 |                 val oldArg = oldArgs[0] as Element.Access
60 |                 val newArgs = oldArgs.toMutableList()
61 |                 val newArg = Element.Pointer(Variable.array(f.id, 0))
62 |                 newArgs[0] = newArg
63 |                 e.arguments = Expression(newArgs)
64 |                 if (f.id != scriptId) {
65 |                     assign(fs.typings.of(newArg), fs.typings.args.getValue(scriptId)[0])
66 |                 }
67 |             }
68 |         }
69 |     }
70 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/util/HashChain.kt:
--------------------------------------------------------------------------------
  1 | package org.runestar.cs2.util
  2 | 
  3 | class HashChain<E : Any> : Chain<E> {
  4 | 
  5 |     private val map = HashMap<E, Link>()
  6 | 
  7 |     private var head: E? = null
  8 | 
  9 |     private var tail: E? = null
 10 | 
 11 |     override val first: E get() = checkNotNull(head)
 12 | 
 13 |     override val last: E get() = checkNotNull(tail)
 14 | 
 15 |     private inner class Link(val e: E) {
 16 | 
 17 |         var next: Link? = null
 18 | 
 19 |         var previous: Link? = null
 20 | 
 21 |         fun unlink() = bind(previous, next)
 22 | 
 23 |         fun bind(a: Link?, b: Link?) {
 24 |             if (a == null) {
 25 |                 head = b?.e
 26 |             } else {
 27 |                 a.next = b
 28 |             }
 29 |             if (b == null) {
 30 |                 tail = a?.e
 31 |             } else {
 32 |                 b.previous = a
 33 |             }
 34 |         }
 35 | 
 36 |         fun insertBefore(e: E): Link {
 37 |             val newLink = Link(e)
 38 |             bind(previous, newLink)
 39 |             bind(newLink, this)
 40 |             return newLink
 41 |         }
 42 | 
 43 |         fun insertAfter(e: E): Link {
 44 |             val newLink = Link(e)
 45 |             bind(newLink, next)
 46 |             bind(this, newLink)
 47 |             return newLink
 48 |         }
 49 |     }
 50 | 
 51 |     override fun insertAfter(e: E, point: E) {
 52 |         map[e] = map.getValue(point).insertAfter(e)
 53 |     }
 54 | 
 55 |     override fun insertBefore(e: E, point: E) {
 56 |         map[e] = map.getValue(point).insertBefore(e)
 57 |     }
 58 | 
 59 |     override fun addFirst(e: E) {
 60 |         if (head != null) {
 61 |            insertBefore(e, first)
 62 |         } else {
 63 |             map[e] = Link(e)
 64 |             head = e
 65 |             tail = e
 66 |         }
 67 |     }
 68 | 
 69 |     override fun addLast(e: E) {
 70 |         if (tail != null) {
 71 |             insertAfter(e, last)
 72 |         } else {
 73 |             map[e] = Link(e)
 74 |             head = e
 75 |             tail = e
 76 |         }
 77 |     }
 78 | 
 79 |     override fun next(e: E): E? = map.getValue(e).next?.e
 80 | 
 81 |     override fun previous(e: E): E? = map.getValue(e).previous?.e
 82 | 
 83 |     override fun remove(e: E) = map.getValue(e).unlink()
 84 | 
 85 |     override fun iterator(from: E, to: E): MutableIterator<E> = LinkIterator(from, to)
 86 | 
 87 |     private inner class LinkIterator(
 88 |             from: E?,
 89 |             val to: E?
 90 |     ) : MutableIterator<E> {
 91 | 
 92 |         var curr: Link? = from?.let { map.getValue(it) }
 93 | 
 94 |         override fun hasNext(): Boolean = curr != null
 95 | 
 96 |         override fun next(): E {
 97 |             val last = curr!!
 98 |             curr = if (last.e == to) null else last.next
 99 |             return last.e
100 |         }
101 | 
102 |         override fun remove() {
103 |             remove(curr!!.previous!!.e)
104 |         }
105 |     }
106 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/ir/Typing.kt:
--------------------------------------------------------------------------------
  1 | package org.runestar.cs2.ir
  2 | 
  3 | import org.runestar.cs2.bin.StackType
  4 | import org.runestar.cs2.bin.Type
  5 | 
  6 | class Typing(val stackType: StackType) {
  7 | 
  8 |     var _type: Type? = null
  9 | 
 10 |     var _identifier: String? = null
 11 | 
 12 |     var freezeType = false
 13 | 
 14 |     var freezeIdentifier = false
 15 | 
 16 |     val from = HashSet<Typing>()
 17 | 
 18 |     val to = HashSet<Typing>()
 19 | 
 20 |     val compare = HashSet<Typing>()
 21 | }
 22 | 
 23 | val Typing.type get() = checkNotNull(_type)
 24 | 
 25 | val Typing.literal get() = type.literal
 26 | 
 27 | val Typing.identifier get() = checkNotNull(_identifier)
 28 | 
 29 | val Typing.prototype get() = Prototype(type, identifier)
 30 | 
 31 | val Typing._prototype: Prototype? get() {
 32 |     val t = _type ?: return null
 33 |     val i = _identifier ?: return null
 34 |     return Prototype(t, i)
 35 | }
 36 | 
 37 | fun Typing.freeze(type: Type) {
 38 |     freezeType = true
 39 |     check(type.stackType == stackType)
 40 |     _type = type
 41 | }
 42 | 
 43 | fun Typing.freeze(identifier: String) {
 44 |     freezeIdentifier = true
 45 |     _identifier = identifier
 46 | }
 47 | 
 48 | fun Typing.freeze(prototype: Prototype) {
 49 |     freeze(prototype.type)
 50 |     freeze(prototype.identifier)
 51 | }
 52 | 
 53 | fun Typing(prototype: Prototype) = Typing(prototype.stackType).apply { freeze(prototype) }
 54 | 
 55 | fun assign(from: Typing, to: Typing) {
 56 |     require(from != to)
 57 |     require(from.stackType == to.stackType)
 58 |     from.to.add(to)
 59 |     to.from.add(from)
 60 | }
 61 | 
 62 | fun assign(from: List<Typing>, to: List<Typing>) {
 63 |     require(from.size == to.size)
 64 |     for (i in from.indices) {
 65 |         assign(from[i], to[i])
 66 |     }
 67 | }
 68 | 
 69 | fun compare(a: Typing, b: Typing) {
 70 |     require(a != b)
 71 |     require(a.stackType == b.stackType)
 72 |     a.compare.add(b)
 73 |     b.compare.add(a)
 74 | }
 75 | 
 76 | fun remove(t: Typing) {
 77 |     t.from.forEach { it.to.remove(t) }
 78 |     t.to.forEach { it.from.remove(t) }
 79 |     t.compare.forEach { it.compare.remove(t) }
 80 | }
 81 | 
 82 | fun replace(t: Typing, by: Typing) {
 83 |     require(t != by)
 84 |     require(t.stackType == by.stackType)
 85 |     check(t._type == null && t._identifier == null)
 86 |     t.from.forEach {
 87 |         it.to.remove(t)
 88 |         if (by != it) {
 89 |             it.to.add(by)
 90 |             by.from.add(it)
 91 |         }
 92 |     }
 93 |     t.to.forEach {
 94 |         it.from.remove(t)
 95 |         if (by != it) {
 96 |             it.from.add(by)
 97 |             by.to.add(it)
 98 |         }
 99 |     }
100 |     t.compare.forEach {
101 |         it.compare.remove(t)
102 |         if (by != it) {
103 |             it.compare.add(by)
104 |             by.compare.add(it)
105 |         }
106 |     }
107 | }
108 | 
109 | fun replace(t: List<Typing>, by: List<Typing>) {
110 |     require(t.size == by.size)
111 |     for (i in t.indices) {
112 |         replace(t[i], by[i])
113 |     }
114 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/ir/Expression.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.ir
 2 | 
 3 | import org.runestar.cs2.bin.*
 4 | import org.runestar.cs2.bin.StackType
 5 | 
 6 | interface Expression {
 7 | 
 8 |     val stackTypes: List<StackType>
 9 | 
10 |     class Compound(val expressions: List<Expression>) : Expression {
11 | 
12 |         init {
13 |             require(expressions.none { it is Compound })
14 |             require(expressions.size != 1)
15 |         }
16 | 
17 |         override val stackTypes get() = expressions.flatMap { it.stackTypes }
18 | 
19 |         override fun toString() = expressions.joinToString(",", "(", ")")
20 |     }
21 | 
22 |     class Operation(
23 |             override val stackTypes: List<StackType>,
24 |             override val opcode: Int,
25 |             var arguments: Expression,
26 |             val dot: Boolean = false,
27 |     ) : Command {
28 | 
29 |         override fun toString() = buildString {
30 |             if (dot) append('.')
31 |             append(opcodeName).append(' ').append(arguments)
32 |         }
33 |     }
34 | 
35 |     interface Command : Expression {
36 | 
37 |         val opcode: Int
38 | 
39 |         val opcodeName: String get() = opcodeNames.getValue(opcode)
40 |     }
41 | 
42 |     interface Script : Command {
43 | 
44 |         val scriptId: Int
45 | 
46 |         val arguments: Expression
47 |     }
48 | 
49 |     class Proc(
50 |             override val stackTypes: List<StackType>,
51 |             override val scriptId: Int,
52 |             override var arguments: Expression,
53 |     ) : Script {
54 | 
55 |         override val opcode get() = GOSUB_WITH_PARAMS
56 | 
57 |         override fun toString() = "~$scriptId $arguments"
58 |     }
59 | 
60 |     class ClientScript(
61 |             override val opcode: Int,
62 |             override val scriptId: Int,
63 |             override var arguments: Expression,
64 |             var triggers: Expression,
65 |             val dot: Boolean,
66 |             var component: Expression?,
67 |     ) : Script {
68 | 
69 |         override val stackTypes get() = emptyList<StackType>()
70 | 
71 |         override fun toString() = buildString {
72 |             if (dot) append('.')
73 |             append(opcodeName).append(' ')
74 |             append(scriptId).append(' ')
75 |             append(arguments).append(' ')
76 |             append(triggers)
77 |             if (component != null) append(' ').append(component)
78 |         }
79 |     }
80 | }
81 | 
82 | fun Expression(): Expression = Expression.Compound(emptyList())
83 | 
84 | fun Expression(expression: Expression): Expression = error(expression)
85 | 
86 | fun Expression(vararg expressions: Expression): Expression = Expression.Compound(expressions.asList())
87 | 
88 | fun Expression(expressions: List<Expression>): Expression = expressions.singleOrNull() ?: Expression.Compound(expressions)
89 | 
90 | operator fun Expression.plus(other: Expression): Expression = Expression(asList + other.asList)
91 | 
92 | val Expression.asList: List<Expression> get() = when (this) {
93 |     is Expression.Compound -> expressions
94 |     else -> listOf(this)
95 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/dfa/AddShortCircuitOperators.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.dfa
 2 | 
 3 | import org.runestar.cs2.bin.*
 4 | import org.runestar.cs2.ir.Expression
 5 | import org.runestar.cs2.ir.Function
 6 | import org.runestar.cs2.ir.FunctionSet
 7 | import org.runestar.cs2.ir.Instruction
 8 | import org.runestar.cs2.util.Chain
 9 | 
10 | object AddShortCircuitOperators : Phase.Individual() {
11 | 
12 |     override fun transform(f: Function, fs: FunctionSet) {
13 |         while (ors(f) || ands(f));
14 |     }
15 | 
16 |     private fun ors(f: Function): Boolean {
17 |         val itr = f.instructions.iterator()
18 |         while (itr.hasNext()) {
19 |             val if1 = itr.next() as? Instruction.Branch ?: continue
20 |             val if2 = f.instructions.next(if1) as? Instruction.Branch ?: continue
21 |             if (if1.pass == if2.pass) {
22 |                 itr.remove()
23 |                 if2.expression = Expression.Operation(emptyList(), SS_OR, Expression(if1.expression, if2.expression))
24 |                 return true
25 |             }
26 |         }
27 |         return false
28 |     }
29 | 
30 |     private fun ands(f: Function): Boolean {
31 |         val itr = f.instructions.iterator()
32 |         while (itr.hasNext()) {
33 |             val if1 = itr.next() as? Instruction.Branch ?: continue
34 |             val if2 = f.instructions.next(if1.pass) as? Instruction.Branch ?: continue
35 | 
36 |             val else1 = f.instructions.next(if1) as? Instruction.Goto ?: continue
37 |             val else2 = f.instructions.next(if2)
38 | 
39 |             when (else2) {
40 |                 is Instruction.Goto -> {
41 |                     if (else1.label == else2.label && isUnused(f.instructions, if1.pass)) {
42 |                         f.instructions.remove(if1.pass)
43 |                         f.instructions.remove(else2)
44 |                         f.instructions.remove(if2)
45 | 
46 |                         if1.pass = if2.pass
47 |                         if1.expression = Expression.Operation(emptyList(), SS_AND, Expression(if1.expression, if2.expression))
48 |                         return true
49 |                     }
50 |                 }
51 |                 is Instruction.Label -> {
52 |                     if (else1.label == else2 && isUnused(f.instructions, if1.pass)) {
53 |                         f.instructions.remove(if1.pass)
54 |                         f.instructions.remove(else1)
55 |                         f.instructions.remove(else2)
56 |                         f.instructions.remove(if2)
57 | 
58 |                         if1.pass = if2.pass
59 |                         if1.expression = Expression.Operation(emptyList(), SS_AND, Expression(if1.expression, if2.expression))
60 |                         return true
61 |                     }
62 |                 }
63 |             }
64 |         }
65 |         return false
66 |     }
67 | 
68 |     private fun isUnused(insns: Chain<Instruction>, label: Instruction.Label): Boolean {
69 |         for (insn in insns.iterator(label, insns.last)) {
70 |             if (insn is Instruction.Goto && insn.label == label) return false
71 |         }
72 |         return true
73 |     }
74 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/ir/Typings.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.ir
 2 | 
 3 | import org.runestar.cs2.bin.StackType
 4 | 
 5 | class Typings {
 6 | 
 7 |     val eventProperties = HashMap<EventProperty, Typing>()
 8 | 
 9 |     val constants = HashMap<Element, Typing>()
10 | 
11 |     val variables = HashMap<Variable, Typing>()
12 | 
13 |     val returns = HashMap<Int, List<Typing>>()
14 | 
15 |     val operations = HashMap<Expression, List<Typing>>()
16 | 
17 |     val prototypes = HashMap<Prototype, Typing>()
18 | 
19 |     val args = HashMap<Int, List<Typing>>()
20 | 
21 |     fun all(): List<Typing> = ArrayList<Typing>().apply {
22 |         addAll(eventProperties.values)
23 |         addAll(constants.values)
24 |         addAll(variables.values)
25 |         returns.values.forEach { addAll(it) }
26 |         operations.values.forEach { addAll(it) }
27 |         addAll(prototypes.values)
28 |     }
29 | 
30 |     fun of(expression: Expression): List<Typing> {
31 |         return when (expression) {
32 |             is Expression.Compound -> expression.expressions.flatMap { of(it) }
33 |             is Expression.Proc -> returns(expression.scriptId, expression.stackTypes)
34 |             is Element -> listOf(of(expression))
35 |             is Expression.ClientScript -> emptyList()
36 |             is Expression.Operation -> operations.getOrPut(expression) { expression.stackTypes.map { Typing(it) } }
37 |             else -> error(expression)
38 |         }
39 |     }
40 | 
41 |     fun of(element: Element): Typing {
42 |         return when (element) {
43 |             is Element.Variable -> of(element.variable)
44 |             is Element.Constant -> constants.getOrPut(element) { Typing(element.stackType) }
45 |             is EventProperty -> eventProperties.getOrPut(element) { Typing(element.prototype) }
46 |             else -> error(element)
47 |         }
48 |     }
49 | 
50 |     fun of(prototype: Prototype): Typing {
51 |         return prototypes.getOrPut(prototype) { Typing(prototype) }
52 |     }
53 | 
54 |     fun of(prototypes: List<Prototype>): List<Typing> {
55 |         return prototypes.map { of(it) }
56 |     }
57 | 
58 |     fun of(variable: Variable): Typing {
59 |         return variables.getOrPut(variable) { Typing(variable.stackType) }
60 |     }
61 | 
62 |     fun args(scriptId: Int, stackTypes: List<StackType>): List<Typing> {
63 |         val ts = args[scriptId]
64 |         if (ts != null) return ts
65 |         var i = 0
66 |         var s = 0
67 |         val ts2 = stackTypes.map { t ->
68 |             val v = when (t) {
69 |                 StackType.INT -> Variable.int(scriptId, i++)
70 |                 StackType.STRING -> Variable.string(scriptId, s++)
71 |             }
72 |             of(v)
73 |         }
74 |         args[scriptId] = ts2
75 |         return ts2
76 |     }
77 | 
78 |     fun returns(scriptId: Int, stackTypes: List<StackType>): List<Typing> {
79 |         return returns.getOrPut(scriptId) { stackTypes.map { Typing(it) } }
80 |     }
81 | 
82 |     fun remove(variable: Variable) {
83 |         remove(variables.remove(variable)!!)
84 |     }
85 | 
86 |     fun remove(constant: Element.Constant) {
87 |         remove(constants.remove(constant)!!)
88 |     }
89 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/bin/Script.kt:
--------------------------------------------------------------------------------
 1 | package org.runestar.cs2.bin
 2 | 
 3 | import org.runestar.cs2.util.CP1252
 4 | import org.runestar.cs2.util.toUnsignedInt
 5 | import java.nio.ByteBuffer
 6 | 
 7 | class Script(
 8 |         val localIntCount: Int,
 9 |         val localStringCount: Int,
10 |         val intArgumentCount: Int,
11 |         val stringArgumentCount: Int,
12 |         val operands: Array<Value>,
13 |         val opcodes: ShortArray,
14 |         val switches: Array<Map<Int, Int>>,
15 | ) {
16 | 
17 |     val returnTypes: List<StackType> = run {
18 |         val ts = ArrayList<StackType>()
19 |         var i = opcodes.size - 2
20 |         while (i >= 0) {
21 |             when (opcodes[i--].toInt()) {
22 |                 PUSH_CONSTANT_INT -> ts.add(StackType.INT)
23 |                 PUSH_CONSTANT_STRING -> ts.add(StackType.STRING)
24 |                 else -> break
25 |             }
26 |         }
27 |         ts.reverse()
28 |         ts
29 |     }
30 | }
31 | 
32 | fun Script(bytes: ByteArray): Script = Script(ByteBuffer.wrap(bytes))
33 | 
34 | fun Script(buffer: ByteBuffer): Script {
35 |     check(buffer.get() == 0.toByte())
36 |     val start = buffer.position()
37 |     buffer.position(buffer.limit() - buffer.getShort(buffer.limit() - 2) - 14)
38 | 
39 |     val instructionCount = buffer.int
40 |     val localIntCount = buffer.short.toUnsignedInt()
41 |     val localStringCount = buffer.short.toUnsignedInt()
42 |     val intArgumentCount = buffer.short.toUnsignedInt()
43 |     val stringArgumentCount = buffer.short.toUnsignedInt()
44 | 
45 |     val switches = Array<Map<Int, Int>>(buffer.get().toUnsignedInt()) {
46 |         val caseCount = buffer.short.toUnsignedInt()
47 |         val switch = LinkedHashMap<Int, Int>(caseCount)
48 |         repeat(caseCount) {
49 |             switch[buffer.int] = buffer.int
50 |         }
51 |         switch
52 |     }
53 | 
54 |     buffer.position(start)
55 | 
56 |     val opcodes = ShortArray(instructionCount)
57 |     val operands = Array(instructionCount) {
58 |         val opcodeShort = buffer.short
59 |         opcodes[it] = opcodeShort
60 |         val opcode = opcodeShort.toUnsignedInt()
61 |         when {
62 |             opcode >= 100 || opcode == RETURN || opcode == POP_INT_DISCARD || opcode == POP_STRING_DISCARD -> Value(buffer.get().toUnsignedInt())
63 |             opcode == PUSH_CONSTANT_STRING -> Value(buffer.readString())
64 |             else -> Value(buffer.int)
65 |         }
66 |     }
67 | 
68 |     buffer.position(buffer.limit())
69 | 
70 |     return Script(
71 |             localIntCount,
72 |             localStringCount,
73 |             intArgumentCount,
74 |             stringArgumentCount,
75 |             operands,
76 |             opcodes,
77 |             switches
78 |     )
79 | }
80 | 
81 | private fun ByteBuffer.readString(): String {
82 |     val start = position()
83 |     while (get() != 0.toByte());
84 |     val len = position() - 1 - start
85 |     if (len == 0) return ""
86 |     val array: ByteArray
87 |     var offset = 0
88 |     if (hasArray()) {
89 |         array = array()
90 |         offset = arrayOffset() + start
91 |     } else {
92 |         array = ByteArray(len)
93 |         position(start)
94 |         get(array)
95 |         position(position() + 1)
96 |     }
97 |     return String(array, offset, len, CP1252)
98 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/dfa/CalcIdentifiers.kt:
--------------------------------------------------------------------------------
  1 | package org.runestar.cs2.dfa
  2 | 
  3 | import org.runestar.cs2.ir.*
  4 | 
  5 | class CalcIdentifiers(private val fs: FunctionSet) {
  6 | 
  7 |     companion object : Phase {
  8 |         override fun transform(fs: FunctionSet) = CalcIdentifiers(fs).transform()
  9 | 
 10 |         private val STRONG = setOf(MESUID, CHATFILTER, RANK, WORLD, KEY, IFTYPE, SETSIZE, SETPOSH, SETPOSV, SETTEXTALIGNH, SETTEXTALIGNV, CHATTYPE, WINDOWMODE, CLIENTTYPE)
 11 |     }
 12 | 
 13 |     private val unidentified = fs.typings.all().filterTo(LinkedHashSet()) { it._identifier == null }
 14 | 
 15 |     private fun transform() {
 16 |         while (
 17 |                 flow(::safeSingle) { from } ||
 18 |                 flow(::safeSingle) { to }
 19 |         );
 20 |         constantComparisons()
 21 |         // todo
 22 |         while (
 23 |                 flow(::union) { from } ||
 24 |                 flow(::union) { to } ||
 25 |                 flow(::union) { compare }
 26 |         );
 27 |         defaults()
 28 |     }
 29 | 
 30 |     private fun flow(
 31 |             merge: (MutableSet<Prototype?>) -> Prototype?,
 32 |             access: Typing.() -> Set<Typing>,
 33 |     ): Boolean {
 34 |         val s = HashSet<Prototype?>()
 35 |         var b = false
 36 |         val itr = unidentified.iterator()
 37 |         for (t in itr) {
 38 |             val f = t.access()
 39 |             if (f.isEmpty()) continue
 40 |             s.clear()
 41 |             f.mapTo(s) { it._prototype }
 42 |             val p = merge(s) ?: continue
 43 |             b = true
 44 |             check(t._type == p.type)
 45 |             t.freeze(p.identifier)
 46 |             itr.remove()
 47 |         }
 48 |         return b
 49 |     }
 50 | 
 51 |     private fun constantComparisons(): Boolean {
 52 |         var b = false
 53 |         for (t in fs.typings.constants.values) {
 54 |             if (t._identifier != null) continue
 55 |             check(t.from.isEmpty())
 56 |             if (t.compare.isNotEmpty()) {
 57 |                 check(t.to.isEmpty())
 58 |                 val c = t.compare.single()
 59 |                 if (c._identifier != null) {
 60 |                     t.freeze(c.identifier)
 61 |                     b = true
 62 |                     unidentified.remove(t)
 63 |                 }
 64 |             }
 65 |         }
 66 |         return b
 67 |     }
 68 | 
 69 |     private fun defaults() {
 70 |         for (t in unidentified) {
 71 |             t._identifier = t.type.literal
 72 |         }
 73 |         unidentified.clear()
 74 |     }
 75 | 
 76 |     private fun safeSingle(s: MutableSet<Prototype?>): Prototype? {
 77 |         val p = s.singleOrNull() ?: return null
 78 |         if (p.isDefault) return null
 79 |         return p
 80 |     }
 81 | 
 82 |     private fun union(s: MutableSet<Prototype?>): Prototype? {
 83 |         for (p in s) {
 84 |             if (p != null && p in STRONG) return p
 85 |         }
 86 |         if (null in s) return null
 87 |         s as MutableSet<Prototype>
 88 |         if (s.any { it.isDefault }) return null
 89 |         when (s.size) {
 90 |             1 -> return s.iterator().next()
 91 |         }
 92 |         if (X in s && WIDTH in s) s.remove(WIDTH)
 93 |         if (Y in s && HEIGHT in s) s.remove(HEIGHT)
 94 |         if (X in s && MOUSEX in s) s.remove(MOUSEX)
 95 |         if (Y in s && MOUSEY in s) s.remove(MOUSEY)
 96 |         if (SLOT in s && COMSUBID in s) s.remove(COMSUBID)
 97 |         if (SLOT in s && DROPSUBID in s) s.remove(DROPSUBID)
 98 |         if (COMSUBID in s && DROPSUBID in s) s.remove(DROPSUBID)
 99 |         if (INDEX in s && COMSUBID in s) s.remove(COMSUBID)
100 |         if (INDEX in s && COUNT in s) s.remove(COUNT)
101 |         if (COUNT in s && LENGTH in s) s.remove(LENGTH)
102 |         if (COMSUBID in s && COUNT in s) s.remove(COUNT)
103 |         if (OP in s && TEXT in s) s.remove(TEXT)
104 |         return s.singleOrNull()
105 |     }
106 | }
107 | 


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/ir/Prototype.kt:
--------------------------------------------------------------------------------
  1 | package org.runestar.cs2.ir
  2 | 
  3 | import org.runestar.cs2.bin.Type
  4 | 
  5 | data class Prototype(
  6 |         val type: Type,
  7 |         val identifier: String,
  8 | ) {
  9 | 
 10 |     constructor(type: Type) : this(type, type.literal)
 11 | 
 12 |     override fun toString() = type.literal + '-' + identifier
 13 | }
 14 | 
 15 | val Prototype.literal get() = type.literal
 16 | 
 17 | val Prototype.isDefault get() = identifier == literal
 18 | 
 19 | val Prototype.stackType get() = type.stackType
 20 | 
 21 | val INT = Prototype(Type.INT)
 22 | val STRING = Prototype(Type.STRING)
 23 | val COMPONENT = Prototype(Type.COMPONENT)
 24 | val BOOLEAN = Prototype(Type.BOOLEAN)
 25 | val OBJ = Prototype(Type.OBJ)
 26 | val ENUM = Prototype(Type.ENUM)
 27 | val STAT = Prototype(Type.STAT)
 28 | val GRAPHIC = Prototype(Type.GRAPHIC)
 29 | val INV = Prototype(Type.INV)
 30 | val MODEL = Prototype(Type.MODEL)
 31 | val COORD = Prototype(Type.COORD)
 32 | val CATEGORY = Prototype(Type.CATEGORY)
 33 | val LOC = Prototype(Type.LOC)
 34 | val AREA = Prototype(Type.AREA)
 35 | val MAPAREA = Prototype(Type.MAPAREA)
 36 | val NAMEDOBJ = Prototype(Type.NAMEDOBJ)
 37 | val FONTMETRICS = Prototype(Type.FONTMETRICS)
 38 | val CHAR = Prototype(Type.CHAR)
 39 | val STRUCT = Prototype(Type.STRUCT)
 40 | val SYNTH = Prototype(Type.SYNTH)
 41 | val MAPELEMENT = Prototype(Type.MAPELEMENT)
 42 | val NPC = Prototype(Type.NPC)
 43 | val SEQ = Prototype(Type.SEQ)
 44 | val INTERFACE = Prototype(Type.INTERFACE)
 45 | val TYPE = Prototype(Type.TYPE)
 46 | val PARAM = Prototype(Type.PARAM)
 47 | val NEWVAR = Prototype(Type.NEWVAR)
 48 | val NPC_UID = Prototype(Type.NPC_UID)
 49 | val PLAYER_UID = Prototype(Type.PLAYER_UID)
 50 | 
 51 | val OPBASE = Prototype(Type.STRING, "opbase")
 52 | val MOUSEX = Prototype(Type.INT, "mousex")
 53 | val MOUSEY = Prototype(Type.INT, "mousey")
 54 | // com
 55 | val OPINDEX = Prototype(Type.INT, "opindex")
 56 | val COMSUBID = Prototype(Type.INT, "comsubid")
 57 | val DROP = Prototype(Type.COMPONENT, "drop")
 58 | val DROPSUBID = Prototype(Type.INT, "dropsubid")
 59 | val KEY = Prototype(Type.INT, "key")
 60 | val KEYCHAR = Prototype(Type.CHAR, "keychar")
 61 | 
 62 | val INDEX = Prototype(Type.INT, "index")
 63 | val LENGTH = Prototype(Type.INT, "length")
 64 | val COUNT = Prototype(Type.INT, "count")
 65 | val TOTAL = Prototype(Type.INT, "total")
 66 | val SIZE = Prototype(Type.INT, "size")
 67 | val NUM = Prototype(Type.INT, "num")
 68 | val X = Prototype(Type.INT, "x")
 69 | val Y = Prototype(Type.INT, "y")
 70 | val Z = Prototype(Type.INT, "z")
 71 | val WIDTH = Prototype(Type.INT, "width")
 72 | val HEIGHT = Prototype(Type.INT, "height")
 73 | val WORLD = Prototype(Type.INT, "world")
 74 | val RANK = Prototype(Type.INT, "rank")
 75 | val XP = Prototype(Type.INT, "xp")
 76 | val LVL = Prototype(Type.INT, "lvl")
 77 | val SLOT = Prototype(Type.INT, "slot")
 78 | val CLANSLOT = Prototype(Type.INT, "clanslot")
 79 | val CLOCK = Prototype(Type.INT, "clock")
 80 | val TRANS = Prototype(Type.INT, "trans")
 81 | val ANGLE = Prototype(Type.INT, "angle")
 82 | val CHATFILTER = Prototype(Type.INT, "chatfilter")
 83 | val MESUID = Prototype(Type.INT, "mesuid")
 84 | val FLAGS = Prototype(Type.INT, "flags")
 85 | val LAYER = Prototype(Type.COMPONENT, "layer")
 86 | val OP = Prototype(Type.STRING, "op")
 87 | val URL = Prototype(Type.STRING, "url")
 88 | val TEXT = Prototype(Type.STRING, "text")
 89 | val MES = Prototype(Type.STRING, "mes")
 90 | val USERNAME = Prototype(Type.STRING, "username")
 91 | 
 92 | val COLOUR = Prototype(Type.INT, "colour")
 93 | val IFTYPE = Prototype(Type.INT, "iftype")
 94 | val SETSIZE = Prototype(Type.INT, "setsize")
 95 | val SETPOSH = Prototype(Type.INT, "setposh")
 96 | val SETPOSV = Prototype(Type.INT, "setposv")
 97 | val SETTEXTALIGNH = Prototype(Type.INT, "settextalignh")
 98 | val SETTEXTALIGNV = Prototype(Type.INT, "settextalignv")
 99 | val CHATTYPE = Prototype(Type.INT, "chattype")
100 | val BOOL = Prototype(Type.INT, "bool")
101 | val WINDOWMODE = Prototype(Type.INT, "windowmode")
102 | val CLIENTTYPE = Prototype(Type.INT, "clienttype")
103 | 


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/dfa/InlineStackDefinitions.kt:
--------------------------------------------------------------------------------
  1 | package org.runestar.cs2.dfa
  2 | 
  3 | import org.runestar.cs2.ir.Element
  4 | import org.runestar.cs2.ir.Expression
  5 | import org.runestar.cs2.ir.Function
  6 | import org.runestar.cs2.ir.FunctionSet
  7 | import org.runestar.cs2.ir.Instruction
  8 | import org.runestar.cs2.ir.Typings
  9 | import org.runestar.cs2.ir.Variable
 10 | import org.runestar.cs2.ir.asList
 11 | import org.runestar.cs2.ir.replace
 12 | import java.util.Collections
 13 | 
 14 | object InlineStackDefinitions : Phase.Individual() {
 15 | 
 16 |     override fun transform(f: Function, fs: FunctionSet) {
 17 |         out@
 18 |         for (insn in f.instructions) {
 19 |             if (insn !is Instruction.Assignment) continue
 20 |             val defs = insn.definitions.asList as List<Element.Access>
 21 |             if (defs.any { it.variable !is Variable.Stack }) continue
 22 |             if (defs.isEmpty()) continue
 23 |             val expr = insn.expression
 24 |             var a: Instruction? = f.instructions.next(insn)!!
 25 |             while (a is Instruction.Evaluation) {
 26 |                 if (replaceExprs(a, defs, expr, fs.typings)) {
 27 |                     f.instructions.remove(insn)
 28 |                     continue@out
 29 |                 }
 30 |                 a = f.instructions.next(a)
 31 |             }
 32 |             if (expr is Element.Constant) {
 33 |                 fs.typings.remove(defs.single().variable)
 34 |                 fs.typings.remove(expr)
 35 |                 f.instructions.remove(insn)
 36 |             } else {
 37 |                 for (d in defs) {
 38 |                     fs.typings.remove(d.variable)
 39 |                 }
 40 |                 insn.definitions = Expression()
 41 |             }
 42 |         }
 43 |     }
 44 | 
 45 |     private fun replaceExprs(dst: Instruction.Evaluation, defs: List<Element.Access>, by: Expression, typings: Typings): Boolean {
 46 |         val e = dst.expression
 47 |         replaceSubExpr(e.asList, defs, by, typings)?.let {
 48 |             dst.expression = it
 49 |             return true
 50 |         }
 51 |         when (e) {
 52 |             is Expression.Operation -> {
 53 |                 replaceSubExpr(e.arguments.asList, defs, by, typings)?.let {
 54 |                     e.arguments = it
 55 |                     return true
 56 |                 }
 57 |             }
 58 |             is Expression.Proc -> {
 59 |                 replaceSubExpr(e.arguments.asList, defs, by, typings)?.let {
 60 |                     e.arguments = it
 61 |                     return true
 62 |                 }
 63 |             }
 64 |             is Expression.ClientScript -> {
 65 |                 val component = e.component
 66 |                 if (defs.size == 1 && component is Element.Access) {
 67 |                     if (defs.single().variable == component.variable) {
 68 |                         replace(typings.of(component), typings.of(by).single())
 69 |                         typings.variables.remove(component.variable)
 70 |                         e.component = by
 71 |                         return true
 72 |                     }
 73 |                 }
 74 |                 replaceSubExpr(e.arguments.asList, defs, by, typings)?.let {
 75 |                     e.arguments = it
 76 |                     return true
 77 |                 }
 78 |                 replaceSubExpr(e.triggers.asList, defs, by, typings)?.let {
 79 |                     e.triggers = it
 80 |                     return true
 81 |                 }
 82 |             }
 83 |         }
 84 |         return false
 85 |     }
 86 | 
 87 | 
 88 |     private fun replaceSubExpr(es1: List<Expression>, es2: List<Element.Access>, by: Expression, typings: Typings): Expression? {
 89 |         val st1 = es1.map { if (it is Element.Access) it.variable else null }
 90 |         val st2 = es2.map { it.variable }
 91 |         val idx = Collections.indexOfSubList(st1, st2)
 92 |         if (idx == -1) return null
 93 |         val es3 = ArrayList<Expression>(es1.size - es2.size + 1)
 94 |         es3.addAll(es1.subList(0, idx))
 95 |         es3.add(by)
 96 |         es3.addAll(es1.subList(idx + es2.size, es1.size))
 97 |         replace(typings.of(Expression(es2)), typings.of(by))
 98 |         es2.forEach { typings.variables.remove(it.variable) }
 99 |         return Expression(es3)
100 |     }
101 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/dfa/CalcTypes.kt:
--------------------------------------------------------------------------------
  1 | package org.runestar.cs2.dfa
  2 | 
  3 | import org.runestar.cs2.bin.StackType
  4 | import org.runestar.cs2.bin.Type
  5 | import org.runestar.cs2.bin.Type.*
  6 | import org.runestar.cs2.ir.FunctionSet
  7 | import org.runestar.cs2.ir.Typing
  8 | import org.runestar.cs2.ir.freeze
  9 | import org.runestar.cs2.ir.type
 10 | 
 11 | class CalcTypes(private val fs: FunctionSet) {
 12 | 
 13 |     companion object : Phase {
 14 |         override fun transform(fs: FunctionSet) = CalcTypes(fs).transform()
 15 |     }
 16 | 
 17 |     private val all = fs.typings.all()
 18 | 
 19 |     private val unidentified = all.filterTo(LinkedHashSet()) { it._type == null }
 20 | 
 21 |     private fun transform() {
 22 |         strings()
 23 |         while (down());
 24 |         while (namedObjs() || any() || compare());
 25 |         // todo
 26 |         while (check());
 27 |         defaults()
 28 |     }
 29 | 
 30 |     private fun strings() {
 31 |         val itr = unidentified.iterator()
 32 |         for (t in itr) {
 33 |             if (t.stackType == StackType.STRING) {
 34 |                 t.freeze(STRING)
 35 |                 itr.remove()
 36 |             }
 37 |         }
 38 |     }
 39 | 
 40 |     private fun defaults() {
 41 |         for (t in unidentified) {
 42 |             t._type = t.stackType.defaultType
 43 |         }
 44 |         unidentified.clear()
 45 |     }
 46 | 
 47 |     private fun namedObjs(): Boolean {
 48 |         var b = false
 49 |         for (t in fs.typings.constants.values) {
 50 |             if (t._type == OBJ) {
 51 |                 b = true
 52 |                 t.freeze(NAMEDOBJ)
 53 |             }
 54 |         }
 55 |         return b
 56 |     }
 57 | 
 58 |     private fun down(): Boolean {
 59 |         val u = HashSet<Type>()
 60 |         var b = false
 61 |         val itr = unidentified.iterator()
 62 |         out@
 63 |         for (t in itr) {
 64 |             u.clear()
 65 |             for (f in t.from) {
 66 |                 if (f._type == null) continue@out
 67 |                 u.add(f.type)
 68 |             }
 69 |             if (u.isNotEmpty()) {
 70 |                 b = true
 71 |                 t.freeze(Type.union(u)!!)
 72 |                 itr.remove()
 73 |             }
 74 |         }
 75 |         return b
 76 |     }
 77 | 
 78 |     private fun any(): Boolean {
 79 |         val newTypes = HashMap<Typing, Type>()
 80 |         val u = HashSet<Type>()
 81 |         val i = HashSet<Type>()
 82 |         val x = HashSet<Type>()
 83 |         var b = false
 84 |         val itr = unidentified.iterator()
 85 |         for (t in itr) {
 86 |             u.clear()
 87 |             i.clear()
 88 |             t.from.mapNotNullTo(u) { it._type }
 89 |             t.to.mapNotNullTo(i) { it._type }
 90 |             if (u.isNotEmpty() || i.isNotEmpty()) {
 91 |                 x.clear()
 92 |                 Type.union(u)?.let { x.add(it) }
 93 |                 Type.intersection(i)?.let { x.add(it) }
 94 |                 newTypes[t] = Type.intersection(x)!!
 95 |                 b = true
 96 |                 itr.remove()
 97 |             }
 98 |         }
 99 |         for ((t, y) in newTypes) {
100 |             t._type = y
101 |         }
102 |         return b
103 |     }
104 | 
105 |     private fun check(): Boolean {
106 |         val newTypes = HashMap<Typing, Type>()
107 |         val u = HashSet<Type>()
108 |         var b = false
109 |         for (t in all) {
110 |             if (t._type == null || t.freezeType) continue
111 |             u.clear()
112 |             t.from.mapNotNullTo(u) { it._type }
113 |             if (u.isNotEmpty()) {
114 |                 val newType = Type.union(u)!!
115 |                 if (t._type != newType) {
116 |                     b = true
117 |                     newTypes[t] = newType
118 |                 }
119 |             }
120 |         }
121 |         for ((t, y) in newTypes) {
122 |             t._type = y
123 |         }
124 |         return b
125 |     }
126 | 
127 |     private fun compare(): Boolean {
128 |         val newTypes = HashMap<Typing, Type>()
129 |         val u = HashSet<Type>()
130 |         var b = false
131 |         val itr = unidentified.iterator()
132 |         for (t in itr) {
133 |             u.clear()
134 |             t.compare.mapNotNullTo(u) { it._type }
135 |             if (u.isNotEmpty()) {
136 |                 newTypes[t] = Type.union(u)!!
137 |                 b = true
138 |                 itr.remove()
139 |             }
140 |         }
141 |         for ((t, y) in newTypes) {
142 |             t._type = y
143 |         }
144 |         return b
145 |     }
146 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/cfa/Reconstruct.kt:
--------------------------------------------------------------------------------
  1 | package org.runestar.cs2.cfa
  2 | 
  3 | import org.runestar.cs2.ir.Expression
  4 | import org.runestar.cs2.ir.Function
  5 | import org.runestar.cs2.ir.Instruction
  6 | import org.runestar.cs2.util.isSuccessorAcyclic
  7 | 
  8 | fun reconstruct(f: Function): Construct {
  9 |     val fg = FlowGraph(f)
 10 |     val root = Construct.Seq()
 11 |     reconstructBlock(fg, root, fg.graph.head, fg.graph.head)
 12 |     return root
 13 | }
 14 | 
 15 | private fun reconstructBlock(
 16 |         flow: FlowGraph,
 17 |         prev: Construct,
 18 |         dominator: BasicBlock,
 19 |         block: BasicBlock
 20 | ): BasicBlock? {
 21 |     if (dominator != block && !flow.dtree.isSuccessorAcyclic(dominator, block)) return block
 22 |     val seq = if (prev is Construct.Seq) {
 23 |         prev
 24 |     } else {
 25 |         val s = Construct.Seq()
 26 |         prev.next = s
 27 |         s
 28 |     }
 29 |     for (insn in block) {
 30 |         if (insn is Instruction.Label) continue
 31 |         if (insn == block.tail) continue
 32 |         seq.instructions.add(insn)
 33 |     }
 34 |     when (val tail = block.tail) {
 35 |         is Instruction.Return -> {
 36 |             seq.instructions.add(tail)
 37 |         }
 38 |         is Instruction.Goto -> {
 39 |             return reconstructBlock(flow, seq, dominator, flow.blocks.block(tail.label))
 40 |         }
 41 |         is Instruction.Switch -> {
 42 |             var after: BasicBlock? = null
 43 |             val cases = LinkedHashMap<Set<Int>, Construct>()
 44 |             val switch = Construct.Switch(tail.expression, cases)
 45 |             seq.next = switch
 46 |             for (v in tail.cases.values.toSet()) {
 47 |                 val keys = LinkedHashSet<Int>()
 48 |                 for (e in tail.cases) {
 49 |                     if (e.value == v) keys.add(e.key)
 50 |                 }
 51 |                 val nxt = Construct.Seq()
 52 |                 cases[keys] = nxt
 53 |                 val dst = flow.blocks.block(v)
 54 |                 after = reconstructBlock(flow, nxt, dst, dst) ?: after
 55 |             }
 56 |             val next = flow.blocks.next(block)
 57 |             val default = Construct.Seq()
 58 |             switch.default = default
 59 |             after = reconstructBlock(flow, default, next, next) ?: after
 60 |             if (default.instructions.isEmpty() && default.next == null) {
 61 |                 switch.default = null
 62 |             }
 63 |             if (after != null) {
 64 |                 return reconstructBlock(flow, switch, block, after)
 65 |             }
 66 |         }
 67 |         is Instruction.Branch -> {
 68 |             val pass = flow.blocks.block(tail.pass)
 69 |             val fail = flow.blocks.next(block)
 70 |             val preds = flow.graph.immediatePredecessors(block)
 71 |             if (preds.any { it.index > block.index }) {
 72 |                 val w = Construct.While(tail.expression as Expression.Operation)
 73 |                 seq.next = w
 74 |                 w.body = Construct.Seq()
 75 |                 reconstructBlock(flow, w.body, pass, pass)
 76 |                 return reconstructBlock(flow, w, fail, fail)
 77 |             } else {
 78 |                 val iff = Construct.If()
 79 |                 seq.next = iff
 80 |                 val branch = Construct.Branch(tail.expression as Expression.Operation, Construct.Seq())
 81 |                 iff.branches.add(branch)
 82 |                 val afterIf = reconstructBlock(flow, branch.body, pass, pass)
 83 |                 val elze = Construct.Seq()
 84 |                 iff.elze = elze
 85 |                 val afterElze = reconstructBlock(flow, elze, fail, fail)
 86 |                 if (elze.instructions.isEmpty() && elze.next == null) {
 87 |                     iff.elze = null
 88 |                 } else if (elze.instructions.isEmpty() && elze.next is Construct.If && elze.next!!.next == null) {
 89 |                     val if2 = elze.next as Construct.If
 90 |                     iff.branches.addAll(if2.branches)
 91 |                     iff.elze = if2.elze
 92 |                 }
 93 | 
 94 |                 if (afterIf == null) {
 95 |                     iff.next = iff.elze
 96 |                     iff.elze = null
 97 |                     if (afterElze != null) {
 98 |                         return reconstructBlock(flow, iff.next ?: iff, block, afterElze)
 99 |                     }
100 |                 } else {
101 |                     return reconstructBlock(flow, iff, block, afterIf)
102 |                 }
103 |             }
104 |         }
105 |         is Instruction.Assignment -> {
106 |             seq.instructions.add(tail)
107 |             return reconstructBlock(flow, seq, dominator, flow.blocks.next(block))
108 |         }
109 |         is Instruction.Label -> {
110 |             return reconstructBlock(flow, seq, dominator, flow.blocks.next(block))
111 |         }
112 |     }
113 |     return null
114 | }


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/ir/Interpreter.kt:
--------------------------------------------------------------------------------
  1 | package org.runestar.cs2.ir
  2 | 
  3 | import org.runestar.cs2.bin.Script
  4 | import org.runestar.cs2.bin.StackType
  5 | import org.runestar.cs2.bin.Type
  6 | import org.runestar.cs2.bin.Value
  7 | import org.runestar.cs2.bin.int
  8 | import org.runestar.cs2.util.Chain
  9 | import org.runestar.cs2.util.HashChain
 10 | import org.runestar.cs2.util.ListStack
 11 | import org.runestar.cs2.util.Loader
 12 | import org.runestar.cs2.util.counter
 13 | import org.runestar.cs2.util.loadNotNull
 14 | import org.runestar.cs2.util.toUnsignedInt
 15 | 
 16 | fun interpret(
 17 |         scripts: Loader.Keyed<Script>,
 18 |         commands: Loader<Command>,
 19 |         paramTypes: Loader<Type>
 20 | ) : FunctionSet {
 21 |     return Interpreter(scripts, commands, paramTypes).interpret()
 22 | }
 23 | 
 24 | private class Interpreter(
 25 |         private val scripts: Loader.Keyed<Script>,
 26 |         private val commands: Loader<Command>,
 27 |         private val paramTypes: Loader<Type>
 28 | ) {
 29 | 
 30 |     private val typings = Typings()
 31 | 
 32 |     private val callGraph = CallGraph()
 33 | 
 34 |     fun interpret() = FunctionSet(scripts.ids.associateWith { interpret(it) }, typings, callGraph)
 35 | 
 36 |     private fun interpret(scriptId: Int): Function {
 37 |         val state = state(scriptId)
 38 |         val instructions = addLabels(interpretInstructions(state))
 39 |         val args = ArrayList<Variable.Local>(state.script.intArgumentCount + state.script.stringArgumentCount)
 40 |         repeat(state.script.intArgumentCount) {
 41 |             args.add(Variable.int(state.scriptId, it))
 42 |         }
 43 |         repeat(state.script.stringArgumentCount) {
 44 |             args.add(Variable.string(state.scriptId, it))
 45 |         }
 46 |         return Function(scriptId, args, instructions, state.script.returnTypes)
 47 |     }
 48 | 
 49 |     private fun state(scriptId: Int) = InterpreterState(scripts, paramTypes, scriptId, scripts.loadNotNull(scriptId), typings, callGraph)
 50 | 
 51 |     private fun interpretInstructions(state: InterpreterState): Array<Instruction> {
 52 |         return Array(state.script.opcodes.size) {
 53 |             val insn = translate(state)
 54 |             state.pc++
 55 |             if (insn !is Instruction.Assignment) {
 56 |                  check(state.stack.isEmpty())
 57 |             }
 58 |             insn
 59 |         }
 60 |     }
 61 | 
 62 |     private fun translate(state: InterpreterState) = commands.loadNotNull(state.opcode).translate(state)
 63 | 
 64 |     private fun addLabels(instructions: Array<Instruction>): Chain<Instruction> {
 65 |         val chain = HashChain<Instruction>()
 66 |         val labels = HashSet<Int>()
 67 |         for (insn in instructions) {
 68 |             when (insn) {
 69 |                 is Instruction.Branch -> labels.add(insn.pass.id)
 70 |                 is Instruction.Goto -> labels.add(insn.label.id)
 71 |                 is Instruction.Switch -> insn.cases.values.mapTo(labels) { it.id }
 72 |             }
 73 |         }
 74 |         instructions.forEachIndexed { index, insn ->
 75 |             if (index in labels) {
 76 |                 chain.addLast(Instruction.Label(index))
 77 |             }
 78 |             chain.addLast(insn)
 79 |         }
 80 |         return chain
 81 |     }
 82 | }
 83 | 
 84 | class InterpreterState(
 85 |         val scripts: Loader<Script>,
 86 |         val paramTypes: Loader<Type>,
 87 |         val scriptId: Int,
 88 |         val script: Script,
 89 |         val typings: Typings,
 90 |         val callGraph: CallGraph,
 91 | ) {
 92 | 
 93 |     var pc: Int = 0
 94 | 
 95 |     internal val stack: ListStack<Element.Access> = ListStack(ArrayList())
 96 | 
 97 |     private val stackCounter = counter()
 98 | 
 99 |     val opcode: Int get() = script.opcodes[pc].toUnsignedInt()
100 | 
101 |     val operand: Value get() = script.operands[pc]
102 | 
103 |     val switch: Map<Int, Int> get() = script.switches[operand.int]
104 | 
105 |     fun push(stackType: StackType, value: Value? = null): Element.Access {
106 |         if (value != null) require(stackType == value.stackType)
107 |         val id = stackCounter()
108 |         val variable = when (stackType) {
109 |             StackType.INT -> Variable.stackint(scriptId, id)
110 |             StackType.STRING -> Variable.stackstring(scriptId, id)
111 |         }
112 |         return Element.Access(variable, value).also { stack.push(it) }
113 |     }
114 | 
115 |     fun push(stackTypes: List<StackType>): List<Element.Access> = stackTypes.map { push(it) }
116 | 
117 |     fun pop(stackType: StackType): Element.Access = stack.pop().also { check(it.stackType == stackType) }
118 | 
119 |     fun pop(count: Int): List<Element.Access> = stack.pop(count)
120 | 
121 |     fun popAll(): List<Element.Access> = stack.popAll()
122 | 
123 |     fun peekValue(): Value? = stack.peek().value
124 | 
125 |     fun popValue(): Value = checkNotNull(stack.pop().value)
126 | }


--------------------------------------------------------------------------------
/src/main/resources/org/runestar/cs2/interface-names.tsv:
--------------------------------------------------------------------------------
  1 | 0	100guide_eggs_overlay
  2 | 1	100guide_flour_overlay
  3 | 2	100guide_inv_flour
  4 | 3	100guide_milk_overlay
  5 | 5	agilityarena_overlay
  6 | 8	ahoy_islandmap
  7 | 9	ahoy_runedraw
  8 | 10	ahoy_windspeed
  9 | 24	barrows_overlay
 10 | 25	barrows_puzzle
 11 | 29	blast_furnace_plan_scroll
 12 | 30	blast_furnace_temp_gauge
 13 | 31	boardgames_challenge
 14 | 32	boardgames_draughts
 15 | 36	boardgames_runelink
 16 | 40	boardgames_runesquares
 17 | 43	boardgames_runesquares_view
 18 | 44	boardgames_runeversi
 19 | 48	bob_locator_amulet
 20 | 54	castlewars_catapult
 21 | 55	castlewars_score
 22 | 56	castlewars_shopside
 23 | 58	castlewars_status_overlay_saradomin
 24 | 59	castlewars_status_overlay_zamorak
 25 | 61	cat_naming
 26 | 62	cave_goblin_markers
 27 | 63	champions_scroll
 28 | 96	darkness_dark
 29 | 97	darkness_light
 30 | 98	darkness_medium
 31 | 99	death_dice
 32 | 103	pattern_next
 33 | 117	enakh_film
 34 | 118	enakh_smoke_overlay
 35 | 123	fairy_certificate
 36 | 124	fairy_symptoms
 37 | 125	farming_tools
 38 | 126	farming_tools_side
 39 | 132	garden_list
 40 | 133	garden_quiz
 41 | 135	aide_compass
 42 | 138	glidermap
 43 | 139	gnomeball
 44 | 142	horror_metaldoor
 45 | 144	hauntedmine_controls
 46 | 149	inventory
 47 | 150	keldagrim_map
 48 | 151	keldagrim_story1
 49 | 152	keldagrim_titles
 50 | 182	logout
 51 | 185	macro_combilock
 52 | 186	macro_evil_bob
 53 | 188	macro_mime_emotes
 54 | 191	macro_quizshow
 55 | 194	magictraining_alchem
 56 | 196	magictraining_grave
 57 | 197	magictraining_shop
 58 | 198	magictraining_tele
 59 | 209	mazetimer
 60 | 218	magic_spellbook
 61 | 220	messagescroll
 62 | 221	messagescroll2
 63 | 223	peng_emote
 64 | 224	misc_shipjourney
 65 | 225	mm_message
 66 | 227	mourning_deathalter_list
 67 | 249	surok_letter1
 68 | 250	surok_letter2
 69 | 252	olaf2_lock_gate
 70 | 253	olaf2_skull_puzzle
 71 | 254	olaf2_treasuremap
 72 | 260	dream_armour
 73 | 261	options
 74 | 273	prisonpete
 75 | 282	ratcatcher_flute
 76 | 283	ratcatcher_flute_music
 77 | 285	rd_combolock
 78 | 286	regicide_still
 79 | 290	roguesden_dials
 80 | 293	roguesden_puzzle
 81 | 294	rum_deal_censor
 82 | 295	rum_deal_title
 83 | 296	sandstorm
 84 | 297	sandwich_tray
 85 | 298	seer_combolock
 86 | 299	ship_journey
 87 | 308	cata_boss
 88 | 313	smokeoverlay
 89 | 315	soulbane_angerbar
 90 | 319	cws_warning_25
 91 | 320	stats
 92 | 321	swamp_boatjourney
 93 | 322	swamp_boatjourney_back
 94 | 324	tanner
 95 | 325	target
 96 | 326	teleport_other
 97 | 327	cws_warning_11
 98 | 329	templetrek_map
 99 | 332	thormac
100 | 334	tradeconfirm
101 | 335	trademain
102 | 336	tradeside
103 | 345	poll_results
104 | 346	trail_map01
105 | 347	trail_map02
106 | 348	trail_map03
107 | 349	trail_map04
108 | 350	trail_map05
109 | 351	trail_map06
110 | 352	trail_map07
111 | 353	trail_map08
112 | 354	trail_map09
113 | 355	trail_map10
114 | 356	trail_map11
115 | 357	trail_map12
116 | 358	trail_map13
117 | 359	trail_map14
118 | 360	trail_map15
119 | 361	trail_map16
120 | 362	trail_map17
121 | 365	trail_sextant
122 | 366	trawler_overlay
123 | 367	trawler_reward
124 | 368	trawler_start
125 | 369	tribal_door
126 | 373	tzhaar_fightpit
127 | 374	tzhaar_fightpit_orb
128 | 378	welcome_screen
129 | 386	wom_telescope
130 | 387	wornitems
131 | 393	poh_hangman
132 | 401	poh_ranging
133 | 403	poh_sawmill
134 | 404	poh_scrying_pool
135 | 407	pest_lander_overlay
136 | 408	pest_status_overlay
137 | 409	mcannon_interface
138 | 410	warguild_defence
139 | 411	warguild_defence_mini
140 | 412	warguild_dummy
141 | 414	brew_game_over
142 | 415	brew_overlay
143 | 417	brew_tools
144 | 420	beehive
145 | 423	fairy2_certificate_broken
146 | 424	fairy2_message
147 | 427	scroll_godfather
148 | 428	ntk_overlay
149 | 433	xbows_pouch
150 | 438	crafting_silver_casting
151 | 452	myq3_statue_painting
152 | 453	myq3_blackout
153 | 461	seaslug_boat_travel
154 | 463	kings_letter_v2
155 | 469	zep_balloon_map
156 | 470	zep_interface
157 | 471	zep_interface_side
158 | 480	anma_rgb
159 | 484	barbassault_horn
160 | 485	barbassault_over_att
161 | 486	barbassault_over_col
162 | 487	barbassault_over_def
163 | 488	barbassault_over_heal
164 | 490	barbassault_playerstat
165 | 494	barbassault_timer_overlay
166 | 495	barbassault_turret
167 | 496	barbassault_tutorial
168 | 497	barbassault_wavecomplete
169 | 498	contact_scroll_blood
170 | 505	peng_ship_journey
171 | 508	tol_homonculus_overlay
172 | 509	tol_cage_puzzle
173 | 510	tol_pressure_machine
174 | 511	tol_pipe_machine
175 | 512	inventory_ranging
176 | 514	brain_cat_overlay
177 | 515	brain_gas_overlay
178 | 521	dream_cyrisus
179 | 522	dream_monster_stat
180 | 523	dream_player_stats
181 | 524	dream_title
182 | 528	vm_digsite
183 | 532	vm_kudos
184 | 534	vm_timeline
185 | 535	grim_piano
186 | 536	grim_recipe
187 | 538	grim_tasklist
188 | 543	dragon_slayer_qip_clouds
189 | 544	dragon_slayer_qip_cr_journey
190 | 545	dragon_slayer_qip_elvarg
191 | 546	dragon_slayer_qip_elvarg_fly
192 | 547	dragon_slayer_qip_map
193 | 548	toplevel
194 | 553	snapshot_main
195 | 559	pattern_cards
196 | 560	cws_warning_9
197 | 562	cws_warning_2
198 | 563	cws_warning_5
199 | 564	cws_warning_23
200 | 565	cws_warning_10
201 | 566	cws_warning_6
202 | 567	cws_warning_14
203 | 568	cws_warning_3
204 | 569	cws_warning_16
205 | 570	cws_warning_17
206 | 571	cws_warning_19
207 | 572	cws_warning_13
208 | 573	cws_warning_12
209 | 574	cws_warning_1
210 | 576	cws_warning_8
211 | 577	cws_warning_18
212 | 578	cws_warning_15
213 | 579	cws_warning_4
214 | 580	cws_warning_20
215 | 581	cws_warning_24
216 | 583	cws_doomsayer
217 | 584	confirm_destroy
218 | 585	kr_pyramid_escape
219 | 588	kr_picklock
220 | 590	poh_jewellery_box


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/cg/Ints.kt:
--------------------------------------------------------------------------------
  1 | package org.runestar.cs2.cg
  2 | 
  3 | import org.runestar.cs2.BOOLEAN_NAMES
  4 | import org.runestar.cs2.CHATFILTER_NAMES
  5 | import org.runestar.cs2.CHATTYPE_NAMES
  6 | import org.runestar.cs2.CLIENTTYPE_NAMES
  7 | import org.runestar.cs2.FONTMETRICS_NAMES
  8 | import org.runestar.cs2.GRAPHIC_NAMES
  9 | import org.runestar.cs2.IFTYPE_NAMES
 10 | import org.runestar.cs2.INTERFACE_NAMES
 11 | import org.runestar.cs2.INV_NAMES
 12 | import org.runestar.cs2.KEY_NAMES
 13 | import org.runestar.cs2.LOC_NAMES
 14 | import org.runestar.cs2.MAPAREA_NAMES
 15 | import org.runestar.cs2.MODEL_NAMES
 16 | import org.runestar.cs2.NPC_NAMES
 17 | import org.runestar.cs2.OBJ_NAMES
 18 | import org.runestar.cs2.PARAM_NAMES
 19 | import org.runestar.cs2.SEQ_NAMES
 20 | import org.runestar.cs2.SETPOSH_NAMES
 21 | import org.runestar.cs2.SETPOSV_NAMES
 22 | import org.runestar.cs2.SETSIZE_NAMES
 23 | import org.runestar.cs2.SETTEXTALIGNH_NAMES
 24 | import org.runestar.cs2.SETTEXTALIGNV_NAMES
 25 | import org.runestar.cs2.STAT_NAMES
 26 | import org.runestar.cs2.STRUCT_NAMES
 27 | import org.runestar.cs2.SYNTH_NAMES
 28 | import org.runestar.cs2.util.Loader
 29 | import org.runestar.cs2.bin.Type
 30 | import org.runestar.cs2.WINDOWMODE_NAMES
 31 | import org.runestar.cs2.ir.*
 32 | import org.runestar.cs2.util.loadNotNull
 33 | import org.runestar.cs2.util.map
 34 | import org.runestar.cs2.util.mapIndexed
 35 | import org.runestar.cs2.util.orElse
 36 | 
 37 | private val VALUE = Loader { it.toString() }
 38 | 
 39 | private val NULL = Loader { if (it == -1) "null" else null }
 40 | 
 41 | private fun Loader<String>.quote() = map { '"' + it + '"' }
 42 | 
 43 | private fun Loader<String>.prefix(prefix: String) = map { prefix + it }
 44 | 
 45 | private val COORDS = Loader {
 46 |     val plane = it ushr 28
 47 |     val x = (it ushr 14) and 0x3FFF
 48 |     val z = it and 0x3FFF
 49 |     "${plane}_${x / 64}_${z / 64}_${x and 0x3F}_${z and 0x3F}"
 50 | }
 51 | 
 52 | private val COLOUR_CONSTANTS = Loader(mapOf(
 53 |         0xFF0000 to "^red",
 54 |         0x00FF00 to "^green",
 55 |         0x0000FF to "^blue",
 56 |         0xFFFF00 to "^yellow",
 57 |         0xFF00FF to "^magenta",
 58 |         0x00FFFF to "^cyan",
 59 |         0xFFFFFF to "^white",
 60 |         0x000000 to "^black"
 61 | ))
 62 | 
 63 | private val COLOURS = Loader {
 64 |     check((it shr 24) == 0)
 65 |     "0x%06x".format(it)
 66 | }
 67 | 
 68 | private val INT_CONSTANTS = Loader(mapOf(
 69 |         Int.MAX_VALUE to "^max_32bit_int",
 70 |         Int.MIN_VALUE to "^min_32bit_int"
 71 | ))
 72 | 
 73 | private val INTERFACES = unique(INTERFACE, INTERFACE_NAMES)
 74 | 
 75 | private val COMPONENTS = Loader { INTERFACES.loadNotNull(it shr 16) + ':' + (it and 0xFFFF) }
 76 | 
 77 | private fun cst(prefix: String, loader: Loader<String>) = loader.prefix('^' + prefix + '_').orElse(NULL).orElse(VALUE)
 78 | 
 79 | private fun Loader<String>.idSuffix() = mapIndexed { id, n -> n + '_' + id }
 80 | 
 81 | private fun unique(prototype: Prototype, loader: Loader<String>) = loader.orElse(unknown(prototype))
 82 | 
 83 | private fun uniqueExhaustive(loader: Loader<String>) = loader.orElse(NULL)
 84 | 
 85 | private fun unknown(prototype: Prototype) = NULL.orElse(Loader(prototype.identifier).idSuffix())
 86 | 
 87 | private fun nonUnique(prototype: Prototype, loader: Loader<String>) = NULL.orElse(loader.orElse(Loader(prototype.identifier)).idSuffix())
 88 | 
 89 | private val PROTOTYPES = HashMap<Prototype, Loader<String>>().apply {
 90 |     this[INT] = INT_CONSTANTS.orElse(VALUE)
 91 |     this[COORD] = NULL.orElse(COORDS)
 92 |     this[COLOUR] = NULL.orElse(COLOUR_CONSTANTS).orElse(COLOURS)
 93 |     this[COMPONENT] = NULL.orElse(COMPONENTS)
 94 |     this[TYPE] = Loader { Type.of(it.toByte()).literal }
 95 |     this[BOOL] = BOOLEAN_NAMES.prefix("^").orElse(NULL)
 96 |     this[GRAPHIC] = NULL.orElse(GRAPHIC_NAMES.orElse(Loader(GRAPHIC.identifier).idSuffix()).quote())
 97 |     this[NPC_UID] = VALUE
 98 | 
 99 |     this[ENUM] = unknown(ENUM)
100 |     this[CATEGORY] = unknown(CATEGORY)
101 | 
102 |     this[CHAR] = NULL
103 |     this[AREA] = NULL
104 |     this[MAPELEMENT] = NULL
105 | 
106 |     this[BOOLEAN] = uniqueExhaustive(BOOLEAN_NAMES)
107 |     this[STAT] = uniqueExhaustive(STAT_NAMES)
108 |     this[MAPAREA] = uniqueExhaustive(MAPAREA_NAMES)
109 |     this[FONTMETRICS] = uniqueExhaustive(FONTMETRICS_NAMES)
110 | 
111 |     this[INV] = unique(INV, INV_NAMES)
112 |     this[SYNTH] = unique(SYNTH, SYNTH_NAMES)
113 |     this[PARAM] = unique(PARAM, PARAM_NAMES)
114 |     this[INTERFACE] = INTERFACES
115 | 
116 |     this[OBJ] = nonUnique(OBJ, OBJ_NAMES)
117 |     this[LOC] = nonUnique(LOC, LOC_NAMES)
118 |     this[MODEL] = nonUnique(MODEL, MODEL_NAMES)
119 |     this[STRUCT] = nonUnique(STRUCT, STRUCT_NAMES)
120 |     this[NPC] = nonUnique(NPC, NPC_NAMES)
121 |     this[SEQ] = nonUnique(SEQ, SEQ_NAMES)
122 |     this[NAMEDOBJ] = getValue(OBJ)
123 | 
124 |     this[KEY] = cst(KEY.identifier, KEY_NAMES)
125 |     this[IFTYPE] = cst(IFTYPE.identifier, IFTYPE_NAMES)
126 |     this[SETSIZE] = cst(SETSIZE.identifier, SETSIZE_NAMES)
127 |     this[SETPOSH] = cst("setpos", SETPOSH_NAMES)
128 |     this[SETPOSV] = cst("setpos", SETPOSV_NAMES)
129 |     this[SETTEXTALIGNH] = cst("settextalign", SETTEXTALIGNH_NAMES)
130 |     this[SETTEXTALIGNV] = cst("settextalign", SETTEXTALIGNV_NAMES)
131 |     this[CHATTYPE] = cst(CHATTYPE.identifier, CHATTYPE_NAMES)
132 |     this[WINDOWMODE] = cst(WINDOWMODE.identifier, WINDOWMODE_NAMES)
133 |     this[CLIENTTYPE] = cst(CLIENTTYPE.identifier, CLIENTTYPE_NAMES)
134 |     this[CHATFILTER] = cst(CHATFILTER.identifier, CHATFILTER_NAMES)
135 | }
136 | 
137 | fun intConstantToString(n: Int, prototype: Prototype): String {
138 |     return (PROTOTYPES[prototype] ?: PROTOTYPES.getValue(Prototype(prototype.type))).loadNotNull(n)
139 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # cs2 [![Discord](https://img.shields.io/discord/384870460640329728.svg?logo=discord)](https://discord.gg/G2kxrnU)
  2 | 
  3 | [**View scripts**](https://github.com/RuneStar/cs2-scripts)
  4 | 
  5 | ClientScript2 (cs2) is a client-side scripting language used in Old School RuneScape to dynamically update interfaces.
  6 | Players load scripts from the game cache in a custom bytecode format to be interpreted by the client.
  7 | 
  8 | #### Model
  9 | 
 10 | There are two main kinds of scripts:
 11 | 
 12 | ClientScript: Added as callbacks for actions such as user interactions with interface components.
 13 | When the user performs the action, such as click or mouse-leave, the script is executed.
 14 | Cannot return any values.
 15 | 
 16 | Procedure: can only be called inside of another script.
 17 | The caller may be of either kind.
 18 | Able to both take arguments and return values.
 19 | 
 20 | #### Signature
 21 | 
 22 | The first line of a script is its signature.
 23 | It contains the script's kind, name, the types and names of its parameters, and its return types.
 24 | A script may return multiple values.
 25 | A Procedure is indicated by `proc` and a ClientScript by `clientscript`.
 26 | 
 27 | `[proc,min](int $a, int $b)(int)`
 28 | 
 29 | `[clientscript,settrans](component $component, int $trans)`
 30 | 
 31 | Each script can take a maximum of 50 arguments and return a maximum of 50 values.
 32 | If a script does not return anything, the parentheses around its return types can be omitted.
 33 | 
 34 | #### Variables
 35 | 
 36 | Global variables:
 37 | Defined outside of scripts in config files.
 38 | Can be used and modified inside any script.
 39 | Accessed by prefixing its name with a percent sign, like `%raids_lobby_partysize`.
 40 | Internally stored as either varps, varbits, or varcs.
 41 | 
 42 | Global constants:
 43 | Unable to be modified.
 44 | Defined outside of scripts.
 45 | Accessed by prefixing its name with a caret, like `^iftype_rectangle`.
 46 | 
 47 | Local variables:
 48 | Must be defined and initialized to a valid value before being used.
 49 | Only accessible inside the script in which it is defined.
 50 | Accessed by prefixing its name with a dollar sign, like `$scrollbar`.
 51 | Arguments are also local variables which are initialized to the passed in values.
 52 | 
 53 | #### Types
 54 | 
 55 | `null` is a valid value for all types except for `string`
 56 | 
 57 | * `int` : a 32-bit signed integer. Written normally or as a hexadecimal literal. `null` is equivalent to `-1`
 58 |     * `5`, `-10`, `0x7f7f7f`
 59 | * `string` : a sequence of characters, can be empty.
 60 | Written enclosed in quotes.
 61 | String interpolation can be performed by enclosing a `string` typed expression in angle brackets and
 62 | embedding it in a `string` literal.
 63 |     * `"Show"`, `"Magic level: <tostring($lvl)>"`
 64 | * `boolean` :
 65 |     * `true`, `false`
 66 | * `coord` : a tile. Written as 5 numbers separated by underscores:
 67 | the plane, the coordinates of the map-square, then the coordinates inside of the map-square
 68 |     * `0_1_2_3_4`
 69 | * `component` an interface component. Written as the interface, a colon, then the component
 70 |     * `poh_jewellery_box:frame`
 71 | * `obj` : an item
 72 | * `namedobj` : an item explicitly specified in the code. Can be used as an `obj`
 73 |     * `lawrune`
 74 | * `enum`
 75 | * `stat` : a skill.
 76 |     * `attack`, `smithing`
 77 | * `graphic` : a sprite. Written with its name enclosed in quotes
 78 |     * `"magicoff,12"`
 79 | * `inv` : an inventory of items such as the player's inventory or the bank
 80 | * `model`
 81 | * `category`
 82 | * `loc`
 83 | * `area`
 84 | * `maparea`
 85 | * `fontmetrics` : a font
 86 |     * `p11_full`
 87 | * `char`
 88 | * `struct`
 89 | * `synth`
 90 | * `mapelement`
 91 | * `npc`
 92 | * `seq`
 93 | 
 94 | #### Arrays
 95 | 
 96 | Are a fixed length and all elements must be the same type.
 97 | Can be of any type except for `string`.
 98 | Max length of 5000.
 99 | `int` elements are initialized to `0`, all other types to `null`.
100 | Max of 5 arrays per script.
101 | Scripts may take only 1 array argument.
102 | Arrays can only be local variables and never globals.
103 | 
104 | Defining `$array` as an `int` array of length `$len` : `def_int $array($len);`
105 | 
106 | Getting the `$i`th element of `$array` : `$array($i)`
107 | 
108 | Setting the `$i`th element of `$array` to `$n` : `$array($i) = $n;` 
109 | 
110 | #### Control Flow
111 | 
112 | The only things which can be used in the test condition of an `if` or `while` statement are the following operators:
113 | 
114 | * Equality comparisons
115 |     * `=` : equals
116 |     * `!` : not equals
117 | * Relational comparisons
118 |     * `<` `>` `<=` `>=` 
119 | * Short circuiting logical operators
120 |     * `&` : AND
121 |     * `|` : OR
122 | 
123 | Combinations of these operators may also be used. 
124 | Variables or other expressions of type `boolean` may not be used on their own or as arguments to the logical operators.
125 | These operators cannot be used outside of an `if` or `while` statement.
126 | 
127 | Using an `if` statement to clamp an `int` value between `$max` and `$min`
128 | 
129 | ```
130 | if ($n > $max) {
131 |     return($max);
132 | } else if ($n < $min) {
133 |     return($min);
134 | } else {
135 |     return($n);
136 | }
137 | ```
138 | 
139 | Using a `while` statement to repeat something 10 times
140 | 
141 | ```
142 | def_int $i = 0;
143 | while ($i < 10) {
144 |     // ...
145 |     $i = calc($i + 1);
146 | }
147 | ```
148 | 
149 | There is no continue or break functionality.
150 | 
151 | Switch
152 | 
153 | Any expression that is not of type `string` can be the target of a `switch` statement.
154 | The cases must be constants.
155 | Multiple cases may lead to the same block.
156 | There is no fall-through between blocks.
157 | An optional `default` case can be used if none of the other cases are matched.
158 | 
159 | #### Comments
160 | 
161 | `//` Indicates the start of a line comment and all following text up until the end of the line is ignored
162 | 
163 | #### Instructions
164 | 
165 | Most instructions are indicated by their name followed by a list of their arguments, `sound_synth(2266, 1, 0)`.
166 | If it takes no arguments the parentheses can be omitted, `clan_leavechat`.
167 | 
168 | A Procedure is called by using a tilde followed by its name and arguments, `~min($a, $b)`.
169 | If it takes no arguments the parentheses can be omitted, `~wilderness_level`.
170 | 
171 | Math on `int` expressions is performed using the `calc` instruction.
172 | It supports the infix operators `+` (addition), `-` (subtraction), `/` (division), `*` (multiplication), `%` (modulus),
173 | `|` (bitwise OR), `&` (bitwise AND).
174 | Precedence can be established using parentheses.
175 | The entire mathematical operation is passed as an argument to `calc` and the result is returned.
176 | `def_int $c = calc($a * $b + 2);`
177 | 
178 | An instruction which returns multiple values can be used either directly as multiple arguments to another instruction or
179 | assigned to multiple variables, `$int2, $int3 = ~poh_jewellerybox_getbuttonspacing(590:2, 3);`
180 | 
181 | #### Hooks
182 | 
183 | A ClientScript can be assigned as a reoccurring callback for an action by using one of the instructions which start with either `if_seton` or `cc_seton`.
184 | They take as their first argument the name of the ClientScript and its arguments all enclosed in quotes.
185 | The ClientScript is not executed immediately but instead executed with the given parameters each time the action occurs.
186 | 
187 | `cc_setonmouseover("autocast_tooltip($component1, $obj5)");`
188 | 
189 | Instead of using existing variables as arguments, special values starting with `event_` can be used which are resolved at the time the action occurs.
190 | If a mouse event is being used `event_mousex` will be replaced by the mouse's x position when the event is triggered.
191 | 
192 | `cc_setondrag("scrollbar_vertical_drag($component0, $component1, event_mousey, false)");`
193 | 
194 | ClientScripts can not only be assigned to interface actions but also to changes in varps, skills, or inventories.
195 | In this case the values which should be watched are added in braces after the arguments.
196 | 
197 | `if_setonvartransmit("deadman_tournament_hudupdate(){var1542, var1293}", 90:11);`


--------------------------------------------------------------------------------
/src/main/resources/org/runestar/cs2/struct-names.tsv:
--------------------------------------------------------------------------------
  1 | 1	your_position
  2 | 299	black_knights_fortress
  3 | 300	cooks_assistant
  4 | 301	the_corsair_curse
  5 | 302	demon_slayer
  6 | 305	ernest_the_chicken
  7 | 306	goblin_diplomacy
  8 | 307	imp_catcher
  9 | 308	the_knights_sword
 10 | 309	misthalin_mystery
 11 | 310	pirates_treasure
 12 | 311	prince_ali_rescue
 13 | 312	the_restless_ghost
 14 | 313	romeo_juliet
 15 | 314	rune_mysteries
 16 | 315	sheep_shearer
 17 | 316	shield_of_arrav
 18 | 317	gravestone
 19 | 318	witchs_potion
 20 | 319	combat_achievement_tasks_completion_popup
 21 | 320	architectural_alliance
 22 | 321	combat_achievement_tasks_repeat_completion
 23 | 322	alfred_grimhands_barcrawl
 24 | 323	combat_achievement_tasks_failure
 25 | 324	the_enchanted_key
 26 | 325	the_generals_shadow
 27 | 326	combat_achievement_tasks_repeat_failure
 28 | 329	family_pest
 29 | 330	mage_arena_ii
 30 | 331	animal_magnetism
 31 | 332	another_slice_of_h_a_m
 32 | 333	between_a_rock
 33 | 334	big_chompy_bird_hunting
 34 | 335	biohazard
 35 | 336	cabin_fever
 36 | 337	clock_tower
 37 | 338	cold_war
 38 | 339	contact
 39 | 340	creature_of_fenkenstrain
 40 | 341	darkness_of_hallowvale
 41 | 342	death_plateau
 42 | 343	death_to_the_dorgeshuun
 43 | 344	the_depths_of_despair
 44 | 345	desert_treasure
 45 | 346	devious_minds
 46 | 347	the_dig_site
 47 | 348	dragon_slayer_ii
 48 | 349	dream_mentor
 49 | 350	druidic_ritual
 50 | 351	dwarf_cannon
 51 | 352	eadgars_ruse
 52 | 353	eagles_peak
 53 | 354	elemental_workshop_i
 54 | 355	elemental_workshop_ii
 55 | 356	enakhras_lament
 56 | 357	enlightened_journey
 57 | 358	the_eyes_of_glouphrie
 58 | 359	fairytale_i_growing_pains
 59 | 360	fairytale_ii_cure_a_queen
 60 | 361	family_crest
 61 | 362	the_feud
 62 | 363	fight_arena
 63 | 364	fishing_contest
 64 | 365	forgettable_tale
 65 | 367	the_fremennik_isles
 66 | 368	the_fremennik_trials
 67 | 369	garden_of_tranquillity
 68 | 370	gertrudes_cat
 69 | 371	ghosts_ahoy
 70 | 372	the_giant_dwarf
 71 | 373	the_golem
 72 | 374	the_grand_tree
 73 | 375	the_great_brain_robbery
 74 | 376	grim_tales
 75 | 377	the_hand_in_the_sand
 76 | 378	haunted_mine
 77 | 379	hazeel_cult
 78 | 381	holy_grail
 79 | 382	horror_from_the_deep
 80 | 383	icthlarins_little_helper
 81 | 384	in_aid_of_the_myreque
 82 | 385	in_search_of_the_myreque
 83 | 386	jungle_potion
 84 | 387	kings_ransom
 85 | 389	lost_city
 86 | 390	the_lost_tribe
 87 | 391	lunar_diplomacy
 88 | 392	making_friends_with_my_arm
 89 | 393	making_history
 90 | 394	merlins_crystal
 91 | 395	monkey_madness_i
 92 | 396	monkey_madness_ii
 93 | 397	monks_friend
 94 | 398	mountain_daughter
 95 | 401	murder_mystery
 96 | 402	my_arms_big_adventure
 97 | 403	nature_spirit
 98 | 406	one_small_favour
 99 | 407	plague_city
100 | 408	priest_in_peril
101 | 409	the_queen_of_thieves
102 | 411	rag_and_bone_man_ii
103 | 412	ratcatchers
104 | 413	recipe_for_disaster
105 | 414	recruitment_drive
106 | 415	regicide
107 | 416	roving_elves
108 | 417	royal_trouble
109 | 418	rum_deal
110 | 419	scorpion_catcher
111 | 420	sea_slug
112 | 421	shades_of_mortton
113 | 422	shadow_of_the_storm
114 | 423	sheep_herder
115 | 424	shilo_village
116 | 425	the_slug_menace
117 | 426	a_souls_bane
118 | 427	spirits_of_the_elid
119 | 428	swan_song
120 | 429	tai_bwo_wannai_trio
121 | 430	a_tail_of_two_cats
122 | 431	tale_of_the_righteous
123 | 432	a_taste_of_hope
124 | 433	tears_of_guthix
125 | 434	temple_of_ikov
126 | 435	throne_of_miscellania
127 | 436	the_tourist_trap
128 | 437	tower_of_life
129 | 438	tree_gnome_village
130 | 439	tribal_totem
131 | 440	troll_romance
132 | 441	troll_stronghold
133 | 442	underground_pass
134 | 444	wanted
135 | 445	watchtower
136 | 447	what_lies_below
137 | 448	witchs_house
138 | 449	zogre_flesh_eaters
139 | 450	varrock
140 | 451	grand_exchange
141 | 452	lumbridge
142 | 453	falador
143 | 454	camelot
144 | 455	seers_village
145 | 456	ardougne
146 | 457	watchtower
147 | 458	yanille
148 | 459	senntisten
149 | 460	marim
150 | 461	kharyrll
151 | 462	lunar_isle
152 | 463	kourend_castle
153 | 464	waterbirth_island
154 | 465	fishing_guild
155 | 466	annakarl
156 | 467	troll_stronghold
157 | 468	catherby
158 | 469	ghorrock
159 | 470	carrallangar
160 | 471	bosses
161 | 472	raids
162 | 473	clues
163 | 474	minigames
164 | 475	other
165 | 476	abyssal_sire
166 | 477	barrows_chests
167 | 478	bryophyta
168 | 479	callisto
169 | 480	cerberus
170 | 481	chaos_elemental
171 | 482	chaos_fanatic
172 | 483	commander_zilyana
173 | 484	corporeal_beast
174 | 485	crazy_archaeologist
175 | 486	dagannoth_kings
176 | 487	general_graardor
177 | 488	giant_mole
178 | 489	grotesque_guardians
179 | 490	kalphite_queen
180 | 491	king_black_dragon
181 | 492	kraken
182 | 493	kreearra
183 | 494	kril_tsutsaroth
184 | 495	obor
185 | 496	scorpia
186 | 497	skotizo
187 | 498	thermonuclear_smoke_devil
188 | 499	the_inferno
189 | 500	the_fight_caves
190 | 501	venenatis
191 | 502	vetion
192 | 503	vorkath
193 | 504	wintertodt
194 | 505	zulrah
195 | 506	theatre_of_blood
196 | 507	chambers_of_xeric
197 | 508	easy_treasure_trails
198 | 509	medium_treasure_trails
199 | 510	hard_treasure_trails
200 | 511	elite_treasure_trails
201 | 512	master_treasure_trails
202 | 513	shared_treasure_trail_rewards
203 | 514	castle_wars
204 | 515	magic_training_arena
205 | 516	barbarian_assault
206 | 517	shades_of_mortton
207 | 518	pest_control
208 | 519	temple_trekking
209 | 520	fishing_trawler
210 | 521	gnome_restaurant
211 | 522	rogues_den
212 | 523	trouble_brewing
213 | 524	tithe_farm
214 | 525	revenants
215 | 526	gloughs_experiments
216 | 527	slayer
217 | 528	champions_challenge
218 | 529	skilling_pets
219 | 530	motherlode_mine
220 | 531	shayzien_armour
221 | 532	cyclopes
222 | 533	chaos_druids
223 | 534	miscellaneous
224 | 535	all_pets
225 | 536	tzhaar
226 | 537	chompy_bird_hunting
227 | 538	random_events
228 | 539	alchemical_hydra
229 | 540	aerial_fishing
230 | 541	hespori
231 | 542	the_ascent_of_arceuus
232 | 543	the_forsaken_tower
233 | 546	creature_creation
234 | 547	rooftop_agility
235 | 548	fossil_island_notes
236 | 549	my_notes
237 | 592	weiss
238 | 593	beginner_treasure_trails
239 | 601	sarachnis
240 | 603	song_of_the_elves
241 | 604	zalcano
242 | 605	the_gauntlet
243 | 719	golden_armadyl_attack
244 | 720	golden_bandos_attack
245 | 721	golden_saradomin_attack
246 | 722	golden_zamorak_attack
247 | 723	leagues_i_twisted
248 | 724	abyssal_accumulator
249 | 725	endless_endurance
250 | 726	dark_altar_devotion
251 | 727	hardcore_harvester
252 | 728	arcane_courier
253 | 729	unnatural_selection
254 | 730	eye_of_the_artisan
255 | 731	gift_of_the_gatherer
256 | 732	way_of_the_warrior
257 | 733	spirit_of_dinh
258 | 734	konars_blessing
259 | 735	treasure_seeker
260 | 736	xerics_focus
261 | 737	xerics_resilience
262 | 738	xerics_wisdom
263 | 752	getting_ahead
264 | 941	game_chat
265 | 949	a_night_at_the_theatre
266 | 968	the_following_options_control_the_warning_messages_for_teleport_tablets_that_take_you_to_the_wilderness_when_enabled_you_will_be_shown_a_warning_message_when_using_a_teleport_tablet_to_the_wilderness
267 | 996	the_following_options_control_the_warning_messages_for_teleport_spells_that_take_you_to_the_wilderness_when_enabled_you_will_be_shown_a_warning_message_when_you_cast_a_teleport_spell_to_the_wilderness
268 | 997	chat_box_scrollbar_position
269 | 1052	transparent_side_panel
270 | 1053	modern_layout_side_panel_can_be_closed_by_the_hotkeys
271 | 1055	show_the_remaining_xp_for_a_level_in_the_stats_panel
272 | 1122	show_prayer_tooltips
273 | 1147	hitsplat_tinting
274 | 1233	show_special_attack_tooltip
275 | 1246	draynor_manor
276 | 1247	battlefront
277 | 1248	mind_altar
278 | 1249	salve_graveyard
279 | 1250	fenken_castle
280 | 1251	west_ardougne
281 | 1252	harmony_island
282 | 1253	cemetery
283 | 1254	barrows
284 | 1255	ape_atoll_dungeon
285 | 1263	the_nightmare
286 | 1275	bear_your_soul
287 | 1276	sins_of_the_father
288 | 1278	vampyre_slayer
289 | 1279	hallowed_sepulchre
290 | 1397	monkey_backpacks
291 | 1688	daddys_home
292 | 1689	mahogany_homes
293 | 1720	last_man_standing
294 | 1721	leagues_ii_trailblazer
295 | 1722	endless_harvest
296 | 1723	production_master
297 | 1724	skilling_prodigy
298 | 1725	fairys_flight
299 | 1726	eternal_jeweller
300 | 1727	last_recall
301 | 1728	quick_shot
302 | 1729	fluid_strikes
303 | 1730	double_cast
304 | 1731	second_inventory
305 | 1732	treasure_seeker
306 | 1733	unnatural_selection
307 | 1734	the_botanist
308 | 1735	infernal_gathering
309 | 1736	equilibrium
310 | 1737	draining_strikes
311 | 1738	exploding_attacks
312 | 1739	weapon_specialist
313 | 1768	hide_roofs
314 | 2154	show_data_orbs
315 | 2232	show_wiki_entity_lookup
316 | 2255	notifications
317 | 2730	transparent_chatbox
318 | 2731	show_the_store_button
319 | 2732	game_client_layout
320 | 2733	scroll_wheel_can_change_zoom_distance
321 | 2734	camera_zoom_distance
322 | 2735	limit_framerate
323 | 2736	screen_brightness
324 | 2737	player_attack_options
325 | 2738	npc_attack_options
326 | 2753	music_volume
327 | 2754	sound_effect_volume
328 | 2755	area_sound_volume
329 | 2756	music_unlock_message
330 | 2757	show_chat_effects
331 | 2758	split_friends_private_chat
332 | 2759	hide_private_chat_when_the_chatbox_is_hidden
333 | 2760	enable_profanity_filter
334 | 2761	loot_drop_notifications
335 | 2762	minimum_item_value_needed_for_loot_notification
336 | 2763	untradeable_loot_notifications
337 | 2764	filter_out_boss_kill_count_with_spam_filter
338 | 2765	drop_item_warning
339 | 2766	minimum_item_value_needed_for_drop_item_warning
340 | 2767	friend_login_logout_messages
341 | 2768	click_through_transparent_chatbox
342 | 2769	single_mouse_button_mode
343 | 2770	middle_mouse_button_controls_the_camera
344 | 2771	move_follower_options_lower_down
345 | 2772	shift_click_to_drop_items
346 | 2773	show_the_function_button
347 | 2774	deadzone_adjuster
348 | 2775	esc_closes_the_current_interface
349 | 2776	restore_default_keybinds
350 | 2777	accept_aid
351 | 2778	show_warning_when_casting_teleport_to_target
352 | 2779	show_warning_when_casting_dareeyak_teleport
353 | 2781	show_warning_when_casting_annakarl_teleport
354 | 2782	show_warning_when_casting_ghorrock_teleport
355 | 2783	casting_alchemy_spells_on_untradeable_items_always_triggers_a_warning
356 | 2784	minimum_item_value_needed_for_alchemy_spells_warning
357 | 2785	show_warning_when_using_tablet_ice_plateau
358 | 2786	show_warning_when_using_tablet_cemetery
359 | 2787	show_warning_when_using_tablet_wilderness_crabs
360 | 2788	show_warning_when_using_tablet_dareeyak
361 | 2790	show_warning_when_using_tablet_annakarl
362 | 2791	show_warning_when_using_tablet_ghorrock
363 | 2792	disable_tablet_warnings
364 | 2793	enable_tablet_warnings
365 | 2794	disable_teleport_warnings
366 | 2795	enable_teleport_warnings
367 | 2797	show_warning_when_casting_carrallangar_teleport
368 | 2798	show_warning_when_using_tablet_carrallangar
369 | 2825	soul_wars
370 | 2851	select_function_mode
371 | 2852	interface_scaling
372 | 2853	reset_interface_scaling
373 | 2854	last_man_standing_fog_colour
374 | 2855	enable_precise_timing
375 | 2858	shooting_stars
376 | 2859	enable_separating_hours
377 | 2861	food_potions_can_form_supply_piles_on_death
378 | 2867	tempoross
379 | 2869	hard_treasure_trails_rare
380 | 2870	elite_treasure_trails_rare
381 | 2871	master_treasure_trails_rare
382 | 2872	volcanic_mine
383 | 2873	brimhaven_agility_arena
384 | 2874	below_ice_mountain
385 | 2885	camdozaal
386 | 2886	modern_layout_side_panel_visual_appearance
387 | 2887	arceuus_library
388 | 2890	chat_colour_opaque
389 | 2891	chat_colour_transparent
390 | 2892	chat_colour_split
391 | 2893	the_following_options_control_which_colour_to_display_chat_messages_in_an_opaque_chatbox
392 | 2894	the_following_options_control_which_colour_to_display_chat_messages_in_a_transparent_chatbox
393 | 2895	the_following_options_control_which_colour_to_display_chat_messages_in_the_split_chat_outside_your_chatbox
394 | 2896	public_chat
395 | 2897	public_chat
396 | 2898	private_chat
397 | 2899	private_chat
398 | 2900	private_chat
399 | 2901	auto_chat
400 | 2902	auto_chat
401 | 2903	broadcast
402 | 2904	broadcast
403 | 2905	broadcast
404 | 2906	friend_chat
405 | 2907	friend_chat
406 | 2908	clan_chat
407 | 2909	clan_chat
408 | 2910	incoming_trade_request
409 | 2911	incoming_trade_request
410 | 2912	incoming_challenge_request
411 | 2913	incoming_challenge_request
412 | 2914	reset_opaque_chat_colours
413 | 2915	reset_transparent_chat_colours
414 | 2916	reset_split_chat_colours
415 | 2917	home_world
416 | 2918	player_count
417 | 2919	lock_hall
418 | 2920	theme
419 | 2943	permission_access
420 | 2946	management
421 | 2947	edit_public_profile
422 | 2948	assign_member_ranks
423 | 2949	edit_rank_titles
424 | 2950	expel_members
425 | 2951	recruitment
426 | 2952	icons
427 | 2953	chat
428 | 2954	talk_in_chat
429 | 2955	kick_from_chat
430 | 2956	ban_from_chat
431 | 2957	guests_may_listen_in_chat
432 | 2958	guest_minimum_combat
433 | 2959	guest_minimum_skill_total
434 | 2960	guest_minimum_qp
435 | 2961	guest_iron_status
436 | 2962	coffer
437 | 2963	deposit_into_coffer
438 | 2964	withdraw_from_coffer
439 | 2965	events
440 | 2966	organise_events
441 | 2967	initiate_clan_wars
442 | 2968	clan_hall
443 | 2969	enter_clan_hall
444 | 2970	edit_clan_hall
445 | 2971	a_kingdom_divided
446 | 2974	music_area_mode
447 | 2975	guest_clan_chat
448 | 2976	guest_clan_chat
449 | 3002	show_boss_health_overlay
450 | 3003	show_normal_health_overlay
451 | 3004	tile_highlighting
452 | 3005	tile_highlight_colour
453 | 3006	show_mouseover_tooltips
454 | 3007	show_mouseover_text
455 | 3008	shift_anti_drag
456 | 3009	data_orbs_regeneration_indicators
457 | 3010	clear_your_highlighted_tiles
458 | 3011	chambers_of_xeric_helper
459 | 3012	chat_timestamps
460 | 3013	fishing_spot_indicators
461 | 3014	fishing_spot_indicators_tools_only
462 | 3015	fishing_spot_indicators_mouse_over_tooltip
463 | 3016	show_attack_style
464 | 3017	display_buff_bar
465 | 3018	tooltips_for_buffs
466 | 3019	display_relics
467 | 3020	home_teleport_cooldown
468 | 3021	minigame_teleport_cooldown
469 | 3022	teleport_block_duration
470 | 3023	charge_buff_duration
471 | 3024	godwars_altar_cooldown
472 | 3025	dragonfire_shield_cooldown
473 | 3026	imbued_heart_cooldown
474 | 3027	vengeance_cooldown
475 | 3028	vengeance_active
476 | 3029	stamina_duration
477 | 3030	prayer_enhance_duration
478 | 3031	overload_duration
479 | 3032	magic_imbue_duration
480 | 3033	abyssal_sire_stun_duration
481 | 3034	freeze_entangled_duration
482 | 3035	staff_of_the_dead_special_duration
483 | 3036	divine_potion_durations
484 | 3037	antifire_potion_durations
485 | 3038	anti_venom_and_poison_potion_durations
486 | 3039	always_on_top
487 | 3040	display_modified_stats_overlay
488 | 3041	show_tooltips_for_modified_stat_overlays
489 | 3042	number_of_modified_stats_to_show
490 | 3043	display_relative_stat_value
491 | 3106	joining_leaving_clan
492 | 3107	quest_broadcasts
493 | 3108	loot_broadcasts
494 | 3109	loot_broadcast_value
495 | 3110	level_up_broadcasts
496 | 3112	corruption_active_and_duration
497 | 3113	mark_of_darkness_active
498 | 3114	shadow_veil_active_and_duration
499 | 3115	death_charge_active_and_duration
500 | 3116	ward_of_arceuus_active_and_duration
501 | 3117	resurrection_active_and_duration
502 | 3135	bone_voyage
503 | 3136	client_of_kourend
504 | 3137	curse_of_the_empty_lord
505 | 3138	dorics_quest
506 | 3139	dragon_slayer_i
507 | 3140	enter_the_abyss
508 | 3141	the_fremennik_exiles
509 | 3142	heroes_quest
510 | 3143	in_search_of_knowledge
511 | 3144	lair_of_tarn_razorlor
512 | 3145	legends_quest
513 | 3146	mage_arena_i
514 | 3147	mournings_end_part_i
515 | 3148	mournings_end_part_ii
516 | 3149	observatory_quest
517 | 3150	olafs_quest
518 | 3151	a_porcine_of_interest
519 | 3152	rag_and_bone_man_i
520 | 3153	skippy_and_the_mogres
521 | 3154	waterfall_quest
522 | 3155	x_marks_the_spot
523 | 3599	combat_achievement_broadcasts
524 | 3623	general
525 | 3624	general
526 | 3625	skills
527 | 3626	combat
528 | 3627	minigames
529 | 3628	control_options
530 | 3629	keybinds
531 | 3630	graphics
532 | 3631	tooltips
533 | 3632	resizable
534 | 3633	modified_stats_overlay
535 | 3634	buff_bar
536 | 3635	options
537 | 3636	general
538 | 3637	teleports
539 | 3638	tablets
540 | 3639	items
541 | 3640	collection_log_new_addition_notification
542 | 3641	collection_log_new_addition_popup
543 | 3642	agility_helper
544 | 3643	highlight_agility_obstacles
545 | 3644	highlight_agility_shortcuts
546 | 3645	highlight_hovered_tile
547 | 3646	highlight_current_tile
548 | 3647	highlight_destination_tile
549 | 3648	highlight_hovered_tile_colour
550 | 3649	highlight_current_tile_colour
551 | 3650	highlight_destination_tile_colour
552 | 3651	highlight_hovered_tile_always_on_top
553 | 3652	highlight_current_tile_always_on_top
554 | 3653	highlight_destination_tile_always_on_top
555 | 3654	enable_minimap_zoom
556 | 3655	restore_minimap_zoom
557 | 3656	view_distance
558 | 3657	interface_scaling_mode
559 | 3658	remaining_ammo
560 | 


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/cg/StrictGenerator.kt:
--------------------------------------------------------------------------------
  1 | package org.runestar.cs2.cg
  2 | 
  3 | import org.runestar.cs2.ir.EventProperty
  4 | import org.runestar.cs2.bin.*
  5 | import org.runestar.cs2.SCRIPT_NAMES
  6 | import org.runestar.cs2.bin.StackType
  7 | import org.runestar.cs2.bin.Trigger
  8 | import org.runestar.cs2.cfa.Construct
  9 | import org.runestar.cs2.bin.int
 10 | import org.runestar.cs2.ir.Element
 11 | import org.runestar.cs2.ir.Expression
 12 | import org.runestar.cs2.ir.Function
 13 | import org.runestar.cs2.ir.FunctionSet
 14 | import org.runestar.cs2.ir.Instruction
 15 | import org.runestar.cs2.ir.Variable
 16 | import org.runestar.cs2.ir.asList
 17 | import org.runestar.cs2.ir.prototype
 18 | import org.runestar.cs2.bin.string
 19 | import org.runestar.cs2.ir.identifier
 20 | import org.runestar.cs2.ir.literal
 21 | 
 22 | fun StrictGenerator(writer: (scriptId: Int, scriptName: String, script: String) -> Unit) = object : StrictGenerator() {
 23 |     override fun write(scriptId: Int, scriptName: String, script: String) = writer(scriptId, scriptName, script)
 24 | }
 25 | 
 26 | abstract class StrictGenerator : Generator {
 27 | 
 28 |     final override fun write(f: Function, fs: FunctionSet, root: Construct) {
 29 |         var scriptName = SCRIPT_NAMES.load(f.id)
 30 |         if (scriptName == null) {
 31 |             var trigger = fs.callGraph.triggers[f.id]
 32 |             if (trigger == null) {
 33 |                 trigger = if (f.returnTypes.isNotEmpty()) Trigger.proc else Trigger.clientscript
 34 |             }
 35 |             scriptName = ScriptName(trigger, "script${f.id}")
 36 |         }
 37 |         val name = scriptName.toString()
 38 |         write(f.id, name, Writer(name, f, fs, root).write())
 39 |     }
 40 | 
 41 |     abstract fun write(scriptId: Int, scriptName: String, script: String)
 42 | }
 43 | 
 44 | private class Writer(
 45 |         private val name: String,
 46 |         private val f: Function,
 47 |         private val fs: FunctionSet,
 48 |         private val root: Construct,
 49 | ) {
 50 | 
 51 |     private val buf = StringBuilder()
 52 | 
 53 |     private var indents = 0
 54 | 
 55 |     private var inCalc = false
 56 | 
 57 |     private var endingLine = true
 58 | 
 59 |     private val definedLocalVariables = HashSet<Variable>(f.arguments)
 60 | 
 61 |     fun write(): String {
 62 |         append("// ").append(f.id).nextLine()
 63 |         append(name)
 64 |         if (f.arguments.isNotEmpty()) {
 65 |             append('(')
 66 |             val args = f.arguments.iterator()
 67 |             appendArg(args.next())
 68 |             for (arg in args) {
 69 |                 append(", ").appendArg(arg)
 70 |             }
 71 |             append(')')
 72 |         } else if (f.returnTypes.isNotEmpty()) {
 73 |             append("()")
 74 |         }
 75 |         if (f.returnTypes.isNotEmpty()) {
 76 |             append('(')
 77 |             val returnTypes = fs.typings.returns(f.id, f.returnTypes).iterator()
 78 |             append(returnTypes.next().literal)
 79 |             for (returnType in returnTypes) {
 80 |                 append(", ").append(returnType.literal)
 81 |             }
 82 |             append(')')
 83 |         }
 84 |         appendConstruct(root)
 85 |         if (endingLine) nextLine()
 86 |         return buf.toString()
 87 |     }
 88 | 
 89 |     private fun appendArg(arg: Variable) {
 90 |         append(fs.typings.of(arg).literal)
 91 |         if (arg is Variable.array) {
 92 |             append("array")
 93 |         }
 94 |         append(" $").appendVarIdentifier(arg)
 95 |     }
 96 | 
 97 |     private fun appendConstruct(construct: Construct) {
 98 |         when (construct) {
 99 |             is Construct.Seq -> appendSeq(construct)
100 |             is Construct.If -> appendIf(construct)
101 |             is Construct.While -> appendWhile(construct)
102 |             is Construct.Switch -> appendSwitch(construct)
103 |         }
104 |     }
105 | 
106 |     private fun appendSeq(construct: Construct.Seq) {
107 |         for (insn in construct.instructions) {
108 |             nextLine()
109 |             appendInsn(insn)
110 |         }
111 |         construct.next?.let { appendConstruct(it) }
112 |     }
113 | 
114 |     private fun appendIf(construct: Construct.If) {
115 |         nextLine()
116 |         val branches = construct.branches.iterator()
117 |         val if0 = branches.next()
118 |         append("if (").appendExpr(if0.condition).append(") {")
119 |         indent {
120 |             appendConstruct(if0.body)
121 |         }
122 |         nextLine()
123 |         append('}')
124 |         for (ifn in branches) {
125 |             append(" else if (").appendExpr(ifn.condition).append(") {")
126 |             indent {
127 |                 appendConstruct(ifn.body)
128 |             }
129 |             nextLine()
130 |             append('}')
131 |         }
132 |         val elze = construct.elze
133 |         if (elze != null) {
134 |             append(" else {")
135 |             indent {
136 |                 appendConstruct(elze)
137 |             }
138 |             nextLine()
139 |             append('}')
140 |         }
141 |         construct.next?.let { appendConstruct(it) }
142 |     }
143 | 
144 |     private fun appendWhile(construct: Construct.While) {
145 |         nextLine()
146 |         append("while (").appendExpr(construct.condition).append(") {")
147 |         indent {
148 |             appendConstruct(construct.body)
149 |         }
150 |         nextLine()
151 |         append('}')
152 |         construct.next?.let { appendConstruct(it) }
153 |     }
154 | 
155 |     private fun appendSwitch(construct: Construct.Switch) {
156 |         nextLine()
157 |         val prototype = fs.typings.of(construct.expression).single().prototype
158 |         append("switch_").append(prototype.literal).append(" (").appendExpr(construct.expression).append(") {")
159 |         for ((ns, body) in construct.cases) {
160 |             indent {
161 |                 nextLine()
162 |                 val cases = ns.iterator()
163 |                 append("case ").append(intConstantToString(cases.next(), prototype))
164 |                 for (case in cases) {
165 |                     append(", ").append(intConstantToString(case, prototype))
166 |                 }
167 |                 append(" :")
168 |                 indent {
169 |                     appendConstruct(body)
170 |                 }
171 |             }
172 |         }
173 |         val default = construct.default
174 |         if (default != null) {
175 |             indent {
176 |                 nextLine()
177 |                 append("case default :")
178 |                 indent {
179 |                     appendConstruct(default)
180 |                 }
181 |             }
182 |         }
183 |         nextLine()
184 |         append('}')
185 |         construct.next?.let { appendConstruct(it) }
186 |     }
187 | 
188 |     private fun appendInsn(insn: Instruction) {
189 |         when (insn) {
190 |             is Instruction.Assignment -> appendAssignment(insn)
191 |             is Instruction.Return -> {
192 |                 if (indents == 0 && f.returnTypes.isEmpty()) {
193 |                     endingLine = false
194 |                     return
195 |                 } else {
196 |                     append("return")
197 |                     val es = insn.expression.asList
198 |                     if (es.isNotEmpty()) {
199 |                         append('(').appendExprs(es).append(')')
200 |                     }
201 |                 }
202 |             }
203 |         }
204 |         append(';')
205 |     }
206 | 
207 |     private fun appendAssignment(insn: Instruction.Assignment) {
208 |         val defs = insn.definitions.asList as List<Element.Access>
209 |         if (defs.isNotEmpty()) {
210 |             if (defs.size == 1) {
211 |                 val def = defs.single()
212 |                 if (def.variable is Variable.Local && definedLocalVariables.add(def.variable)) {
213 |                     append("def_").append(fs.typings.of(def.variable).literal).append(' ')
214 |                 }
215 |                 appendVarAccess(def)
216 |             } else {
217 |                 appendExprs(defs)
218 |             }
219 |             append(" = ")
220 |         }
221 |         appendExpr(insn.expression)
222 |     }
223 | 
224 |     private fun appendExpr(expr: Expression): Writer = apply {
225 |         when (expr) {
226 |             is EventProperty -> append(expr.literal)
227 |             is Element.Access -> appendVarAccess(expr)
228 |             is Element.Pointer -> appendVarIdentifier(expr.variable)
229 |             is Element.Constant -> appendConst(expr)
230 |             is Expression.ClientScript -> appendClientScript(expr)
231 |             is Expression.Proc -> appendProc(expr)
232 |             is Expression.Operation -> appendOperation(expr)
233 |             is Expression.Compound -> appendExprs(expr.expressions)
234 |         }
235 |     }
236 | 
237 |     private fun appendVarAccess(e: Element.Access) = apply {
238 |         when (e.variable) {
239 |             is Variable.Local -> append('$')
240 |             is Variable.Global -> append('%')
241 |             else -> error(e)
242 |         }
243 |         appendVarIdentifier(e.variable)
244 |     }
245 | 
246 |     private fun appendVarIdentifier(v: Variable) = apply {
247 |         when (v) {
248 |             is Variable.int, is Variable.string, is Variable.array -> {
249 |                 val identifier = fs.typings.of(v).identifier
250 |                 append(identifier)
251 |                 if (v is Variable.array) {
252 |                     append("array")
253 |                 }
254 |                 append(v.id)
255 |             }
256 |             is Variable.varp -> append("var").append(v.id)
257 |             is Variable.varbit -> append("varbit").append(v.id)
258 |             is Variable.varcint -> append("varcint").append(v.id)
259 |             is Variable.varcstring -> append("varcstring").append(v.id)
260 |             is Variable.varclansetting -> append("varclansetting").append(v.id)
261 |             is Variable.varclan -> append("varclan").append(v.id)
262 |             else -> error(v)
263 |         }
264 |     }
265 | 
266 |     private fun appendConst(const: Element.Constant) {
267 |         when (const.value.stackType) {
268 |             StackType.STRING -> append('"').append(const.value.string).append('"')
269 |             StackType.INT -> append(intConstantToString(const.value.int, fs.typings.of(const).prototype))
270 |         }
271 |     }
272 | 
273 |     private fun appendOperation(expr: Expression.Operation) {
274 |         val args = expr.arguments.asList
275 |         val opcode = expr.opcode
276 |         when (opcode) {
277 |             DEFINE_ARRAY -> {
278 |                 val array = args[0] as Element.Access
279 |                 append("def_").append(fs.typings.of(array).literal).append(' ').appendVarAccess(array).append('(').appendExpr(args[1]).append(')')
280 |                 return
281 |             }
282 |             PUSH_ARRAY_INT -> {
283 |                 appendVarAccess(args[0] as Element.Access).append('(').appendExpr(args[1]).append(')')
284 |                 return
285 |             }
286 |             POP_ARRAY_INT -> {
287 |                 appendVarAccess(args[0] as Element.Access).append('(').appendExpr(args[1]).append(") = ").appendExpr(args[2])
288 |                 return
289 |             }
290 |             JOIN_STRING -> {
291 |                 append('"')
292 |                 for (a in args) {
293 |                     if (a is Element.Constant && a.value.stackType == StackType.STRING) {
294 |                         append(a.value.string)
295 |                     } else {
296 |                         append('<').appendExpr(a).append('>')
297 |                     }
298 |                 }
299 |                 append('"')
300 |                 return
301 |             }
302 |         }
303 |         val branchInfix = BRANCH_INFIX_MAP[expr.opcode]
304 |         val calcInfix = CALC_INFIX_MAP[expr.opcode]
305 |         if (branchInfix != null) {
306 |             appendBinaryOperation(args[0], expr, args[1], branchInfix)
307 |         } else if (calcInfix != null) {
308 |             val wasCalc = inCalc
309 |             if (!inCalc) {
310 |                 append("calc(")
311 |                 inCalc = true
312 |             }
313 |             appendBinaryOperation(args[0], expr, args[1], calcInfix)
314 |             inCalc = wasCalc
315 |             if (!inCalc) append(')')
316 |         } else {
317 |             if (expr.dot) {
318 |                 append('.')
319 |             }
320 |             append(expr.opcodeName)
321 |             if (args.isNotEmpty()) {
322 |                 append('(').appendExprs(args).append(')')
323 |             }
324 |         }
325 |     }
326 | 
327 |     private fun appendBinaryOperation(lhs: Expression, op: Expression.Operation, rhs: Expression, opText: String) {
328 |         appendExpressionPrec(lhs, op, false)
329 |         append(' ')
330 |         append(opText)
331 |         append(' ')
332 |         appendExpressionPrec(rhs, op, true)
333 |     }
334 | 
335 |     private fun appendExpressionPrec(expr: Expression, op: Expression.Operation, assoc: Boolean) {
336 |         val opPrec = PRECEDENCE_MAP[op.opcode] ?: error("Missing precedence for binary operation: ${op.opcode}")
337 |         val exprPrec = if (expr is Expression.Operation) PRECEDENCE_MAP[expr.opcode] ?: 0 else 0
338 |         val parenthesis = exprPrec > opPrec || (assoc && opPrec == exprPrec)
339 |         if (parenthesis) append('(')
340 |         appendExpr(expr)
341 |         if (parenthesis) append(')')
342 |     }
343 | 
344 |     private fun appendExprs(exprs: List<Expression>) = apply {
345 |         if (exprs.isEmpty()) return this
346 |         val es = exprs.iterator()
347 |         appendExpr(es.next())
348 |         for (e in es) {
349 |             append(", ").appendExpr(e)
350 |         }
351 |     }
352 | 
353 |     private fun appendClientScript(cs: Expression.ClientScript) {
354 |         val args = cs.arguments.asList
355 |         val triggers = cs.triggers.asList
356 |         val component = cs.component
357 |         if (cs.dot) {
358 |             append('.')
359 |         }
360 |         append(cs.opcodeName).append('(')
361 | 
362 |         if (cs.scriptId == -1) {
363 |             append(null)
364 |         } else {
365 |             val scriptName = SCRIPT_NAMES.load(cs.scriptId)
366 |             append('"')
367 |             if (scriptName == null) {
368 |                 append("script").append(cs.scriptId)
369 |             } else {
370 |                 require(scriptName.trigger == Trigger.clientscript) { "$scriptName must be a ${Trigger.clientscript}" }
371 |                 append(scriptName.name)
372 |             }
373 | 
374 |             if (args.isNotEmpty()) {
375 |                 append('(').appendExprs(args).append(')')
376 |             }
377 |             if (triggers.isNotEmpty()) {
378 |                 append('{').appendExprs(triggers).append('}')
379 |             }
380 |             append('"')
381 |         }
382 |         if (component != null) {
383 |             append(", ").appendExpr(component)
384 |         }
385 |         append(')')
386 |     }
387 | 
388 |     private fun appendProc(proc: Expression.Proc) {
389 |         val args = proc.arguments.asList
390 |         append('~')
391 |         val scriptName = SCRIPT_NAMES.load(proc.scriptId)
392 |         if (scriptName == null) {
393 |             append("script").append(proc.scriptId)
394 |         } else {
395 |             require(scriptName.trigger == Trigger.proc) { "$scriptName must be a ${Trigger.proc}" }
396 |             append(scriptName.name)
397 |         }
398 |         if (args.isNotEmpty()) {
399 |             append('(').appendExprs(args).append(')')
400 |         }
401 |     }
402 | 
403 |     private inline fun indent(action: () -> Unit) {
404 |         indents++
405 |         action()
406 |         indents--
407 |     }
408 | 
409 |     private fun nextLine() = apply {
410 |         append('\n')
411 |         repeat(indents) { append('\t') }
412 |     }
413 | 
414 |     private fun append(s: String?) = apply { buf.append(s) }
415 | 
416 |     private fun append(c: Char) = apply { buf.append(c) }
417 | 
418 |     private fun append(n: Int) = apply { buf.append(n) }
419 | }
420 | 
421 | val CALC_INFIX_MAP = mapOf(
422 |         ADD to "+",
423 |         SUB to "-",
424 |         MULTIPLY to "*",
425 |         DIV to "/",
426 |         MOD to "%",
427 |         AND to "&",
428 |         OR to "|"
429 | )
430 | 
431 | val BRANCH_INFIX_MAP = mapOf(
432 |         BRANCH_EQUALS to "=",
433 |         BRANCH_GREATER_THAN to ">",
434 |         BRANCH_GREATER_THAN_OR_EQUALS to ">=",
435 |         BRANCH_LESS_THAN to "<",
436 |         BRANCH_LESS_THAN_OR_EQUALS to "<=",
437 |         BRANCH_NOT to "!",
438 |         SS_OR to "|",
439 |         SS_AND to "&"
440 | )
441 | 
442 | val PRECEDENCE_MAP = mapOf(
443 |         // Calc ops
444 |         MULTIPLY to 1,
445 |         DIV to 1,
446 |         MOD to 1,
447 |         ADD to 2,
448 |         SUB to 2,
449 |         // Branch ops
450 |         BRANCH_GREATER_THAN to 3,
451 |         BRANCH_GREATER_THAN_OR_EQUALS to 3,
452 |         BRANCH_LESS_THAN to 3,
453 |         BRANCH_LESS_THAN_OR_EQUALS to 3,
454 |         BRANCH_EQUALS to 4,
455 |         BRANCH_NOT to 4,
456 |         AND to 5,
457 |         OR to 6,
458 |         SS_AND to 7,
459 |         SS_OR to 8
460 | )


--------------------------------------------------------------------------------
/src/main/resources/org/runestar/cs2/param-types.tsv:
--------------------------------------------------------------------------------
   1 | 0	0
   2 | 1	0
   3 | 2	0
   4 | 3	0
   5 | 4	0
   6 | 5	0
   7 | 6	0
   8 | 7	0
   9 | 8	0
  10 | 9	0
  11 | 10	0
  12 | 11	0
  13 | 12	0
  14 | 13	0
  15 | 14	0
  16 | 15	0
  17 | 16	0
  18 | 17	0
  19 | 18	0
  20 | 19	0
  21 | 20	0
  22 | 21	0
  23 | 22	0
  24 | 23	0
  25 | 24	0
  26 | 25	0
  27 | 26	0
  28 | 27	0
  29 | 28	0
  30 | 29	0
  31 | 30	0
  32 | 31	0
  33 | 32	0
  34 | 33	0
  35 | 34	0
  36 | 35	0
  37 | 36	0
  38 | 37	0
  39 | 38	0
  40 | 39	0
  41 | 40	0
  42 | 41	0
  43 | 42	0
  44 | 43	0
  45 | 44	0
  46 | 45	0
  47 | 46	0
  48 | 47	0
  49 | 48	0
  50 | 49	0
  51 | 50	0
  52 | 51	0
  53 | 52	0
  54 | 53	0
  55 | 54	0
  56 | 55	0
  57 | 56	0
  58 | 57	0
  59 | 58	0
  60 | 59	0
  61 | 60	0
  62 | 61	0
  63 | 62	0
  64 | 63	0
  65 | 64	0
  66 | 65	0
  67 | 66	0
  68 | 67	0
  69 | 68	0
  70 | 69	0
  71 | 70	0
  72 | 71	0
  73 | 72	0
  74 | 73	0
  75 | 74	0
  76 | 75	0
  77 | 76	0
  78 | 77	0
  79 | 78	0
  80 | 79	0
  81 | 80	0
  82 | 81	0
  83 | 82	0
  84 | 83	0
  85 | 84	0
  86 | 85	0
  87 | 86	0
  88 | 87	103
  89 | 88	0
  90 | 89	0
  91 | 90	0
  92 | 91	0
  93 | 92	0
  94 | 93	0
  95 | 94	0
  96 | 95	0
  97 | 96	0
  98 | 97	0
  99 | 98	0
 100 | 99	0
 101 | 100	0
 102 | 101	0
 103 | 102	0
 104 | 103	0
 105 | 104	0
 106 | 105	0
 107 | 106	0
 108 | 107	0
 109 | 108	0
 110 | 109	0
 111 | 110	0
 112 | 111	0
 113 | 112	0
 114 | 113	0
 115 | 114	0
 116 | 115	0
 117 | 116	0
 118 | 117	0
 119 | 118	0
 120 | 119	0
 121 | 120	0
 122 | 121	0
 123 | 122	0
 124 | 123	0
 125 | 124	0
 126 | 125	0
 127 | 126	0
 128 | 127	0
 129 | 128	0
 130 | 129	0
 131 | 130	0
 132 | 131	0
 133 | 132	0
 134 | 133	0
 135 | 134	0
 136 | 135	0
 137 | 136	0
 138 | 137	0
 139 | 138	0
 140 | 139	0
 141 | 140	0
 142 | 141	0
 143 | 142	0
 144 | 143	0
 145 | 144	0
 146 | 145	0
 147 | 146	0
 148 | 147	0
 149 | 148	105
 150 | 149	100
 151 | 150	79
 152 | 151	105
 153 | 152	105
 154 | 153	0
 155 | 154	0
 156 | 155	105
 157 | 156	0
 158 | 157	0
 159 | 158	0
 160 | 159	0
 161 | 160	0
 162 | 161	0
 163 | 162	0
 164 | 163	0
 165 | 164	0
 166 | 165	0
 167 | 166	0
 168 | 167	0
 169 | 168	0
 170 | 169	0
 171 | 170	0
 172 | 171	0
 173 | 172	0
 174 | 173	0
 175 | 174	0
 176 | 175	0
 177 | 176	0
 178 | 177	0
 179 | 178	0
 180 | 179	0
 181 | 180	0
 182 | 181	0
 183 | 182	0
 184 | 183	0
 185 | 184	0
 186 | 185	0
 187 | 186	109
 188 | 187	0
 189 | 188	0
 190 | 189	0
 191 | 190	0
 192 | 191	105
 193 | 192	0
 194 | 193	0
 195 | 194	0
 196 | 195	0
 197 | 196	0
 198 | 197	0
 199 | 198	0
 200 | 199	0
 201 | 200	0
 202 | 201	0
 203 | 202	0
 204 | 203	0
 205 | 204	0
 206 | 205	0
 207 | 206	0
 208 | 207	0
 209 | 208	0
 210 | 209	0
 211 | 210	0
 212 | 211	0
 213 | 212	0
 214 | 213	0
 215 | 214	0
 216 | 215	0
 217 | 216	0
 218 | 217	0
 219 | 218	0
 220 | 219	0
 221 | 220	0
 222 | 221	0
 223 | 222	0
 224 | 223	0
 225 | 224	0
 226 | 225	0
 227 | 226	0
 228 | 227	0
 229 | 228	0
 230 | 229	0
 231 | 230	0
 232 | 231	0
 233 | 232	0
 234 | 233	0
 235 | 234	0
 236 | 235	0
 237 | 236	0
 238 | 237	0
 239 | 238	0
 240 | 239	0
 241 | 240	0
 242 | 241	0
 243 | 242	0
 244 | 243	0
 245 | 244	0
 246 | 245	0
 247 | 246	0
 248 | 247	0
 249 | 248	0
 250 | 249	0
 251 | 250	0
 252 | 251	0
 253 | 252	0
 254 | 253	0
 255 | 254	0
 256 | 255	0
 257 | 256	0
 258 | 257	0
 259 | 258	0
 260 | 259	0
 261 | 260	0
 262 | 261	0
 263 | 262	0
 264 | 263	0
 265 | 264	0
 266 | 265	0
 267 | 266	0
 268 | 267	0
 269 | 268	0
 270 | 269	0
 271 | 270	0
 272 | 271	0
 273 | 272	0
 274 | 273	0
 275 | 274	0
 276 | 275	0
 277 | 276	0
 278 | 277	0
 279 | 278	0
 280 | 279	0
 281 | 280	0
 282 | 281	0
 283 | 282	0
 284 | 283	0
 285 | 284	0
 286 | 285	0
 287 | 286	0
 288 | 287	0
 289 | 288	0
 290 | 289	0
 291 | 290	0
 292 | 291	0
 293 | 292	0
 294 | 293	0
 295 | 294	0
 296 | 295	0
 297 | 296	0
 298 | 297	0
 299 | 298	0
 300 | 299	0
 301 | 300	0
 302 | 301	0
 303 | 302	0
 304 | 303	0
 305 | 304	0
 306 | 305	0
 307 | 306	0
 308 | 307	0
 309 | 308	0
 310 | 309	0
 311 | 310	0
 312 | 311	0
 313 | 312	0
 314 | 313	0
 315 | 314	0
 316 | 315	0
 317 | 316	0
 318 | 317	0
 319 | 318	0
 320 | 319	0
 321 | 320	0
 322 | 321	0
 323 | 322	0
 324 | 323	0
 325 | 324	0
 326 | 325	0
 327 | 326	0
 328 | 327	0
 329 | 328	0
 330 | 329	0
 331 | 330	0
 332 | 331	0
 333 | 332	0
 334 | 333	0
 335 | 334	0
 336 | 335	0
 337 | 336	105
 338 | 337	0
 339 | 338	0
 340 | 339	0
 341 | 340	0
 342 | 341	0
 343 | 342	0
 344 | 343	0
 345 | 344	0
 346 | 345	0
 347 | 346	0
 348 | 347	0
 349 | 348	0
 350 | 349	0
 351 | 350	0
 352 | 351	0
 353 | 352	0
 354 | 353	0
 355 | 354	0
 356 | 355	0
 357 | 356	0
 358 | 357	0
 359 | 358	0
 360 | 359	0
 361 | 360	0
 362 | 361	0
 363 | 362	0
 364 | 363	115
 365 | 364	0
 366 | 365	111
 367 | 366	105
 368 | 367	111
 369 | 368	105
 370 | 369	111
 371 | 370	105
 372 | 371	0
 373 | 372	0
 374 | 373	0
 375 | 374	0
 376 | 375	0
 377 | 376	0
 378 | 377	0
 379 | 378	0
 380 | 379	0
 381 | 380	0
 382 | 381	0
 383 | 382	0
 384 | 383	0
 385 | 384	0
 386 | 385	105
 387 | 386	0
 388 | 387	0
 389 | 388	0
 390 | 389	0
 391 | 390	0
 392 | 391	0
 393 | 392	0
 394 | 393	0
 395 | 394	0
 396 | 395	0
 397 | 396	0
 398 | 397	0
 399 | 398	0
 400 | 399	0
 401 | 400	0
 402 | 401	105
 403 | 402	0
 404 | 403	0
 405 | 404	0
 406 | 405	0
 407 | 406	0
 408 | 407	0
 409 | 408	0
 410 | 409	0
 411 | 410	0
 412 | 411	0
 413 | 412	0
 414 | 413	0
 415 | 414	0
 416 | 415	0
 417 | 416	0
 418 | 417	0
 419 | 418	0
 420 | 419	0
 421 | 420	0
 422 | 421	0
 423 | 422	0
 424 | 423	0
 425 | 424	0
 426 | 425	0
 427 | 426	0
 428 | 427	0
 429 | 428	0
 430 | 429	0
 431 | 430	0
 432 | 431	0
 433 | 432	0
 434 | 433	0
 435 | 434	0
 436 | 435	0
 437 | 436	0
 438 | 437	0
 439 | 438	0
 440 | 439	0
 441 | 440	0
 442 | 441	0
 443 | 442	0
 444 | 443	0
 445 | 444	0
 446 | 445	0
 447 | 446	103
 448 | 447	0
 449 | 448	0
 450 | 449	0
 451 | 450	0
 452 | 451	115
 453 | 452	115
 454 | 453	115
 455 | 454	115
 456 | 455	115
 457 | 456	115
 458 | 457	115
 459 | 458	115
 460 | 459	100
 461 | 460	100
 462 | 461	100
 463 | 462	105
 464 | 463	0
 465 | 464	0
 466 | 465	0
 467 | 466	0
 468 | 467	0
 469 | 468	0
 470 | 469	0
 471 | 470	0
 472 | 471	0
 473 | 472	0
 474 | 473	0
 475 | 474	0
 476 | 475	0
 477 | 476	0
 478 | 477	0
 479 | 478	0
 480 | 479	0
 481 | 480	0
 482 | 481	0
 483 | 482	0
 484 | 483	0
 485 | 484	0
 486 | 485	0
 487 | 486	0
 488 | 487	0
 489 | 488	0
 490 | 489	0
 491 | 490	0
 492 | 491	0
 493 | 492	0
 494 | 493	0
 495 | 494	0
 496 | 495	0
 497 | 496	0
 498 | 497	0
 499 | 498	0
 500 | 499	0
 501 | 500	0
 502 | 501	0
 503 | 502	0
 504 | 503	0
 505 | 504	0
 506 | 505	0
 507 | 506	115
 508 | 507	0
 509 | 508	0
 510 | 509	105
 511 | 510	115
 512 | 511	0
 513 | 512	0
 514 | 513	0
 515 | 514	0
 516 | 515	0
 517 | 516	0
 518 | 517	0
 519 | 518	0
 520 | 519	0
 521 | 520	0
 522 | 521	0
 523 | 522	0
 524 | 523	0
 525 | 524	0
 526 | 525	0
 527 | 526	0
 528 | 527	0
 529 | 528	105
 530 | 529	0
 531 | 530	0
 532 | 531	0
 533 | 532	0
 534 | 533	0
 535 | 534	0
 536 | 535	0
 537 | 536	0
 538 | 537	0
 539 | 538	0
 540 | 539	0
 541 | 540	0
 542 | 541	0
 543 | 542	0
 544 | 543	0
 545 | 544	0
 546 | 545	0
 547 | 546	105
 548 | 547	0
 549 | 548	0
 550 | 549	0
 551 | 550	0
 552 | 551	0
 553 | 552	105
 554 | 553	0
 555 | 554	0
 556 | 555	0
 557 | 556	0
 558 | 557	0
 559 | 558	0
 560 | 559	115
 561 | 560	0
 562 | 561	0
 563 | 562	0
 564 | 563	0
 565 | 564	0
 566 | 565	0
 567 | 566	0
 568 | 567	0
 569 | 568	105
 570 | 569	79
 571 | 570	0
 572 | 571	0
 573 | 572	0
 574 | 573	0
 575 | 574	0
 576 | 575	0
 577 | 576	0
 578 | 577	0
 579 | 578	79
 580 | 579	115
 581 | 580	0
 582 | 581	0
 583 | 582	0
 584 | 583	0
 585 | 584	0
 586 | 585	0
 587 | 586	0
 588 | 587	0
 589 | 588	0
 590 | 589	0
 591 | 590	0
 592 | 591	0
 593 | 592	0
 594 | 593	0
 595 | 594	0
 596 | 595	115
 597 | 596	73
 598 | 597	100
 599 | 598	100
 600 | 599	100
 601 | 600	100
 602 | 601	115
 603 | 602	115
 604 | 603	49
 605 | 604	105
 606 | 605	105
 607 | 606	111
 608 | 607	105
 609 | 608	111
 610 | 609	0
 611 | 610	115
 612 | 611	105
 613 | 612	105
 614 | 613	105
 615 | 614	105
 616 | 615	105
 617 | 616	83
 618 | 617	105
 619 | 618	83
 620 | 619	105
 621 | 620	83
 622 | 621	105
 623 | 622	83
 624 | 623	105
 625 | 624	83
 626 | 625	105
 627 | 626	83
 628 | 627	105
 629 | 628	83
 630 | 629	105
 631 | 630	83
 632 | 631	105
 633 | 632	83
 634 | 633	105
 635 | 634	83
 636 | 635	105
 637 | 636	83
 638 | 637	105
 639 | 638	83
 640 | 639	105
 641 | 640	83
 642 | 641	105
 643 | 642	83
 644 | 643	105
 645 | 644	83
 646 | 645	105
 647 | 646	83
 648 | 647	105
 649 | 648	74
 650 | 649	74
 651 | 650	74
 652 | 651	74
 653 | 652	74
 654 | 653	74
 655 | 654	74
 656 | 655	105
 657 | 656	105
 658 | 657	105
 659 | 658	0
 660 | 659	105
 661 | 660	115
 662 | 661	108
 663 | 662	108
 664 | 663	108
 665 | 664	79
 666 | 665	79
 667 | 666	79
 668 | 667	79
 669 | 668	105
 670 | 669	105
 671 | 670	105
 672 | 671	105
 673 | 672	83
 674 | 673	105
 675 | 674	105
 676 | 675	100
 677 | 676	100
 678 | 677	100
 679 | 678	100
 680 | 679	74
 681 | 680	74
 682 | 681	105
 683 | 682	115
 684 | 683	103
 685 | 684	105
 686 | 685	73
 687 | 686	73
 688 | 687	73
 689 | 688	73
 690 | 689	115
 691 | 690	103
 692 | 691	0
 693 | 692	0
 694 | 693	0
 695 | 694	0
 696 | 695	0
 697 | 696	0
 698 | 697	0
 699 | 698	0
 700 | 699	0
 701 | 700	0
 702 | 701	0
 703 | 702	0
 704 | 703	0
 705 | 704	0
 706 | 705	0
 707 | 706	0
 708 | 707	0
 709 | 708	0
 710 | 709	105
 711 | 710	0
 712 | 711	0
 713 | 712	0
 714 | 713	0
 715 | 714	0
 716 | 715	0
 717 | 716	0
 718 | 717	0
 719 | 718	0
 720 | 719	0
 721 | 720	0
 722 | 721	0
 723 | 722	0
 724 | 723	0
 725 | 724	0
 726 | 725	0
 727 | 726	0
 728 | 727	0
 729 | 728	0
 730 | 729	115
 731 | 730	0
 732 | 731	0
 733 | 732	115
 734 | 733	111
 735 | 734	111
 736 | 735	105
 737 | 736	105
 738 | 737	111
 739 | 738	115
 740 | 739	49
 741 | 740	49
 742 | 741	49
 743 | 742	49
 744 | 743	105
 745 | 744	115
 746 | 745	103
 747 | 746	0
 748 | 747	0
 749 | 748	0
 750 | 749	0
 751 | 750	0
 752 | 751	0
 753 | 752	0
 754 | 753	0
 755 | 754	0
 756 | 755	0
 757 | 756	0
 758 | 757	0
 759 | 758	0
 760 | 759	0
 761 | 760	0
 762 | 761	0
 763 | 762	0
 764 | 763	0
 765 | 764	0
 766 | 765	0
 767 | 766	0
 768 | 767	0
 769 | 768	0
 770 | 769	0
 771 | 770	0
 772 | 771	0
 773 | 772	0
 774 | 773	0
 775 | 774	0
 776 | 775	0
 777 | 776	0
 778 | 777	0
 779 | 778	0
 780 | 779	0
 781 | 780	0
 782 | 781	0
 783 | 782	0
 784 | 783	0
 785 | 784	0
 786 | 785	0
 787 | 786	0
 788 | 787	0
 789 | 788	0
 790 | 789	0
 791 | 790	0
 792 | 791	0
 793 | 792	0
 794 | 793	0
 795 | 794	0
 796 | 795	0
 797 | 796	0
 798 | 797	0
 799 | 798	0
 800 | 799	0
 801 | 800	0
 802 | 801	0
 803 | 802	0
 804 | 803	0
 805 | 804	0
 806 | 805	0
 807 | 806	105
 808 | 807	105
 809 | 808	74
 810 | 809	105
 811 | 810	115
 812 | 811	100
 813 | 812	115
 814 | 813	115
 815 | 814	115
 816 | 815	83
 817 | 816	105
 818 | 817	0
 819 | 818	105
 820 | 819	111
 821 | 820	103
 822 | 821	103
 823 | 822	100
 824 | 823	115
 825 | 824	115
 826 | 825	49
 827 | 826	105
 828 | 827	74
 829 | 828	115
 830 | 829	105
 831 | 830	100
 832 | 831	100
 833 | 832	0
 834 | 833	103
 835 | 834	49
 836 | 835	0
 837 | 836	0
 838 | 837	110
 839 | 838	103
 840 | 839	103
 841 | 840	103
 842 | 841	103
 843 | 842	115
 844 | 843	115
 845 | 844	105
 846 | 845	105
 847 | 846	0
 848 | 847	0
 849 | 848	0
 850 | 849	0
 851 | 850	105
 852 | 851	0
 853 | 852	105
 854 | 853	115
 855 | 854	115
 856 | 855	111
 857 | 856	0
 858 | 857	0
 859 | 858	115
 860 | 859	0
 861 | 860	0
 862 | 861	0
 863 | 862	0
 864 | 863	0
 865 | 864	99
 866 | 865	105
 867 | 866	103
 868 | 867	103
 869 | 868	103
 870 | 869	103
 871 | 870	103
 872 | 871	105
 873 | 872	105
 874 | 873	105
 875 | 874	115
 876 | 875	115
 877 | 876	105
 878 | 877	105
 879 | 878	103
 880 | 879	115
 881 | 880	115
 882 | 881	100
 883 | 882	100
 884 | 883	100
 885 | 884	100
 886 | 885	105
 887 | 886	103
 888 | 887	103
 889 | 888	103
 890 | 889	103
 891 | 890	103
 892 | 891	103
 893 | 892	103
 894 | 893	103
 895 | 894	103
 896 | 895	103
 897 | 896	105
 898 | 897	0
 899 | 898	0
 900 | 899	0
 901 | 900	0
 902 | 901	79
 903 | 902	79
 904 | 903	79
 905 | 904	115
 906 | 905	115
 907 | 906	115
 908 | 907	105
 909 | 908	105
 910 | 909	105
 911 | 910	100
 912 | 911	100
 913 | 912	100
 914 | 913	49
 915 | 914	115
 916 | 915	103
 917 | 916	105
 918 | 917	105
 919 | 918	105
 920 | 919	0
 921 | 920	0
 922 | 921	0
 923 | 922	0
 924 | 923	105
 925 | 924	0
 926 | 925	49
 927 | 926	105
 928 | 927	99
 929 | 928	-75
 930 | 929	49
 931 | 930	110
 932 | 931	105
 933 | 932	99
 934 | 933	121
 935 | 934	103
 936 | 935	121
 937 | 936	115
 938 | 937	0
 939 | 938	115
 940 | 939	0
 941 | 940	0
 942 | 941	0
 943 | 942	0
 944 | 943	105
 945 | 944	105
 946 | 945	105
 947 | 946	105
 948 | 947	105
 949 | 948	105
 950 | 949	0
 951 | 950	0
 952 | 951	0
 953 | 952	0
 954 | 953	0
 955 | 954	0
 956 | 955	0
 957 | 956	0
 958 | 957	0
 959 | 958	0
 960 | 959	0
 961 | 960	0
 962 | 961	0
 963 | 962	0
 964 | 963	0
 965 | 964	0
 966 | 965	0
 967 | 966	0
 968 | 967	0
 969 | 968	0
 970 | 969	0
 971 | 970	0
 972 | 971	0
 973 | 972	0
 974 | 973	0
 975 | 974	0
 976 | 975	0
 977 | 976	0
 978 | 977	0
 979 | 978	0
 980 | 979	0
 981 | 980	0
 982 | 981	0
 983 | 982	0
 984 | 983	103
 985 | 984	0
 986 | 985	115
 987 | 986	49
 988 | 987	0
 989 | 988	0
 990 | 989	103
 991 | 990	0
 992 | 991	0
 993 | 992	0
 994 | 993	0
 995 | 994	0
 996 | 995	0
 997 | 996	0
 998 | 997	0
 999 | 998	0
1000 | 999	0
1001 | 1000	0
1002 | 1001	0
1003 | 1002	0
1004 | 1003	0
1005 | 1004	0
1006 | 1005	0
1007 | 1006	0
1008 | 1007	0
1009 | 1008	0
1010 | 1009	0
1011 | 1010	105
1012 | 1011	103
1013 | 1012	115
1014 | 1013	115
1015 | 1014	115
1016 | 1015	115
1017 | 1016	105
1018 | 1017	105
1019 | 1018	105
1020 | 1019	74
1021 | 1020	115
1022 | 1021	116
1023 | 1022	100
1024 | 1023	100
1025 | 1024	100
1026 | 1025	100
1027 | 1026	100
1028 | 1027	105
1029 | 1028	105
1030 | 1029	105
1031 | 1030	49
1032 | 1031	100
1033 | 1032	100
1034 | 1033	74
1035 | 1034	103
1036 | 1035	103
1037 | 1036	103
1038 | 1037	103
1039 | 1038	103
1040 | 1039	105
1041 | 1040	105
1042 | 1041	105
1043 | 1042	115
1044 | 1043	115
1045 | 1044	115
1046 | 1045	0
1047 | 1046	0
1048 | 1047	0
1049 | 1048	0
1050 | 1049	0
1051 | 1050	0
1052 | 1051	0
1053 | 1052	0
1054 | 1053	0
1055 | 1054	0
1056 | 1055	115
1057 | 1056	105
1058 | 1057	111
1059 | 1058	105
1060 | 1059	105
1061 | 1060	105
1062 | 1061	111
1063 | 1062	105
1064 | 1063	111
1065 | 1064	105
1066 | 1065	111
1067 | 1066	105
1068 | 1067	111
1069 | 1068	105
1070 | 1069	111
1071 | 1070	105
1072 | 1071	111
1073 | 1072	105
1074 | 1073	0
1075 | 1074	0
1076 | 1075	0
1077 | 1076	0
1078 | 1077	105
1079 | 1078	105
1080 | 1079	105
1081 | 1080	103
1082 | 1081	103
1083 | 1082	103
1084 | 1083	103
1085 | 1084	49
1086 | 1085	49
1087 | 1086	115
1088 | 1087	115
1089 | 1088	115
1090 | 1089	105
1091 | 1090	105
1092 | 1091	103
1093 | 1092	103
1094 | 1093	105
1095 | 1094	49
1096 | 1095	49
1097 | 1096	115
1098 | 1097	115
1099 | 1098	100
1100 | 1099	99
1101 | 1100	105
1102 | 1101	105
1103 | 1102	105
1104 | 1103	103
1105 | 1104	115
1106 | 1105	49
1107 | 1106	49
1108 | 1107	49
1109 | 1108	49
1110 | 1109	105
1111 | 1110	105
1112 | 1111	115
1113 | 1112	115
1114 | 1113	115
1115 | 1114	115
1116 | 1115	49
1117 | 1116	115
1118 | 1117	115
1119 | 1118	49
1120 | 1119	49
1121 | 1120	0
1122 | 1121	0
1123 | 1122	0
1124 | 1123	0
1125 | 1124	0
1126 | 1125	0
1127 | 1126	0
1128 | 1127	0
1129 | 1128	0
1130 | 1129	0
1131 | 1130	0
1132 | 1131	0
1133 | 1132	0
1134 | 1133	0
1135 | 1134	99
1136 | 1135	99
1137 | 1136	99
1138 | 1137	105
1139 | 1138	0
1140 | 1139	0
1141 | 1140	0
1142 | 1141	0
1143 | 1142	0
1144 | 1143	100
1145 | 1144	100
1146 | 1145	103
1147 | 1146	103
1148 | 1147	103
1149 | 1148	0
1150 | 1149	0
1151 | 1150	0
1152 | 1151	0
1153 | 1152	105
1154 | 1153	0
1155 | 1154	0
1156 | 1155	0
1157 | 1156	0
1158 | 1157	49
1159 | 1158	49
1160 | 1159	105
1161 | 1160	105
1162 | 1161	105
1163 | 1162	105
1164 | 1163	49
1165 | 1164	0
1166 | 1165	0
1167 | 1166	0
1168 | 1167	0
1169 | 1168	0
1170 | 1169	0
1171 | 1170	0
1172 | 1171	0
1173 | 1172	0
1174 | 1173	0
1175 | 1174	0
1176 | 1175	0
1177 | 1176	0
1178 | 1177	0
1179 | 1178	0
1180 | 1179	0
1181 | 1180	0
1182 | 1181	0
1183 | 1182	115
1184 | 1183	115
1185 | 1184	109
1186 | 1185	105
1187 | 1186	49
1188 | 1187	83
1189 | 1188	105
1190 | 1189	74
1191 | 1190	105
1192 | 1191	0
1193 | 1192	0
1194 | 1193	0
1195 | 1194	0
1196 | 1195	0
1197 | 1196	0
1198 | 1197	0
1199 | 1198	0
1200 | 1199	0
1201 | 1200	0
1202 | 1201	0
1203 | 1202	0
1204 | 1203	0
1205 | 1204	0
1206 | 1205	0
1207 | 1206	0
1208 | 1207	0
1209 | 1208	0
1210 | 1209	0
1211 | 1210	0
1212 | 1211	0
1213 | 1212	0
1214 | 1213	0
1215 | 1214	0
1216 | 1215	0
1217 | 1216	0
1218 | 1217	0
1219 | 1218	0
1220 | 1219	0
1221 | 1220	0
1222 | 1221	0
1223 | 1222	0
1224 | 1223	0
1225 | 1224	0
1226 | 1225	0
1227 | 1226	0
1228 | 1227	0
1229 | 1228	49
1230 | 1229	49
1231 | 1230	105
1232 | 1231	105
1233 | 1232	115
1234 | 1233	115
1235 | 1234	105
1236 | 1235	73
1237 | 1236	73
1238 | 1237	109
1239 | 1238	109
1240 | 1239	80
1241 | 1240	115
1242 | 1241	105
1243 | 1242	0
1244 | 1243	105
1245 | 1244	105
1246 | 1245	0
1247 | 1246	0
1248 | 1247	0
1249 | 1248	0
1250 | 1249	0
1251 | 1250	0
1252 | 1251	115
1253 | 1252	115
1254 | 1253	105
1255 | 1254	74
1256 | 1255	49
1257 | 1256	0
1258 | 1257	0
1259 | 1258	0
1260 | 1259	0
1261 | 1260	0
1262 | 1261	0
1263 | 1262	105
1264 | 1263	0
1265 | 1264	49
1266 | 1265	79
1267 | 1266	103
1268 | 1267	49
1269 | 1268	79
1270 | 1269	103
1271 | 1270	79
1272 | 1271	49
1273 | 1272	49
1274 | 1273	49
1275 | 1274	74
1276 | 1275	105
1277 | 1276	105
1278 | 1277	105
1279 | 1278	100
1280 | 1279	115
1281 | 1280	99
1282 | 1281	79
1283 | 1282	49
1284 | 1283	118
1285 | 1284	99
1286 | 1285	103
1287 | 1286	103
1288 | 1287	0
1289 | 1288	49
1290 | 1289	105
1291 | 1290	49
1292 | 1291	105
1293 | 1292	49
1294 | 1293	0
1295 | 1294	0
1296 | 1295	0
1297 | 1296	0
1298 | 1297	49
1299 | 1298	99
1300 | 1299	49
1301 | 1300	115
1302 | 1301	115
1303 | 1302	105
1304 | 1303	105
1305 | 1304	115
1306 | 1305	115
1307 | 1306	105
1308 | 1307	74
1309 | 1308	115
1310 | 1309	115
1311 | 1310	105
1312 | 1311	105
1313 | 1312	105
1314 | 1313	115
1315 | 1314	105
1316 | 1315	105
1317 | 1316	100
1318 | 1317	99
1319 | 1318	-75
1320 | 1319	115
1321 | 1320	115
1322 | 1321	115
1323 | 1322	109
1324 | 1323	65
1325 | 1324	105
1326 | 1325	105
1327 | 1326	105
1328 | 1327	105
1329 | 1328	105
1330 | 1329	105
1331 | 1330	115
1332 | 1331	100
1333 | 1332	100
1334 | 1333	111
1335 | 1334	103
1336 | 1335	111
1337 | 1336	103
1338 | 1337	111
1339 | 1338	111
1340 | 1339	103
1341 | 1340	0
1342 | 1341	0
1343 | 1342	0
1344 | 1343	0
1345 | 1344	0
1346 | 1345	0
1347 | 1346	-75
1348 | 1347	108
1349 | 1348	99
1350 | 1349	110
1351 | 1350	103
1352 | 1351	105
1353 | 1352	49
1354 | 


--------------------------------------------------------------------------------
/src/main/java/org/runestar/cs2/bin/Opcodes.kt:
--------------------------------------------------------------------------------
  1 | package org.runestar.cs2.bin
  2 | 
  3 | import org.runestar.cs2.util.thisClass
  4 | 
  5 | val opcodes: Map<String, Int> = thisClass.declaredFields.filter { it.type == Integer.TYPE }.associate { it.name to it.getInt(null) }
  6 | val opcodeNames: Map<Int, String> = opcodes.entries.associate { it.value to it.key.toLowerCase() }
  7 | 
  8 | const val SS_AND = -2
  9 | const val SS_OR = -1
 10 | 
 11 | const val PUSH_CONSTANT_INT = 0
 12 | const val PUSH_VAR = 1
 13 | const val POP_VAR = 2
 14 | const val PUSH_CONSTANT_STRING = 3
 15 | const val BRANCH = 6
 16 | const val BRANCH_NOT = 7
 17 | const val BRANCH_EQUALS = 8
 18 | const val BRANCH_LESS_THAN = 9
 19 | const val BRANCH_GREATER_THAN = 10
 20 | const val RETURN = 21
 21 | const val PUSH_VARBIT = 25
 22 | const val POP_VARBIT = 27
 23 | const val BRANCH_LESS_THAN_OR_EQUALS = 31
 24 | const val BRANCH_GREATER_THAN_OR_EQUALS = 32
 25 | const val PUSH_INT_LOCAL = 33
 26 | const val POP_INT_LOCAL = 34
 27 | const val PUSH_STRING_LOCAL = 35
 28 | const val POP_STRING_LOCAL = 36
 29 | const val JOIN_STRING = 37
 30 | const val POP_INT_DISCARD = 38
 31 | const val POP_STRING_DISCARD = 39
 32 | const val GOSUB_WITH_PARAMS = 40
 33 | const val PUSH_VARC_INT = 42
 34 | const val POP_VARC_INT = 43
 35 | const val DEFINE_ARRAY = 44
 36 | const val PUSH_ARRAY_INT = 45
 37 | const val POP_ARRAY_INT = 46
 38 | const val PUSH_VARC_STRING_OLD = 47
 39 | const val POP_VARC_STRING_OLD = 48
 40 | const val PUSH_VARC_STRING = 49
 41 | const val POP_VARC_STRING = 50
 42 | const val SWITCH = 60
 43 | const val PUSH_VARCLANSETTING = 74
 44 | const val PUSH_VARCLAN = 76
 45 | const val CC_CREATE = 100
 46 | const val CC_DELETE = 101
 47 | const val _103 = 103
 48 | const val _104 = 104
 49 | const val CC_DELETEALL = 102
 50 | const val CC_FIND = 200
 51 | const val IF_FIND = 201
 52 | const val _202 = 202
 53 | const val _203 = 202
 54 | const val CC_SETPOSITION = 1000
 55 | const val CC_SETSIZE = 1001
 56 | const val CC_SETHIDE = 1003
 57 | const val CC_SETNOCLICKTHROUGH = 1005
 58 | const val CC_SETNOSCROLLTHROUGH = 1006
 59 | const val CC_SETSCROLLPOS = 1100
 60 | const val CC_SETCOLOUR = 1101
 61 | const val CC_SETFILL = 1102
 62 | const val CC_SETTRANS = 1103
 63 | const val CC_SETLINEWID = 1104
 64 | const val CC_SETGRAPHIC = 1105
 65 | const val CC_SET2DANGLE = 1106
 66 | const val CC_SETTILING = 1107
 67 | const val CC_SETMODEL = 1108
 68 | const val CC_SETMODELANGLE = 1109
 69 | const val CC_SETMODELANIM = 1110
 70 | const val CC_SETMODELORTHOG = 1111
 71 | const val CC_SETTEXT = 1112
 72 | const val CC_SETTEXTFONT = 1113
 73 | const val CC_SETTEXTALIGN = 1114
 74 | const val CC_SETTEXTSHADOW = 1115
 75 | const val CC_SETOUTLINE = 1116
 76 | const val CC_SETGRAPHICSHADOW = 1117
 77 | const val CC_SETVFLIP = 1118
 78 | const val CC_SETHFLIP = 1119
 79 | const val CC_SETSCROLLSIZE = 1120
 80 | const val CC_RESUME_PAUSEBUTTON = 1121
 81 | const val _1122 = 1122
 82 | const val CC_SETFILLCOLOUR = 1123
 83 | const val _1124 = 1124
 84 | const val _1125 = 1125
 85 | const val CC_SETLINEDIRECTION = 1126
 86 | const val CC_SETMODELTRANSPARENT = 1127
 87 | const val _1128 = 1128
 88 | const val CC_SETOBJECT = 1200
 89 | const val CC_SETNPCHEAD = 1201
 90 | const val CC_SETPLAYERHEAD_SELF = 1202
 91 | const val CC_SETOBJECT_NONUM = 1205
 92 | const val CC_SETOBJECT_ALWAYS_NUM = 1212
 93 | const val CC_SETOP = 1300
 94 | const val CC_SETDRAGGABLE = 1301
 95 | const val CC_SETDRAGGABLEBEHAVIOR = 1302
 96 | const val CC_SETDRAGDEADZONE = 1303
 97 | const val CC_SETDRAGDEADTIME = 1304
 98 | const val CC_SETOPBASE = 1305
 99 | const val CC_SETTARGETVERB = 1306
100 | const val CC_CLEAROPS = 1307
101 | const val _1308 = 1308
102 | const val _1309 = 1309
103 | const val CC_SETOPKEY = 1350
104 | const val CC_SETOPTKEY = 1351
105 | const val CC_SETOPKEYRATE = 1352
106 | const val CC_SETOPTKEYRATE = 1353
107 | const val CC_SETOPKEYIGNOREHELD = 1354
108 | const val CC_SETOPTKEYIGNOREHELD = 1355
109 | const val CC_SETONCLICK = 1400
110 | const val CC_SETONHOLD = 1401
111 | const val CC_SETONRELEASE = 1402
112 | const val CC_SETONMOUSEOVER = 1403
113 | const val CC_SETONMOUSELEAVE = 1404
114 | const val CC_SETONDRAG = 1405
115 | const val CC_SETONTARGETLEAVE = 1406
116 | const val CC_SETONVARTRANSMIT = 1407
117 | const val CC_SETONTIMER = 1408
118 | const val CC_SETONOP = 1409
119 | const val CC_SETONDRAGCOMPLETE = 1410
120 | const val CC_SETONCLICKREPEAT = 1411
121 | const val CC_SETONMOUSEREPEAT = 1412
122 | const val CC_SETONINVTRANSMIT = 1414
123 | const val CC_SETONSTATTRANSMIT = 1415
124 | const val CC_SETONTARGETENTER = 1416
125 | const val CC_SETONSCROLLWHEEL = 1417
126 | const val CC_SETONCHATTRANSMIT = 1418
127 | const val CC_SETONKEY = 1419
128 | const val CC_SETONFRIENDTRANSMIT = 1420
129 | const val CC_SETONCLANTRANSMIT = 1421
130 | const val CC_SETONMISCTRANSMIT = 1422
131 | const val CC_SETONDIALOGABORT = 1423
132 | const val CC_SETONSUBCHANGE = 1424
133 | const val CC_SETONSTOCKTRANSMIT = 1425
134 | const val _1426 = 1426
135 | const val CC_SETONRESIZE = 1427
136 | const val CC_SETONCLANSETTINGSTRANSMIT = 1428
137 | const val CC_SETONCLANCHANNELTRANSMIT = 1429
138 | const val CC_GETX = 1500
139 | const val CC_GETY = 1501
140 | const val CC_GETWIDTH = 1502
141 | const val CC_GETHEIGHT = 1503
142 | const val CC_GETHIDE = 1504
143 | const val CC_GETLAYER = 1505
144 | const val CC_GETSCROLLX = 1600
145 | const val CC_GETSCROLLY = 1601
146 | const val CC_GETTEXT = 1602
147 | const val CC_GETSCROLLWIDTH = 1603
148 | const val CC_GETSCROLLHEIGHT = 1604
149 | const val CC_GETMODELZOOM = 1605
150 | const val CC_GETMODELANGLE_X = 1606
151 | const val CC_GETMODELANGLE_Z = 1607
152 | const val CC_GETMODELANGLE_Y = 1608
153 | const val CC_GETTRANS = 1609
154 | const val _1610 = 1610
155 | const val CC_GETCOLOUR = 1611
156 | const val CC_GETFILLCOLOUR = 1612
157 | const val _1613 = 1613
158 | const val CC_GETMODELTRANSPARENT = 1614
159 | const val _1615 = 1615
160 | const val _1616 = 1616
161 | const val CC_GETINVOBJECT = 1700
162 | const val CC_GETINVCOUNT = 1701
163 | const val CC_GETID = 1702
164 | const val CC_GETTARGETMASK = 1800
165 | const val CC_GETOP = 1801
166 | const val CC_GETOPBASE = 1802
167 | const val CC_CALLONRESIZE = 1927
168 | const val CC_TRIGGEROP = 1928
169 | const val IF_SETPOSITION = 2000
170 | const val IF_SETSIZE = 2001
171 | const val IF_SETHIDE = 2003
172 | const val IF_SETNOCLICKTHROUGH = 2005
173 | const val IF_SETNOSCROLLTHROUGH = 2006
174 | const val IF_SETSCROLLPOS = 2100
175 | const val IF_SETCOLOUR = 2101
176 | const val IF_SETFILL = 2102
177 | const val IF_SETTRANS = 2103
178 | const val IF_SETLINEWID = 2104
179 | const val IF_SETGRAPHIC = 2105
180 | const val IF_SET2DANGLE = 2106
181 | const val IF_SETTILING = 2107
182 | const val IF_SETMODEL = 2108
183 | const val IF_SETMODELANGLE = 2109
184 | const val IF_SETMODELANIM = 2110
185 | const val IF_SETMODELORTHOG = 2111
186 | const val IF_SETTEXT = 2112
187 | const val IF_SETTEXTFONT = 2113
188 | const val IF_SETTEXTALIGN = 2114
189 | const val IF_SETTEXTSHADOW = 2115
190 | const val IF_SETOUTLINE = 2116
191 | const val IF_SETGRAPHICSHADOW = 2117
192 | const val IF_SETVFLIP = 2118
193 | const val IF_SETHFLIP = 2119
194 | const val IF_SETSCROLLSIZE = 2120
195 | const val IF_RESUME_PAUSEBUTTON = 2121
196 | const val _2122 = 2122
197 | const val IF_SETFILLCOLOUR = 2123
198 | const val _2124 = 2124
199 | const val _2125 = 2125
200 | const val IF_SETLINEDIRECTION = 2126
201 | const val IF_SETMODELTRANSPARENT = 2127
202 | const val _2128 = 2128
203 | const val IF_SETOBJECT = 2200
204 | const val IF_SETNPCHEAD = 2201
205 | const val IF_SETPLAYERHEAD_SELF = 2202
206 | const val IF_SETOBJECT_NONUM = 2205
207 | const val IF_SETOBJECT_ALWAYS_NUM = 2212
208 | const val IF_SETOP = 2300
209 | const val IF_SETDRAGGABLE = 2301
210 | const val IF_SETDRAGGABLEBEHAVIOR = 2302
211 | const val IF_SETDRAGDEADZONE = 2303
212 | const val IF_SETDRAGDEADTIME = 2304
213 | const val IF_SETOPBASE = 2305
214 | const val IF_SETTARGETVERB = 2306
215 | const val IF_CLEAROPS = 2307
216 | const val _2308 = 2308
217 | const val _2309 = 2309
218 | const val IF_SETOPKEY = 2350
219 | const val IF_SETOPTKEY = 2351
220 | const val IF_SETOPKEYRATE = 2352
221 | const val IF_SETOPTKEYRATE = 2353
222 | const val IF_SETOPKEYIGNOREHELD = 2354
223 | const val IF_SETOPTKEYIGNOREHELD = 2355
224 | const val IF_SETONCLICK = 2400
225 | const val IF_SETONHOLD = 2401
226 | const val IF_SETONRELEASE = 2402
227 | const val IF_SETONMOUSEOVER = 2403
228 | const val IF_SETONMOUSELEAVE = 2404
229 | const val IF_SETONDRAG = 2405
230 | const val IF_SETONTARGETLEAVE = 2406
231 | const val IF_SETONVARTRANSMIT = 2407
232 | const val IF_SETONTIMER = 2408
233 | const val IF_SETONOP = 2409
234 | const val IF_SETONDRAGCOMPLETE = 2410
235 | const val IF_SETONCLICKREPEAT = 2411
236 | const val IF_SETONMOUSEREPEAT = 2412
237 | const val IF_SETONINVTRANSMIT = 2414
238 | const val IF_SETONSTATTRANSMIT = 2415
239 | const val IF_SETONTARGETENTER = 2416
240 | const val IF_SETONSCROLLWHEEL = 2417
241 | const val IF_SETONCHATTRANSMIT = 2418
242 | const val IF_SETONKEY = 2419
243 | const val IF_SETONFRIENDTRANSMIT = 2420
244 | const val IF_SETONCLANTRANSMIT = 2421
245 | const val IF_SETONMISCTRANSMIT = 2422
246 | const val IF_SETONDIALOGABORT = 2423
247 | const val IF_SETONSUBCHANGE = 2424
248 | const val IF_SETONSTOCKTRANSMIT = 2425
249 | const val _2426 = 2426
250 | const val IF_SETONRESIZE = 2427
251 | const val IF_SETONCLANSETTINGSTRANSMIT = 2428
252 | const val IF_SETONCLANCHANNELTRANSMIT = 2429
253 | const val IF_GETX = 2500
254 | const val IF_GETY = 2501
255 | const val IF_GETWIDTH = 2502
256 | const val IF_GETHEIGHT = 2503
257 | const val IF_GETHIDE = 2504
258 | const val IF_GETLAYER = 2505
259 | const val IF_GETSCROLLX = 2600
260 | const val IF_GETSCROLLY = 2601
261 | const val IF_GETTEXT = 2602
262 | const val IF_GETSCROLLWIDTH = 2603
263 | const val IF_GETSCROLLHEIGHT = 2604
264 | const val IF_GETMODELZOOM = 2605
265 | const val IF_GETMODELANGLE_X = 2606
266 | const val IF_GETMODELANGLE_Z = 2607
267 | const val IF_GETMODELANGLE_Y = 2608
268 | const val IF_GETTRANS = 2609
269 | const val _2610 = 2610
270 | const val IF_GETCOLOUR = 2611
271 | const val IF_GETFILLCOLOUR = 2612
272 | const val _2613 = 2613
273 | const val IF_GETMODELTRANSPARENT = 2614
274 | const val _2615 = 2615
275 | const val _2616 = 2616
276 | const val IF_GETINVOBJECT = 2700
277 | const val IF_GETINVCOUNT = 2701
278 | const val IF_HASSUB = 2702
279 | const val IF_GETTOP = 2706
280 | const val IF_GETTARGETMASK = 2800
281 | const val IF_GETOP = 2801
282 | const val IF_GETOPBASE = 2802
283 | const val IF_CALLONRESIZE = 2927
284 | const val IF_TRIGGEROP = 2928
285 | const val MES = 3100
286 | const val ANIM = 3101
287 | const val IF_CLOSE = 3103
288 | const val RESUME_COUNTDIALOG = 3104
289 | const val RESUME_NAMEDIALOG = 3105
290 | const val RESUME_STRINGDIALOG = 3106
291 | const val OPPLAYER = 3107
292 | const val IF_DRAGPICKUP = 3108
293 | const val CC_DRAGPICKUP = 3109
294 | const val SETMOUSECAM = 3110
295 | const val GETREMOVEROOFS = 3111
296 | const val SETREMOVEROOFS = 3112
297 | const val OPENURL = 3113
298 | const val RESUME_OBJDIALOG = 3115
299 | const val BUG_REPORT = 3116
300 | const val SETSHIFTCLICKDROP = 3117
301 | const val SETSHOWMOUSEOVERTEXT = 3118
302 | const val RENDERSELF = 3119
303 | const val _3120 = 3120
304 | const val _3121 = 3121
305 | const val _3122 = 3122
306 | const val _3123 = 3123
307 | const val _3124 = 3124
308 | const val SETSHOWMOUSECROSS = 3125
309 | const val SETSHOWLOADINGMESSAGES = 3126
310 | const val SETTAPTODROP = 3127
311 | const val GETTAPTODROP = 3128
312 | const val _3129 = 3129
313 | const val _3130 = 3130
314 | const val _3131 = 3131
315 | const val GETCANVASSIZE = 3132
316 | const val MOBILE_SETFPS = 3133
317 | const val MOBILE_OPENSTORE = 3134
318 | const val MOBILE_OPENSTORECATEGORY = 3135
319 | const val _3136 = 3136
320 | const val _3137 = 3137
321 | const val _3138 = 3138
322 | const val _3139 = 3139
323 | const val _3140 = 3140
324 | const val SETHIDEUSERNAME = 3141
325 | const val GETHIDEUSERNAME = 3142
326 | const val SETREMEMBERUSERNAME = 3143
327 | const val GETREMEMBERUSERNAME = 3144
328 | const val SHOW_IOS_REVIEW = 3145
329 | const val _3157 = 3157
330 | const val SETBRIGHTNESS = 3181
331 | const val GETBRIGHTNESS = 3182
332 | const val SETANTIDRAG = 3183
333 | const val _3184 = 3184
334 | const val SOUND_SYNTH = 3200
335 | const val SOUND_SONG = 3201
336 | const val SOUND_JINGLE = 3202
337 | const val SETVOLUMEMUSIC = 3203
338 | const val GETVOLUMEMUSIC = 3204
339 | const val SETVOLUMESOUNDS = 3205
340 | const val GETVOLUMESOUNDS = 3206
341 | const val SETVOLUMEAREASOUNDS = 3207
342 | const val GETVOLUMEAREASOUNDS = 3208
343 | const val _3209 = 3209
344 | const val _3210 = 3210
345 | const val CLIENTCLOCK = 3300
346 | const val INV_GETOBJ = 3301
347 | const val INV_GETNUM = 3302
348 | const val INV_TOTAL = 3303
349 | const val INV_SIZE = 3304
350 | const val STAT = 3305
351 | const val STAT_BASE = 3306
352 | const val STAT_XP = 3307
353 | const val COORD = 3308
354 | const val COORDX = 3309
355 | const val COORDY = 3310
356 | const val COORDZ = 3311
357 | const val MAP_MEMBERS = 3312
358 | const val INVOTHER_GETOBJ = 3313
359 | const val INVOTHER_GETNUM = 3314
360 | const val INVOTHER_TOTAL = 3315
361 | const val STAFFMODLEVEL = 3316
362 | const val REBOOTTIMER = 3317
363 | const val MAP_WORLD = 3318
364 | const val RUNENERGY_VISIBLE = 3321
365 | const val RUNWEIGHT_VISIBLE = 3322
366 | const val PLAYERMOD = 3323
367 | const val WORLDFLAGS = 3324
368 | const val MOVECOORD = 3325
369 | const val MOUSE_GETX = 3326
370 | const val MOUSE_GETY = 3327
371 | const val _3330 = 3330
372 | const val ENUM_STRING = 3400
373 | const val ENUM = 3408
374 | const val ENUM_GETOUTPUTCOUNT = 3411
375 | const val FRIEND_COUNT = 3600
376 | const val FRIEND_GETNAME = 3601
377 | const val FRIEND_GETWORLD = 3602
378 | const val FRIEND_GETRANK = 3603
379 | const val FRIEND_SETRANK = 3604
380 | const val FRIEND_ADD = 3605
381 | const val FRIEND_DEL = 3606
382 | const val IGNORE_ADD = 3607
383 | const val IGNORE_DEL = 3608
384 | const val FRIEND_TEST = 3609
385 | const val CLAN_GETCHATDISPLAYNAME = 3611
386 | const val CLAN_GETCHATCOUNT = 3612
387 | const val CLAN_GETCHATUSERNAME = 3613
388 | const val CLAN_GETCHATUSERWORLD = 3614
389 | const val CLAN_GETCHATUSERRANK = 3615
390 | const val CLAN_GETCHATMINKICK = 3616
391 | const val CLAN_KICKUSER = 3617
392 | const val CLAN_GETCHATRANK = 3618
393 | const val CLAN_JOINCHAT = 3619
394 | const val CLAN_LEAVECHAT = 3620
395 | const val IGNORE_COUNT = 3621
396 | const val IGNORE_GETNAME = 3622
397 | const val IGNORE_TEST = 3623
398 | const val CLAN_ISSELF = 3624
399 | const val CLAN_GETCHATOWNERNAME = 3625
400 | const val CLAN_ISFRIEND = 3626
401 | const val CLAN_ISIGNORE = 3627
402 | const val _3628 = 3628
403 | const val _3629 = 3629
404 | const val _3630 = 3630
405 | const val _3631 = 3631
406 | const val _3632 = 3632
407 | const val _3633 = 3633
408 | const val _3634 = 3634
409 | const val _3635 = 3635
410 | const val _3636 = 3636
411 | const val _3637 = 3637
412 | const val _3638 = 3638
413 | const val _3639 = 3639
414 | const val _3640 = 3640
415 | const val _3641 = 3641
416 | const val _3642 = 3642
417 | const val _3643 = 3643
418 | const val _3644 = 3644
419 | const val _3645 = 3645
420 | const val _3646 = 3646
421 | const val _3647 = 3647
422 | const val _3648 = 3648
423 | const val _3649 = 3649
424 | const val _3650 = 3650
425 | const val _3651 = 3651
426 | const val _3652 = 3652
427 | const val _3653 = 3653
428 | const val _3654 = 3654
429 | const val _3655 = 3655
430 | const val _3656 = 3656
431 | const val _3657 = 3657
432 | const val _3700 = 3700
433 | const val _3701 = 3701
434 | const val _3702 = 3702
435 | const val ACTIVECLANSETTINGS_FIND_LISTENED = 3800
436 | const val ACTIVECLANSETTINGS_FIND_AFFINED = 3801
437 | const val ACTIVECLANSETTINGS_GETCLANNAME = 3802
438 | const val ACTIVECLANSETTINGS_GETALLOWUNAFFINED = 3803
439 | const val ACTIVECLANSETTINGS_GETRANKTALK = 3804
440 | const val ACTIVECLANSETTINGS_GETRANKKICK = 3805
441 | const val ACTIVECLANSETTINGS_GETRANKLOOTSHARE = 3806
442 | const val ACTIVECLANSETTINGS_GETCOINSHARE = 3807
443 | const val ACTIVECLANSETTINGS_GETAFFINEDCOUNT = 3809
444 | const val ACTIVECLANSETTINGS_GETAFFINEDDISPLAYNAME = 3810
445 | const val ACTIVECLANSETTINGS_GETAFFINEDRANK = 3811
446 | const val ACTIVECLANSETTINGS_GETBANNEDCOUNT = 3812
447 | const val ACTIVECLANSETTINGS_GETBANNEDDISPLAYNAME = 3813
448 | const val ACTIVECLANSETTINGS_GETAFFINEDEXTRAINFO = 3814
449 | const val ACTIVECLANSETTINGS_GETCURRENTOWNER_SLOT = 3815
450 | const val ACTIVECLANSETTINGS_GETREPLACEMENTOWNER_SLOT = 3816
451 | const val ACTIVECLANSETTINGS_GETAFFINEDSLOT = 3817
452 | const val ACTIVECLANSETTINGS_GETSORTEDAFFINEDSLOT = 3818
453 | const val AFFINEDCLANSETTINGS_ADDBANNED_FROMCHANNEL = 3819
454 | const val ACTIVECLANSETTINGS_GETAFFINEDJOINRUNEDAY = 3820
455 | const val AFFINEDCLANSETTINGS_SETMUTED_FROMCHANNEL = 3821
456 | const val ACTIVECLANSETTINGS_GETAFFINEDMUTED = 3822
457 | const val ACTIVECLANCHANNEL_FIND_LISTENED = 3850
458 | const val ACTIVECLANCHANNEL_FIND_AFFINED = 3851
459 | const val ACTIVECLANCHANNEL_GETCLANNAME = 3852
460 | const val ACTIVECLANCHANNEL_GETRANKKICK = 3853
461 | const val ACTIVECLANCHANNEL_GETRANKTALK = 3854
462 | const val ACTIVECLANCHANNEL_GETUSERCOUNT = 3855
463 | const val ACTIVECLANCHANNEL_GETUSERDISPLAYNAME = 3856
464 | const val ACTIVECLANCHANNEL_GETUSERRANK = 3857
465 | const val ACTIVECLANCHANNEL_GETUSERWORLD = 3858
466 | const val ACTIVECLANCHANNEL_KICKUSER = 3859
467 | const val ACTIVECLANCHANNEL_GETUSERSLOT = 3860
468 | const val ACTIVECLANCHANNEL_GETSORTEDUSERSLOT = 3861
469 | const val CLANPROFILE_FIND = 3890
470 | const val STOCKMARKET_GETOFFERTYPE = 3903
471 | const val STOCKMARKET_GETOFFERITEM = 3904
472 | const val STOCKMARKET_GETOFFERPRICE = 3905
473 | const val STOCKMARKET_GETOFFERCOUNT = 3906
474 | const val STOCKMARKET_GETOFFERCOMPLETEDCOUNT = 3907
475 | const val STOCKMARKET_GETOFFERCOMPLETEDGOLD = 3908
476 | const val STOCKMARKET_ISOFFEREMPTY = 3910
477 | const val STOCKMARKET_ISOFFERSTABLE = 3911
478 | const val STOCKMARKET_ISOFFERFINISHED = 3912
479 | const val STOCKMARKET_ISOFFERADDING = 3913
480 | const val TRADINGPOST_SORTBY_NAME = 3914
481 | const val TRADINGPOST_SORTBY_PRICE = 3915
482 | const val TRADINGPOST_SORTFILTERBY_WORLD = 3916
483 | const val TRADINGPOST_SORTBY_AGE = 3917
484 | const val TRADINGPOST_SORTBY_COUNT = 3918
485 | const val TRADINGPOST_GETTOTALOFFERS = 3919
486 | const val TRADINGPOST_GETOFFERWORLD = 3920
487 | const val TRADINGPOST_GETOFFERNAME = 3921
488 | const val TRADINGPOST_GETOFFERPREVIOUSNAME = 3922
489 | const val TRADINGPOST_GETOFFERAGE = 3923
490 | const val TRADINGPOST_GETOFFERCOUNT = 3924
491 | const val TRADINGPOST_GETOFFERPRICE = 3925
492 | const val TRADINGPOST_GETOFFERITEM = 3926
493 | const val ADD = 4000
494 | const val SUB = 4001
495 | const val MULTIPLY = 4002
496 | const val DIV = 4003
497 | const val RANDOM = 4004
498 | const val RANDOMINC = 4005
499 | const val INTERPOLATE = 4006
500 | const val ADDPERCENT = 4007
501 | const val SETBIT = 4008
502 | const val CLEARBIT = 4009
503 | const val TESTBIT = 4010
504 | const val MOD = 4011
505 | const val POW = 4012
506 | const val INVPOW = 4013
507 | const val AND = 4014
508 | const val OR = 4015
509 | const val SCALE = 4018
510 | const val BITCOUNT = 4025
511 | const val TOGGLEBIT = 4026
512 | const val SETBIT_RANGE = 4027
513 | const val CLEARBIT_RANGE = 4028
514 | const val GETBIT_RANGE = 4029
515 | const val SETBIT_RANGE_TOINT = 4030
516 | const val SIN_DEG = 4032
517 | const val COS_DEG = 4033
518 | const val _4034 = 4034
519 | const val ABS = 4035
520 | const val APPEND_NUM = 4100
521 | const val APPEND = 4101
522 | const val APPEND_SIGNNUM = 4102
523 | const val LOWERCASE = 4103
524 | const val FROMDATE = 4104
525 | const val TEXT_GENDER = 4105
526 | const val TOSTRING = 4106
527 | const val COMPARE = 4107
528 | const val PARAHEIGHT = 4108
529 | const val PARAWIDTH = 4109
530 | const val TEXT_SWITCH = 4110
531 | const val ESCAPE = 4111
532 | const val APPEND_CHAR = 4112
533 | const val CHAR_ISPRINTABLE = 4113
534 | const val CHAR_ISALPHANUMERIC = 4114
535 | const val CHAR_ISALPHA = 4115
536 | const val CHAR_ISNUMERIC = 4116
537 | const val STRING_LENGTH = 4117
538 | const val SUBSTRING = 4118
539 | const val REMOVETAGS = 4119
540 | const val STRING_INDEXOF_CHAR = 4120
541 | const val STRING_INDEXOF_STRING = 4121
542 | const val OC_NAME = 4200
543 | const val OC_OP = 4201
544 | const val OC_IOP = 4202
545 | const val OC_COST = 4203
546 | const val OC_STACKABLE = 4204
547 | const val OC_CERT = 4205
548 | const val OC_UNCERT = 4206
549 | const val OC_MEMBERS = 4207
550 | const val OC_PLACEHOLDER = 4208
551 | const val OC_UNPLACEHOLDER = 4209
552 | const val OC_FIND = 4210
553 | const val OC_FINDNEXT = 4211
554 | const val OC_FINDRESET = 4212
555 | const val CHAT_GETFILTER_PUBLIC = 5000
556 | const val CHAT_SETFILTER = 5001
557 | const val CHAT_SENDABUSEREPORT = 5002
558 | const val CHAT_GETHISTORY_BYTYPEANDLINE = 5003
559 | const val CHAT_GETHISTORY_BYUID = 5004
560 | const val CHAT_GETFILTER_PRIVATE = 5005
561 | const val CHAT_SENDPUBLIC = 5008
562 | const val CHAT_SENDPRIVATE = 5009
563 | const val CHAT_SENDCLAN = 5010
564 | const val CHAT_PLAYERNAME = 5015
565 | const val CHAT_GETFILTER_TRADE = 5016
566 | const val CHAT_GETHISTORYLENGTH = 5017
567 | const val CHAT_GETNEXTUID = 5018
568 | const val CHAT_GETPREVUID = 5019
569 | const val DOCHEAT = 5020
570 | const val CHAT_SETMESSAGEFILTER = 5021
571 | const val CHAT_GETMESSAGEFILTER = 5022
572 | const val WRITECONSOLE = 5023
573 | const val CHAT_SETTIMESTAMPS = 5024
574 | const val CHAT_GETTIMESTAMPS = 5025
575 | const val CHAT_GETHISTORYEX_BYTYPEANDLINE = 5030
576 | const val CHAT_GETHISTORYEX_BYUID = 5031
577 | const val GETWINDOWMODE = 5306
578 | const val SETWINDOWMODE = 5307
579 | const val GETDEFAULTWINDOWMODE = 5308
580 | const val SETDEFAULTWINDOWMODE = 5309
581 | const val _5310 = 5310
582 | const val _5311 = 5311
583 | const val _5312 = 5312
584 | const val _5350 = 5350
585 | const val _5351 = 5351
586 | const val CAM_FORCEANGLE = 5504
587 | const val CAM_GETANGLE_XA = 5505
588 | const val CAM_GETANGLE_YA = 5506
589 | const val CAM_SETFOLLOWHEIGHT = 5530
590 | const val CAM_GETFOLLOWHEIGHT = 5531
591 | const val LOGOUT = 5630
592 | const val FEDERATED_LOGIN = 5631
593 | const val _5632 = 5632
594 | const val _5633 = 5633
595 | const val VIEWPORT_SETFOV = 6200
596 | const val VIEWPORT_SETZOOM = 6201
597 | const val VIEWPORT_CLAMPFOV = 6202
598 | const val VIEWPORT_GETEFFECTIVESIZE = 6203
599 | const val VIEWPORT_GETZOOM = 6204
600 | const val VIEWPORT_GETFOV = 6205
601 | const val _6210 = 6210
602 | const val _6212 = 6212
603 | const val _6220 = 6220
604 | const val _6221 = 6221
605 | const val _6222 = 6222
606 | const val _6223 = 6223
607 | const val WORLDLIST_FETCH = 6500
608 | const val WORLDLIST_START = 6501
609 | const val WORLDLIST_NEXT = 6502
610 | const val WORLDLIST_SPECIFIC = 6506
611 | const val WORLDLIST_SORT = 6507
612 | const val _6511 = 6511
613 | const val SETFOLLOWEROPSLOWPRIORITY = 6512
614 | const val NC_PARAM = 6513
615 | const val LC_PARAM = 6514
616 | const val OC_PARAM = 6515
617 | const val STRUCT_PARAM = 6516
618 | const val ON_MOBILE = 6518
619 | const val CLIENTTYPE = 6519
620 | const val _6520 = 6520
621 | const val MOBILE_KEYBOARDHIDE = 6521
622 | const val _6522 = 6522
623 | const val _6523 = 6523
624 | const val MOBILE_BATTERYLEVEL = 6524
625 | const val MOBILE_BATTERYCHARGING = 6525
626 | const val MOBILE_WIFIAVAILABLE = 6526
627 | const val _6527 = 6527
628 | const val _6600 = 6600
629 | const val WORLDMAP_GETMAPNAME = 6601
630 | const val WORLDMAP_SETMAP = 6602
631 | const val WORLDMAP_GETZOOM = 6603
632 | const val WORLDMAP_SETZOOM = 6604
633 | const val WORLDMAP_ISLOADED = 6605
634 | const val WORLDMAP_JUMPTODISPLAYCOORD = 6606
635 | const val WORLDMAP_JUMPTODISPLAYCOORD_INSTANT = 6607
636 | const val WORLDMAP_JUMPTOSOURCECOORD = 6608
637 | const val WORLDMAP_JUMPTOSOURCECOORD_INSTANT = 6609
638 | const val WORLDMAP_GETDISPLAYPOSITION = 6610
639 | const val WORLDMAP_GETCONFIGORIGIN = 6611
640 | const val WORLDMAP_GETCONFIGSIZE = 6612
641 | const val WORLDMAP_GETCONFIGBOUNDS = 6613
642 | const val WORLDMAP_GETCONFIGZOOM = 6614
643 | const val _6615 = 6615
644 | const val WORLDMAP_GETCURRENTMAP = 6616
645 | const val WORLDMAP_GETDISPLAYCOORD = 6617
646 | const val _6618 = 6618
647 | const val _6619 = 6619
648 | const val _6620 = 6620
649 | const val WORLDMAP_COORDINMAP = 6621
650 | const val WORLDMAP_GETSIZE = 6622
651 | const val _6623 = 6623
652 | const val _6624 = 6624
653 | const val _6625 = 6625
654 | const val _6626 = 6626
655 | const val _6627 = 6627
656 | const val WORLDMAP_PERPETUALFLASH = 6628
657 | const val WORLDMAP_FLASHELEMENT = 6629
658 | const val WORLDMAP_FLASHELEMENTCATEGORY = 6630
659 | const val WORLDMAP_STOPCURRENTFLASHES = 6631
660 | const val WORLDMAP_DISABLEELEMENTS = 6632
661 | const val WORLDMAP_DISABLEELEMENT = 6633
662 | const val WORLDMAP_DISABLEELEMENTCATEGORY = 6634
663 | const val WORLDMAP_GETDISABLEELEMENTS = 6635
664 | const val WORLDMAP_GETDISABLEELEMENT = 6636
665 | const val WORLDMAP_GETDISABLEELEMENTCATEGORY = 6637
666 | const val _6638 = 6638
667 | const val WORLDMAP_LISTELEMENT_START = 6639
668 | const val WORLDMAP_LISTELEMENT_NEXT = 6640
669 | const val MEC_TEXT = 6693
670 | const val MEC_TEXTSIZE = 6694
671 | const val MEC_CATEGORY = 6695
672 | const val MEC_SPRITE = 6696
673 | const val WORLDMAP_ELEMENT = 6697
674 | const val _6698 = 6698
675 | const val WORLDMAP_ELEMENTCOORD = 6699
676 | const val _6700 = 6700
677 | const val _6701 = 6701
678 | const val _6702 = 6702
679 | const val _6703 = 6703
680 | const val _6704 = 6704
681 | const val _6705 = 6705
682 | const val _6706 = 6706
683 | const val _6707 = 6707
684 | const val _6708 = 6708
685 | const val _6709 = 6709
686 | const val _6750 = 6750
687 | const val _6751 = 6751
688 | const val _6752 = 6752
689 | const val _6753 = 6753
690 | const val NC_NAME = 6754
691 | const val _6800 = 6800
692 | const val _6801 = 6801
693 | const val _6802 = 6802
694 | const val _6850 = 6850
695 | const val _6851 = 6851
696 | const val _6852 = 6852
697 | const val _6853 = 6853
698 | const val _6900 = 6900
699 | const val _6902 = 6902
700 | const val _6903 = 6903
701 | const val _6904 = 6904
702 | const val _6905 = 6905
703 | const val _6950 = 6950
704 | const val _7000 = 7000
705 | const val HIGHLIGHT_NPC_ON = 7001
706 | const val HIGHLIGHT_NPC_OFF = 7002
707 | const val _7003 = 7003
708 | const val _7004 = 7004
709 | const val _7005 = 7005
710 | const val HIGHLIGHT_NPCTYPE_ON = 7006
711 | const val HIGHLIGHT_NPCTYPE_OFF = 7007
712 | const val _7008 = 7008
713 | const val _7009 = 7009
714 | const val _7010 = 7010
715 | const val HIGHLIGHT_LOC_ON = 7011
716 | const val HIGHLIGHT_LOC_OFF = 7012
717 | const val _7013 = 7013
718 | const val _7014 = 7014
719 | const val _7015 = 7015
720 | const val HIGHLIGHT_LOCTYPE_ON = 7016
721 | const val HIGHLIGHT_LOCTYPE_OFF = 7017
722 | const val _7018 = 7018
723 | const val _7019 = 7019
724 | const val _7020 = 7020
725 | const val HIGHLIGHT_OBJ_ON = 7021
726 | const val HIGHLIGHT_OBJ_OFF = 7022
727 | const val _7023 = 7023
728 | const val _7024 = 7024
729 | const val _7025 = 7025
730 | const val HIGHLIGHT_OBJTYPE_ON = 7026
731 | const val HIGHLIGHT_OBJTYPE_OFF = 7027
732 | const val _7028 = 7028
733 | const val _7029 = 7029
734 | const val _7030 = 7030
735 | const val HIGHLIGHT_PLAYER_ON = 7031
736 | const val HIGHLIGHT_PLAYER_OFF = 7032
737 | const val _7033 = 7033
738 | const val _7034 = 7034
739 | const val _7035 = 7035
740 | const val HIGHLIGHT_TILE_ON = 7036
741 | const val HIGHLIGHT_TILE_OFF = 7037
742 | const val _7038 = 7038
743 | const val _7039 = 7039
744 | const val _7100 = 7100
745 | const val _7101 = 7101
746 | const val _7102 = 7102
747 | const val _7103 = 7103
748 | const val _7104 = 7104
749 | const val _7105 = 7105
750 | const val _7106 = 7106
751 | const val _7107 = 7107
752 | const val _7108 = 7108
753 | const val _7109 = 7109
754 | const val _7110 = 7110
755 | const val _7120 = 7120
756 | const val _7121 = 7121
757 | const val _7122 = 7122
758 | const val _7200 = 7200
759 | const val _7201 = 7201
760 | const val _7202 = 7202
761 | const val _7203 = 7203
762 | const val _7204 = 7204
763 | const val _7205 = 7205
764 | const val _7206 = 7206
765 | const val _7207 = 7207
766 | const val _7208 = 7208
767 | const val _7209 = 7209
768 | const val _7210 = 7210
769 | const val _7211 = 7211
770 | const val _7212 = 7212
771 | const val _7213 = 7213
772 | const val _7214 = 7214
773 | const val SETMINIMAPLOCK = 7250
774 | const val _7252 = 7252
775 | 


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


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