From 48653ec89538f1650106a5e77463412cad4684c2 Mon Sep 17 00:00:00 2001
From: Soopyboo32 <49228220+Soopyboo32@users.noreply.github.com>
Date: Sun, 31 Oct 2021 09:49:42 +0800
Subject: first commit
---
featureClass/class.js | 139 +++++++++++++++
featureClass/featureManager.js | 384 +++++++++++++++++++++++++++++++++++++++++
featureClass/forgeEvents.js | 93 ++++++++++
3 files changed, 616 insertions(+)
create mode 100644 featureClass/class.js
create mode 100644 featureClass/featureManager.js
create mode 100644 featureClass/forgeEvents.js
(limited to 'featureClass')
diff --git a/featureClass/class.js b/featureClass/class.js
new file mode 100644
index 0000000..1cfdd8b
--- /dev/null
+++ b/featureClass/class.js
@@ -0,0 +1,139 @@
+///
+
+import logger from "../logger"
+
+///
+
+class Feature {
+ constructor(){
+ this.FeatureManager = undefined
+ this.events = {}
+ this.customEvents = {}
+ this.forgeEvents = {}
+ this.soopyEvents = {}
+
+ this.id = undefined
+
+ this.enabled = false
+ }
+
+ setId(id){
+ this.id = id
+ }
+ getId(){
+ return this.id
+ }
+
+ _onDisable(){
+ Object.values(this.events).forEach(e=>this.FeatureManager.unregisterEvent(e)) //calling parent unregister to avoid the set in unregister event
+ Object.values(this.customEvents).forEach(e=>this.FeatureManager.unregisterCustom(e)) //calling parent unregister to avoid the set in unregister event
+
+ this.onDisable()
+
+ this.events = {}
+ this.customEvents = {}
+ this.enabled = false
+ }
+
+ _onEnable(parent){
+ this.FeatureManager = parent
+
+ this.enabled = true
+
+ this.onEnable()
+ }
+
+ onDisable(){}
+ onEnable(){}
+
+ registerEvent(event, func){
+ let theEvent = this.FeatureManager.registerEvent(event, func, this)
+
+ this.events[theEvent.id] = theEvent
+
+ return theEvent
+ }
+
+ unregisterEvent(event){
+ this.FeatureManager.unregisterEvent(event)
+
+ delete this.events[event.id]
+ }
+ registerSoopy(event, func){
+ let theEvent = this.FeatureManager.registerSoopy(event, func, this)
+
+ this.soopyEvents[theEvent.id] = theEvent
+
+ return theEvent
+ }
+
+ unregisterSoopy(event){
+ this.FeatureManager.unregisterSoopy(event)
+
+ delete this.soopyEvents[event.id]
+ }
+
+ registerForge(event, func){
+ let theEvent = this.FeatureManager.registerForge(event, func, this)
+
+ this.forgeEvents[theEvent.id] = theEvent
+
+ return theEvent
+ }
+
+ unregisterForge(event){
+ this.FeatureManager.unregisterForge(event)
+
+ delete this.forgeEvents[event.id]
+ }
+
+ registerChat(criteria, func){
+ let theEvent = this.FeatureManager.registerChat(criteria, func, this)
+
+ this.customEvents[theEvent.id] = theEvent
+
+ return theEvent
+ }
+ registerStep(isFps, interval, func){
+ let theEvent = this.FeatureManager.registerStep(isFps, interval, func, this)
+
+ this.customEvents[theEvent.id] = theEvent
+
+ return theEvent
+ }
+
+ registerCustom(event, func){
+ let theEvent = this.FeatureManager.registerCustom(event, func, this)
+
+ this.customEvents[theEvent.id] = theEvent
+
+ return theEvent
+ }
+
+ registerCommand(name, func){
+ this.FeatureManager.commandFuncs[name] = func
+
+ this.FeatureManager.registerCommand(name, (...args)=>{
+ if(this.FeatureManager.commandFuncs[name]){
+ this.FeatureManager.commandFuncs[name].call(this, ...(args || []))
+ }else{
+ ChatLib.chat("&cThis command is not available atm")
+ }
+ }, this)
+ }
+ unregisterCommand(name){
+ delete this.FeatureManager.commandFuncs[name]
+ }
+
+ unregisterCustom(event){
+ this.FeatureManager.unregisterCustom(event)
+
+ delete this.customEvents[event.id]
+ }
+
+ createCustomEvent(eventId){
+ return this.FeatureManager.createCustomEvent(eventId)
+ }
+}
+
+export default Feature
\ No newline at end of file
diff --git a/featureClass/featureManager.js b/featureClass/featureManager.js
new file mode 100644
index 0000000..92b9cd8
--- /dev/null
+++ b/featureClass/featureManager.js
@@ -0,0 +1,384 @@
+///
+///
+import LocationSetting from "../features/settings/settingThings/location";
+import logger from "../logger";
+const File = Java.type("java.io.File")
+import metadata from "../metadata.js"
+import { registerForge as registerForgeBase, unregisterForge as unregisterForgeBase} from "./forgeEvents.js"
+
+class FeatureManager {
+ constructor(){
+
+ this.enabled = true //make triggers work with this context
+
+ this.features = {};
+ this.events = {}
+ this.eventObjects = {}
+ this.soopyEventHandlers = {}
+
+ this.parent = undefined
+
+ this.commandFuncs = {}
+
+ this.lastEventId = 0
+
+ this.customEvents = {}
+ this.lastChatEventId = 0
+
+ this.forgeEvents = {}
+ this.lastForgeEventId = 0
+
+ this.lastSoopyEventId = 0
+
+ this.featureSettingsDataLastUpdated = false
+
+ this.featureMetas = {}
+
+ this.featureSettingsData = {}
+
+ new Thread(()=>{
+ this.loadFeatureMetas()
+
+ this.loadFeatureSettings()
+
+ Object.keys(this.featureMetas).forEach((feature)=>{
+ if(this.featureSettingsData[feature] && this.featureSettingsData[feature].enabled){
+ this.loadFeature(feature)
+ }
+ })
+ }).start()
+
+ this.registerStep(false, 30, ()=>{
+ if(this.featureSettingsDataLastUpdated){
+ new Thread(()=>{
+ this.saveFeatureSettings()
+ }).start()
+ }
+ }, this)
+
+ this.registerEvent("worldUnload", this.saveFeatureSettings, this)
+ this.registerEvent("gameUnload", this.saveFeatureSettings, this)
+
+ this.registerCommand("soopyunloadfeature", (args)=>{
+ new Thread(()=>{
+ this.unloadFeature(args)
+ }).start()
+ }, this)
+ this.registerCommand("soopyloadfeature", (args)=>{
+ new Thread(()=>{
+ this.loadFeature(args)
+ }).start()
+ }, this)
+ this.registerCommand("soopyreloadfeature", (args)=>{
+ new Thread(()=>{
+ this.unloadFeature(args)
+
+ this.loadFeature(args)
+ }).start()
+ }, this)
+ }
+
+ loadFeatureSettings(){
+ logger.logMessage("Loading settings", 4)
+
+ let data = FileLib.read("soopyAddonsData", "soopyaddonsbetafeaturesdata.json")
+
+ if(!data){
+ this.loadDefaultFeatureSettings();
+ return;
+ }
+
+ data = JSON.parse(data)
+
+ this.featureSettingsData = data
+
+ this.ensureNewSettingsExist()
+ }
+
+ saveFeatureSettings(){
+ if(!this.featureSettingsDataLastUpdated) return
+
+ FileLib.write("soopyAddonsData", "soopyaddonsbetafeaturesdata.json", JSON.stringify(this.featureSettingsData))
+
+ this.featureSettingsDataLastUpdated = false
+
+ logger.logMessage("Saved settings", 4)
+ }
+
+ loadDefaultFeatureSettings(){
+ Object.keys(this.featureMetas).forEach((feature)=>{
+ this.featureSettingsData[feature] = {
+ enabled: this.featureMetas[feature].defaultEnabled,
+ subSettings: {}
+ }
+ })
+
+ this.featureSettingsDataLastUpdated= true
+
+ logger.logMessage("Loaded default settings", 4)
+ }
+
+ ensureNewSettingsExist(){
+ Object.keys(this.featureMetas).forEach((feature)=>{
+ if(!this.featureSettingsData[feature]){
+ this.featureSettingsData[feature] = {
+ enabled: this.featureMetas[feature].defaultEnabled,
+ subSettings: {}
+ }
+ this.featureSettingsDataLastUpdated= true
+ logger.logMessage("Loaded default settings for " + feature, 4)
+ }
+ })
+ }
+
+ startCatchingEvent(event){
+ if(this.eventObjects[event]) return
+
+ //SBA compatability or something (removed)
+ // if(event === "renderOverlay"){
+ // let lastPartialTick = undefined
+ // this.eventObjects[event] = register(event, (...args)=>{
+ // let pTicks = Tessellator.getPartialTicks()
+ // if(pTicks !== lastPartialTick){
+ // lastPartialTick = pTicks
+ // this.triggerEvent(event, args)
+ // }
+ // })
+ // }else{
+ this.eventObjects[event] = register(event, (...args)=>{
+ this.triggerEvent(event, args)
+ })
+ //}
+
+ logger.logMessage("Registered " + event + " event", 4)
+ }
+
+ triggerEvent(event, args){
+ if(this.events[event])
+ try{
+ for(Event of Object.values(this.events[event])){
+ if(Event.context.enabled) Event.func.call(Event.context, ...args)
+ }
+ }catch(e){
+ logger.logMessage("Error in " + event + " event: " + JSON.stringify(e, undefined, 2), 2)
+ }
+ }
+ triggerSoopy(event, args){
+ if(this.soopyEventHandlers[event])
+ try{
+ for(Event of Object.values(this.soopyEventHandlers[event])){
+ if(Event.context.enabled) Event.func.call(Event.context, ...args)
+ }
+ }catch(e){
+ logger.logMessage("Error in soopy " + event + " event: " + JSON.stringify(e, undefined, 2), 2)
+ }
+ }
+
+ stopCatchingEvent(event){
+ if(!this.eventObjects[event]) return
+
+ this.eventObjects[event].unregister()
+ delete this.eventObjects[event]
+ delete this.events[event]
+ logger.logMessage("Unregistered " + event + " event", 4)
+ }
+
+ registerEvent(event, func, context){
+ if(!this.events[event]){
+ this.events[event] = []
+ this.startCatchingEvent(event)
+ }
+
+ let theEvent = {
+ func: func,
+ context: context,
+ id: this.lastEventId++,
+ event: event
+ }
+ this.events[event].push(theEvent)
+
+ return theEvent
+ }
+ registerSoopy(event, func, context){
+ if(!this.soopyEventHandlers[event]){
+ this.soopyEventHandlers[event] = []
+ }
+
+ let theEvent = {
+ func: func,
+ context: context,
+ id: this.lastSoopyEventId++,
+ event: event
+ }
+ this.soopyEventHandlers[event].push(theEvent)
+
+ return theEvent
+ }
+
+ registerChat(criteria, func, context){
+
+ let event = this.registerCustom("chat", func, context)
+
+ event.trigger.setChatCriteria(criteria)
+
+ return event
+ }
+ registerCommand(commandName, func, context){
+
+ let event = this.registerCustom("command", func, context)
+
+ event.trigger.setName(commandName)
+
+ return event
+ }
+ registerStep(isFps, interval, func, context){
+
+ let event = this.registerCustom("step", func, context)
+
+ event.trigger[isFps?"setFps":"setDelay"](interval) //TODO: make this group events similar to registerEvent()
+
+ return event
+ }
+
+ registerCustom(type, func, context){
+
+ let id = this.lastChatEventId++
+
+ this.customEvents[id] = {
+ func: func,
+ context: context,
+ trigger: register(type, (...args)=>{
+ try{
+ if(context.enabled) func.call(context, ...(args || []))
+ }catch(e){
+ logger.logMessage("Error in " + type + " event: " + JSON.stringify(e, undefined, 2), 2)
+ }
+ }),
+ id: id
+ }
+
+ return this.customEvents[id]
+ }
+
+ registerForge(event, func, context){
+ let id = this.lastForgeEventId++
+
+ this.forgeEvents[id] = {
+ func: func,
+ context: context,
+ trigger: registerForgeBase(event, (...args)=>{
+ try{
+ if(context.enabled) func.call(context, ...args)
+ }catch(e){
+ logger.logMessage("Error in " + event.class.toString() + " (forge) event: " + JSON.stringify(e, undefined, 2), 2)
+ }
+ }),
+ id: id
+ }
+
+ return this.forgeEvents[id]
+ }
+
+ unregisterForge(event){
+ unregisterForgeBase(this.forgeEvents[event.id].trigger)
+ delete this.forgeEvents[event.id]
+ }
+
+ unregisterCustom(event){
+ event.trigger.unregister()
+
+ delete this.customEvents[event.id]
+ }
+
+ unregisterEvent(event){
+ if(!this.events[event.event]) return
+
+ this.events[event.event] = this.events[event.event].filter((e)=>{
+ return e.id !== event.id
+ })
+
+ if(this.events[event.event].length === 0){
+ this.stopCatchingEvent(event.event)
+ delete this.events[event.event]
+ }
+ }
+
+ unregisterSoopy(event){
+ if(!this.soopyEventHandlers[event.event]) return
+
+ this.soopyEventHandlers[event.event] = this.soopyEventHandlers[event.event].filter((e)=>{
+ return e.id !== event.id
+ })
+
+ if(this.soopyEventHandlers[event.event].length === 0){
+ delete this.events[event.event]
+ }
+ }
+
+ loadFeatureMetas(){
+ featuresDir = new File("./config/ChatTriggers/modules/" + metadata.name + "/features")
+
+ featuresDir.list().forEach((pathName)=>{
+ if(pathName.includes(".")) return;
+
+ try{
+ let data = JSON.parse(FileLib.read( metadata.name + "/features/" + pathName,"metadata.json"))
+ if(data === null){
+ return;
+ }
+ data.id = pathName
+ this.featureMetas[pathName] = data
+ }catch(_){}
+ })
+ }
+
+ loadFeature(feature){ //run in seperate thread so onenable can do network requests
+ if(this.features[feature]) return
+
+ let LoadedFeature = require("../features/" + feature + "/index.js")
+
+ this.features[feature] = LoadedFeature
+
+ LoadedFeature.class.setId(feature)
+
+ LoadedFeature.class._onEnable(this)
+
+ logger.logMessage("Loaded feature " + feature, 3)
+
+ return this
+ }
+
+ unloadFeature(feature){ //run in seperate thread so ondisable can do network requests
+ if(!this.features[feature]) return
+
+ this.features[feature].class._onDisable()
+
+ delete this.features[feature]
+
+ logger.logMessage("Unloaded feature " + feature, 3)
+
+ return this
+ }
+
+ isFeatureLoaded(feature){
+ return !!this.features[feature]
+ }
+
+ getLoadedFeatures(){
+ return Object.keys(this.features)
+ }
+
+ createCustomEvent(eventId){
+ logger.logMessage("Registered custom " + eventId + " event", 4)
+
+ return {
+ trigger: (...args)=>{
+ this.triggerSoopy(eventId, args)
+ }
+ }
+ }
+}
+
+const featureManager = new FeatureManager();
+
+export default featureManager;
\ No newline at end of file
diff --git a/featureClass/forgeEvents.js b/featureClass/forgeEvents.js
new file mode 100644
index 0000000..e852c49
--- /dev/null
+++ b/featureClass/forgeEvents.js
@@ -0,0 +1,93 @@
+importClass(net.minecraftforge.common.MinecraftForge) //i would have used the ct module but it is broken (line 78) (this is fixed verison)
+importPackage(net.minecraftforge.fml.common.eventhandler)
+importPackage(org.objectweb.asm)
+importClass(java.lang.ClassLoader)
+importClass(org.apache.commons.lang3.RandomStringUtils)
+importClass(java.util.function.Consumer)
+
+const L = s => `L${s};`
+
+const LoadedInsts = []
+
+function defineClassBytes(name, bytes) {
+ const classLoader = Packages.com.chattriggers.ctjs.CTJS.class.getClassLoader()
+
+ const defClass = ClassLoader.class.getDeclaredMethods()[23] // defineClass()
+
+ defClass.setAccessible(true)
+
+ const n = new java.lang.String(name)
+ const o = new java.lang.Integer(0)
+ const s = new java.lang.Integer(bytes.length)
+ return defClass.invoke(classLoader, n, bytes, o, s)
+}
+
+const registerForge = (e, cb) => {
+ const cw = new ClassWriter(0)
+
+ const event = Type.getType(e.class).internalName
+ const name = RandomStringUtils.randomAlphabetic(7)
+
+ const consumer = Type.getType(Consumer.class).internalName
+ const mcForge = Type.getType(MinecraftForge.class).internalName
+ const eventBus = Type.getType(EventBus.class).internalName
+ const subscribeEvent = Type.getType(SubscribeEvent.class).internalName
+ const obj = Type.getType(java.lang.Object.class).internalName
+
+ cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, name, null, obj, null)
+ // cw.visitInnerClass("net/minecraftforge/event/entity/player/PlayerEvent$BreakSpeed", "net/minecraftforge/event/entity/player/PlayerEvent", "BreakSpeed", ACC_PUBLIC + ACC_STATIC);
+ {
+ cw.visitField(Opcodes.ACC_PRIVATE + Opcodes.ACC_FINAL, "callback", L(consumer), L(consumer + "<" + L(event) + ">"), null).visitEnd()
+ }
+ {
+ const con = cw.visitMethod(Opcodes.ACC_PUBLIC, "", "(" + L(consumer) + ")V", "(" + L(consumer + "<" + L(event) + ">") + ")V", null)
+ con.visitCode()
+ con.visitVarInsn(Opcodes.ALOAD, 0)
+ con.visitMethodInsn(Opcodes.INVOKESPECIAL, obj, "", "()V", false)
+
+ con.visitVarInsn(Opcodes.ALOAD, 0)
+ con.visitVarInsn(Opcodes.ALOAD, 1)
+ con.visitFieldInsn(Opcodes.PUTFIELD, name, "callback", L(consumer))
+ con.visitFieldInsn(Opcodes.GETSTATIC, mcForge, "EVENT_BUS", L(eventBus))
+ con.visitVarInsn(Opcodes.ALOAD, 0)
+ con.visitMethodInsn(Opcodes.INVOKEVIRTUAL, eventBus, "register", "(" + L(obj) + ")V", false)
+ con.visitInsn(Opcodes.RETURN)
+ con.visitMaxs(2, 2)
+ con.visitEnd()
+ }
+ {
+ const mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "on", "(" + L(event) + ")V", null, null)
+ {
+ const av = mv.visitAnnotation(L(subscribeEvent), true)
+ av.visitEnd()
+ }
+ mv.visitCode()
+ mv.visitVarInsn(Opcodes.ALOAD, 0)
+ mv.visitFieldInsn(Opcodes.GETFIELD, name, "callback", L(consumer))
+ mv.visitVarInsn(Opcodes.ALOAD, 1)
+ mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, consumer, "accept", "(" + L(obj) + ")V", true)
+ mv.visitInsn(Opcodes.RETURN)
+ mv.visitMaxs(2, 2)
+ mv.visitEnd()
+ }
+ cw.visitEnd()
+
+ const inst = defineClassBytes(name, cw.toByteArray())
+ .getDeclaredConstructor(Consumer.class)
+ .newInstance(new java.util.function.Consumer({
+ accept: function (t) { cb(t) }
+ }))
+ LoadedInsts.push(inst)
+ return inst;
+}
+
+const unregisterForge = inst => {
+ MinecraftForge.EVENT_BUS.unregister(inst)
+}
+
+register("gameUnload", () => {
+ LoadedInsts.forEach(unregisterForge)
+ LoadedInsts.length = 0
+})
+
+export { registerForge, unregisterForge }
--
cgit