diff --git a/src/api b/src/api index 305a3778c..d003d6d87 160000 --- a/src/api +++ b/src/api @@ -1 +1 @@ -Subproject commit 305a3778c86fed2680b8cad173b7e5fb0f3c98e6 +Subproject commit d003d6d870db13d56fce223050a06faf15050eae diff --git a/src/main/java/noppes/npcs/client/gui/script/GuiScriptInterface.java b/src/main/java/noppes/npcs/client/gui/script/GuiScriptInterface.java index 1a00de918..6a7d201b3 100644 --- a/src/main/java/noppes/npcs/client/gui/script/GuiScriptInterface.java +++ b/src/main/java/noppes/npcs/client/gui/script/GuiScriptInterface.java @@ -195,6 +195,9 @@ public class GuiScriptInterface extends GuiNPCInterface implements GuiYesNoCallb activeArea.init(editorX, editorY, editorWidth, editorHeight, container == null ? "" : container.script); } + + // Set the scripting language for proper syntax highlighting + activeArea.setLanguage(this.handler.getLanguage()); // Setup fullscreen key binding GuiScriptTextArea.KEYS.FULLSCREEN.setTask(e -> { diff --git a/src/main/java/noppes/npcs/client/gui/util/GuiScriptTextArea.java b/src/main/java/noppes/npcs/client/gui/util/GuiScriptTextArea.java index c45c0b817..55ab59f97 100644 --- a/src/main/java/noppes/npcs/client/gui/util/GuiScriptTextArea.java +++ b/src/main/java/noppes/npcs/client/gui/util/GuiScriptTextArea.java @@ -2331,6 +2331,26 @@ public class GuiScriptTextArea extends GuiNpcTextField { this.enableCodeHighlighting = true; this.container.formatCodeText(); } + + /** + * Set the scripting language for syntax highlighting and type inference. + * @param language The language name (e.g., "ECMAScript", "Groovy") + */ + public void setLanguage(String language) { + if (this.container != null) { + this.container.setLanguage(language); + if (this.enableCodeHighlighting) { + this.container.formatCodeText(); + } + } + } + + /** + * Get the current scripting language. + */ + public String getLanguage() { + return this.container != null ? this.container.getLanguage() : "ECMAScript"; + } public void setListener(ITextChangeListener listener) { this.listener = listener; diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ScriptDocument.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ScriptDocument.java index 583ecc12a..fdf540934 100644 --- a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ScriptDocument.java +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ScriptDocument.java @@ -8,6 +8,7 @@ import noppes.npcs.client.gui.util.script.interpreter.field.AssignmentInfo; import noppes.npcs.client.gui.util.script.interpreter.field.EnumConstantInfo; import noppes.npcs.client.gui.util.script.interpreter.field.FieldAccessInfo; import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSScriptAnalyzer; import noppes.npcs.client.gui.util.script.interpreter.method.MethodCallInfo; import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; import noppes.npcs.client.gui.util.script.interpreter.method.MethodSignature; @@ -114,6 +115,9 @@ public class ScriptDocument { // Type resolver private final TypeResolver typeResolver; + + // Script language: "ECMAScript", "Groovy", etc. + private String language = "ECMAScript"; // Layout properties public int lineHeight = 13; @@ -132,6 +136,33 @@ public class ScriptDocument { this.typeResolver = resolver != null ? resolver : TypeResolver.getInstance(); setText(text); } + + public ScriptDocument(String text, String language) { + this.typeResolver = TypeResolver.getInstance(); + this.language = language != null ? language : "ECMAScript"; + setText(text); + } + + /** + * Set the scripting language. + */ + public void setLanguage(String language) { + this.language = language != null ? language : "ECMAScript"; + } + + /** + * Get the scripting language. + */ + public String getLanguage() { + return language; + } + + /** + * Check if this is a JavaScript/ECMAScript document. + */ + public boolean isJavaScript() { + return "ECMAScript".equalsIgnoreCase(language); + } // ==================== TEXT MANAGEMENT ==================== @@ -219,18 +250,15 @@ public class ScriptDocument { methodCalls.clear(); externalFieldAssignments.clear(); declarationErrors.clear(); - - // Phase 1: Find excluded regions (strings/comments) - findExcludedRanges(); - - // Phase 2: Parse imports - parseImports(); - - // Phase 3: Parse structure (script types, methods, fields, locals) - parseStructure(); - - // Phase 4: Build marks and assign to lines - List marks = buildMarks(); + + List marks; + + // Use different analysis paths for JavaScript vs Java + if (isJavaScript()) { + marks = formatJavaScript(); + } else { + marks = formatJava(); + } // Phase 5: Resolve conflicts and sort marks = resolveConflicts(marks); @@ -243,6 +271,32 @@ public class ScriptDocument { // Phase 7: Compute indent guides computeIndentGuides(marks); } + + /** + * Format JavaScript/ECMAScript code using the JS type inference system. + */ + private List formatJavaScript() { + // Use JSScriptAnalyzer for JS-specific analysis + JSScriptAnalyzer analyzer = new JSScriptAnalyzer(text); + return analyzer.analyze(); + } + + /** + * Format Java/Groovy code using the full Java analysis system. + */ + private List formatJava() { + // Phase 1: Find excluded regions (strings/comments) + findExcludedRanges(); + + // Phase 2: Parse imports + parseImports(); + + // Phase 3: Parse structure (script types, methods, fields, locals) + parseStructure(); + + // Phase 4: Build marks and assign to lines + return buildMarks(); + } // ==================== PHASE 1: EXCLUDED RANGES ==================== diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ScriptTextContainer.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ScriptTextContainer.java index c2a26596b..b905ca412 100644 --- a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ScriptTextContainer.java +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ScriptTextContainer.java @@ -31,6 +31,9 @@ public class ScriptTextContainer extends JavaTextContainer { public static boolean USE_NEW_INTERPRETER = true; private ScriptDocument document; + + /** The scripting language: "ECMAScript", "Groovy", etc. */ + private String language = "ECMAScript"; public ScriptTextContainer(String text) { super(text); @@ -38,6 +41,32 @@ public class ScriptTextContainer extends JavaTextContainer { document = new ScriptDocument(text); } } + + public ScriptTextContainer(String text, String language) { + super(text); + this.language = language != null ? language : "ECMAScript"; + if (USE_NEW_INTERPRETER) { + document = new ScriptDocument(text, this.language); + } + } + + /** + * Set the scripting language. This affects syntax highlighting and type inference. + * @param language The language name (e.g., "ECMAScript", "Groovy") + */ + public void setLanguage(String language) { + this.language = language != null ? language : "ECMAScript"; + if (document != null) { + document.setLanguage(this.language); + } + } + + /** + * Get the current scripting language. + */ + public String getLanguage() { + return language; + } @Override public void init(int width, int height) { @@ -73,7 +102,7 @@ public class ScriptTextContainer extends JavaTextContainer { return; } - document = new ScriptDocument(this.text); + document = new ScriptDocument(this.text, this.language); init(width, height); } diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSFieldInfo.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSFieldInfo.java new file mode 100644 index 000000000..4ff653071 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSFieldInfo.java @@ -0,0 +1,51 @@ +package noppes.npcs.client.gui.util.script.interpreter.js_parser; + +/** + * Represents a field/property in a TypeScript interface. + */ +public class JSFieldInfo { + + private final String name; + private final String type; // Raw type string + private final boolean readonly; + private String documentation; + + public JSFieldInfo(String name, String type, boolean readonly) { + this.name = name; + this.type = type; + this.readonly = readonly; + } + + public JSFieldInfo setDocumentation(String documentation) { + this.documentation = documentation; + return this; + } + + // Getters + public String getName() { return name; } + public String getType() { return type; } + public boolean isReadonly() { return readonly; } + public String getDocumentation() { return documentation; } + + /** + * Build hover info HTML for this field. + */ + public String buildHoverInfo() { + StringBuilder sb = new StringBuilder(); + if (readonly) { + sb.append("readonly "); + } + sb.append("").append(name).append(": ").append(type).append(""); + + if (documentation != null && !documentation.isEmpty()) { + sb.append("

").append(documentation); + } + + return sb.toString(); + } + + @Override + public String toString() { + return (readonly ? "readonly " : "") + name + ": " + type; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSHoverInfo.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSHoverInfo.java new file mode 100644 index 000000000..edc2879ca --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSHoverInfo.java @@ -0,0 +1,117 @@ +package noppes.npcs.client.gui.util.script.interpreter.js_parser; + +import java.util.List; + +/** + * Container classes for hover information in JS scripts. + */ +public class JSHoverInfo { + + /** + * Hover info for a variable. + */ + public static class VariableInfo { + public final String name; + public final String typeName; + public final JSTypeInfo resolvedType; + + public VariableInfo(String name, String typeName, JSTypeInfo resolvedType) { + this.name = name; + this.typeName = typeName; + this.resolvedType = resolvedType; + } + + public String buildHoverHtml() { + StringBuilder sb = new StringBuilder(); + sb.append("").append(name).append(": ").append(typeName).append(""); + + if (resolvedType != null && resolvedType.getDocumentation() != null) { + sb.append("

").append(resolvedType.getDocumentation()); + } + + return sb.toString(); + } + } + + /** + * Hover info for a method. + */ + public static class MethodInfo { + public final JSMethodInfo method; + public final JSTypeInfo containingType; + + public MethodInfo(JSMethodInfo method, JSTypeInfo containingType) { + this.method = method; + this.containingType = containingType; + } + + public String buildHoverHtml() { + StringBuilder sb = new StringBuilder(); + + // Show containing type + if (containingType != null) { + sb.append("").append(containingType.getFullName()).append("
"); + } + + // Show method signature + sb.append(method.buildHoverInfo()); + + return sb.toString(); + } + } + + /** + * Hover info for a field. + */ + public static class FieldInfo { + public final JSFieldInfo field; + public final JSTypeInfo containingType; + + public FieldInfo(JSFieldInfo field, JSTypeInfo containingType) { + this.field = field; + this.containingType = containingType; + } + + public String buildHoverHtml() { + StringBuilder sb = new StringBuilder(); + + // Show containing type + if (containingType != null) { + sb.append("").append(containingType.getFullName()).append("
"); + } + + // Show field info + sb.append(field.buildHoverInfo()); + + return sb.toString(); + } + } + + /** + * Hover info for a hook function. + */ + public static class FunctionInfo { + public final String name; + public final List signatures; + + public FunctionInfo(String name, List signatures) { + this.name = name; + this.signatures = signatures; + } + + public String buildHoverHtml() { + StringBuilder sb = new StringBuilder(); + sb.append("Hook: ").append(name).append(""); + + if (!signatures.isEmpty()) { + sb.append("

Overloads:"); + for (JSTypeRegistry.HookSignature sig : signatures) { + sb.append("
• function ").append(name).append("(") + .append(sig.paramName).append(": ").append(sig.paramType).append(")"); + } + } + + return sb.toString(); + } + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSMethodInfo.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSMethodInfo.java new file mode 100644 index 000000000..2d5c03d1d --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSMethodInfo.java @@ -0,0 +1,93 @@ +package noppes.npcs.client.gui.util.script.interpreter.js_parser; + +import java.util.*; + +/** + * Represents a method signature parsed from .d.ts files. + */ +public class JSMethodInfo { + + private final String name; + private final String returnType; // Raw type string, e.g., "number", "IEntity", "void" + private final List parameters; + private String documentation; + + public JSMethodInfo(String name, String returnType, List parameters) { + this.name = name; + this.returnType = returnType; + this.parameters = parameters != null ? new ArrayList<>(parameters) : new ArrayList<>(); + } + + public JSMethodInfo setDocumentation(String documentation) { + this.documentation = documentation; + return this; + } + + // Getters + public String getName() { return name; } + public String getReturnType() { return returnType; } + public List getParameters() { return parameters; } + public String getDocumentation() { return documentation; } + public int getParameterCount() { return parameters.size(); } + + /** + * Get a formatted signature string for display. + */ + public String getSignature() { + StringBuilder sb = new StringBuilder(); + sb.append(name).append("("); + for (int i = 0; i < parameters.size(); i++) { + if (i > 0) sb.append(", "); + JSParameterInfo param = parameters.get(i); + sb.append(param.getName()).append(": ").append(param.getType()); + } + sb.append("): ").append(returnType); + return sb.toString(); + } + + /** + * Build hover info HTML for this method. + */ + public String buildHoverInfo() { + StringBuilder sb = new StringBuilder(); + sb.append("").append(name).append("("); + for (int i = 0; i < parameters.size(); i++) { + if (i > 0) sb.append(", "); + JSParameterInfo param = parameters.get(i); + sb.append(param.getName()).append(": ").append(param.getType()).append(""); + } + sb.append("): ").append(returnType).append(""); + + if (documentation != null && !documentation.isEmpty()) { + sb.append("

").append(documentation); + } + + return sb.toString(); + } + + @Override + public String toString() { + return getSignature(); + } + + /** + * Represents a parameter in a method signature. + */ + public static class JSParameterInfo { + private final String name; + private final String type; + + public JSParameterInfo(String name, String type) { + this.name = name; + this.type = type; + } + + public String getName() { return name; } + public String getType() { return type; } + + @Override + public String toString() { + return name + ": " + type; + } + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSScriptAnalyzer.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSScriptAnalyzer.java new file mode 100644 index 000000000..6da33a795 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSScriptAnalyzer.java @@ -0,0 +1,388 @@ +package noppes.npcs.client.gui.util.script.interpreter.js_parser; + +import noppes.npcs.client.gui.util.script.interpreter.ScriptLine; +import noppes.npcs.client.gui.util.script.interpreter.token.TokenType; + +import java.util.*; +import java.util.regex.*; + +/** + * Analyzes JavaScript scripts to produce syntax highlighting marks and type information. + * Uses the JSTypeRegistry to resolve types and validate member access. + */ +public class JSScriptAnalyzer { + + private final String text; + private final JSTypeRegistry registry; + + // Variable tracking: varName -> inferred type name + private final Map variableTypes = new HashMap<>(); + + // Function parameter types: funcName -> paramName -> typeName + private final Map> functionParams = new HashMap<>(); + + // Excluded ranges (strings, comments) + private final List excludedRanges = new ArrayList<>(); + + // Patterns + private static final Pattern STRING_PATTERN = Pattern.compile("\"(?:[^\"\\\\]|\\\\.)*\"|'(?:[^'\\\\]|\\\\.)*'"); + private static final Pattern COMMENT_PATTERN = Pattern.compile("//.*?$|/\\*.*?\\*/", Pattern.MULTILINE | Pattern.DOTALL); + private static final Pattern FUNCTION_PATTERN = Pattern.compile("function\\s+(\\w+)\\s*\\(([^)]*)\\)"); + private static final Pattern VAR_DECL_PATTERN = Pattern.compile("(?:var|let|const)\\s+(\\w+)(?:\\s*=\\s*([^;]+))?"); + private static final Pattern ASSIGNMENT_PATTERN = Pattern.compile("(\\w+)\\s*=\\s*([^;]+)"); + private static final Pattern METHOD_CALL_PATTERN = Pattern.compile("(\\w+(?:\\.\\w+)*)\\s*\\("); + private static final Pattern MEMBER_ACCESS_PATTERN = Pattern.compile("(\\w+)(?:\\.(\\w+))+"); + private static final Pattern IDENTIFIER_PATTERN = Pattern.compile("\\b([a-zA-Z_][a-zA-Z0-9_]*)\\b"); + + private static final Pattern JS_KEYWORD_PATTERN = Pattern.compile( + "\\b(function|var|let|const|if|else|for|while|do|switch|case|break|continue|return|" + + "try|catch|finally|throw|new|typeof|instanceof|in|of|this|null|undefined|true|false|" + + "class|extends|import|export|default|async|await|yield)\\b"); + + private static final Pattern NUMBER_PATTERN = Pattern.compile("\\b\\d+\\.?\\d*\\b"); + + public JSScriptAnalyzer(String text) { + this.text = text; + this.registry = JSTypeRegistry.getInstance(); + // Ensure registry is initialized + if (!registry.isInitialized()) { + registry.initializeFromResources(); + } + } + + /** + * Analyze the script and produce marks. + */ + public List analyze() { + List marks = new ArrayList<>(); + + // First pass: find excluded regions + findExcludedRanges(); + + // Mark comments and strings + addPatternMarks(marks, COMMENT_PATTERN, TokenType.COMMENT); + addPatternMarks(marks, STRING_PATTERN, TokenType.STRING); + + // Mark keywords + addPatternMarks(marks, JS_KEYWORD_PATTERN, TokenType.KEYWORD); + + // Mark numbers + addPatternMarks(marks, NUMBER_PATTERN, TokenType.LITERAL); + + // Parse functions and infer parameter types from hooks + parseFunctions(marks); + + // Parse variable declarations + parseVariables(marks); + + // Mark member accesses with type validation + markMemberAccesses(marks); + + // Mark method calls + markMethodCalls(marks); + + return marks; + } + + /** + * Find strings and comments to exclude from analysis. + */ + private void findExcludedRanges() { + Matcher m = STRING_PATTERN.matcher(text); + while (m.find()) { + excludedRanges.add(new int[]{m.start(), m.end()}); + } + + m = COMMENT_PATTERN.matcher(text); + while (m.find()) { + excludedRanges.add(new int[]{m.start(), m.end()}); + } + } + + private boolean isExcluded(int pos) { + for (int[] range : excludedRanges) { + if (pos >= range[0] && pos < range[1]) return true; + } + return false; + } + + /** + * Parse function declarations and infer parameter types from hook signatures. + */ + private void parseFunctions(List marks) { + Matcher m = FUNCTION_PATTERN.matcher(text); + while (m.find()) { + if (isExcluded(m.start())) continue; + + String funcName = m.group(1); + String params = m.group(2); + + // Mark function name + int nameStart = m.start(1); + int nameEnd = m.end(1); + + // Check if this is a known hook + if (registry.isHook(funcName)) { + marks.add(new ScriptLine.Mark(nameStart, nameEnd, TokenType.METHOD_DECL, + new JSHoverInfo.FunctionInfo(funcName, registry.getHookSignatures(funcName)))); + + // Infer parameter types from hook + List sigs = registry.getHookSignatures(funcName); + if (!sigs.isEmpty() && !params.isEmpty()) { + // Parse parameter names from function + String[] paramNames = params.split(","); + if (paramNames.length > 0) { + String paramName = paramNames[0].trim(); + // Use first hook signature's type + String paramType = sigs.get(0).paramType; + + // Store in function params and variable types + Map funcParamMap = new HashMap<>(); + funcParamMap.put(paramName, paramType); + functionParams.put(funcName, funcParamMap); + variableTypes.put(paramName, paramType); + + // Mark the parameter + int paramStart = m.start(2) + params.indexOf(paramName); + int paramEnd = paramStart + paramName.length(); + JSTypeInfo typeInfo = registry.getType(paramType); + marks.add(new ScriptLine.Mark(paramStart, paramEnd, TokenType.PARAMETER, + new JSHoverInfo.VariableInfo(paramName, paramType, typeInfo))); + } + } + } else { + marks.add(new ScriptLine.Mark(nameStart, nameEnd, TokenType.METHOD_DECL, funcName)); + } + } + } + + /** + * Parse variable declarations and infer types. + */ + private void parseVariables(List marks) { + Matcher m = VAR_DECL_PATTERN.matcher(text); + while (m.find()) { + if (isExcluded(m.start())) continue; + + String varName = m.group(1); + String initializer = m.group(2); + + // Infer type from initializer + String inferredType = null; + if (initializer != null) { + inferredType = inferTypeFromExpression(initializer.trim()); + } + + if (inferredType != null) { + variableTypes.put(varName, inferredType); + } + + // Mark variable declaration + int varStart = m.start(1); + int varEnd = m.end(1); + JSTypeInfo typeInfo = inferredType != null ? registry.getType(inferredType) : null; + marks.add(new ScriptLine.Mark(varStart, varEnd, TokenType.LOCAL_FIELD, + new JSHoverInfo.VariableInfo(varName, inferredType != null ? inferredType : "any", typeInfo))); + } + } + + /** + * Infer type from an expression. + */ + private String inferTypeFromExpression(String expr) { + if (expr == null || expr.isEmpty()) return null; + + // String literal + if (expr.startsWith("\"") || expr.startsWith("'")) { + return "string"; + } + + // Number literal + if (expr.matches("\\d+\\.?\\d*")) { + return "number"; + } + + // Boolean literal + if (expr.equals("true") || expr.equals("false")) { + return "boolean"; + } + + // null/undefined + if (expr.equals("null")) return "null"; + if (expr.equals("undefined")) return "undefined"; + + // Array literal + if (expr.startsWith("[")) { + return "any[]"; + } + + // Object literal + if (expr.startsWith("{")) { + return "object"; + } + + // Method call: something.method() - infer from method return type + if (expr.contains(".") && expr.contains("(")) { + return inferTypeFromMethodCall(expr); + } + + // Variable reference + if (variableTypes.containsKey(expr)) { + return variableTypes.get(expr); + } + + return null; + } + + /** + * Infer type from a method call chain. + */ + private String inferTypeFromMethodCall(String expr) { + // Remove trailing parentheses and args for analysis + int parenIndex = expr.indexOf('('); + if (parenIndex > 0) { + expr = expr.substring(0, parenIndex); + } + + String[] parts = expr.split("\\."); + if (parts.length < 2) return null; + + // Start with the receiver type + String currentType = variableTypes.get(parts[0]); + if (currentType == null) return null; + + // Walk the chain + for (int i = 1; i < parts.length; i++) { + JSTypeInfo typeInfo = registry.getType(currentType); + if (typeInfo == null) return null; + + String member = parts[i]; + + // Check if it's a method + JSMethodInfo method = typeInfo.getMethod(member); + if (method != null) { + currentType = method.getReturnType(); + continue; + } + + // Check if it's a field + JSFieldInfo field = typeInfo.getField(member); + if (field != null) { + currentType = field.getType(); + continue; + } + + return null; // Unknown member + } + + return currentType; + } + + /** + * Mark member accesses (x.y.z) with type validation. + */ + private void markMemberAccesses(List marks) { + Matcher m = MEMBER_ACCESS_PATTERN.matcher(text); + while (m.find()) { + if (isExcluded(m.start())) continue; + + String fullAccess = m.group(0); + String[] parts = fullAccess.split("\\."); + + if (parts.length < 2) continue; + + // Get receiver type + String receiverName = parts[0]; + String currentType = variableTypes.get(receiverName); + + int pos = m.start(); + + // Mark receiver + if (currentType != null) { + JSTypeInfo typeInfo = registry.getType(currentType); + marks.add(new ScriptLine.Mark(pos, pos + receiverName.length(), TokenType.LOCAL_FIELD, + new JSHoverInfo.VariableInfo(receiverName, currentType, typeInfo))); + } + + pos += receiverName.length() + 1; // +1 for the dot + + // Walk the chain and mark each member + for (int i = 1; i < parts.length; i++) { + String member = parts[i]; + int memberStart = pos; + int memberEnd = pos + member.length(); + + if (currentType != null) { + JSTypeInfo typeInfo = registry.getType(currentType); + if (typeInfo != null) { + // Check method first + JSMethodInfo method = typeInfo.getMethod(member); + if (method != null) { + marks.add(new ScriptLine.Mark(memberStart, memberEnd, TokenType.METHOD_CALL, + new JSHoverInfo.MethodInfo(method, typeInfo))); + currentType = method.getReturnType(); + } else { + // Check field + JSFieldInfo field = typeInfo.getField(member); + if (field != null) { + marks.add(new ScriptLine.Mark(memberStart, memberEnd, TokenType.GLOBAL_FIELD, + new JSHoverInfo.FieldInfo(field, typeInfo))); + currentType = field.getType(); + } else { + // Unknown member - mark as undefined + marks.add(new ScriptLine.Mark(memberStart, memberEnd, TokenType.UNDEFINED_VAR, + "Unknown member '" + member + "' on type " + typeInfo.getFullName())); + currentType = null; + } + } + } else { + currentType = null; + } + } + + pos = memberEnd + 1; // +1 for the next dot + } + } + } + + /** + * Mark method calls. + */ + private void markMethodCalls(List marks) { + Matcher m = METHOD_CALL_PATTERN.matcher(text); + while (m.find()) { + if (isExcluded(m.start())) continue; + + String callExpr = m.group(1); + if (!callExpr.contains(".")) { + // Simple function call + int nameStart = m.start(1); + int nameEnd = m.end(1); + + if (registry.isHook(callExpr)) { + // It's a known hook being called + marks.add(new ScriptLine.Mark(nameStart, nameEnd, TokenType.METHOD_CALL, + new JSHoverInfo.FunctionInfo(callExpr, registry.getHookSignatures(callExpr)))); + } + } + // Chained calls are handled in markMemberAccesses + } + } + + /** + * Add pattern-based marks. + */ + private void addPatternMarks(List marks, Pattern pattern, TokenType type) { + Matcher m = pattern.matcher(text); + while (m.find()) { + marks.add(new ScriptLine.Mark(m.start(), m.end(), type)); + } + } + + /** + * Get the inferred type of a variable at a position. + */ + public String getVariableType(String varName) { + return variableTypes.get(varName); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSTypeInfo.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSTypeInfo.java new file mode 100644 index 000000000..7efdd8481 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSTypeInfo.java @@ -0,0 +1,166 @@ +package noppes.npcs.client.gui.util.script.interpreter.js_parser; + +import java.util.*; + +/** + * Represents a TypeScript interface/type parsed from .d.ts files. + * This is the JS equivalent of TypeInfo for Java types. + */ +public class JSTypeInfo { + + private final String simpleName; // e.g., "InteractEvent" + private final String fullName; // e.g., "IPlayerEvent.InteractEvent" + private final String namespace; // e.g., "IPlayerEvent" (parent namespace, null for top-level) + + // Members + private final Map methods = new LinkedHashMap<>(); + private final Map fields = new LinkedHashMap<>(); + + // Inheritance + private String extendsType; // The type this interface extends + private JSTypeInfo resolvedParent; // Resolved parent type (after registry is built) + + // Inner types (for namespaces) + private final Map innerTypes = new LinkedHashMap<>(); + private JSTypeInfo parentType; // The containing type (for inner types) + + // Documentation + private String documentation; + + public JSTypeInfo(String simpleName, String namespace) { + this.simpleName = simpleName; + this.namespace = namespace; + this.fullName = namespace != null ? namespace + "." + simpleName : simpleName; + } + + // Builder methods + public JSTypeInfo setExtends(String extendsType) { + this.extendsType = extendsType; + return this; + } + + public JSTypeInfo setDocumentation(String documentation) { + this.documentation = documentation; + return this; + } + + public void addMethod(JSMethodInfo method) { + // Handle overloads - store with index if name already exists + String key = method.getName(); + if (methods.containsKey(key)) { + // Find next available key for overload + int index = 1; + while (methods.containsKey(key + "$" + index)) { + index++; + } + methods.put(key + "$" + index, method); + } else { + methods.put(key, method); + } + } + + public void addField(JSFieldInfo field) { + fields.put(field.getName(), field); + } + + public void addInnerType(JSTypeInfo inner) { + inner.parentType = this; + innerTypes.put(inner.getSimpleName(), inner); + } + + public void setResolvedParent(JSTypeInfo parent) { + this.resolvedParent = parent; + } + + // Getters + public String getSimpleName() { return simpleName; } + public String getFullName() { return fullName; } + public String getNamespace() { return namespace; } + public String getExtendsType() { return extendsType; } + public JSTypeInfo getResolvedParent() { return resolvedParent; } + public String getDocumentation() { return documentation; } + public JSTypeInfo getParentType() { return parentType; } + + public Map getMethods() { return methods; } + public Map getFields() { return fields; } + public Map getInnerTypes() { return innerTypes; } + + /** + * Get a method by name, including inherited methods. + */ + public JSMethodInfo getMethod(String name) { + JSMethodInfo method = methods.get(name); + if (method != null) return method; + + // Check parent + if (resolvedParent != null) { + return resolvedParent.getMethod(name); + } + return null; + } + + /** + * Get all methods with a given name (for overloads). + */ + public List getMethodOverloads(String name) { + List overloads = new ArrayList<>(); + + // Get from this type + if (methods.containsKey(name)) { + overloads.add(methods.get(name)); + } + // Get numbered overloads + int index = 1; + while (methods.containsKey(name + "$" + index)) { + overloads.add(methods.get(name + "$" + index)); + index++; + } + + // Get from parent + if (resolvedParent != null) { + overloads.addAll(resolvedParent.getMethodOverloads(name)); + } + + return overloads; + } + + /** + * Check if this type has a method (including inherited). + */ + public boolean hasMethod(String name) { + return getMethod(name) != null; + } + + /** + * Get a field by name, including inherited fields. + */ + public JSFieldInfo getField(String name) { + JSFieldInfo field = fields.get(name); + if (field != null) return field; + + // Check parent + if (resolvedParent != null) { + return resolvedParent.getField(name); + } + return null; + } + + /** + * Check if this type has a field (including inherited). + */ + public boolean hasField(String name) { + return getField(name) != null; + } + + /** + * Get an inner type by name. + */ + public JSTypeInfo getInnerType(String name) { + return innerTypes.get(name); + } + + @Override + public String toString() { + return "JSTypeInfo{" + fullName + "}"; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSTypeRegistry.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSTypeRegistry.java new file mode 100644 index 000000000..7234197d1 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSTypeRegistry.java @@ -0,0 +1,379 @@ +package noppes.npcs.client.gui.util.script.interpreter.js_parser; + +import net.minecraft.client.Minecraft; +import net.minecraft.util.ResourceLocation; + +import java.io.*; +import java.util.*; + +/** + * Central registry for all TypeScript types parsed from .d.ts files. + * Also manages hook function signatures and type aliases. + */ +public class JSTypeRegistry { + + private static JSTypeRegistry INSTANCE; + + // Resource location for the API definitions + private static final String API_RESOURCE_PATH = "customnpcs:api/"; + + // All registered types by full name (e.g., "IPlayerEvent.InteractEvent") + private final Map types = new LinkedHashMap<>(); + + // Type aliases (simple name -> full type name) + private final Map typeAliases = new HashMap<>(); + + // Hook function signatures: functionName -> list of (paramName, paramType) pairs + // Multiple entries for overloaded hooks + private final Map> hooks = new LinkedHashMap<>(); + + // Primitive types + private static final Set PRIMITIVES = new HashSet<>(Arrays.asList( + "number", "string", "boolean", "void", "any", "null", "undefined", "never", "object" + )); + + private boolean initialized = false; + private boolean initializationAttempted = false; + + public static JSTypeRegistry getInstance() { + if (INSTANCE == null) { + INSTANCE = new JSTypeRegistry(); + } + return INSTANCE; + } + + private JSTypeRegistry() {} + + /** + * Initialize the registry from the embedded resources. + * This loads .d.ts files from assets/customnpcs/api/ + */ + public void initializeFromResources() { + if (initialized || initializationAttempted) return; + initializationAttempted = true; + + try { + TypeScriptDefinitionParser parser = new TypeScriptDefinitionParser(this); + + // Load hooks.d.ts first (defines function parameter types) + loadResourceFile(parser, "hooks.d.ts"); + + // Load index.d.ts (type aliases) + loadResourceFile(parser, "index.d.ts"); + + // Load main API files + loadResourceDirectory(parser, "noppes/npcs/api/"); + loadResourceDirectory(parser, "noppes/npcs/api/entity/"); + loadResourceDirectory(parser, "noppes/npcs/api/event/"); + loadResourceDirectory(parser, "noppes/npcs/api/handler/"); + loadResourceDirectory(parser, "noppes/npcs/api/item/"); + loadResourceDirectory(parser, "noppes/npcs/api/block/"); + loadResourceDirectory(parser, "noppes/npcs/api/gui/"); + + resolveInheritance(); + initialized = true; + System.out.println("[JSTypeRegistry] Loaded " + types.size() + " types, " + hooks.size() + " hooks from resources"); + } catch (Exception e) { + System.err.println("[JSTypeRegistry] Failed to load type definitions from resources: " + e.getMessage()); + e.printStackTrace(); + } + } + + /** + * Load a specific .d.ts file from resources. + */ + private void loadResourceFile(TypeScriptDefinitionParser parser, String fileName) { + try { + ResourceLocation loc = new ResourceLocation("customnpcs", "api/" + fileName); + InputStream is = Minecraft.getMinecraft().getResourceManager().getResource(loc).getInputStream(); + if (is != null) { + try (BufferedReader reader = new BufferedReader(new InputStreamReader(is))) { + StringBuilder sb = new StringBuilder(); + String line; + while ((line = reader.readLine()) != null) { + sb.append(line).append("\n"); + } + parser.parseDefinitionFile(sb.toString(), fileName); + } + } + } catch (Exception e) { + // File might not exist, that's ok + System.out.println("[JSTypeRegistry] Could not load " + fileName + ": " + e.getMessage()); + } + } + + /** + * Load all .d.ts files from a resource directory. + */ + private void loadResourceDirectory(TypeScriptDefinitionParser parser, String dirPath) { + // In Minecraft resources, we can't list directory contents directly + // So we'll try to load known files from a manifest or just try common patterns + // For now, let's try loading specific known files + String[] knownFiles = getKnownFilesForDirectory(dirPath); + for (String file : knownFiles) { + loadResourceFile(parser, dirPath + file); + } + } + + /** + * Get list of known .d.ts files for a directory. + * This is a workaround since we can't list resource directories. + */ + private String[] getKnownFilesForDirectory(String dirPath) { + // These are the known API files based on the actual file structure + if (dirPath.endsWith("noppes/npcs/api/")) { + return new String[]{ + "AbstractNpcAPI.d.ts", "IBlock.d.ts", "ICommand.d.ts", "IContainer.d.ts", + "IDamageSource.d.ts", "INbt.d.ts", "IParticle.d.ts", "IPixelmonPlayerData.d.ts", + "IPos.d.ts", "IScreenSize.d.ts", "ISkinOverlay.d.ts", "ITileEntity.d.ts", + "ITimers.d.ts", "IWorld.d.ts" + }; + } else if (dirPath.endsWith("entity/")) { + return new String[]{ + "ICustomNpc.d.ts", "IEntity.d.ts", "IEntityItem.d.ts", "IEntityLiving.d.ts", + "IEntityLivingBase.d.ts", "IPlayer.d.ts", "IProjectile.d.ts", "IAnimal.d.ts", + "IAnimatable.d.ts", "IArrow.d.ts", "IDBCPlayer.d.ts", "IFishHook.d.ts", + "IMonster.d.ts", "IPixelmon.d.ts", "IThrowable.d.ts", "IVillager.d.ts" + }; + } else if (dirPath.endsWith("event/")) { + return new String[]{ + "INpcEvent.d.ts", "IPlayerEvent.d.ts", "IItemEvent.d.ts", "IBlockEvent.d.ts", + "IDialogEvent.d.ts", "IQuestEvent.d.ts", "ICustomGuiEvent.d.ts", + "IAnimationEvent.d.ts", "ICustomNPCsEvent.d.ts", "IFactionEvent.d.ts", + "IForgeEvent.d.ts", "ILinkedItemEvent.d.ts", "IPartyEvent.d.ts", + "IProjectileEvent.d.ts", "IRecipeEvent.d.ts" + }; + } else if (dirPath.endsWith("handler/")) { + return new String[]{ + "ICloneHandler.d.ts", "IDialogHandler.d.ts", "IFactionHandler.d.ts", + "IQuestHandler.d.ts", "IRecipeHandler.d.ts", "ITagHandler.d.ts", + "IAnimationHandler.d.ts", "IActionManager.d.ts", "IAttributeHandler.d.ts", + "ICustomEffectHandler.d.ts", "IMagicHandler.d.ts", "INaturalSpawnsHandler.d.ts", + "IOverlayHandler.d.ts", "IPartyHandler.d.ts", "IPlayerBankData.d.ts", + "IPlayerData.d.ts", "IPlayerDialogData.d.ts", "IPlayerFactionData.d.ts", + "IPlayerItemGiverData.d.ts", "IPlayerMailData.d.ts", "IPlayerQuestData.d.ts", + "IPlayerTransportData.d.ts", "IProfileHandler.d.ts", "ITransportHandler.d.ts" + }; + } else if (dirPath.endsWith("item/")) { + return new String[]{ + "IItemStack.d.ts", "IItemArmor.d.ts", "IItemBook.d.ts", "IItemBlock.d.ts", + "IItemCustom.d.ts", "IItemCustomizable.d.ts", "IItemLinked.d.ts" + }; + } else if (dirPath.endsWith("block/")) { + return new String[]{ + "IBlockScripted.d.ts", "ITextPlane.d.ts" + }; + } else if (dirPath.endsWith("gui/")) { + return new String[]{ + "IButton.d.ts", "ICustomGui.d.ts", "ILabel.d.ts", "ITextField.d.ts", + "ITexturedRect.d.ts", "IScroll.d.ts", "IItemSlot.d.ts", "ICustomGuiComponent.d.ts", + "ILine.d.ts" + }; + } + return new String[]{}; + } + + /** + * Initialize the registry from a directory containing .d.ts files. + */ + public void initializeFromDirectory(File directory) { + if (initialized) return; + + try { + TypeScriptDefinitionParser parser = new TypeScriptDefinitionParser(this); + parser.parseDirectory(directory); + resolveInheritance(); + initialized = true; + System.out.println("[JSTypeRegistry] Loaded " + types.size() + " types, " + hooks.size() + " hooks"); + } catch (IOException e) { + System.err.println("[JSTypeRegistry] Failed to load type definitions: " + e.getMessage()); + e.printStackTrace(); + } + } + + /** + * Initialize the registry from a VSIX file. + */ + public void initializeFromVsix(File vsixFile) { + if (initialized) return; + + try { + TypeScriptDefinitionParser parser = new TypeScriptDefinitionParser(this); + parser.parseVsixArchive(vsixFile); + resolveInheritance(); + initialized = true; + System.out.println("[JSTypeRegistry] Loaded " + types.size() + " types, " + hooks.size() + " hooks from VSIX"); + } catch (IOException e) { + System.err.println("[JSTypeRegistry] Failed to load VSIX: " + e.getMessage()); + e.printStackTrace(); + } + } + + /** + * Register a type. + */ + public void registerType(JSTypeInfo type) { + types.put(type.getFullName(), type); + } + + /** + * Register a type alias. + */ + public void registerTypeAlias(String alias, String fullType) { + typeAliases.put(alias, fullType); + } + + /** + * Register a hook function signature. + */ + public void registerHook(String functionName, String paramName, String paramType) { + hooks.computeIfAbsent(functionName, k -> new ArrayList<>()) + .add(new HookSignature(paramName, paramType)); + } + + /** + * Get a type by name (handles aliases and primitives). + */ + public JSTypeInfo getType(String name) { + return getType(name, new HashSet<>()); + } + + /** + * Internal method with cycle detection for type aliases. + */ + private JSTypeInfo getType(String name, Set visited) { + if (name == null || name.isEmpty()) return null; + + // Strip array brackets for lookup + String baseName = name.replace("[]", "").trim(); + + // Check if primitive + if (PRIMITIVES.contains(baseName)) { + return null; // Primitives don't have JSTypeInfo + } + + // Detect circular alias references + if (visited.contains(baseName)) { + System.err.println("[JSTypeRegistry] Circular type alias detected: " + baseName); + return null; + } + visited.add(baseName); + + // Direct lookup + if (types.containsKey(baseName)) { + return types.get(baseName); + } + + // Check type aliases + if (typeAliases.containsKey(baseName)) { + String resolved = typeAliases.get(baseName); + return getType(resolved, visited); + } + + // Try simple name lookup (for types like "IEntity" without namespace) + for (JSTypeInfo type : types.values()) { + if (type.getSimpleName().equals(baseName)) { + return type; + } + } + + return null; + } + + /** + * Check if a type name is a known primitive. + */ + public boolean isPrimitive(String typeName) { + return PRIMITIVES.contains(typeName); + } + + /** + * Get hook signatures for a function name. + */ + public List getHookSignatures(String functionName) { + return hooks.getOrDefault(functionName, Collections.emptyList()); + } + + /** + * Check if a function name is a known hook. + */ + public boolean isHook(String functionName) { + return hooks.containsKey(functionName); + } + + /** + * Get the parameter type for a hook function. + * If multiple overloads exist, returns the first one. + */ + public String getHookParameterType(String functionName) { + List sigs = hooks.get(functionName); + if (sigs != null && !sigs.isEmpty()) { + return sigs.get(0).paramType; + } + return null; + } + + /** + * Resolve inheritance relationships between types. + */ + private void resolveInheritance() { + for (JSTypeInfo type : types.values()) { + String extendsType = type.getExtendsType(); + if (extendsType != null) { + JSTypeInfo parent = getType(extendsType); + if (parent != null) { + type.setResolvedParent(parent); + } + } + } + } + + /** + * Get all registered types. + */ + public Collection getAllTypes() { + return types.values(); + } + + /** + * Get all registered hooks. + */ + public Map> getAllHooks() { + return hooks; + } + + /** + * Check if initialized. + */ + public boolean isInitialized() { + return initialized; + } + + /** + * Clear the registry (for reloading). + */ + public void clear() { + types.clear(); + typeAliases.clear(); + hooks.clear(); + initialized = false; + } + + /** + * Represents a hook function signature. + */ + public static class HookSignature { + public final String paramName; + public final String paramType; + + public HookSignature(String paramName, String paramType) { + this.paramName = paramName; + this.paramType = paramType; + } + + @Override + public String toString() { + return paramName + ": " + paramType; + } + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/TypeScriptDefinitionParser.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/TypeScriptDefinitionParser.java new file mode 100644 index 000000000..726672b47 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/TypeScriptDefinitionParser.java @@ -0,0 +1,355 @@ +package noppes.npcs.client.gui.util.script.interpreter.js_parser; + +import java.io.*; +import java.util.*; +import java.util.regex.*; +import java.util.zip.*; + +/** + * Parses TypeScript definition files (.d.ts) to extract type information. + * Can read from individual files, directories, or .vsix archives. + */ +public class TypeScriptDefinitionParser { + + // Patterns for parsing .d.ts content + private static final Pattern INTERFACE_PATTERN = Pattern.compile( + "export\\s+interface\\s+(\\w+)(?:\\s+extends\\s+([\\w.]+))?\\s*\\{"); + + private static final Pattern NAMESPACE_PATTERN = Pattern.compile( + "export\\s+namespace\\s+(\\w+)\\s*\\{"); + + private static final Pattern TYPE_ALIAS_PATTERN = Pattern.compile( + "export\\s+type\\s+(\\w+)\\s*=\\s*([^;]+);"); + + private static final Pattern METHOD_PATTERN = Pattern.compile( + "^\\s*(\\w+)\\s*\\(([^)]*)\\)\\s*:\\s*([^;]+);", Pattern.MULTILINE); + + private static final Pattern FIELD_PATTERN = Pattern.compile( + "^\\s*(readonly\\s+)?(\\w+)\\s*:\\s*([^;]+);", Pattern.MULTILINE); + + private static final Pattern GLOBAL_FUNCTION_PATTERN = Pattern.compile( + "function\\s+(\\w+)\\s*\\(([^)]*)\\)\\s*:\\s*([^;]+);"); + + private static final Pattern GLOBAL_TYPE_ALIAS_PATTERN = Pattern.compile( + "type\\s+(\\w+)\\s*=\\s*import\\(['\"]([^'\"]+)['\"]\\)\\.([\\w.]+);"); + + private final JSTypeRegistry registry; + + public TypeScriptDefinitionParser(JSTypeRegistry registry) { + this.registry = registry; + } + + /** + * Parse all .d.ts files from a VSIX archive. + */ + public void parseVsixArchive(File vsixFile) throws IOException { + try (ZipFile zip = new ZipFile(vsixFile)) { + Enumeration entries = zip.entries(); + while (entries.hasMoreElements()) { + ZipEntry entry = entries.nextElement(); + if (entry.getName().endsWith(".d.ts")) { + try (InputStream is = zip.getInputStream(entry); + BufferedReader reader = new BufferedReader(new InputStreamReader(is))) { + String content = readFully(reader); + String fileName = entry.getName(); + parseDefinitionFile(content, fileName); + } + } + } + } + } + + /** + * Parse all .d.ts files from a directory recursively. + */ + public void parseDirectory(File directory) throws IOException { + if (!directory.isDirectory()) { + throw new IllegalArgumentException("Not a directory: " + directory); + } + parseDirectoryRecursive(directory); + } + + private void parseDirectoryRecursive(File dir) throws IOException { + File[] files = dir.listFiles(); + if (files == null) return; + + for (File file : files) { + if (file.isDirectory()) { + parseDirectoryRecursive(file); + } else if (file.getName().endsWith(".d.ts")) { + parseFile(file); + } + } + } + + /** + * Parse a single .d.ts file. + */ + public void parseFile(File file) throws IOException { + try (BufferedReader reader = new BufferedReader(new FileReader(file))) { + String content = readFully(reader); + parseDefinitionFile(content, file.getName()); + } + } + + /** + * Parse a .d.ts file content. + */ + public void parseDefinitionFile(String content, String fileName) { + // Special handling for hooks.d.ts - extract function signatures + if (fileName.contains("hooks.d.ts")) { + parseHooksFile(content); + return; + } + + // Special handling for index.d.ts - extract global type aliases + if (fileName.contains("index.d.ts")) { + parseIndexFile(content); + return; + } + + // Parse regular interface files + parseInterfaceFile(content, null); + } + + /** + * Parse hooks.d.ts to extract function signatures for JS hooks. + */ + private void parseHooksFile(String content) { + Matcher m = GLOBAL_FUNCTION_PATTERN.matcher(content); + while (m.find()) { + String funcName = m.group(1); + String params = m.group(2); + String returnType = m.group(3).trim(); + + // Parse parameter - format is "paramName: TypeName" + if (!params.isEmpty()) { + String[] parts = params.split(":\\s*", 2); + if (parts.length == 2) { + String paramName = parts[0].trim(); + String paramType = parts[1].trim(); + registry.registerHook(funcName, paramName, paramType); + } + } + } + } + + /** + * Parse index.d.ts to extract global type aliases. + */ + private void parseIndexFile(String content) { + Matcher m = GLOBAL_TYPE_ALIAS_PATTERN.matcher(content); + while (m.find()) { + String aliasName = m.group(1); + String importPath = m.group(2); + String typeName = m.group(3); + registry.registerTypeAlias(aliasName, typeName); + } + } + + /** + * Parse interface definitions from content. + */ + private void parseInterfaceFile(String content, String parentNamespace) { + // Find interfaces + Matcher interfaceMatcher = INTERFACE_PATTERN.matcher(content); + while (interfaceMatcher.find()) { + String interfaceName = interfaceMatcher.group(1); + String extendsType = interfaceMatcher.group(2); + + JSTypeInfo typeInfo = new JSTypeInfo(interfaceName, parentNamespace); + if (extendsType != null) { + typeInfo.setExtends(extendsType); + } + + // Find the body of this interface + int bodyStart = interfaceMatcher.end(); + int bodyEnd = findMatchingBrace(content, bodyStart - 1); + if (bodyEnd > bodyStart) { + String body = content.substring(bodyStart, bodyEnd); + parseInterfaceBody(body, typeInfo); + } + + registry.registerType(typeInfo); + } + + // Find namespaces (which contain inner types) + Matcher namespaceMatcher = NAMESPACE_PATTERN.matcher(content); + while (namespaceMatcher.find()) { + String namespaceName = namespaceMatcher.group(1); + + // Find the body of this namespace + int bodyStart = namespaceMatcher.end(); + int bodyEnd = findMatchingBrace(content, bodyStart - 1); + if (bodyEnd > bodyStart) { + String body = content.substring(bodyStart, bodyEnd); + + // Recursively parse inner types with namespace prefix + String fullNamespace = parentNamespace != null ? + parentNamespace + "." + namespaceName : namespaceName; + parseInterfaceFile(body, fullNamespace); + + // Also handle type aliases within namespace + parseTypeAliases(body, fullNamespace); + } + } + + // Handle top-level type aliases + if (parentNamespace == null) { + parseTypeAliases(content, null); + } + } + + /** + * Parse type aliases (export type X = Y). + */ + private void parseTypeAliases(String content, String namespace) { + Matcher m = TYPE_ALIAS_PATTERN.matcher(content); + while (m.find()) { + String aliasName = m.group(1); + String targetType = m.group(2).trim(); + + // Create a simple type that extends the target + JSTypeInfo typeInfo = new JSTypeInfo(aliasName, namespace); + typeInfo.setExtends(targetType); + registry.registerType(typeInfo); + } + } + + /** + * Parse the body of an interface to extract methods and fields. + */ + private void parseInterfaceBody(String body, JSTypeInfo typeInfo) { + // Parse methods + Matcher methodMatcher = METHOD_PATTERN.matcher(body); + while (methodMatcher.find()) { + String methodName = methodMatcher.group(1); + String params = methodMatcher.group(2); + String returnType = cleanType(methodMatcher.group(3)); + + List parameters = parseParameters(params); + JSMethodInfo method = new JSMethodInfo(methodName, returnType, parameters); + typeInfo.addMethod(method); + } + + // Parse fields (that aren't method signatures) + Matcher fieldMatcher = FIELD_PATTERN.matcher(body); + while (fieldMatcher.find()) { + String fieldText = fieldMatcher.group(0); + // Skip if this looks like a method (has parentheses in the match) + if (fieldText.contains("(")) continue; + + boolean readonly = fieldMatcher.group(1) != null; + String fieldName = fieldMatcher.group(2); + String fieldType = cleanType(fieldMatcher.group(3)); + + JSFieldInfo field = new JSFieldInfo(fieldName, fieldType, readonly); + typeInfo.addField(field); + } + } + + /** + * Parse parameters string into list of parameter info. + */ + private List parseParameters(String params) { + List result = new ArrayList<>(); + if (params == null || params.trim().isEmpty()) { + return result; + } + + // Split by comma, but be careful of nested types like Map + List paramParts = splitParameters(params); + + for (String part : paramParts) { + part = part.trim(); + if (part.isEmpty()) continue; + + // Format: name: type or name?: type + int colonIndex = part.indexOf(':'); + if (colonIndex > 0) { + String name = part.substring(0, colonIndex).trim().replace("?", ""); + String type = cleanType(part.substring(colonIndex + 1).trim()); + result.add(new JSMethodInfo.JSParameterInfo(name, type)); + } + } + + return result; + } + + /** + * Split parameters respecting nested angle brackets. + */ + private List splitParameters(String params) { + List result = new ArrayList<>(); + int depth = 0; + int start = 0; + + for (int i = 0; i < params.length(); i++) { + char c = params.charAt(i); + if (c == '<' || c == '(' || c == '[') { + depth++; + } else if (c == '>' || c == ')' || c == ']') { + depth--; + } else if (c == ',' && depth == 0) { + result.add(params.substring(start, i)); + start = i + 1; + } + } + + if (start < params.length()) { + result.add(params.substring(start)); + } + + return result; + } + + /** + * Clean up a type string (remove import() syntax, trim, etc.). + */ + private String cleanType(String type) { + if (type == null) return "any"; + type = type.trim(); + + // Handle import('./path').TypeName syntax + if (type.startsWith("import(")) { + // Extract the type name after the import + int dotIndex = type.lastIndexOf(")."); + if (dotIndex > 0) { + type = type.substring(dotIndex + 2); + } + } + + // Handle arrays + type = type.replace("[]", "[]"); + + return type; + } + + /** + * Find the matching closing brace. + */ + private int findMatchingBrace(String text, int openBracePos) { + int depth = 1; + for (int i = openBracePos + 1; i < text.length(); i++) { + char c = text.charAt(i); + if (c == '{') depth++; + else if (c == '}') { + depth--; + if (depth == 0) return i; + } + } + return -1; + } + + /** + * Read entire content from reader. + */ + private String readFully(BufferedReader reader) throws IOException { + StringBuilder sb = new StringBuilder(); + String line; + while ((line = reader.readLine()) != null) { + sb.append(line).append("\n"); + } + return sb.toString(); + } +} diff --git a/src/main/resources/assets/customnpcs/api/forge-events-raw.d.ts b/src/main/resources/assets/customnpcs/api/forge-events-raw.d.ts new file mode 100644 index 000000000..30846c672 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/forge-events-raw.d.ts @@ -0,0 +1,697 @@ +/** + * Specialized Raw Forge 1.7.10 Event Definitions + * Deep package hierarchy to match Java source (Forge/MCP). + */ + +declare global { + namespace cpw.mods.fml.common.eventhandler { + /** cpw.mods.fml.common.eventhandler.Event */ + export interface Event { + /** @returns If this event can be canceled */ + isCancelable(): boolean; + /** @returns If this event has been canceled */ + isCanceled(): boolean; + /** Sets the canceled state */ + setCanceled(cancel: boolean): void; + /** @returns The current result (ALLOW, DENY, DEFAULT) */ + getResult(): 'ALLOW' | 'DENY' | 'DEFAULT'; + /** Sets the result */ + setResult(result: 'ALLOW' | 'DENY' | 'DEFAULT'): void; + /** @returns If this event has a result */ + hasResult(): boolean; + } + } + + namespace cpw.mods.fml.common.gameevent { + /** cpw.mods.fml.common.gameevent.TickEvent */ + export interface TickEvent extends cpw.mods.fml.common.eventhandler.Event { + type: 'PLAYER' | 'WORLD' | 'SERVER' | 'CLIENT' | 'RENDER'; + side: 'CLIENT' | 'SERVER'; + phase: 'START' | 'END'; + } + + export namespace TickEvent { + /** cpw.mods.fml.common.gameevent.TickEvent.PlayerTickEvent */ + export interface PlayerTickEvent extends cpw.mods.fml.common.gameevent.TickEvent { + player: net.minecraft.entity.player.EntityPlayer; + } + /** cpw.mods.fml.common.gameevent.TickEvent.WorldTickEvent */ + export interface WorldTickEvent extends cpw.mods.fml.common.gameevent.TickEvent { + world: net.minecraft.world.World; + } + /** cpw.mods.fml.common.gameevent.TickEvent.ServerTickEvent */ + export type ServerTickEvent = cpw.mods.fml.common.gameevent.TickEvent + /** cpw.mods.fml.common.gameevent.TickEvent.ClientTickEvent */ + export type ClientTickEvent = cpw.mods.fml.common.gameevent.TickEvent + /** cpw.mods.fml.common.gameevent.TickEvent.RenderTickEvent */ + export interface RenderTickEvent extends cpw.mods.fml.common.gameevent.TickEvent { + renderTickTime: number; + } + } + + /** cpw.mods.fml.common.gameevent.InputEvent */ + export type InputEvent = cpw.mods.fml.common.eventhandler.Event + export namespace InputEvent { + /** cpw.mods.fml.common.gameevent.InputEvent.KeyInputEvent */ + export type KeyInputEvent = InputEvent + /** cpw.mods.fml.common.gameevent.InputEvent.MouseInputEvent */ + export type MouseInputEvent = InputEvent + } + + /** cpw.mods.fml.common.gameevent.PlayerEvent */ + export interface PlayerEvent extends cpw.mods.fml.common.eventhandler.Event { + player: net.minecraft.entity.player.EntityPlayer; + } + export namespace PlayerEvent { + /** cpw.mods.fml.common.gameevent.PlayerEvent.PlayerLoggedInEvent */ + export type PlayerLoggedInEvent = cpw.mods.fml.common.gameevent.PlayerEvent + /** cpw.mods.fml.common.gameevent.PlayerEvent.PlayerLoggedOutEvent */ + export type PlayerLoggedOutEvent = cpw.mods.fml.common.gameevent.PlayerEvent + /** cpw.mods.fml.common.gameevent.PlayerEvent.PlayerRespawnEvent */ + export type PlayerRespawnEvent = cpw.mods.fml.common.gameevent.PlayerEvent + /** cpw.mods.fml.common.gameevent.PlayerEvent.PlayerChangedDimensionEvent */ + export interface PlayerChangedDimensionEvent extends cpw.mods.fml.common.gameevent.PlayerEvent { + fromDim: number; + toDim: number; + } + /** cpw.mods.fml.common.gameevent.PlayerEvent.ItemPickupEvent */ + export interface ItemPickupEvent extends cpw.mods.fml.common.gameevent.PlayerEvent { + pickedUp: net.minecraft.entity.EntityItem; + } + /** cpw.mods.fml.common.gameevent.PlayerEvent.ItemCraftedEvent */ + export interface ItemCraftedEvent extends cpw.mods.fml.common.gameevent.PlayerEvent { + craftMatrix: any; + crafting: net.minecraft.item.ItemStack; + } + /** cpw.mods.fml.common.gameevent.PlayerEvent.ItemSmeltedEvent */ + export interface ItemSmeltedEvent extends cpw.mods.fml.common.gameevent.PlayerEvent { + smelting: net.minecraft.item.ItemStack; + } + } + } + + namespace net.minecraftforge.event { + /** net.minecraftforge.event.AnvilUpdateEvent */ + export interface AnvilUpdateEvent extends cpw.mods.fml.common.eventhandler.Event { + left: net.minecraft.item.ItemStack; + right: net.minecraft.item.ItemStack; + name: string; + output: net.minecraft.item.ItemStack; + cost: number; + materialCost: number; + } + + /** net.minecraftforge.event.CommandEvent */ + export interface CommandEvent extends cpw.mods.fml.common.eventhandler.Event { + command: any; + sender: any; + parameters: string[]; + exception: any; + } + + /** net.minecraftforge.event.ServerChatEvent */ + export interface ServerChatEvent extends cpw.mods.fml.common.eventhandler.Event { + message: string; + username: string; + player: net.minecraft.entity.player.EntityPlayer; + component: any; + } + + /** net.minecraftforge.event.FuelBurnTimeEvent */ + export interface FuelBurnTimeEvent extends cpw.mods.fml.common.eventhandler.Event { + fuel: net.minecraft.item.ItemStack; + burnTime: number; + } + + export namespace brewing { + /** net.minecraftforge.event.brewing.PotionBrewEvent */ + export interface PotionBrewEvent extends cpw.mods.fml.common.eventhandler.Event { + getItem(index: number): net.minecraft.item.ItemStack; + setItem(index: number, stack: net.minecraft.item.ItemStack): void; + getLength(): number; + } + export namespace PotionBrewEvent { + export type Pre = PotionBrewEvent + export type Post = PotionBrewEvent + } + /** net.minecraftforge.event.brewing.PotionBrewedEvent */ + export interface PotionBrewedEvent extends cpw.mods.fml.common.eventhandler.Event { + brewingStacks: net.minecraft.item.ItemStack[]; + } + } + + export namespace entity { + /** net.minecraftforge.event.entity.EntityEvent */ + export interface EntityEvent extends cpw.mods.fml.common.eventhandler.Event { + entity: net.minecraft.entity.Entity; + } + export namespace EntityEvent { + /** net.minecraftforge.event.entity.EntityEvent.EntityConstructing */ + export type EntityConstructing = net.minecraftforge.event.entity.EntityEvent + /** net.minecraftforge.event.entity.EntityEvent.CanUpdate */ + export interface CanUpdate extends net.minecraftforge.event.entity.EntityEvent { + canUpdate: boolean; + } + /** net.minecraftforge.event.entity.EntityEvent.EnteringChunk */ + export interface EnteringChunk extends net.minecraftforge.event.entity.EntityEvent { + newChunkX: number; + newChunkZ: number; + oldChunkX: number; + oldChunkZ: number; + } + } + + /** net.minecraftforge.event.entity.EntityJoinWorldEvent */ + export interface EntityJoinWorldEvent extends net.minecraftforge.event.entity.EntityEvent { + world: net.minecraft.world.World; + } + + /** net.minecraftforge.event.entity.EntityStruckByLightningEvent */ + export interface EntityStruckByLightningEvent extends net.minecraftforge.event.entity.EntityEvent { + lightning: net.minecraft.entity.Entity; + } + + /** net.minecraftforge.event.entity.PlaySoundAtEntityEvent */ + export interface PlaySoundAtEntityEvent extends net.minecraftforge.event.entity.EntityEvent { + name: string; + volume: number; + pitch: number; + } + + export namespace item { + /** net.minecraftforge.event.entity.item.ItemEvent */ + export interface ItemEvent extends net.minecraftforge.event.entity.EntityEvent { + entityItem: net.minecraft.entity.EntityItem; + } + /** net.minecraftforge.event.entity.item.ItemExpireEvent */ + export interface ItemExpireEvent extends net.minecraftforge.event.entity.item.ItemEvent { + extraLife: number; + } + /** net.minecraftforge.event.entity.item.ItemTossEvent */ + export interface ItemTossEvent extends net.minecraftforge.event.entity.item.ItemEvent { + player: net.minecraft.entity.player.EntityPlayer; + } + } + + export namespace living { + /** net.minecraftforge.event.entity.living.LivingEvent */ + export interface LivingEvent extends net.minecraftforge.event.entity.EntityEvent { + entityLiving: net.minecraft.entity.EntityLivingBase; + } + export namespace LivingEvent { + /** net.minecraftforge.event.entity.living.LivingEvent.LivingUpdateEvent */ + export type LivingUpdateEvent = net.minecraftforge.event.entity.living.LivingEvent + /** net.minecraftforge.event.entity.living.LivingEvent.LivingJumpEvent */ + export type LivingJumpEvent = net.minecraftforge.event.entity.living.LivingEvent + } + + /** net.minecraftforge.event.entity.living.LivingAttackEvent */ + export interface LivingAttackEvent extends net.minecraftforge.event.entity.living.LivingEvent { + source: net.minecraft.damage.DamageSource; + ammount: number; + } + + /** net.minecraftforge.event.entity.living.LivingDeathEvent */ + export interface LivingDeathEvent extends net.minecraftforge.event.entity.living.LivingEvent { + source: net.minecraft.damage.DamageSource; + } + + /** net.minecraftforge.event.entity.living.LivingDropsEvent */ + export interface LivingDropsEvent extends net.minecraftforge.event.entity.living.LivingEvent { + source: net.minecraft.damage.DamageSource; + drops: any[]; + lootingLevel: number; + recentlyHit: boolean; + specialDropValue: number; + } + + /** net.minecraftforge.event.entity.living.LivingFallEvent */ + export interface LivingFallEvent extends net.minecraftforge.event.entity.living.LivingEvent { + distance: number; + } + + /** net.minecraftforge.event.entity.living.LivingHealEvent */ + export interface LivingHealEvent extends net.minecraftforge.event.entity.living.LivingEvent { + amount: number; + } + + /** net.minecraftforge.event.entity.living.LivingHurtEvent */ + export interface LivingHurtEvent extends net.minecraftforge.event.entity.living.LivingEvent { + source: net.minecraft.damage.DamageSource; + ammount: number; + } + + /** net.minecraftforge.event.entity.living.LivingPackSizeEvent */ + export interface LivingPackSizeEvent extends net.minecraftforge.event.entity.living.LivingEvent { + maxPackSize: number; + } + + /** net.minecraftforge.event.entity.living.LivingSetAttackTargetEvent */ + export interface LivingSetAttackTargetEvent extends net.minecraftforge.event.entity.living.LivingEvent { + target: net.minecraft.entity.EntityLivingBase; + } + + /** net.minecraftforge.event.entity.living.EnderTeleportEvent */ + export interface EnderTeleportEvent extends net.minecraftforge.event.entity.living.LivingEvent { + targetX: number; + targetY: number; + targetZ: number; + attackDamage: number; + } + + export namespace LivingSpawnEvent { + /** net.minecraftforge.event.entity.living.LivingSpawnEvent */ + export interface LivingSpawnEvent extends net.minecraftforge.event.entity.living.LivingEvent { + world: net.minecraft.world.World; + x: number; + y: number; + z: number; + } + /** net.minecraftforge.event.entity.living.LivingSpawnEvent.CheckSpawn */ + export type CheckSpawn = net.minecraftforge.event.entity.living.LivingSpawnEvent.LivingSpawnEvent + /** net.minecraftforge.event.entity.living.LivingSpawnEvent.SpecialSpawn */ + export type SpecialSpawn = net.minecraftforge.event.entity.living.LivingSpawnEvent.LivingSpawnEvent + /** net.minecraftforge.event.entity.living.LivingSpawnEvent.AllowDespawn */ + export type AllowDespawn = net.minecraftforge.event.entity.living.LivingSpawnEvent.LivingSpawnEvent + } + + export namespace ZombieEvent { + /** net.minecraftforge.event.entity.living.ZombieEvent.SummonAidEvent */ + export interface SummonAidEvent extends net.minecraftforge.event.entity.EntityEvent { + customSummonedAid: net.minecraft.entity.EntityZombie; + world: net.minecraft.world.World; + x: number; + y: number; + z: number; + attacker: net.minecraft.entity.EntityLivingBase; + summonChance: number; + } + } + } + + export namespace player { + /** net.minecraftforge.event.entity.player.PlayerEvent */ + export interface PlayerEvent extends net.minecraftforge.event.entity.living.LivingEvent { + /** WARNING: Forge 1.7.10 uses 'entityPlayer' as the field name in this class! */ + entityPlayer: net.minecraft.entity.player.EntityPlayer; + } + export namespace PlayerEvent { + /** net.minecraftforge.event.entity.player.PlayerEvent.HarvestCheck */ + export interface HarvestCheck extends net.minecraftforge.event.entity.player.PlayerEvent { + block: net.minecraft.block.Block; + success: boolean; + } + /** net.minecraftforge.event.entity.player.PlayerEvent.BreakSpeed */ + export interface BreakSpeed extends net.minecraftforge.event.entity.player.PlayerEvent { + block: net.minecraft.block.Block; + metadata: number; + originalSpeed: number; + newSpeed: number; + x: number; + y: number; + z: number; + } + /** net.minecraftforge.event.entity.player.PlayerEvent.NameFormat */ + export interface NameFormat extends net.minecraftforge.event.entity.player.PlayerEvent { + username: string; + displayname: string; + } + /** net.minecraftforge.event.entity.player.PlayerEvent.Clone */ + export interface Clone extends net.minecraftforge.event.entity.player.PlayerEvent { + original: net.minecraft.entity.player.EntityPlayer; + wasDeath: boolean; + } + /** net.minecraftforge.event.entity.player.PlayerEvent.StartTracking */ + export interface StartTracking extends net.minecraftforge.event.entity.player.PlayerEvent { + target: net.minecraft.entity.Entity; + } + /** net.minecraftforge.event.entity.player.PlayerEvent.StopTracking */ + export interface StopTracking extends net.minecraftforge.event.entity.player.PlayerEvent { + target: net.minecraft.entity.Entity; + } + /** net.minecraftforge.event.entity.player.PlayerEvent.LoadFromFile */ + export interface LoadFromFile extends net.minecraftforge.event.entity.player.PlayerEvent { + playerDirectory: any; + playerUUID: string; + getPlayerFile(suffix: string): any; + } + /** net.minecraftforge.event.entity.player.PlayerEvent.SaveToFile */ + export interface SaveToFile extends net.minecraftforge.event.entity.player.PlayerEvent { + playerDirectory: any; + playerUUID: string; + getPlayerFile(suffix: string): any; + } + } + + /** net.minecraftforge.event.entity.player.AchievementEvent */ + export interface AchievementEvent extends net.minecraftforge.event.entity.player.PlayerEvent { + achievement: any; + } + + /** net.minecraftforge.event.entity.player.AnvilRepairEvent */ + export interface AnvilRepairEvent extends net.minecraftforge.event.entity.player.PlayerEvent { + left: net.minecraft.item.ItemStack; + right: net.minecraft.item.ItemStack; + output: net.minecraft.item.ItemStack; + } + + /** net.minecraftforge.event.entity.player.ArrowLooseEvent */ + export interface ArrowLooseEvent extends net.minecraftforge.event.entity.player.PlayerEvent { + bow: net.minecraft.item.ItemStack; + charge: number; + } + + /** net.minecraftforge.event.entity.player.ArrowNockEvent */ + export interface ArrowNockEvent extends net.minecraftforge.event.entity.player.PlayerEvent { + result: net.minecraft.item.ItemStack; + } + + /** net.minecraftforge.event.entity.player.AttackEntityEvent */ + export interface AttackEntityEvent extends net.minecraftforge.event.entity.player.PlayerEvent { + target: net.minecraft.entity.Entity; + } + + /** net.minecraftforge.event.entity.player.BonemealEvent */ + export interface BonemealEvent extends net.minecraftforge.event.entity.player.PlayerEvent { + world: net.minecraft.world.World; + block: net.minecraft.block.Block; + x: number; + y: number; + z: number; + } + + /** net.minecraftforge.event.entity.player.EntityInteractEvent */ + export interface EntityInteractEvent extends net.minecraftforge.event.entity.player.PlayerEvent { + target: net.minecraft.entity.Entity; + } + + /** net.minecraftforge.event.entity.player.EntityItemPickupEvent */ + export interface EntityItemPickupEvent extends net.minecraftforge.event.entity.player.PlayerEvent { + item: net.minecraft.entity.EntityItem; + } + + /** net.minecraftforge.event.entity.player.FillBucketEvent */ + export interface FillBucketEvent extends net.minecraftforge.event.entity.player.PlayerEvent { + current: net.minecraft.item.ItemStack; + result: net.minecraft.item.ItemStack; + world: net.minecraft.world.World; + target: net.minecraft.util.MovingObjectPosition; + } + + /** net.minecraftforge.event.entity.player.ItemTooltipEvent */ + export interface ItemTooltipEvent extends net.minecraftforge.event.entity.player.PlayerEvent { + showAdvancedItemTooltips: boolean; + itemStack: net.minecraft.item.ItemStack; + toolTip: string[]; + } + + /** net.minecraftforge.event.entity.player.PlayerDestroyItemEvent */ + export interface PlayerDestroyItemEvent extends net.minecraftforge.event.entity.player.PlayerEvent { + original: net.minecraft.item.ItemStack; + } + + /** net.minecraftforge.event.entity.player.PlayerDropsEvent */ + export interface PlayerDropsEvent extends net.minecraftforge.event.entity.living.LivingDropsEvent { + entityPlayer: net.minecraft.entity.player.EntityPlayer; + } + + /** net.minecraftforge.event.entity.player.PlayerFlyableFallEvent */ + export interface PlayerFlyableFallEvent extends net.minecraftforge.event.entity.player.PlayerEvent { + distance: number; + } + + /** net.minecraftforge.event.entity.player.PlayerInteractEvent */ + export interface PlayerInteractEvent extends net.minecraftforge.event.entity.player.PlayerEvent { + action: 'RIGHT_CLICK_AIR' | 'RIGHT_CLICK_BLOCK' | 'LEFT_CLICK_BLOCK'; + x: number; + y: number; + z: number; + face: number; + world: net.minecraft.world.World; + useBlock: 'ALLOW' | 'DENY' | 'DEFAULT'; + useItem: 'ALLOW' | 'DENY' | 'DEFAULT'; + } + + /** net.minecraftforge.event.entity.player.PlayerOpenContainerEvent */ + export interface PlayerOpenContainerEvent extends net.minecraftforge.event.entity.player.PlayerEvent { + canInteractWith: boolean; + } + + /** net.minecraftforge.event.entity.player.PlayerPickupXpEvent */ + export interface PlayerPickupXpEvent extends net.minecraftforge.event.entity.player.PlayerEvent { + orb: any; + } + + /** net.minecraftforge.event.entity.player.PlayerSleepInBedEvent */ + export interface PlayerSleepInBedEvent extends net.minecraftforge.event.entity.player.PlayerEvent { + x: number; + y: number; + z: number; + result: 'OK' | 'NOT_POSSIBLE_HERE' | 'NOT_POSSIBLE_NOW' | 'TOO_FAR_AWAY' | 'OTHER_PROBLEM' | 'NOT_SAFE'; + } + + /** net.minecraftforge.event.entity.player.PlayerUseItemEvent */ + export interface PlayerUseItemEvent extends net.minecraftforge.event.entity.player.PlayerEvent { + item: net.minecraft.item.ItemStack; + duration: number; + } + export namespace PlayerUseItemEvent { + export type Start = net.minecraftforge.event.entity.player.PlayerUseItemEvent + export type Tick = net.minecraftforge.event.entity.player.PlayerUseItemEvent + export type Stop = net.minecraftforge.event.entity.player.PlayerUseItemEvent + export type Finish = net.minecraftforge.event.entity.player.PlayerUseItemEvent + } + + /** net.minecraftforge.event.entity.player.PlayerWakeUpEvent */ + export interface PlayerWakeUpEvent extends net.minecraftforge.event.entity.player.PlayerEvent { + wakeImmediately: boolean; + updateWorld: boolean; + setSpawn: boolean; + } + + /** net.minecraftforge.event.entity.player.UseHoeEvent */ + export interface UseHoeEvent extends net.minecraftforge.event.entity.player.PlayerEvent { + current: net.minecraft.item.ItemStack; + world: net.minecraft.world.World; + x: number; + y: number; + z: number; + } + } + } + + export namespace world { + /** net.minecraftforge.event.world.WorldEvent */ + export interface WorldEvent extends cpw.mods.fml.common.eventhandler.Event { + world: net.minecraft.world.World; + } + export namespace WorldEvent { + export type Load = net.minecraftforge.event.world.WorldEvent + export type Unload = net.minecraftforge.event.world.WorldEvent + export type Save = net.minecraftforge.event.world.WorldEvent + export interface PotentialSpawns extends net.minecraftforge.event.world.WorldEvent { + type: any; + x: number; + y: number; + z: number; + list: any[]; + } + export interface CreateSpawnPosition extends net.minecraftforge.event.world.WorldEvent { + settings: any; + } + } + + export namespace BlockEvent { + /** net.minecraftforge.event.world.BlockEvent */ + export interface BlockEvent extends cpw.mods.fml.common.eventhandler.Event { + x: number; + y: number; + z: number; + world: net.minecraft.world.World; + block: net.minecraft.block.Block; + blockMetadata: number; + } + /** net.minecraftforge.event.world.BlockEvent.BreakEvent */ + export interface BreakEvent extends net.minecraftforge.event.world.BlockEvent.BlockEvent { + /** @returns The player who broke the block */ + getPlayer(): net.minecraft.entity.player.EntityPlayer; + /** @returns The experience to drop */ + getExpToDrop(): number; + /** Sets the experience to drop */ + setExpToDrop(exp: number): void; + } + /** net.minecraftforge.event.world.BlockEvent.HarvestDropsEvent */ + export interface HarvestDropsEvent extends net.minecraftforge.event.world.BlockEvent.BlockEvent { + fortuneLevel: number; + drops: net.minecraft.item.ItemStack[]; + isSilkTouching: boolean; + dropChance: number; + /** May be null for non-player harvesting */ + harvester: net.minecraft.entity.player.EntityPlayer; + } + /** net.minecraftforge.event.world.BlockEvent.PlaceEvent */ + export interface PlaceEvent extends net.minecraftforge.event.world.BlockEvent.BlockEvent { + player: net.minecraft.entity.player.EntityPlayer; + itemInHand: net.minecraft.item.ItemStack; + placedBlock: net.minecraft.block.Block; + placedAgainst: net.minecraft.block.Block; + /** Note: BlockSnapshot is a complex structure, simplifying here */ + blockSnapshot: any; + } + /** net.minecraftforge.event.world.BlockEvent.MultiPlaceEvent */ + export interface MultiPlaceEvent extends net.minecraftforge.event.world.BlockEvent.PlaceEvent { + /** @returns A list of replaced block snapshots */ + getReplacedBlockSnapshots(): any[]; + } + } + + export namespace explosion { + /** net.minecraftforge.event.world.ExplosionEvent */ + export interface ExplosionEvent extends cpw.mods.fml.common.eventhandler.Event { + world: net.minecraft.world.World; + explosion: any; + } + export namespace ExplosionEvent { + export type Start = net.minecraftforge.event.world.explosion.ExplosionEvent + export interface Detonate extends net.minecraftforge.event.world.explosion.ExplosionEvent { + affectedEntities: net.minecraft.entity.Entity[]; + } + } + } + + export namespace note { + /** net.minecraftforge.event.world.NoteBlockEvent */ + export type NoteBlockEvent = net.minecraftforge.event.world.BlockEvent.BlockEvent + export namespace NoteBlockEvent { + export interface Play extends net.minecraftforge.event.world.note.NoteBlockEvent { + instrument: any; + note: number; + } + export interface Change extends net.minecraftforge.event.world.note.NoteBlockEvent { + oldInstrument: any; + oldNote: number; + newInstrument: any; + newNote: number; + } + } + } + } + } + + // ============================================================================ + // GLOBAL ALIASES - To match CustomNPC+ pattern (e.g., IForgeEvent.AnvilUpdateEvent) + // Points to the new deep structure to ensure correct tooltips. + // ============================================================================ + namespace IForgeEvent { + export type InitEvent = cpw.mods.fml.common.eventhandler.Event; + + export type AnvilUpdateEvent = net.minecraftforge.event.AnvilUpdateEvent; + export type CommandEvent = net.minecraftforge.event.CommandEvent; + export type ServerChatEvent = net.minecraftforge.event.ServerChatEvent; + export type FuelBurnTimeEvent = net.minecraftforge.event.FuelBurnTimeEvent; + + export type PotionBrewEvent = net.minecraftforge.event.brewing.PotionBrewEvent; + export type PotionBrewedEvent = net.minecraftforge.event.brewing.PotionBrewedEvent; + + export type EntityConstructing = net.minecraftforge.event.entity.EntityEvent.EntityConstructing; + export type CanUpdate = net.minecraftforge.event.entity.EntityEvent.CanUpdate; + export type EnteringChunk = net.minecraftforge.event.entity.EntityEvent.EnteringChunk; + export type EntityJoinWorldEvent = net.minecraftforge.event.entity.EntityJoinWorldEvent; + export type EntityStruckByLightningEvent = net.minecraftforge.event.entity.EntityStruckByLightningEvent; + export type PlaySoundAtEntityEvent = net.minecraftforge.event.entity.PlaySoundAtEntityEvent; + + export type ItemEvent = net.minecraftforge.event.entity.item.ItemEvent; + export type ItemExpireEvent = net.minecraftforge.event.entity.item.ItemExpireEvent; + export type ItemTossEvent = net.minecraftforge.event.entity.item.ItemTossEvent; + + export type LivingUpdateEvent = net.minecraftforge.event.entity.living.LivingEvent.LivingUpdateEvent; + export type LivingJumpEvent = net.minecraftforge.event.entity.living.LivingEvent.LivingJumpEvent; + export type LivingAttackEvent = net.minecraftforge.event.entity.living.LivingAttackEvent; + export type LivingDeathEvent = net.minecraftforge.event.entity.living.LivingDeathEvent; + export type LivingDropsEvent = net.minecraftforge.event.entity.living.LivingDropsEvent; + export type LivingFallEvent = net.minecraftforge.event.entity.living.LivingFallEvent; + export type LivingHealEvent = net.minecraftforge.event.entity.living.LivingHealEvent; + export type LivingHurtEvent = net.minecraftforge.event.entity.living.LivingHurtEvent; + export type LivingPackSizeEvent = net.minecraftforge.event.entity.living.LivingPackSizeEvent; + export type LivingSetAttackTargetEvent = net.minecraftforge.event.entity.living.LivingSetAttackTargetEvent; + export type EnderTeleportEvent = net.minecraftforge.event.entity.living.EnderTeleportEvent; + + export type CheckSpawn = net.minecraftforge.event.entity.living.LivingSpawnEvent.CheckSpawn; + export type SpecialSpawn = net.minecraftforge.event.entity.living.LivingSpawnEvent.SpecialSpawn; + export type AllowDespawn = net.minecraftforge.event.entity.living.LivingSpawnEvent.AllowDespawn; + export type SummonAidEvent = net.minecraftforge.event.entity.living.ZombieEvent.SummonAidEvent; + + export type HarvestCheck = net.minecraftforge.event.entity.player.PlayerEvent.HarvestCheck; + export type BreakSpeed = net.minecraftforge.event.entity.player.PlayerEvent.BreakSpeed; + export type NameFormat = net.minecraftforge.event.entity.player.PlayerEvent.NameFormat; + export type Clone = net.minecraftforge.event.entity.player.PlayerEvent.Clone; + export type StartTracking = net.minecraftforge.event.entity.player.PlayerEvent.StartTracking; + export type StopTracking = net.minecraftforge.event.entity.player.PlayerEvent.StopTracking; + export type LoadFromFile = net.minecraftforge.event.entity.player.PlayerEvent.LoadFromFile; + export type SaveToFile = net.minecraftforge.event.entity.player.PlayerEvent.SaveToFile; + + export type AchievementEvent = net.minecraftforge.event.entity.player.AchievementEvent; + export type AnvilRepairEvent = net.minecraftforge.event.entity.player.AnvilRepairEvent; + export type ArrowLooseEvent = net.minecraftforge.event.entity.player.ArrowLooseEvent; + export type ArrowNockEvent = net.minecraftforge.event.entity.player.ArrowNockEvent; + export type AttackEntityEvent = net.minecraftforge.event.entity.player.AttackEntityEvent; + export type BonemealEvent = net.minecraftforge.event.entity.player.BonemealEvent; + export type EntityInteractEvent = net.minecraftforge.event.entity.player.EntityInteractEvent; + export type EntityItemPickupEvent = net.minecraftforge.event.entity.player.EntityItemPickupEvent; + export type FillBucketEvent = net.minecraftforge.event.entity.player.FillBucketEvent; + export type ItemTooltipEvent = net.minecraftforge.event.entity.player.ItemTooltipEvent; + export type PlayerDestroyItemEvent = net.minecraftforge.event.entity.player.PlayerDestroyItemEvent; + export type PlayerDropsEvent = net.minecraftforge.event.entity.player.PlayerDropsEvent; + export type PlayerFlyableFallEvent = net.minecraftforge.event.entity.player.PlayerFlyableFallEvent; + export type PlayerInteractEvent = net.minecraftforge.event.entity.player.PlayerInteractEvent; + export type PlayerOpenContainerEvent = net.minecraftforge.event.entity.player.PlayerOpenContainerEvent; + export type PlayerPickupXpEvent = net.minecraftforge.event.entity.player.PlayerPickupXpEvent; + export type PlayerSleepInBedEvent = net.minecraftforge.event.entity.player.PlayerSleepInBedEvent; + export type UseHoeEvent = net.minecraftforge.event.entity.player.UseHoeEvent; + + export type PlayerUseItemStart = net.minecraftforge.event.entity.player.PlayerUseItemEvent.Start; + export type PlayerUseItemTick = net.minecraftforge.event.entity.player.PlayerUseItemEvent.Tick; + export type PlayerUseItemStop = net.minecraftforge.event.entity.player.PlayerUseItemEvent.Stop; + export type PlayerUseItemFinish = net.minecraftforge.event.entity.player.PlayerUseItemEvent.Finish; + export type PlayerWakeUpEvent = net.minecraftforge.event.entity.player.PlayerWakeUpEvent; + + export type WorldLoad = net.minecraftforge.event.world.WorldEvent.Load; + export type WorldUnload = net.minecraftforge.event.world.WorldEvent.Unload; + export type WorldSave = net.minecraftforge.event.world.WorldEvent.Save; + export type PotentialSpawns = net.minecraftforge.event.world.WorldEvent.PotentialSpawns; + export type CreateSpawnPosition = net.minecraftforge.event.world.WorldEvent.CreateSpawnPosition; + + export type BreakEvent = net.minecraftforge.event.world.BlockEvent.BreakEvent; + export type HarvestDropsEvent = net.minecraftforge.event.world.BlockEvent.HarvestDropsEvent; + export type PlaceEvent = net.minecraftforge.event.world.BlockEvent.PlaceEvent; + export type MultiPlaceEvent = net.minecraftforge.event.world.BlockEvent.MultiPlaceEvent; + export type BlockEvent = net.minecraftforge.event.world.BlockEvent.BlockEvent; + + export type ExplosionStart = net.minecraftforge.event.world.explosion.ExplosionEvent.Start; + export type ExplosionDetonate = net.minecraftforge.event.world.explosion.ExplosionEvent.Detonate; + + export type NotePlay = net.minecraftforge.event.world.note.NoteBlockEvent.Play; + export type NoteChange = net.minecraftforge.event.world.note.NoteBlockEvent.Change; + + // FML Events + export type PlayerTickEvent = cpw.mods.fml.common.gameevent.TickEvent.PlayerTickEvent; + export type WorldTickEvent = cpw.mods.fml.common.gameevent.TickEvent.WorldTickEvent; + export type ServerTickEvent = cpw.mods.fml.common.gameevent.TickEvent.ServerTickEvent; + export type ClientTickEvent = cpw.mods.fml.common.gameevent.TickEvent.ClientTickEvent; + export type RenderTickEvent = cpw.mods.fml.common.gameevent.TickEvent.RenderTickEvent; + export type TickEvent = cpw.mods.fml.common.gameevent.TickEvent; + + export type KeyInputEvent = cpw.mods.fml.common.gameevent.InputEvent.KeyInputEvent; + export type MouseInputEvent = cpw.mods.fml.common.gameevent.InputEvent.MouseInputEvent; + + export type PlayerLoggedInEvent = cpw.mods.fml.common.gameevent.PlayerEvent.PlayerLoggedInEvent; + export type PlayerLoggedOutEvent = cpw.mods.fml.common.gameevent.PlayerEvent.PlayerLoggedOutEvent; + export type PlayerRespawnEvent = cpw.mods.fml.common.gameevent.PlayerEvent.PlayerRespawnEvent; + export type PlayerChangedDimensionEvent = cpw.mods.fml.common.gameevent.PlayerEvent.PlayerChangedDimensionEvent; + export type PlayerItemPickupEvent = cpw.mods.fml.common.gameevent.PlayerEvent.ItemPickupEvent; + export type PlayerItemCraftedEvent = cpw.mods.fml.common.gameevent.PlayerEvent.ItemCraftedEvent; + export type PlayerItemSmeltedEvent = cpw.mods.fml.common.gameevent.PlayerEvent.ItemSmeltedEvent; + } +} + +export { }; diff --git a/src/main/resources/assets/customnpcs/api/hooks.d.ts b/src/main/resources/assets/customnpcs/api/hooks.d.ts new file mode 100644 index 000000000..3a5811ab8 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/hooks.d.ts @@ -0,0 +1,259 @@ +import './minecraft-raw.d.ts'; +import './forge-events-raw.d.ts'; + +/** + * CustomNPC+ Event Hook Overloads + * + * Functions are grouped by name to enable precise type inference. + * For common hooks (init, tick, damaged), parameter names (INpcEvent, IPlayerEvent, etc.) + * are used to help the LSP distinguish between multiple valid overloads. + */ + +declare global { + // ============ Global Lifecycle & Common Hooks ============ + function init(INpcEvent: INpcEvent.InitEvent): void; + function init(IPlayerEvent: IPlayerEvent.InitEvent): void; + function init(IItemEvent: IItemEvent.InitEvent): void; + function init(IBlockEvent: IBlockEvent.InitEvent): void; + function init(ForgeEvent: cpw.mods.fml.common.eventhandler.Event): void; + + function tick(INpcEvent: INpcEvent.UpdateEvent): void; + function tick(IPlayerEvent: IPlayerEvent.UpdateEvent): void; + function tick(IItemEvent: IItemEvent.UpdateEvent): void; + function tick(IBlockEvent: IBlockEvent.UpdateEvent): void; + + function interact(INpcEvent: INpcEvent.InteractEvent): void; + function interact(IPlayerEvent: IPlayerEvent.InteractEvent): void; + function interact(IItemEvent: IItemEvent.InteractEvent): void; + function interact(IBlockEvent: IBlockEvent.InteractEvent): void; + + function rightClick(IPlayerEvent: IPlayerEvent.RightClickEvent): void; + function rightClick(IItemEvent: IItemEvent.RightClickEvent): void; + + function attack(IPlayerEvent: IPlayerEvent.AttackEvent): void; + function attack(IItemEvent: IItemEvent.AttackEvent): void; + + function damaged(INpcEvent: INpcEvent.DamagedEvent): void; + function damaged(IPlayerEvent: IPlayerEvent.DamagedEvent): void; + function damaged(ForgeEvent: net.minecraftforge.event.entity.living.LivingHurtEvent): void; + + function killed(INpcEvent: INpcEvent.DiedEvent): void; + function killed(IPlayerEvent: IPlayerEvent.DiedEvent): void; + + function kills(INpcEvent: INpcEvent.KilledEntityEvent): void; + function kills(IPlayerEvent: IPlayerEvent.KilledEntityEvent): void; + + function timer(INpcEvent: INpcEvent.TimerEvent): void; + function timer(IPlayerEvent: IPlayerEvent.TimerEvent): void; + function timer(IBlockEvent: IBlockEvent.TimerEvent): void; + + function dialogClose(INpcEvent: INpcEvent.DialogClosedEvent): void; + function dialogClose(IDialogEvent: IDialogEvent.DialogClosed): void; + + function rangedLaunched(INpcEvent: INpcEvent.RangedLaunchedEvent): void; + function rangedLaunched(IPlayerEvent: IPlayerEvent.RangedLaunchedEvent): void; + + function startItem(IPlayerEvent: IPlayerEvent.StartUsingItem): void; + function startItem(IItemEvent: IItemEvent.StartUsingItem): void; + + function usingItem(IPlayerEvent: IPlayerEvent.UsingItem): void; + function usingItem(IItemEvent: IItemEvent.UsingItem): void; + + function stopItem(IPlayerEvent: IPlayerEvent.StopUsingItem): void; + function stopItem(IItemEvent: IItemEvent.StopUsingItem): void; + + function finishItem(IPlayerEvent: IPlayerEvent.FinishUsingItem): void; + function finishItem(IItemEvent: IItemEvent.FinishUsingItem): void; + + // ============ Player Specific Hooks ============ + function attacked(IPlayerEvent: IPlayerEvent.AttackedEvent): void; + function damagedEntity(IPlayerEvent: IPlayerEvent.DamagedEntityEvent): void; + function drop(IPlayerEvent: IPlayerEvent.DropEvent): void; + function respawn(IPlayerEvent: IPlayerEvent.RespawnEvent): void; + function breakBlock(IPlayerEvent: IPlayerEvent.BreakEvent): void; + function chat(IPlayerEvent: IPlayerEvent.ChatEvent): void; + function login(IPlayerEvent: IPlayerEvent.LoginEvent): void; + function logout(IPlayerEvent: IPlayerEvent.LogoutEvent): void; + function keyPressed(IPlayerEvent: IPlayerEvent.KeyPressedEvent): void; + function mouseClicked(IPlayerEvent: IPlayerEvent.MouseClickedEvent): void; + function toss(IPlayerEvent: IPlayerEvent.TossEvent): void; + function pickUp(IPlayerEvent: IPlayerEvent.PickUpEvent): void; + function pickupXP(IPlayerEvent: IPlayerEvent.PickupXPEvent): void; + function rangedCharge(IPlayerEvent: IPlayerEvent.RangedChargeEvent): void; + function containerOpen(IPlayerEvent: IPlayerEvent.ContainerOpen): void; + function useHoe(IPlayerEvent: IPlayerEvent.UseHoeEvent): void; + function bonemeal(IPlayerEvent: IPlayerEvent.BonemealEvent): void; + function fillBucket(IPlayerEvent: IPlayerEvent.FillBucketEvent): void; + function jump(IPlayerEvent: IPlayerEvent.JumpEvent): void; + function fall(IPlayerEvent: IPlayerEvent.FallEvent): void; + function wakeUp(IPlayerEvent: IPlayerEvent.WakeUpEvent): void; + function sleep(IPlayerEvent: IPlayerEvent.SleepEvent): void; + function playSound(IPlayerEvent: IPlayerEvent.SoundEvent): void; + function lightning(IPlayerEvent: IPlayerEvent.LightningEvent): void; + function changedDim(IPlayerEvent: IPlayerEvent.ChangedDimension): void; + + // ============ NPC Specific Hooks ============ + function dialog(INpcEvent: INpcEvent.DialogEvent): void; + function meleeAttack(INpcEvent: INpcEvent.MeleeAttackEvent): void; + function meleeSwing(INpcEvent: INpcEvent.SwingEvent): void; + function target(INpcEvent: INpcEvent.TargetEvent): void; + function collide(INpcEvent: INpcEvent.CollideEvent): void; + function targetLost(INpcEvent: INpcEvent.TargetLostEvent): void; + + // ============ Item Specific Hooks ============ + function tossed(IItemEvent: IItemEvent.TossedEvent): void; + function pickedUp(IItemEvent: IItemEvent.PickedUpEvent): void; + function spawn(IItemEvent: IItemEvent.SpawnEvent): void; + + // ============ Projectile Specific Hooks ============ + function projectileTick(IProjectileEvent: IProjectileEvent.UpdateEvent): void; + function projectileImpact(IProjectileEvent: IProjectileEvent.ImpactEvent): void; + + // ============ Block Specific Hooks ============ + function redstone(IBlockEvent: IBlockEvent.RedstoneEvent): void; + function broken(IBlockEvent: IBlockEvent.BreakEvent): void; + function exploded(IBlockEvent: IBlockEvent.ExplodedEvent): void; + function rainFilled(IBlockEvent: IBlockEvent.RainFillEvent): void; + function neighborChanged(IBlockEvent: IBlockEvent.NeighborChangedEvent): void; + function clicked(IBlockEvent: IBlockEvent.ClickedEvent): void; + function harvested(IBlockEvent: IBlockEvent.HarvestedEvent): void; + function collide(IBlockEvent: IBlockEvent.CollidedEvent): void; + function fallenUpon(IBlockEvent: IBlockEvent.EntityFallenUponEvent): void; + + // ============ Specialized Systems (Quest, Dialog, GUI, etc.) ============ + function questStart(IQuestEvent: IQuestEvent.QuestStartEvent): void; + function questCompleted(IQuestEvent: IQuestEvent.QuestCompletedEvent): void; + function questTurnIn(IQuestEvent: IQuestEvent.QuestTurnedInEvent): void; + function factionPoints(IFactionEvent: IFactionEvent.FactionPointsEvent): void; + function dialogOpen(IDialogEvent: IDialogEvent.DialogClosed): void; + function dialogOption(IDialogEvent: IDialogEvent.DialogOption): void; + function customGuiClosed(ICustomGuiEvent: ICustomGuiEvent.CloseEvent): void; + function customGuiButton(ICustomGuiEvent: ICustomGuiEvent.ButtonEvent): void; + function customGuiSlot(ICustomGuiEvent: ICustomGuiEvent.SlotEvent): void; + function customGuiSlotClicked(ICustomGuiEvent: ICustomGuiEvent.SlotClickEvent): void; + function customGuiScroll(ICustomGuiEvent: ICustomGuiEvent.ScrollEvent): void; + + // ============ DBC Addon Hooks ============ + function dbcFormChange(IDBCEvent: import('./kamkeel/npcdbc/api/event/IDBCEvent').IDBCEvent.FormChangeEvent): void; + function dbcDamaged(IDBCEvent: import('./kamkeel/npcdbc/api/event/IDBCEvent').IDBCEvent.DamagedEvent): void; + function dbcCapsuleUsed(IDBCEvent: import('./kamkeel/npcdbc/api/event/IDBCEvent').IDBCEvent.CapsuleUsedEvent): void; + function dbcSenzuUsed(IDBCEvent: import('./kamkeel/npcdbc/api/event/IDBCEvent').IDBCEvent.SenzuUsedEvent): void; + function dbcRevived(IDBCEvent: import('./kamkeel/npcdbc/api/event/IDBCEvent').IDBCEvent.DBCReviveEvent): void; + function dbcKnockout(IDBCEvent: import('./kamkeel/npcdbc/api/event/IDBCEvent').IDBCEvent.DBCKnockout): void; + + // ============ Forge & Minecraft RAW Hooks ============ + function onCNPCNaturalSpawn(ICustomNPCsEvent: ICustomNPCsEvent.CNPCNaturalSpawnEvent): void; + + function anvilUpdateEvent(ForgeEvent: net.minecraftforge.event.AnvilUpdateEvent): void; + function tickEventPlayerTickEvent(ForgeEvent: cpw.mods.fml.common.gameevent.TickEvent.PlayerTickEvent): void; + function tickEventWorldTickEvent(ForgeEvent: cpw.mods.fml.common.gameevent.TickEvent.WorldTickEvent): void; + function tickEventServerTickEvent(ForgeEvent: cpw.mods.fml.common.gameevent.TickEvent.ServerTickEvent): void; + function commandEvent(ForgeEvent: net.minecraftforge.event.CommandEvent): void; + function serverChatEvent(ForgeEvent: net.minecraftforge.event.ServerChatEvent): void; + function itemTossEvent(ForgeEvent: net.minecraftforge.event.entity.item.ItemTossEvent): void; + function livingHurtEvent(ForgeEvent: net.minecraftforge.event.entity.living.LivingHurtEvent): void; + function fillBucketEvent(ForgeEvent: net.minecraftforge.event.entity.player.FillBucketEvent): void; + + function inputEventKeyInputEvent(ForgeEvent: cpw.mods.fml.common.gameevent.InputEvent.KeyInputEvent): void; + function inputEventMouseInputEvent(ForgeEvent: cpw.mods.fml.common.gameevent.InputEvent.MouseInputEvent): void; + function playerEventPlayerChangedDimensionEvent(ForgeEvent: cpw.mods.fml.common.gameevent.PlayerEvent.PlayerChangedDimensionEvent): void; + function playerEventPlayerRespawnEvent(ForgeEvent: cpw.mods.fml.common.gameevent.PlayerEvent.PlayerRespawnEvent): void; + function playerEventPlayerLoggedOutEvent(ForgeEvent: cpw.mods.fml.common.gameevent.PlayerEvent.PlayerLoggedOutEvent): void; + function playerEventPlayerLoggedInEvent(ForgeEvent: cpw.mods.fml.common.gameevent.PlayerEvent.PlayerLoggedInEvent): void; + function playerEventItemSmeltedEvent(ForgeEvent: cpw.mods.fml.common.gameevent.PlayerEvent.ItemSmeltedEvent): void; + function playerEventItemCraftedEvent(ForgeEvent: cpw.mods.fml.common.gameevent.PlayerEvent.ItemCraftedEvent): void; + function playerEventItemPickupEvent(ForgeEvent: cpw.mods.fml.common.gameevent.PlayerEvent.ItemPickupEvent): void; + function fuelBurnTimeEvent(ForgeEvent: net.minecraftforge.event.FuelBurnTimeEvent): void; + function potionBrewEventPost(ForgeEvent: net.minecraftforge.event.brewing.PotionBrewEvent.Post): void; + function potionBrewEventPre(ForgeEvent: net.minecraftforge.event.brewing.PotionBrewEvent.Pre): void; + function potionBrewedEvent(ForgeEvent: net.minecraftforge.event.brewing.PotionBrewedEvent): void; + function entityEventEnteringChunk(ForgeEvent: net.minecraftforge.event.entity.EntityEvent.EnteringChunk): void; + function entityEventCanUpdate(ForgeEvent: net.minecraftforge.event.entity.EntityEvent.CanUpdate): void; + function entityJoinWorldEvent(ForgeEvent: net.minecraftforge.event.entity.EntityJoinWorldEvent): void; + function entityStruckByLightningEvent(ForgeEvent: net.minecraftforge.event.entity.EntityStruckByLightningEvent): void; + function playSoundAtEntityEvent(ForgeEvent: net.minecraftforge.event.entity.PlaySoundAtEntityEvent): void; + function itemEvent(ForgeEvent: net.minecraftforge.event.entity.item.ItemEvent): void; + function itemExpireEvent(ForgeEvent: net.minecraftforge.event.entity.item.ItemExpireEvent): void; + function enderTeleportEvent(ForgeEvent: net.minecraftforge.event.entity.living.EnderTeleportEvent): void; + function livingAttackEvent(ForgeEvent: net.minecraftforge.event.entity.living.LivingAttackEvent): void; + function livingDeathEvent(ForgeEvent: net.minecraftforge.event.entity.living.LivingDeathEvent): void; + function livingDropsEvent(ForgeEvent: net.minecraftforge.event.entity.living.LivingDropsEvent): void; + function livingEventLivingJumpEvent(ForgeEvent: net.minecraftforge.event.entity.living.LivingEvent.LivingJumpEvent): void; + function livingFallEvent(ForgeEvent: net.minecraftforge.event.entity.living.LivingFallEvent): void; + function livingHealEvent(ForgeEvent: net.minecraftforge.event.entity.living.LivingHealEvent): void; + function livingPackSizeEvent(ForgeEvent: net.minecraftforge.event.entity.living.LivingPackSizeEvent): void; + function livingSetAttackTargetEvent(ForgeEvent: net.minecraftforge.event.entity.living.LivingSetAttackTargetEvent): void; + function livingSpawnEventAllowDespawn(ForgeEvent: net.minecraftforge.event.entity.living.LivingSpawnEvent.AllowDespawn): void; + function livingSpawnEventSpecialSpawn(ForgeEvent: net.minecraftforge.event.entity.living.LivingSpawnEvent.SpecialSpawn): void; + function livingSpawnEventCheckSpawn(ForgeEvent: net.minecraftforge.event.entity.living.LivingSpawnEvent.CheckSpawn): void; + function zombieEventSummonAidEvent(ForgeEvent: net.minecraftforge.event.entity.living.ZombieEvent.SummonAidEvent): void; + function minecartCollisionEvent(ForgeEvent: cpw.mods.fml.common.eventhandler.Event): void; + function minecartEvent(ForgeEvent: cpw.mods.fml.common.eventhandler.Event): void; + function minecartInteractEvent(ForgeEvent: cpw.mods.fml.common.eventhandler.Event): void; + function minecartUpdateEvent(ForgeEvent: cpw.mods.fml.common.eventhandler.Event): void; + function achievementEvent(ForgeEvent: net.minecraftforge.event.entity.player.AchievementEvent): void; + function anvilRepairEvent(ForgeEvent: net.minecraftforge.event.entity.player.AnvilRepairEvent): void; + function arrowLooseEvent(ForgeEvent: net.minecraftforge.event.entity.player.ArrowLooseEvent): void; + function arrowNockEvent(ForgeEvent: net.minecraftforge.event.entity.player.ArrowNockEvent): void; + function attackEntityEvent(ForgeEvent: net.minecraftforge.event.entity.player.AttackEntityEvent): void; + function bonemealEvent(ForgeEvent: net.minecraftforge.event.entity.player.BonemealEvent): void; + function entityInteractEvent(ForgeEvent: net.minecraftforge.event.entity.player.EntityInteractEvent): void; + function entityItemPickupEvent(ForgeEvent: net.minecraftforge.event.entity.player.EntityItemPickupEvent): void; + function playerDestroyItemEvent(ForgeEvent: net.minecraftforge.event.entity.player.PlayerDestroyItemEvent): void; + function playerDropsEvent(ForgeEvent: net.minecraftforge.event.entity.player.PlayerDropsEvent): void; + function playerEventSaveToFile(ForgeEvent: net.minecraftforge.event.entity.player.PlayerEvent.SaveToFile): void; + function playerEventLoadFromFile(ForgeEvent: net.minecraftforge.event.entity.player.PlayerEvent.LoadFromFile): void; + function playerEventStopTracking(ForgeEvent: net.minecraftforge.event.entity.player.PlayerEvent.StopTracking): void; + function playerEventStartTracking(ForgeEvent: net.minecraftforge.event.entity.player.PlayerEvent.StartTracking): void; + function playerEventClone(ForgeEvent: net.minecraftforge.event.entity.player.PlayerEvent.Clone): void; + function playerEventNameFormat(ForgeEvent: net.minecraftforge.event.entity.player.PlayerEvent.NameFormat): void; + function playerEventBreakSpeed(ForgeEvent: net.minecraftforge.event.entity.player.PlayerEvent.BreakSpeed): void; + function playerEventHarvestCheck(ForgeEvent: net.minecraftforge.event.entity.player.PlayerEvent.HarvestCheck): void; + function playerFlyableFallEvent(ForgeEvent: net.minecraftforge.event.entity.player.PlayerFlyableFallEvent): void; + function playerOpenContainerEvent(ForgeEvent: net.minecraftforge.event.entity.player.PlayerOpenContainerEvent): void; + function playerPickupXpEvent(ForgeEvent: net.minecraftforge.event.entity.player.PlayerPickupXpEvent): void; + function playerSleepInBedEvent(ForgeEvent: net.minecraftforge.event.entity.player.PlayerSleepInBedEvent): void; + function playerUseItemEventFinish(ForgeEvent: net.minecraftforge.event.entity.player.PlayerUseItemEvent.Finish): void; + function playerUseItemEventStop(ForgeEvent: net.minecraftforge.event.entity.player.PlayerUseItemEvent.Stop): void; + function playerUseItemEventTick(ForgeEvent: net.minecraftforge.event.entity.player.PlayerUseItemEvent.Tick): void; + function playerUseItemEventStart(ForgeEvent: net.minecraftforge.event.entity.player.PlayerUseItemEvent.Start): void; + function playerWakeUpEvent(ForgeEvent: net.minecraftforge.event.entity.player.PlayerWakeUpEvent): void; + function useHoeEvent(ForgeEvent: net.minecraftforge.event.entity.player.UseHoeEvent): void; + function blockEventMultiPlaceEvent(ForgeEvent: net.minecraftforge.event.world.BlockEvent.MultiPlaceEvent): void; + function blockEventPlaceEvent(ForgeEvent: net.minecraftforge.event.world.BlockEvent.PlaceEvent): void; + function blockEventBreakEvent(ForgeEvent: net.minecraftforge.event.world.BlockEvent.BreakEvent): void; + function blockEventHarvestDropsEvent(ForgeEvent: net.minecraftforge.event.world.BlockEvent.HarvestDropsEvent): void; + function explosionEventDetonate(ForgeEvent: net.minecraftforge.event.world.explosion.ExplosionEvent.Detonate): void; + function explosionEventStart(ForgeEvent: net.minecraftforge.event.world.explosion.ExplosionEvent.Start): void; + function noteBlockEventChange(ForgeEvent: net.minecraftforge.event.world.note.NoteBlockEvent.Change): void; + function noteBlockEventPlay(ForgeEvent: net.minecraftforge.event.world.note.NoteBlockEvent.Play): void; + function worldEventCreateSpawnPosition(ForgeEvent: net.minecraftforge.event.world.WorldEvent.CreateSpawnPosition): void; + function worldEventSave(ForgeEvent: net.minecraftforge.event.world.WorldEvent.Save): void; + function worldEventUnload(ForgeEvent: net.minecraftforge.event.world.WorldEvent.Unload): void; + function worldEventLoad(ForgeEvent: net.minecraftforge.event.world.WorldEvent.Load): void; + + // ============ Other Systems ============ + function scriptCommand(ICustomNPCsEvent: ICustomNPCsEvent.ScriptedCommandEvent): void; + + function partyQuestCompleted(IPartyEvent: IPartyEvent.PartyQuestCompletedEvent): void; + function partyQuestSet(IPartyEvent: IPartyEvent.PartyQuestSetEvent): void; + function partyQuestTurnedIn(IPartyEvent: IPartyEvent.PartyQuestTurnedInEvent): void; + function partyInvite(IPartyEvent: IPartyEvent.PartyInviteEvent): void; + function partyKick(IPartyEvent: IPartyEvent.PartyKickEvent): void; + function partyLeave(IPartyEvent: IPartyEvent.PartyLeaveEvent): void; + function partyDisband(IPartyEvent: IPartyEvent.PartyDisbandEvent): void; + + function animationStart(IAnimationEvent: IAnimationEvent.Started): void; + function animationEnd(IAnimationEvent: IAnimationEvent.Ended): void; + function frameEnter(IAnimationEvent: IAnimationEvent.IFrameEvent): void; + function frameExit(IAnimationEvent: IAnimationEvent.IFrameEvent): void; + + function profileChange(IPlayerEvent: IPlayerEvent.ProfileEvent.Changed): void; + function profileRemove(IPlayerEvent: IPlayerEvent.ProfileEvent.Removed): void; + function profileCreate(IPlayerEvent: IPlayerEvent.ProfileEvent.Create): void; + function onEffectAdd(IPlayerEvent: IPlayerEvent.EffectEvent.Added): void; + function onEffectTick(IPlayerEvent: IPlayerEvent.EffectEvent.Ticked): void; + function onEffectRemove(IPlayerEvent: IPlayerEvent.EffectEvent.Removed): void; +} + +export { }; diff --git a/src/main/resources/assets/customnpcs/api/index.d.ts b/src/main/resources/assets/customnpcs/api/index.d.ts new file mode 100644 index 000000000..43c76fc9d --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/index.d.ts @@ -0,0 +1,303 @@ +/** + * Centralized global declarations for CustomNPC+ scripting in VSCode. + * + * This file combines: + * 1. Type aliases for all generated interfaces (so you can use INpcEvent, IPlayer, etc. without imports) + * 2. Ambient function declarations for handler names (so VSCode infers the event type by function name) + * + * Include this file in jsconfig.json so all .js scripts see these globals without per-file imports. + */ + +declare global { + // ============================================================================ + // TYPE ALIASES - Make all interfaces available globally in JS scripts + // ============================================================================ + + type AbstractNpcAPI = import('./noppes/npcs/api/AbstractNpcAPI').AbstractNpcAPI; + type BlockPos = import('./net/minecraft/util/math/BlockPos').BlockPos; + type IAction = import('./noppes/npcs/api/handler/data/IAction').IAction; + type IActionChain = import('./noppes/npcs/api/handler/data/IActionChain').IActionChain; + type IActionListener = import('./noppes/npcs/api/handler/data/IActionListener').IActionListener; + type IActionManager = import('./noppes/npcs/api/handler/IActionManager').IActionManager; + type IActionQueue = import('./noppes/npcs/api/handler/data/IActionQueue').IActionQueue; + type IAnimal = import('./noppes/npcs/api/entity/IAnimal').IAnimal; + type IAnimatable = import('./noppes/npcs/api/entity/IAnimatable').IAnimatable; + type IAnimation = import('./noppes/npcs/api/handler/data/IAnimation').IAnimation; + type IAnimationData = import('./noppes/npcs/api/handler/data/IAnimationData').IAnimationData; + type IAnimationEvent = import('./noppes/npcs/api/event/IAnimationEvent').IAnimationEvent; + type IAnimationHandler = import('./noppes/npcs/api/handler/IAnimationHandler').IAnimationHandler; + type IAnvilRecipe = import('./noppes/npcs/api/handler/data/IAnvilRecipe').IAnvilRecipe; + type IArrow = import('./noppes/npcs/api/entity/IArrow').IArrow; + type IAttributeDefinition = import('./noppes/npcs/api/handler/data/IAttributeDefinition').IAttributeDefinition; + type IAttributeHandler = import('./noppes/npcs/api/handler/IAttributeHandler').IAttributeHandler; + type IAvailability = import('./noppes/npcs/api/handler/data/IAvailability').IAvailability; + type IBlock = import('./noppes/npcs/api/IBlock').IBlock; + type IBlockEvent = import('./noppes/npcs/api/event/IBlockEvent').IBlockEvent; + type IBlockScripted = import('./noppes/npcs/api/block/IBlockScripted').IBlockScripted; + type IBlockState = import('./net/minecraft/block/state/IBlockState').IBlockState; + type IButton = import('./noppes/npcs/api/gui/IButton').IButton; + type ICloneHandler = import('./noppes/npcs/api/handler/ICloneHandler').ICloneHandler; + type ICommand = import('./noppes/npcs/api/ICommand').ICommand; + type IConditionalAction = import('./noppes/npcs/api/handler/data/actions/IConditionalAction').IConditionalAction; + type IContainer = import('./noppes/npcs/api/IContainer').IContainer; + type ICustomAttribute = import('./noppes/npcs/api/handler/data/ICustomAttribute').ICustomAttribute; + type ICustomEffect = import('./noppes/npcs/api/handler/data/ICustomEffect').ICustomEffect; + type ICustomEffectHandler = import('./noppes/npcs/api/handler/ICustomEffectHandler').ICustomEffectHandler; + type ICustomGui = import('./noppes/npcs/api/gui/ICustomGui').ICustomGui; + type ICustomGuiComponent = import('./noppes/npcs/api/gui/ICustomGuiComponent').ICustomGuiComponent; + type ICustomGuiEvent = import('./noppes/npcs/api/event/ICustomGuiEvent').ICustomGuiEvent; + type ICustomNPCsEvent = import('./noppes/npcs/api/event/ICustomNPCsEvent').ICustomNPCsEvent; + type ICustomNpc = import('./noppes/npcs/api/entity/ICustomNpc').ICustomNpc; + type ICustomOverlay = import('./noppes/npcs/api/overlay/ICustomOverlay').ICustomOverlay; + type ICustomOverlayComponent = import('./noppes/npcs/api/overlay/ICustomOverlayComponent').ICustomOverlayComponent; + type IDBCPlayer = import('./noppes/npcs/api/entity/IDBCPlayer').IDBCPlayer; + type IDamageSource = import('./noppes/npcs/api/IDamageSource').IDamageSource; + type IDialog = import('./noppes/npcs/api/handler/data/IDialog').IDialog; + type IDialogCategory = import('./noppes/npcs/api/handler/data/IDialogCategory').IDialogCategory; + type IDialogEvent = import('./noppes/npcs/api/event/IDialogEvent').IDialogEvent; + type IDialogHandler = import('./noppes/npcs/api/handler/IDialogHandler').IDialogHandler; + type IDialogImage = import('./noppes/npcs/api/handler/data/IDialogImage').IDialogImage; + type IDialogOption = import('./noppes/npcs/api/handler/data/IDialogOption').IDialogOption; + type IEntity = import('./noppes/npcs/api/entity/IEntity').IEntity; + type IEntityItem = import('./noppes/npcs/api/entity/IEntityItem').IEntityItem; + type IEntityLiving = import('./noppes/npcs/api/entity/IEntityLiving').IEntityLiving; + type IFaction = import('./noppes/npcs/api/handler/data/IFaction').IFaction; + type IFactionEvent = import('./noppes/npcs/api/event/IFactionEvent').IFactionEvent; + type IFactionHandler = import('./noppes/npcs/api/handler/IFactionHandler').IFactionHandler; + type IFishHook = import('./noppes/npcs/api/entity/IFishHook').IFishHook; + type IForgeEvent = import('./noppes/npcs/api/event/IForgeEvent').IForgeEvent; + type IFrame = import('./noppes/npcs/api/handler/data/IFrame').IFrame; + type IFramePart = import('./noppes/npcs/api/handler/data/IFramePart').IFramePart; + type IItemArmor = import('./noppes/npcs/api/item/IItemArmor').IItemArmor; + type IItemBlock = import('./noppes/npcs/api/item/IItemBlock').IItemBlock; + type IItemBook = import('./noppes/npcs/api/item/IItemBook').IItemBook; + type IItemCustom = import('./noppes/npcs/api/item/IItemCustom').IItemCustom; + type IItemCustomizable = import('./noppes/npcs/api/item/IItemCustomizable').IItemCustomizable; + type IItemEvent = import('./noppes/npcs/api/event/IItemEvent').IItemEvent; + type IItemLinked = import('./noppes/npcs/api/item/IItemLinked').IItemLinked; + type IItemSlot = import('./noppes/npcs/api/gui/IItemSlot').IItemSlot; + type IItemStack = import('./noppes/npcs/api/item/IItemStack').IItemStack; + type IJob = import('./noppes/npcs/api/jobs/IJob').IJob; + type IJobBard = import('./noppes/npcs/api/jobs/IJobBard').IJobBard; + type IJobConversation = import('./noppes/npcs/api/jobs/IJobConversation').IJobConversation; + type IJobFollower = import('./noppes/npcs/api/jobs/IJobFollower').IJobFollower; + type IJobGuard = import('./noppes/npcs/api/jobs/IJobGuard').IJobGuard; + type IJobHealer = import('./noppes/npcs/api/jobs/IJobHealer').IJobHealer; + type IJobItemGiver = import('./noppes/npcs/api/jobs/IJobItemGiver').IJobItemGiver; + type IJobSpawner = import('./noppes/npcs/api/jobs/IJobSpawner').IJobSpawner; + type ILinkedItemEvent = import('./noppes/npcs/api/event/ILinkedItemEvent').ILinkedItemEvent; + type IMarketCategory = import('./noppes/npcs/api/handler/data/IMarketCategory').IMarketCategory; + type IMessage = import('./noppes/npcs/api/handler/data/IMessage').IMessage; + type IModel = import('./noppes/npcs/api/handler/data/IModel').IModel; + type IModelData = import('./noppes/npcs/api/handler/data/IModelData').IModelData; + type IModelPart = import('./noppes/npcs/api/handler/data/IModelPart').IModelPart; + type IModelRotate = import('./noppes/npcs/api/handler/data/IModelRotate').IModelRotate; + type IModelRotatePart = import('./noppes/npcs/api/handler/data/IModelRotatePart').IModelRotatePart; + type IMonster = import('./noppes/npcs/api/entity/IMonster').IMonster; + type INbtTagCompound = import('./noppes/npcs/api/INbt').INbtTagCompound; + type INpcEvent = import('./noppes/npcs/api/event/INpcEvent').INpcEvent; + type IParallel = import('./noppes/npcs/api/handler/data/IParallel').IParallel; + type IParallelLine = import('./noppes/npcs/api/handler/data/IParallelLine').IParallelLine; + type IPartyEvent = import('./noppes/npcs/api/event/IPartyEvent').IPartyEvent; + type IPartyHandler = import('./noppes/npcs/api/handler/IPartyHandler').IPartyHandler; + type IPayloadCompound = import('./noppes/npcs/api/IPayloadCompound').IPayloadCompound; + type IPixelmon = import('./noppes/npcs/api/entity/IPixelmon').IPixelmon; + type IPixelmonPlayerData = import('./noppes/npcs/api/IPixelmonPlayerData').IPixelmonPlayerData; + type IPlayer = import('./noppes/npcs/api/entity/IPlayer').IPlayer; + type IPlayerEvent = import('./noppes/npcs/api/event/IPlayerEvent').IPlayerEvent; + type IPos = import('./noppes/npcs/api/IPos').IPos; + type IProjectile = import('./noppes/npcs/api/entity/IProjectile').IProjectile; + type IProjectileEvent = import('./noppes/npcs/api/event/IProjectileEvent').IProjectileEvent; + type IQuestEvent = import('./noppes/npcs/api/event/IQuestEvent').IQuestEvent; + type IQuestHandler = import('./noppes/npcs/api/handler/IQuestHandler').IQuestHandler; + type IRecipeEvent = import('./noppes/npcs/api/event/IRecipeEvent').IRecipeEvent; + type IRole = import('./noppes/npcs/api/roles/IRole').IRole; + type IRoleArmor = import('./noppes/npcs/api/roles/IRoleArmor').IRoleArmor; + type IRoleDye = import('./noppes/npcs/api/roles/IRoleDye').IRoleDye; + type IRoleHair = import('./noppes/npcs/api/roles/IRoleHair').IRoleHair; + type IRoleHat = import('./noppes/npcs/api/roles/IRoleHat').IRoleHat; + type IRoleHeld = import('./noppes/npcs/api/roles/IRoleHeld').IRoleHeld; + type IRoleLeft = import('./noppes/npcs/api/roles/IRoleLeft').IRoleLeft; + type IRoleRight = import('./noppes/npcs/api/roles/IRoleRight').IRoleRight; + type IRoleSkinPart = import('./noppes/npcs/api/roles/IRoleSkinPart').IRoleSkinPart; + type IRoleSmile = import('./noppes/npcs/api/roles/IRoleSmile').IRoleSmile; + type IScoreboard = import('./noppes/npcs/api/scoreboard/IScoreboard').IScoreboard; + type IScoreboardFont = import('./noppes/npcs/api/scoreboard/IScoreboardFont').IScoreboardFont; + type IScreenSize = import('./noppes/npcs/api/IScreenSize').IScreenSize; + type ISerializable = import('./noppes/npcs/api/ISerializable').ISerializable; + type IShapedRecipe = import('./noppes/npcs/api/IShapedRecipe').IShapedRecipe; + type IShapelessRecipe = import('./noppes/npcs/api/IShapelessRecipe').IShapelessRecipe; + type IShop = import('./noppes/npcs/api/handler/data/IShop').IShop; + type IShopCategory = import('./noppes/npcs/api/handler/data/IShopCategory').IShopCategory; + type IShopItem = import('./noppes/npcs/api/handler/data/IShopItem').IShopItem; + type ISkinOverlay = import('./noppes/npcs/api/ISkinOverlay').ISkinOverlay; + type ISlot = import('./noppes/npcs/api/handler/data/ISlot').ISlot; + type ISound = import('./noppes/npcs/api/handler/data/ISound').ISound; + type ITag = import('./noppes/npcs/api/handler/data/ITag').ITag; + type ITagHandler = import('./noppes/npcs/api/handler/ITagHandler').ITagHandler; + type ITextField = import('./noppes/npcs/api/gui/ITextField').ITextField; + type ITextPlane = import('./noppes/npcs/api/block/ITextPlane').ITextPlane; + type ITexturedRect = import('./noppes/npcs/api/gui/ITexturedRect').ITexturedRect; + type IThrowable = import('./noppes/npcs/api/entity/IThrowable').IThrowable; + type ITileEntity = import('./noppes/npcs/api/ITileEntity').ITileEntity; + type ITimers = import('./noppes/npcs/api/ITimers').ITimers; + type ITransportCategory = import('./noppes/npcs/api/handler/data/ITransportCategory').ITransportCategory; + type ITransportHandler = import('./noppes/npcs/api/handler/ITransportHandler').ITransportHandler; + type ITransportLocation = import('./noppes/npcs/api/handler/data/ITransportLocation').ITransportLocation; + type IVillager = import('./noppes/npcs/api/entity/IVillager').IVillager; + type IWorld = import('./noppes/npcs/api/IWorld').IWorld; + type IntHashMap = import('./net/minecraft/util/math/IntHashMap').IntHashMap; + type Vec3i = import('./net/minecraft/util/Vec3i').Vec3i; + + // ============================================================================ + // GLOBAL API INSTANCE + // ============================================================================ + + const API: import('./noppes/npcs/api/AbstractNpcAPI').AbstractNpcAPI; + + // ============================================================================ + // NESTED INTERFACES - Allow autocomplete like INpcEvent.InitEvent + // ============================================================================ + + namespace INpcEvent { + interface CollideEvent extends INpcEvent {} + interface DamagedEvent extends INpcEvent {} + interface RangedLaunchedEvent extends INpcEvent {} + interface MeleeAttackEvent extends INpcEvent {} + interface SwingEvent extends INpcEvent {} + interface KilledEntityEvent extends INpcEvent {} + interface DiedEvent extends INpcEvent {} + interface InteractEvent extends INpcEvent {} + interface DialogEvent extends INpcEvent {} + interface TimerEvent extends INpcEvent {} + interface TargetEvent extends INpcEvent {} + interface TargetLostEvent extends INpcEvent {} + interface DialogClosedEvent extends INpcEvent {} + interface UpdateEvent extends INpcEvent {} + interface InitEvent extends INpcEvent {} + } + + namespace IPlayerEvent { + interface ChatEvent extends IPlayerEvent {} + interface KeyPressedEvent extends IPlayerEvent {} + interface MouseClickedEvent extends IPlayerEvent {} + interface PickupXPEvent extends IPlayerEvent {} + interface LevelUpEvent extends IPlayerEvent {} + interface LogoutEvent extends IPlayerEvent {} + interface LoginEvent extends IPlayerEvent {} + interface RespawnEvent extends IPlayerEvent {} + interface ChangedDimension extends IPlayerEvent {} + interface TimerEvent extends IPlayerEvent {} + interface AttackedEvent extends IPlayerEvent {} + interface DamagedEvent extends IPlayerEvent {} + interface LightningEvent extends IPlayerEvent {} + interface SoundEvent extends IPlayerEvent {} + interface FallEvent extends IPlayerEvent {} + interface JumpEvent extends IPlayerEvent {} + interface KilledEntityEvent extends IPlayerEvent {} + interface DiedEvent extends IPlayerEvent {} + interface RangedLaunchedEvent extends IPlayerEvent {} + interface AttackEvent extends IPlayerEvent {} + interface DamagedEntityEvent extends IPlayerEvent {} + interface ContainerClosed extends IPlayerEvent {} + interface ContainerOpen extends IPlayerEvent {} + interface PickUpEvent extends IPlayerEvent {} + interface DropEvent extends IPlayerEvent {} + interface TossEvent extends IPlayerEvent {} + interface InteractEvent extends IPlayerEvent {} + interface RightClickEvent extends IPlayerEvent {} + interface UpdateEvent extends IPlayerEvent {} + interface InitEvent extends IPlayerEvent {} + interface StartUsingItem extends IPlayerEvent {} + interface UsingItem extends IPlayerEvent {} + interface StopUsingItem extends IPlayerEvent {} + interface FinishUsingItem extends IPlayerEvent {} + interface BreakEvent extends IPlayerEvent {} + interface UseHoeEvent extends IPlayerEvent {} + interface WakeUpEvent extends IPlayerEvent {} + interface SleepEvent extends IPlayerEvent {} + interface AchievementEvent extends IPlayerEvent {} + interface FillBucketEvent extends IPlayerEvent {} + interface BonemealEvent extends IPlayerEvent {} + interface RangedChargeEvent extends IPlayerEvent {} + interface EffectEvent extends IPlayerEvent {} + interface ProfileEvent extends IPlayerEvent {} + } + + namespace IProjectileEvent { + interface UpdateEvent extends IProjectileEvent {} + interface ImpactEvent extends IProjectileEvent {} + } + + namespace IQuestEvent { + interface QuestStartEvent extends IQuestEvent {} + interface QuestCompletedEvent extends IQuestEvent {} + interface QuestTurnedInEvent extends IQuestEvent {} + } + + namespace IDialogEvent { + interface DialogClosed extends IDialogEvent {} + } + + namespace IFactionEvent { + interface FactionPointsEvent extends IFactionEvent {} + } + + namespace IPartyEvent { + interface PartyQuestCompletedEvent extends IPartyEvent {} + interface PartyQuestSetEvent extends IPartyEvent {} + interface PartyQuestTurnedInEvent extends IPartyEvent {} + interface PartyInviteEvent extends IPartyEvent {} + interface PartyKickEvent extends IPartyEvent {} + interface PartyLeaveEvent extends IPartyEvent {} + interface PartyDisbandEvent extends IPartyEvent {} + } + + namespace IBlockEvent { + interface InitEvent extends IBlockEvent {} + interface InteractEvent extends IBlockEvent {} + interface UpdateEvent extends IBlockEvent {} + interface TimerEvent extends IBlockEvent {} + } + + namespace ICustomGuiEvent { + interface CloseEvent extends ICustomGuiEvent {} + interface ButtonEvent extends ICustomGuiEvent {} + interface SlotEvent extends ICustomGuiEvent {} + interface SlotClickEvent extends ICustomGuiEvent {} + interface ScrollEvent extends ICustomGuiEvent {} + } + + namespace IAnimationEvent { + interface Started extends IAnimationEvent {} + interface Ended extends IAnimationEvent {} + interface IFrameEvent extends IAnimationEvent {} + } + + namespace IItemEvent { + interface InitEvent extends IItemEvent {} + interface UpdateEvent extends IItemEvent {} + interface TossedEvent extends IItemEvent {} + interface PickedUpEvent extends IItemEvent {} + interface SpawnEvent extends IItemEvent {} + interface InteractEvent extends IItemEvent {} + interface RightClickEvent extends IItemEvent {} + interface AttackEvent extends IItemEvent {} + interface StartUsingItem extends IItemEvent {} + interface UsingItem extends IItemEvent {} + interface StopUsingItem extends IItemEvent {} + interface FinishUsingItem extends IItemEvent {} + } + + // ============================================================================ + // AMBIENT HANDLER FUNCTIONS - Defined in hooks.d.ts + // ============================================================================ + // For type-safe handlers with overloads (parameter names determine event type), + // see hooks.d.ts which includes declare function overloads. + // + // Example: + // function damaged(INpcEvent: INpcEvent.DamagedEvent) { INpcEvent. } // infers INpcEvent.DamagedEvent + // function damaged(IPlayerEvent: IPlayerEvent.DamagedEvent) { IPlayerEvent. } // infers IPlayerEvent.DamagedEvent +} + +export {}; diff --git a/src/main/resources/assets/customnpcs/api/kamkeel/npcdbc/api/IDBCAddon.d.ts b/src/main/resources/assets/customnpcs/api/kamkeel/npcdbc/api/IDBCAddon.d.ts new file mode 100644 index 000000000..58f98ec62 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/kamkeel/npcdbc/api/IDBCAddon.d.ts @@ -0,0 +1,162 @@ +/** + * Generated from Java file for CustomNPC+ DBC Addon + * Package: kamkeel.npcdbc.api + */ + +import { IDBCPlayer } from '../../../noppes/npcs/api/entity/IDBCPlayer'; +import { IEntityLivingBase } from '../../../noppes/npcs/api/entity/IEntityLivingBase'; +import { IForm } from './form/IForm'; +import { IAura } from './aura/IAura'; +import { IOutline } from './outline/IOutline'; +import { IKiAttack } from './IKiAttack'; +import { IPlayer } from '../../../noppes/npcs/api/entity/IPlayer'; + +export interface IDBCAddon extends IDBCPlayer { + getAllFullAttributes(): number[]; + getUsedMind(): number; + getAvailableMind(): number; + setLockOnTarget(lockOnTarget: IEntityLivingBase): void; + setKiFistOn(on: boolean): void; + setKiProtectionOn(on: boolean): void; + setKiWeaponType(type: number): void; + kiFistOn(): boolean; + kiProtectionOn(): boolean; + getKiWeaponType(): number; + isTurboOn(): boolean; + setTurboState(on: boolean): void; + getMaxBody(): number; + getMaxHP(): number; + getBodyPercentage(): number; + getMaxKi(): number; + getMaxStamina(): number; + getAllAttributes(): number[]; + modifyAllAttributes(attri: number[], multiplyAddedAttris: boolean, multiValue: number): void; + modifyAllAttributes(Num: number, setStatsToNum: boolean): void; + modifyAllAttributes(submitted: number[], setStats: boolean): void; + multiplyAttribute(statid: number, multi: number): void; + multiplyAllAttributes(multi: number): void; + getFullAttribute(statid: number): number; + getRaceName(): string; + getCurrentDBCFormName(): string; + changeDBCMastery(formName: string, amount: number, add: boolean): void; + getDBCMasteryValue(formName: string): number; + getAllDBCMasteries(): string; + isDBCFusionSpectator(): boolean; + isChargingKi(): boolean; + getSkillLevel(skillname: string): number; + getMaxStat(attribute: number): number; + getCurrentStat(attribute: number): number; + getCurrentFormMultiplier(): number; + getMajinAbsorptionRace(): number; + setMajinAbsorptionRace(race: number): void; + getMajinAbsorptionPower(): number; + setMajinAbsorptionPower(power: number): void; + isMUI(): boolean; + isKO(): boolean; + isUI(): boolean; + isMystic(): boolean; + isKaioken(): boolean; + isGOD(): boolean; + isLegendary(): boolean; + isDivine(): boolean; + isMajin(): boolean; + + // Custom Form Setters (Grouped) + setCustomForm(formID: number): void; + setCustomForm(formID: number, ignoreUnlockCheck: boolean): void; + setCustomForm(form: IForm): void; + setCustomForm(form: IForm, ignoreUnlockCheck: boolean): void; + setCustomForm(formName: string): void; + setCustomForm(formName: string, ignoreUnlockCheck: boolean): void; + + // Custom Form Management (Grouped) + hasCustomForm(formName: string): boolean; + hasCustomForm(formID: number): boolean; + getCustomForms(): IForm[]; + giveCustomForm(formName: string): void; + giveCustomForm(form: IForm): void; + removeCustomForm(formName: string): void; + removeCustomForm(formName: string, removesMastery: boolean): void; + removeCustomForm(form: IForm): void; + removeCustomForm(form: IForm, removesMastery: boolean): void; + + // Flight + setFlight(flightOn: boolean): void; + isFlying(): boolean; + setAllowFlight(allowFlight: boolean): void; + setFlightSpeedRelease(release: number): void; + setBaseFlightSpeed(speed: number): void; + setDynamicFlightSpeed(speed: number): void; + setFlightGravity(isEffected: boolean): void; + setFlightDefaults(): void; + setSprintSpeed(speed: number): void; + + // Selected Form + getSelectedForm(): IForm; + setSelectedForm(form: IForm): void; + setSelectedForm(formID: number): void; + removeSelectedForm(): void; + getSelectedDBCForm(): number; + setSelectedDBCForm(formID: number): void; + removeSelectedDBCForm(): void; + getCurrentForm(): IForm; + isInCustomForm(): boolean; + isInCustomForm(form: IForm): boolean; + isInCustomForm(formID: number): boolean; + + // Aura + setAuraSelection(auraName: string): void; + setAuraSelection(aura: IAura): void; + setAuraSelection(auraID: number): void; + giveAura(auraName: string): void; + giveAura(aura: IAura): void; + giveAura(auraID: number): void; + hasAura(auraName: string): boolean; + hasAura(auraId: number): boolean; + removeAura(auraName: string): void; + removeAura(aura: IAura): void; + removeAura(auraID: number): void; + setAura(auraName: string): void; + setAura(aura: IAura): void; + setAura(auraID: number): void; + removeCurrentAura(): void; + removeAuraSelection(): void; + isInAura(): boolean; + isInAura(aura: IAura): boolean; + isInAura(auraName: string): boolean; + isInAura(auraID: number): boolean; + + // Mastery + setCustomMastery(formID: number, value: number): void; + setCustomMastery(formID: number, value: number, ignoreUnlockCheck: boolean): void; + setCustomMastery(form: IForm, value: number): void; + setCustomMastery(form: IForm, value: number, ignoreUnlockCheck: boolean): void; + addCustomMastery(formID: number, value: number): void; + addCustomMastery(formID: number, value: number, ignoreUnlockCheck: boolean): void; + addCustomMastery(form: IForm, value: number): void; + addCustomMastery(form: IForm, value: number, ignoreUnlockCheck: boolean): void; + getCustomMastery(formID: number): number; + getCustomMastery(formID: number, checkFusion: boolean): number; + getCustomMastery(form: IForm): number; + getCustomMastery(form: IForm, checkFusion: boolean): number; + removeCustomMastery(formID: number): void; + removeCustomMastery(form: IForm): void; + + // Outline + removeOutline(): void; + setOutline(outline: IOutline): void; + setOutline(outlineName: string): void; + setOutline(outlineID: number): void; + getOutline(): IOutline; + + // Other + getFusionPartner(): IPlayer; + fireKiAttack(type: number, speed: number, damage: number, hasEffect: boolean, color: number, density: number, hasSound: boolean, chargePercent: number): void; + fireKiAttack(kiAttack: IKiAttack): void; + isReleasing(): boolean; + isMeditating(): boolean; + isSuperRegen(): boolean; + isSwooping(): boolean; + isInMedicalLiquid(): boolean; + getAttackFromSlot(slot: number): IKiAttack; +} diff --git a/src/main/resources/assets/customnpcs/api/kamkeel/npcdbc/api/IKiAttack.d.ts b/src/main/resources/assets/customnpcs/api/kamkeel/npcdbc/api/IKiAttack.d.ts new file mode 100644 index 000000000..1e7503cb5 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/kamkeel/npcdbc/api/IKiAttack.d.ts @@ -0,0 +1,22 @@ +export interface IKiAttack { + getType(): number; + setType(type: number): void; + getSpeed(): number; + setSpeed(speed: number): void; + getDamage(): number; + setDamage(damage: number): void; + hasEffect(): boolean; + setHasEffect(hasEffect: boolean): void; + getColor(): number; + setColor(color: number): void; + getDensity(): number; + setDensity(density: number): void; + hasSound(): boolean; + setHasSound(hasSound: boolean): void; + getChargePercent(): number; + setChargePercent(chargePercent: number): void; + respectFormDestoryerConfig(): boolean; + setRespectFormDestroyerConfig(respectFormConfig: boolean): void; + isDestroyerAttack(): boolean; + setDestroyerAttack(isDestroyer: boolean): void; +} diff --git a/src/main/resources/assets/customnpcs/api/kamkeel/npcdbc/api/aura/IAura.d.ts b/src/main/resources/assets/customnpcs/api/kamkeel/npcdbc/api/aura/IAura.d.ts new file mode 100644 index 000000000..66968ff0b --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/kamkeel/npcdbc/api/aura/IAura.d.ts @@ -0,0 +1,19 @@ +export interface IAura { + getName(): string; + setName(name: string): void; + getMenuName(): string; + setMenuName(name: string): void; + getID(): number; + setID(newID: number): void; + assignToPlayer(player: IPlayer): void; + removeFromPlayer(player: IPlayer): void; + assignToPlayer(playerName: string): void; + removeFromPlayer(playerName: string): void; + getDisplay(): any; // IAuraDisplay + getSecondaryAuraID(): number; + getSecondaryAura(): IAura; + setSecondaryAura(id: number): void; + setSecondaryAura(aura: IAura): void; + clone(): IAura; + save(): IAura; +} diff --git a/src/main/resources/assets/customnpcs/api/kamkeel/npcdbc/api/event/IDBCEvent.d.ts b/src/main/resources/assets/customnpcs/api/kamkeel/npcdbc/api/event/IDBCEvent.d.ts new file mode 100644 index 000000000..02347f3eb --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/kamkeel/npcdbc/api/event/IDBCEvent.d.ts @@ -0,0 +1,49 @@ +/** + * Generated from Java file for CustomNPC+ DBC Addon + * Package: kamkeel.npcdbc.api.event + */ + +import { IPlayerEvent } from '../../../noppes/npcs/api/event/IPlayerEvent'; +import { IDamageSource } from '../../../noppes/npcs/api/IDamageSource'; + +export type IDBCEvent = IPlayerEvent + +export namespace IDBCEvent { + export interface CapsuleUsedEvent extends IDBCEvent { + getType(): number; + getSubType(): number; + getCapsuleName(): string; + } + + export type SenzuUsedEvent = IDBCEvent + + export interface FormChangeEvent extends IDBCEvent { + getFormBeforeID(): number; + getFormAfterID(): number; + isFormBeforeCustom(): boolean; + isFormAfterCustom(): boolean; + } + + export interface DamagedEvent extends IDBCEvent { + getDamage(): number; + setDamage(damage: number): void; + + getStaminaReduced(): number; + setStaminaReduced(stamina: number): void; + + willKo(): boolean; + + getKiReduced(): number; + setKiReduced(ki: number): void; + + getDamageSource(): IDamageSource; + isDamageSourceKiAttack(): boolean; + getType(): number; + } + + export type DBCReviveEvent = IDBCEvent + + export interface DBCKnockout extends IDBCEvent { + getDamageSource(): IDamageSource; + } +} diff --git a/src/main/resources/assets/customnpcs/api/kamkeel/npcdbc/api/form/IForm.d.ts b/src/main/resources/assets/customnpcs/api/kamkeel/npcdbc/api/form/IForm.d.ts new file mode 100644 index 000000000..e7e5f5926 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/kamkeel/npcdbc/api/form/IForm.d.ts @@ -0,0 +1,55 @@ +export interface IForm { + getName(): string; + setName(name: string): void; + getMenuName(): string; + setMenuName(name: string): void; + getRace(): number; + setRace(race: number): void; + getAllMulti(): number[]; // float[] + setAllMulti(allMulti: number): void; // float + raceEligible(race: number): boolean; + raceEligible(player: IPlayer): boolean; + setAttributeMulti(id: number, multi: number): void; + getAttributeMulti(id: number): number; + assignToPlayer(player: IPlayer): void; + removeFromPlayer(player: IPlayer): void; + assignToPlayer(playerName: string): void; + removeFromPlayer(playerName: string): void; + removeFromPlayer(player: IPlayer, removesMastery: boolean): void; + removeFromPlayer(playerName: string, removesMastery: boolean): void; + getAscendSound(): string; + setAscendSound(directory: string): void; + getDescendSound(): string; + setDescendSound(directory: string): void; + getID(): number; + setID(newID: number): void; + getChildID(): number; + hasChild(): boolean; + linkChild(formID: number): void; + linkChild(form: IForm): void; + isFromParentOnly(): boolean; + setFromParentOnly(set: boolean): void; + addFormRequirement(race: number, state: number): void; + removeFormRequirement(race: number): void; + getFormRequirement(race: number): number; + isChildOf(parent: IForm): boolean; + getChild(): IForm; + removeChildForm(): void; + getParentID(): number; + hasParent(): boolean; + linkParent(formID: number): void; + linkParent(form: IForm): void; + getParent(): IForm; + getTimer(): number; + setTimer(timeInTicks: number): void; + hasTimer(): boolean; + removeParentForm(): void; + getMastery(): any; // IFormMastery + getDisplay(): any; // IFormDisplay + getStackable(): any; // IFormStackable + getAdvanced(): any; // IFormAdvanced + setMindRequirement(mind: number): void; + getMindRequirement(): number; + clone(): IForm; + save(): IForm; +} diff --git a/src/main/resources/assets/customnpcs/api/kamkeel/npcdbc/api/outline/IOutline.d.ts b/src/main/resources/assets/customnpcs/api/kamkeel/npcdbc/api/outline/IOutline.d.ts new file mode 100644 index 000000000..5e6050320 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/kamkeel/npcdbc/api/outline/IOutline.d.ts @@ -0,0 +1,18 @@ +export interface IOutline { + setInnerColor(color: number, alpha: number): void; + setOuterColor(color: number, alpha: number): void; + setSize(size: number): IOutline; + setNoiseSize(size: number): IOutline; + setSpeed(speed: number): IOutline; + setPulsingSpeed(speed: number): IOutline; + setColorSmoothness(smoothness: number): IOutline; + setColorInterpolation(interp: number): IOutline; + getName(): string; + setName(name: string): void; + getMenuName(): string; + setMenuName(name: string): void; + getID(): number; + setID(newID: number): void; + clone(): IOutline; + save(): IOutline; +} diff --git a/src/main/resources/assets/customnpcs/api/minecraft-raw.d.ts b/src/main/resources/assets/customnpcs/api/minecraft-raw.d.ts new file mode 100644 index 000000000..a0695de2f --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/minecraft-raw.d.ts @@ -0,0 +1,278 @@ +/** + * Raw Minecraft 1.7.10 Type Definitions (MCP Names) + * These represent the internal deobfuscated Minecraft classes. + */ + +declare global { + namespace net.minecraft { + export namespace block { + export interface Block { + /** @returns The unlocalized name of the block */ + getUnlocalizedName(): string; + /** @returns The localized name of the block */ + getLocalizedName(): string; + /** @returns Light opacity of the block */ + getLightOpacity(): number; + /** @returns Light value of the block */ + getLightValue(): number; + } + } + + export namespace damage { + export interface DamageSource { + /** The type of damage (e.g. "player", "fall", "magic") */ + damageType: string; + /** @returns True if damage bypasses armor */ + isUnblockable(): boolean; + /** @returns True if damage is absolute (bypasses potions etc) */ + isDamageAbsolute(): boolean; + /** @returns The entity that caused the damage */ + getEntity(): net.minecraft.entity.Entity; + /** @returns The entity that directly dealt the damage (e.g. arrow) */ + getSourceOfDamage(): net.minecraft.entity.Entity; + } + } + + export namespace entity { + /** Base class for all entities in Minecraft 1.7.10 */ + export interface Entity { + /** The entity's unique ID */ + entityId: number; + /** The world the entity is in */ + worldObj: net.minecraft.world.World; + /** X position */ + posX: number; + /** Y position */ + posY: number; + /** Z position */ + posZ: number; + /** X motion */ + motionX: number; + /** Y motion */ + motionY: number; + /** Z motion */ + motionZ: number; + /** Rotation yaw */ + rotationYaw: number; + /** Rotation pitch */ + rotationPitch: number; + /** Entity width */ + width: number; + /** Entity height */ + height: number; + /** Whether the entity is on the ground */ + onGround: boolean; + /** Whether the entity is in water */ + isInWeb: boolean; + /** Ticks the entity has been alive */ + ticksExisted: number; + /** Remaining air */ + air: number; + /** Damage sustained from falling */ + fallDistance: number; + + /** Gets a unique string key for this entity type */ + getEntityString(): string; + /** Sets the entity's position */ + setPosition(x: number, y: number, z: number): void; + /** Sets the entity's rotation */ + setRotation(yaw: number, pitch: number): void; + /** Marks the entity for removal */ + setDead(): void; + /** @returns True if the entity is burning */ + isBurning(): boolean; + /** @returns True if the entity is sneaking */ + isSneaking(): boolean; + /** @returns True if the entity is sprinting */ + isSprinting(): boolean; + /** @returns True if the entity is invisible */ + isInvisible(): boolean; + } + + export interface EntityLivingBase extends Entity { + /** @returns Current health */ + getHealth(): number; + /** Sets the entity's health */ + setHealth(health: number): void; + /** @returns Max health */ + getMaxHealth(): number; + /** @returns True if entity is child */ + isChild(): boolean; + /** Sets entity on fire */ + setFire(seconds: number): void; + } + + export interface EntityLiving extends EntityLivingBase { + /** Sets the attack target */ + setAttackTarget(target: net.minecraft.entity.EntityLivingBase): void; + /** @returns The current attack target */ + getAttackTarget(): net.minecraft.entity.EntityLivingBase; + /** @returns True if the entity can pick up loot */ + canPickUpLoot(): boolean; + /** Sets if the entity can pick up loot */ + setCanPickUpLoot(can: boolean): void; + } + + export interface EntityItem extends Entity { + /** The ItemStack contained in this entity */ + getEntityItem(): net.minecraft.item.ItemStack; + /** Sets the ItemStack contained in this entity */ + setEntityItemStack(stack: net.minecraft.item.ItemStack): void; + } + + export interface EntityZombie extends EntityLiving { + /** @returns True if the zombie is a child */ + isChild(): boolean; + /** Sets if the zombie is a child */ + setChild(child: boolean): void; + } + + export namespace player { + /** Representation of a Player in Minecraft 1.7.10 */ + export interface EntityPlayer extends net.minecraft.entity.Entity { + /** The player's inventory */ + inventory: net.minecraft.entity.player.InventoryPlayer; + /** The player's experience level */ + experienceLevel: number; + /** Total experience points */ + experienceTotal: number; + /** Progress to next level (0.0 to 1.0) */ + experience: number; + /** Player capabilities (flying, creative, etc.) */ + capabilities: net.minecraft.entity.player.PlayerCapabilities; + /** Food stats (hunger, saturation) */ + foodStats: any; + /** The player's dimension ID */ + dimension: number; + + /** Sends a chat message to the player */ + addChatMessage(component: any): void; + /** @returns The display name of the player */ + getDisplayName(): string; + /** @returns The actual username/command sender name */ + getCommandSenderName(): string; + /** Closes any open GUI */ + closeScreen(): void; + } + + export interface InventoryPlayer { + /** Current selected slot index (0-8) */ + currentItem: number; + /** Main inventory array (36 slots) */ + mainInventory: net.minecraft.item.ItemStack[]; + /** Armor inventory array (4 slots) */ + armorInventory: net.minecraft.item.ItemStack[]; + + /** Gets the currently held item */ + getCurrentItem(): net.minecraft.item.ItemStack; + /** Consumes 1 of the item in the specified slot */ + consumeInventoryItem(item: any): boolean; + /** Checks if the player has a specific item */ + hasItem(item: any): boolean; + } + + export interface PlayerCapabilities { + /** Whether the player is invulnerable */ + disableDamage: boolean; + /** Whether the player is flying */ + isFlying: boolean; + /** Whether the player can fly */ + allowFlying: boolean; + /** Whether the player is in creative mode */ + isCreativeMode: boolean; + /** Flying speed */ + flySpeed: number; + /** Walking speed */ + walkSpeed: number; + } + } + } + + export namespace world { + /** Representation of the World in Minecraft 1.7.10 */ + export interface World { + /** World provider (dimension info) */ + provider: net.minecraft.world.WorldProvider; + /** List of all entities in the world */ + loadedEntityList: net.minecraft.entity.Entity[]; + /** List of all players in the world */ + playerEntities: net.minecraft.entity.player.EntityPlayer[]; + /** True if this is a client-side world */ + isRemote: boolean; + /** World time in ticks */ + worldTime: number; + /** The world's difficulty (0-3) */ + difficultySetting: number; + + /** @returns The block at the given coordinates */ + getBlock(x: number, y: number, z: number): net.minecraft.block.Block; + /** @returns The metadata of the block at the given coordinates */ + getBlockMetadata(x: number, y: number, z: number): number; + /** Sets the block and metadata at the given coordinates */ + setBlock(x: number, y: number, z: number, block: net.minecraft.block.Block, metadata: number, flags: number): boolean; + /** Spawns an entity in the world */ + spawnEntityInWorld(entity: net.minecraft.entity.Entity): boolean; + /** Plays a sound at the given coordinates */ + playSoundEffect(x: number, y: number, z: number, name: string, volume: number, pitch: number): void; + } + + export interface WorldProvider { + /** Dimension ID (0 = Overworld, -1 = Nether, 1 = End) */ + dimensionId: number; + /** Name of the dimension type */ + dimensionName: string; + /** Whether this dimension has a sky */ + hasSkyLight: boolean; + } + } + + export namespace item { + /** Representation of an Item stack in Minecraft 1.7.10 */ + export interface ItemStack { + /** Number of items in the stack */ + stackSize: number; + /** Damage/Metadata value of the item */ + itemDamage: number; + /** The underlying Item object */ + item: any; + /** NBT data of the stack */ + stackTagCompound: any; + + /** @returns The display name of the item */ + getDisplayName(): string; + /** @returns True if the item has NBT data */ + hasTagCompound(): boolean; + /** Copies the item stack */ + copy(): net.minecraft.item.ItemStack; + } + } + + export namespace util { + /** Result of a raytrace in 1.7.10 */ + export interface MovingObjectPosition { + /** 0 = MISS, 1 = BLOCK, 2 = ENTITY */ + typeOfHit: number; + /** X coordinate of the hit block */ + blockX: number; + /** Y coordinate of the hit block */ + blockY: number; + /** Z coordinate of the hit block */ + blockZ: number; + /** Side of the block hit (0-5) */ + sideHit: number; + /** The entity hit, if typeOfHit is ENTITY */ + entityHit: net.minecraft.entity.Entity; + /** The exact hit vector */ + hitVec: net.minecraft.util.Vec3; + } + + export interface Vec3 { + xCoord: number; + yCoord: number; + zCoord: number; + } + } + } +} + +export { }; diff --git a/src/main/resources/assets/customnpcs/api/net/minecraft/block/properties/IProperty.d.ts b/src/main/resources/assets/customnpcs/api/net/minecraft/block/properties/IProperty.d.ts new file mode 100644 index 000000000..a40d27121 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/net/minecraft/block/properties/IProperty.d.ts @@ -0,0 +1,18 @@ +/** + * Generated from Java interface net.minecraft.block.properties.IProperty + * Source: CustomNPC+ JavaDoc (Minecraft 1.7.10) + */ + +export interface IProperty { + /** Returns the property name */ + getName(): string; + + /** Returns the allowed values for this property */ + getAllowedValues(): Array; + + /** Returns the runtime value class for this property (approximation) */ + getValueClass(): Function; + + /** Returns the name for a given value */ + getName(value: T): string; +} diff --git a/src/main/resources/assets/customnpcs/api/net/minecraft/block/state/IBlockState.d.ts b/src/main/resources/assets/customnpcs/api/net/minecraft/block/state/IBlockState.d.ts new file mode 100644 index 000000000..7361d198a --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/net/minecraft/block/state/IBlockState.d.ts @@ -0,0 +1,16 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: net.minecraft.block.state + */ + +export interface IBlockState { + + // Methods + getPropertyNames(): Array { + + // Fields + x: number; + y: number; + z: number; + xd: number; + yd: number; + zd: number; + true: any; + false: any; + vec3I: import('./Vec3i').Vec3i; + + // Methods + equals(p_equals_1_: any): boolean; + hashCode(): number; + compareTo(p_compareTo_1_: import('./Vec3i').Vec3i): number; + getX(): number; + getY(): number; + getZ(): number; + getXD(): number; + getYD(): number; + getZD(): number; + crossProduct(vec: import('./Vec3i').Vec3i): i; + toString(): string; + +} diff --git a/src/main/resources/assets/customnpcs/api/net/minecraft/util/math/BlockPos.d.ts b/src/main/resources/assets/customnpcs/api/net/minecraft/util/math/BlockPos.d.ts new file mode 100644 index 000000000..df828d373 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/net/minecraft/util/math/BlockPos.d.ts @@ -0,0 +1,82 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: net.minecraft.util.math + */ + +export class BlockPos extends Vec3i { + + // Fields + LOGGER: Logger; + ORIGIN: import('./BlockPos').BlockPos; + NUM_X_BITS: number; + NUM_Z_BITS: number; + NUM_Y_BITS: number; + Y_SHIFT: number; + X_SHIFT: number; + X_MASK: number; + Y_MASK: number; + Z_MASK: number; + x: any; + x: any; + n: any; + 0: <<; + i: number; + j: number; + k: number; + blockpos: import('./BlockPos').BlockPos; + blockpos1: import('./BlockPos').BlockPos; + lastReturned: import('./BlockPos').BlockPos; + i: number; + j: number; + k: number; + x: number; + y: number; + z: number; + this: any; + released: boolean; + POOL: Array { + + // Methods + isBreedingItem(itemStack: import('../item/IItemStack').IItemStack): boolean; + interact(player: import('./IPlayer').IPlayer): boolean; + setFollowPlayer(player: import('./IPlayer').IPlayer): void; + followingPlayer(): import('./IPlayer').IPlayer; + isInLove(): boolean; + resetInLove(): void; + canMateWith(animal: import('./IAnimal').IAnimal): boolean; + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IAnimatable.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IAnimatable.d.ts new file mode 100644 index 000000000..bd933971b --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IAnimatable.d.ts @@ -0,0 +1,11 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.entity + */ + +export interface IAnimatable { + + // Methods + getAnimationData(): import('../handler/data/IAnimationData').IAnimationData; + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IArrow.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IArrow.d.ts new file mode 100644 index 000000000..719076b1a --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IArrow.d.ts @@ -0,0 +1,13 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.entity + */ + +export interface IArrow extends IEntity { + + // Methods + getShooter(): import('./IEntity').IEntity; + getDamage(): number; + kill(): void; + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/ICustomNpc.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/ICustomNpc.d.ts new file mode 100644 index 000000000..d99948448 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/ICustomNpc.d.ts @@ -0,0 +1,217 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.entity + */ + +export interface ICustomNpc extends IEntityLiving, IAnimatable { + + // Methods + getSize(): number; + setSize(size: number): void; + getModelType(): number; + setModelType(modelType: number): void; + getName(): string; + setRotation(rotation: number): void; + setRotationType(rotationType: number): void; + getRotationType(): number; + setMovingType(movingType: number): void; + getMovingType(): number; + setName(name: string): void; + getTitle(): string; + setTitle(title: string): void; + getTexture(): string; + setTexture(texture: string): void; + getHome(): import('../IPos').IPos; + getHomeX(): number; + setHomeX(x: number): void; + getHomeY(): number; + setHomeY(y: number): void; + getHomeZ(): number; + setHomeZ(z: number): void; + setHome(x: number, y: number, z: number): void; + setHome(pos: import('../IPos').IPos): void; + setMaxHealth(health: number): void; + setReturnToHome(bo: boolean): void; + getReturnToHome(): boolean; + getFaction(): import('../handler/data/IFaction').IFaction; + setFaction(id: number): void; + setAttackFactions(attackOtherFactions: boolean): void; + getAttackFactions(): boolean; + setDefendFaction(defendFaction: boolean): void; + getDefendFaction(): boolean; + getType(): number; + typeOf(type: number): boolean; + shootItem(target: IEntityLivingBase, item: import('../item/IItemStack').IItemStack, accuracy: number): void; + setProjectilesKeepTerrain(b: boolean): void; + getProjectilesKeepTerrain(): boolean; + say(message: string): void; + say(player: import('./IPlayer').IPlayer, message: string): void; + getDialog(slot: number): import('../handler/data/IDialog').IDialog; + getDialogId(slot: number): number; + setDialog(slot: number, dialog: import('../handler/data/IDialog').IDialog): void; + setDialog(slot: number, dialogId: number): void; + getInteractLines(): import('../handler/data/ILines').ILines; + getWorldLines(): import('../handler/data/ILines').ILines; + getAttackLines(): import('../handler/data/ILines').ILines; + getKilledLines(): import('../handler/data/ILines').ILines; + getKillLines(): import('../handler/data/ILines').ILines; + kill(): void; + reset(): void; + getAnimationData(): import('../handler/data/IAnimationData').IAnimationData; + getRole(): import('../roles/IRole').IRole; + setRole(role: number): void; + getJob(): import('../jobs/IJob').IJob; + setJob(job: number): void; + getRightItem(): import('../item/IItemStack').IItemStack; + setRightItem(item: import('../item/IItemStack').IItemStack): void; + getLefttItem(): import('../item/IItemStack').IItemStack; + getLeftItem(): import('../item/IItemStack').IItemStack; + setLeftItem(item: import('../item/IItemStack').IItemStack): void; + getProjectileItem(): import('../item/IItemStack').IItemStack; + setProjectileItem(item: import('../item/IItemStack').IItemStack): void; + canAimWhileShooting(): boolean; + aimWhileShooting(aimWhileShooting: boolean): void; + setAimType(aimWhileShooting: byte): void; + getAimType(): byte; + setMinProjectileDelay(minDelay: number): void; + getMinProjectileDelay(): number; + setMaxProjectileDelay(maxDelay: number): void; + getMaxProjectileDelay(): number; + setRangedRange(rangedRange: number): void; + getRangedRange(): number; + setFireRate(rate: number): void; + getFireRate(): number; + setBurstCount(burstCount: number): void; + getBurstCount(): number; + setShotCount(shotCount: number): void; + getShotCount(): number; + setAccuracy(accuracy: number): void; + getAccuracy(): number; + getFireSound(): string; + setFireSound(fireSound: string): void; + getArmor(slot: number): import('../item/IItemStack').IItemStack; + setArmor(slot: number, item: import('../item/IItemStack').IItemStack): void; + getLootItem(slot: number): import('../item/IItemStack').IItemStack; + setLootItem(slot: number, item: import('../item/IItemStack').IItemStack): void; + getLootChance(slot: number): number; + setLootChance(slot: number, chance: number): void; + getLootMode(): number; + setLootMode(lootMode: number): void; + setMinLootXP(lootXP: number): void; + setMaxLootXP(lootXP: number): void; + getMinLootXP(): number; + getMaxLootXP(): number; + getCanDrown(): boolean; + setDrowningType(type: number): void; + canBreathe(): boolean; + setAnimation(type: number): void; + setTacticalVariant(variant: number): void; + getTacticalVariant(): number; + setTacticalVariant(variant: string): void; + getTacticalVariantName(): string; + getCombatPolicyName(): string; + setCombatPolicy(policy: number): void; + getCombatPolicy(): number; + setCombatPolicy(policy: string): void; + setTacticalRadius(tacticalRadius: number): void; + getTacticalRadius(): number; + setIgnoreCobweb(ignore: boolean): void; + getIgnoreCobweb(): boolean; + setOnFoundEnemy(onAttack: number): void; + onFoundEnemy(): number; + setShelterFrom(shelterFrom: number): void; + getShelterFrom(): number; + hasLivingAnimation(): boolean; + setLivingAnimation(livingAnimation: boolean): void; + setVisibleType(type: number): void; + getVisibleType(): number; + setVisibleTo(player: import('./IPlayer').IPlayer, visible: boolean): void; + isVisibleTo(player: import('./IPlayer').IPlayer): boolean; + setShowName(type: number): void; + getShowName(): number; + getShowBossBar(): number; + setShowBossBar(type: number): void; + getMeleeStrength(): number; + setMeleeStrength(strength: number): void; + getMeleeSpeed(): number; + setMeleeSpeed(speed: number): void; + getMeleeRange(): number; + setMeleeRange(range: number): void; + getSwingWarmup(): number; + setSwingWarmup(ticks: number): void; + getKnockback(): number; + setKnockback(knockback: number): void; + getAggroRange(): number; + setAggroRange(aggroRange: number): void; + getRangedStrength(): number; + setRangedStrength(strength: number): void; + getRangedSpeed(): number; + setRangedSpeed(speed: number): void; + getRangedBurst(): number; + setRangedBurst(count: number): void; + getRespawnTime(): number; + setRespawnTime(time: number): void; + getRespawnCycle(): number; + setRespawnCycle(cycle: number): void; + getHideKilledBody(): boolean; + hideKilledBody(hide: boolean): void; + naturallyDespawns(): boolean; + setNaturallyDespawns(canDespawn: boolean): void; + spawnedFromSoulStone(): boolean; + getSoulStonePlayerName(): string; + isSoulStoneInit(): boolean; + getRefuseSoulStone(): boolean; + setRefuseSoulStone(refuse: boolean): void; + getMinPointsToSoulStone(): number; + setMinPointsToSoulStone(points: number): void; + giveItem(player: import('./IPlayer').IPlayer, item: import('../item/IItemStack').IItemStack): void; + executeCommand(command: string): void; + getModelData(): import('./data/IModelData').IModelData; + setHeadScale(x: number, y: number, z: number): void; + setBodyScale(x: number, y: number, z: number): void; + setArmsScale(x: number, y: number, z: number): void; + setLegsScale(x: number, y: number, z: number): void; + setExplosionResistance(resistance: number): void; + getExplosionResistance(): number; + setMeleeResistance(resistance: number): void; + getMeleeResistance(): number; + setArrowResistance(resistance: number): void; + getArrowResistance(): number; + setKnockbackResistance(resistance: number): void; + getKnockbackResistance(): number; + setRetaliateType(type: number): void; + getCombatRegen(): number; + setCombatRegen(regen: number): void; + getHealthRegen(): number; + setHealthRegen(regen: number): void; + getAge(): number; + getTimers(): import('../ITimers').ITimers; + setFly(fly: number): void; + canFly(): boolean; + setFlySpeed(flySpeed: number): void; + getFlySpeed(unused: number): number; + setFlyGravity(flyGravity: number): void; + getFlyGravity(unused: number): number; + setFlyHeightLimit(flyHeightLimit: number): void; + getFlyHeightLimit(unused: number): number; + limitFlyHeight(limit: boolean): void; + isFlyHeightLimited(unused: boolean): boolean; + setSpeed(speed: number): void; + getSpeed(): number; + setSkinType(type: byte): void; + getSkinType(): byte; + setSkinUrl(url: string): void; + getSkinUrl(): string; + setCloakTexture(cloakTexture: string): void; + getCloakTexture(): string; + setOverlayTexture(overlayTexture: string): void; + getOverlayTexture(): string; + getOverlays(): import('../handler/IOverlayHandler').IOverlayHandler; + setCollisionType(type: number): void; + getCollisionType(): number; + updateClient(): void; + updateAI(): void; + getActionManager(): import('../handler/IActionManager').IActionManager; + getMagicData(): import('../handler/data/IMagicData').IMagicData; + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IDBCPlayer.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IDBCPlayer.d.ts new file mode 100644 index 000000000..0d3fa22c9 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IDBCPlayer.d.ts @@ -0,0 +1,71 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.entity + */ + +export interface IDBCPlayer extends IPlayer { + + // Methods + setStat(stat: string, value: number): void; + getStat(stat: string): number; + addBonusAttribute(stat: string, bonusID: string, operation: string, attributeValue: number): void; + addBonusAttribute(stat: string, bonusID: string, operation: string, attributeValue: number, endOfTheList: boolean): void; + addToBonusAttribute(stat: string, bonusID: string, operation: string, attributeValue: number): void; + setBonusAttribute(stat: string, bonusID: string, operation: string, attributeValue: number): void; + getBonusAttribute(stat: string, bonusID: string): void; + removeBonusAttribute(stat: string, bonusID: string): void; + clearBonusAttribute(stat: string): void; + bonusAttribute(action: string, stat: string, bonusID: string): string; + bonusAttribute(action: string, stat: string, bonusID: string, operation: string, attributeValue: number, endOfTheList: boolean): string; + setRelease(release: byte): void; + getRelease(): byte; + setBody(body: number): void; + getBody(): number; + setHP(hp: number): void; + getHP(): number; + setStamina(stamina: number): void; + getStamina(): number; + setKi(ki: number): void; + getKi(): number; + setTP(tp: number): void; + getTP(): number; + setGravity(gravity: number): void; + getGravity(): number; + isBlocking(): boolean; + setHairCode(hairCode: string): void; + getHairCode(): string; + setExtraCode(extraCode: string): void; + getExtraCode(): string; + setItem(itemStack: import('../item/IItemStack').IItemStack, slot: byte, vanity: boolean): void; + getItem(slot: byte, vanity: boolean): import('../item/IItemStack').IItemStack; + getInventory(): import('../item/IItemStack').IItemStack[]; + setForm(form: byte): void; + getForm(): byte; + setForm2(form2: byte): void; + getForm2(): byte; + getRacialFormMastery(form: byte): number; + setRacialFormMastery(form: byte, value: number): void; + addRacialFormMastery(form: byte, value: number): void; + getOtherFormMastery(formName: string): number; + setOtherFormMastery(formName: string, value: number): void; + addOtherFormMastery(formName: string, value: number): void; + setPowerPoints(points: number): void; + getPowerPoints(): number; + setAuraColor(color: number): void; + getAuraColor(): number; + setFormLevel(level: number): void; + getFormLevel(): number; + setSkills(skills: string): void; + getSkills(): string; + setJRMCSE(statusEffects: string): void; + getJRMCSE(): string; + setRace(race: byte): void; + getRace(): number; + setDBCClass(dbcClass: byte): void; + getDBCClass(): byte; + setPowerType(powerType: byte): void; + getPowerType(): number; + getKillCount(type: string): number; + getFusionString(): string; + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IEntity.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IEntity.d.ts new file mode 100644 index 000000000..49f0fd439 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IEntity.d.ts @@ -0,0 +1,101 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.entity + */ + +export interface IEntity { + + // Methods + spawnParticle(entityParticle: import('../IParticle').IParticle): void; + getEntityId(): number; + getUniqueID(): string; + getYOffset(): number; + getWidth(): number; + getHeight(): number; + getX(): number; + setX(x: number): void; + getY(): number; + setY(y: number): void; + getZ(): number; + setZ(z: number): void; + getMotionX(): number; + setMotionX(x: number): void; + getMotionY(): number; + setMotionY(y: number): void; + getMotionZ(): number; + setMotionZ(z: number): void; + setMotion(x: number, y: number, z: number): void; + setMotion(pos: import('../IPos').IPos): void; + getMotion(): import('../IPos').IPos; + isAirborne(): boolean; + getBlockX(): number; + getBlockY(): number; + getBlockZ(): number; + setPosition(x: number, y: number, z: number): void; + setPosition(pos: import('../IPos').IPos): void; + getPosition(): import('../IPos').IPos; + getDimension(): number; + setDimension(dimensionId: number): void; + getCollidingEntities(): import('./IEntity').IEntity[]; + getSurroundingEntities(range: number): import('./IEntity').IEntity[]; + getSurroundingEntities(range: number, type: number): import('./IEntity').IEntity[]; + isAlive(): boolean; + getTempData(key: string): any; + setTempData(key: string, value: any): void; + hasTempData(key: string): boolean; + removeTempData(key: string): void; + clearTempData(): void; + getTempDataKeys(): string[]; + getStoredData(key: string): any; + setStoredData(key: string, value: any): void; + hasStoredData(key: string): boolean; + removeStoredData(key: string): void; + clearStoredData(): void; + getStoredDataKeys(): string[]; + getAge(): number; + despawn(): void; + inWater(): boolean; + inLava(): boolean; + inFire(): boolean; + isBurning(): boolean; + setBurning(ticks: number): void; + extinguish(): void; + getTypeName(): string; + dropItem(item: import('../item/IItemStack').IItemStack): void; + getRider(): import('./IEntity').IEntity; + setRider(entity: import('./IEntity').IEntity): void; + getMount(): import('./IEntity').IEntity; + setMount(entity: import('./IEntity').IEntity): void; + getType(): number; + typeOf(type: number): boolean; + setRotation(rotation: number): void; + setRotation(rotationYaw: number, rotationPitch: number): void; + getRotation(): number; + setPitch(pitch: number): void; + getPitch(): number; + knockback(power: number, direction: number): void; + knockback(xpower: number, ypower: number, zpower: number, direction: number): void; + knockback(pos: import('../IPos').IPos, direction: number): void; + setImmune(ticks: number): void; + setInvisible(invisible: boolean): void; + setSneaking(sneaking: boolean): void; + setSprinting(sprinting: boolean): void; + hasCollided(): boolean; + hasCollidedVertically(): boolean; + hasCollidedHorizontally(): boolean; + capturesDrops(): boolean; + setCapturesDrops(capture: boolean): void; + setCapturedDrops(capturedDrops: IEntity { + + // Methods + getOwner(): string; + setOwner(name: string): void; + getThrower(): string; + setThrower(name: string): void; + getPickupDelay(): number; + setPickupDelay(delay: number): void; + getAge(): number; + setAge(age: number): void; + getLifeSpawn(): number; + setLifeSpawn(age: number): void; + getItem(): import('../item/IItemStack').IItemStack; + setItem(item: import('../item/IItemStack').IItemStack): void; + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IEntityLiving.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IEntityLiving.d.ts new file mode 100644 index 000000000..fbb890558 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IEntityLiving.d.ts @@ -0,0 +1,33 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.entity + */ + +export interface IEntityLiving extends IEntityLivingBase { + + // Methods + isNavigating(): boolean; + clearNavigation(): void; + navigateTo(x: number, y: number, z: number, speed: number): void; + getMCEntity(): T; + playLivingSound(): void; + spawnExplosionParticle(): void; + setMoveForward(speed: number): void; + faceEntity(entity: import('./IEntity').IEntity, pitch: number, yaw: number): void; + canPickUpLoot(): boolean; + setCanPickUpLoot(pickUp: boolean): void; + isPersistent(): boolean; + enablePersistence(): void; + setCustomNameTag(text: string): void; + getCustomNameTag(): string; + hasCustomNameTag(): boolean; + setAlwaysRenderNameTag(alwaysRender: boolean): void; + getAlwaysRenderNameTag(): boolean; + clearLeashed(sendPacket: boolean, dropLeash: boolean): void; + allowLeashing(): boolean; + getLeashed(): boolean; + getLeashedTo(): import('./IEntity').IEntity; + setLeashedTo(entity: import('./IEntity').IEntity, sendPacket: boolean): void; + canBeSteered(): boolean; + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IEntityLivingBase.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IEntityLivingBase.d.ts new file mode 100644 index 000000000..3a9aef6ce --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IEntityLivingBase.d.ts @@ -0,0 +1,65 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.entity + */ + +export interface IEntityLivingBase extends import('./IEntity').IEntity { + + // Methods + getHealth(): number; + setHealth(health: number): void; + hurt(damage: number): void; + hurt(damage: number, source: import('./IEntity').IEntity): void; + hurt(damage: number, damageSource: import('../IDamageSource').IDamageSource): void; + setMaxHurtTime(time: number): void; + getMaxHurtTime(): number; + getMaxHealth(): number; + getFollowRange(): number; + getKnockbackResistance(): number; + getSpeed(): number; + getMeleeStrength(): number; + setMaxHealth(health: number): void; + setFollowRange(range: number): void; + setKnockbackResistance(knockbackResistance: number): void; + setSpeed(speed: number): void; + setMeleeStrength(attackDamage: number): void; + isAttacking(): boolean; + setAttackTarget(living: IEntityLivingBase): void; + getAttackTarget(): IEntityLivingBase; + getAttackTargetTime(): number; + setLastAttacker(p_130011_1_: import('./IEntity').IEntity): void; + getLastAttacker(): import('./IEntity').IEntity; + getLastAttackerTime(): number; + canBreatheUnderwater(): boolean; + getType(): number; + typeOf(type: number): boolean; + getLookVector(): import('../IPos').IPos; + getLookingAtBlock(maxDistance: number, stopOnBlock: boolean, stopOnLiquid: boolean, stopOnCollision: boolean): import('../IBlock').IBlock; + getLookingAtBlock(maxDistance: number): import('../IBlock').IBlock; + getLookingAtPos(maxDistance: number, stopOnBlock: boolean, stopOnLiquid: boolean, stopOnCollision: boolean): import('../IPos').IPos; + getLookingAtPos(maxDistance: number): import('../IPos').IPos; + getLookingAtEntities(ignoreEntities: import('./IEntity').IEntity[], maxDistance: number, offset: number, range: number, stopOnBlock: boolean, stopOnLiquid: boolean, stopOnCollision: boolean): import('./IEntity').IEntity[]; + getLookingAtEntities(maxDistance: number, offset: number, range: number, stopOnBlock: boolean, stopOnLiquid: boolean, stopOnCollision: boolean): import('./IEntity').IEntity[]; + getLookingAtEntities(maxDistance: number, offset: number, range: number): import('./IEntity').IEntity[]; + getMCEntity(): T; + swingHand(): void; + addPotionEffect(effect: number, duration: number, strength: number, hideParticles: boolean): void; + clearPotionEffects(): void; + getPotionEffect(effect: number): number; + getHeldItem(): import('../item/IItemStack').IItemStack; + setHeldItem(item: import('../item/IItemStack').IItemStack): void; + getArmor(slot: number): import('../item/IItemStack').IItemStack; + setArmor(slot: number, item: import('../item/IItemStack').IItemStack): void; + isChild(): boolean; + renderBrokenItemStack(itemStack: import('../item/IItemStack').IItemStack): void; + isOnLadder(): boolean; + getTotalArmorValue(): number; + getArrowCountInEntity(): number; + setArrowCountInEntity(count: number): void; + dismountEntity(entity: import('./IEntity').IEntity): void; + setAIMoveSpeed(speed: number): void; + getAIMoveSpeed(): number; + setAbsorptionAmount(amount: number): void; + getAbsorptionAmount(): number; + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IFishHook.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IFishHook.d.ts new file mode 100644 index 000000000..4b1c9b09f --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IFishHook.d.ts @@ -0,0 +1,12 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.entity + */ + +export interface IFishHook extends IEntity { + + // Methods + getCaster(): import('./IPlayer').IPlayer; + kill(): void; + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IMonster.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IMonster.d.ts new file mode 100644 index 000000000..10c4632d1 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IMonster.d.ts @@ -0,0 +1,8 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.entity + */ + +export interface IMonster extends IEntityLiving { + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IPixelmon.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IPixelmon.d.ts new file mode 100644 index 000000000..b397fb06c --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IPixelmon.d.ts @@ -0,0 +1,33 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.entity + */ + +export interface IPixelmon extends IAnimal { + + // Methods + getIsShiny(): boolean; + setIsShiny(bo: boolean): void; + getLevel(): number; + setLevel(level: number): void; + getIV(type: number): number; + setIV(type: number, value: number): void; + getEV(type: number): number; + setEV(type: number, value: number): void; + getStat(type: number): number; + setStat(type: number, value: number): void; + getSize(): number; + setSize(type: number): void; + getHapiness(): number; + setHapiness(value: number): void; + getNature(): number; + setNature(type: number): void; + getPokeball(): number; + setPokeball(type: number): void; + getNickname(): string; + hasNickname(): boolean; + setNickname(name: string): void; + getMove(slot: number): string; + setMove(slot: number, move: string): void; + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IPlayer.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IPlayer.d.ts new file mode 100644 index 000000000..efeaafc75 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IPlayer.d.ts @@ -0,0 +1,106 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.entity + */ + +export interface IPlayer extends IEntityLivingBase, IAnimatable { + + // Methods + getDisplayName(): string; + getName(): string; + kick(reason: string): void; + setPosition(x: number, y: number, z: number): void; + setPosition(pos: import('../IPos').IPos): void; + setPosition(x: number, y: number, z: number, dimensionId: number): void; + setPosition(pos: import('../IPos').IPos, dimensionId: number): void; + setPosition(x: number, y: number, z: number, world: import('../IWorld').IWorld): void; + setPosition(pos: import('../IPos').IPos, world: import('../IWorld').IWorld): void; + setDimension(dimension: number): void; + getHunger(): number; + setHunger(hunger: number): void; + getSaturation(): number; + setSaturation(saturation: number): void; + showDialog(dialog: import('../handler/data/IDialog').IDialog): void; + hasReadDialog(dialog: import('../handler/data/IDialog').IDialog): boolean; + readDialog(dialog: import('../handler/data/IDialog').IDialog): void; + unreadDialog(dialog: import('../handler/data/IDialog').IDialog): void; + showDialog(id: number): void; + hasReadDialog(id: number): boolean; + readDialog(id: number): void; + unreadDialog(id: number): void; + hasFinishedQuest(quest: import('../handler/data/IQuest').IQuest): boolean; + hasActiveQuest(quest: import('../handler/data/IQuest').IQuest): boolean; + startQuest(quest: import('../handler/data/IQuest').IQuest): void; + finishQuest(quest: import('../handler/data/IQuest').IQuest): void; + stopQuest(quest: import('../handler/data/IQuest').IQuest): void; + removeQuest(quest: import('../handler/data/IQuest').IQuest): void; + hasFinishedQuest(id: number): boolean; + hasActiveQuest(id: number): boolean; + startQuest(id: number): void; + finishQuest(id: number): void; + stopQuest(id: number): void; + removeQuest(id: number): void; + getFinishedQuests(): import('../handler/data/IQuest').IQuest[]; + getType(): number; + typeOf(type: number): boolean; + addFactionPoints(faction: number, points: number): void; + setFactionPoints(faction: number, points: number): void; + getFactionPoints(faction: number): number; + sendMessage(message: string): void; + getMode(): number; + setMode(type: number): void; + getInventory(): import('../item/IItemStack').IItemStack[]; + inventoryItemCount(item: import('../item/IItemStack').IItemStack, ignoreNBT: boolean, ignoreDamage: boolean): number; + removeItem(id: string, damage: number, amount: number): boolean; + removeItem(item: import('../item/IItemStack').IItemStack, amount: number, ignoreNBT: boolean, ignoreDamage: boolean): boolean; + removeAllItems(item: import('../item/IItemStack').IItemStack, ignoreNBT: boolean, ignoreDamage: boolean): number; + giveItem(item: import('../item/IItemStack').IItemStack, amount: number): boolean; + giveItem(id: string, damage: number, amount: number): boolean; + setSpawnpoint(x: number, y: number, z: number): void; + setSpawnpoint(pos: import('../IPos').IPos): void; + resetSpawnpoint(): void; + setRotation(rotationYaw: number, rotationPitch: number): void; + disableMouseInput(time: number, buttonIds: ): void; + stopUsingItem(): void; + clearItemInUse(): void; + clearInventory(): void; + playSound(name: string, volume: number, pitch: number): void; + playSound(id: number, sound: import('../handler/data/ISound').ISound): void; + playSound(sound: import('../handler/data/ISound').ISound): void; + stopSound(id: number): void; + pauseSounds(): void; + continueSounds(): void; + stopSounds(): void; + mountEntity(ridingEntity: Entity): void; + dropOneItem(dropStack: boolean): import('./IEntity').IEntity; + canHarvestBlock(block: import('../IBlock').IBlock): boolean; + interactWith(entity: import('./IEntity').IEntity): boolean; + hasAchievement(achievement: string): boolean; + hasBukkitPermission(permission: string): boolean; + getExpLevel(): number; + setExpLevel(level: number): void; + getPixelmonData(): import('../IPixelmonPlayerData').IPixelmonPlayerData; + getTimers(): import('../ITimers').ITimers; + updatePlayerInventory(): void; + getDBCPlayer(): import('../../kamkeel/npcdbc/api/IDBCAddon').IDBCAddon; + blocking(): boolean; + getData(): import('../handler/IPlayerData').IPlayerData; + isScriptingDev(): boolean; + getActiveQuests(): import('../handler/data/IQuest').IQuest[]; + getOpenContainer(): import('../IContainer').IContainer; + showCustomGui(gui: import('../gui/ICustomGui').ICustomGui): void; + getCustomGui(): import('../gui/ICustomGui').ICustomGui; + closeGui(): void; + showCustomOverlay(overlay: import('../overlay/ICustomOverlay').ICustomOverlay): void; + closeOverlay(id: number): void; + getOverlays(): import('../handler/IOverlayHandler').IOverlayHandler; + getAnimationData(): import('../handler/data/IAnimationData').IAnimationData; + setConqueredEnd(conqueredEnd: boolean): void; + conqueredEnd(): boolean; + getScreenSize(): import('../IScreenSize').IScreenSize; + getMagicData(): import('../handler/data/IMagicData').IMagicData; + getAttributes(): import('../handler/data/IPlayerAttributes').IPlayerAttributes; + getActionManager(): import('../handler/IActionManager').IActionManager; + getPartyMembers(): import('./IPlayer').IPlayer[]; + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IProjectile.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IProjectile.d.ts new file mode 100644 index 000000000..d3142f27e --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IProjectile.d.ts @@ -0,0 +1,21 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.entity + */ + +export interface IProjectile { + + // Methods + getItem(): import('../item/IItemStack').IItemStack; + setItem(item: import('../item/IItemStack').IItemStack): void; + getHasGravity(): boolean; + setHasGravity(bo: boolean): void; + getAccuracy(): number; + setAccuracy(accuracy: number): void; + setHeading(entity: import('./IEntity').IEntity): void; + setHeading(x: number, y: number, z: number): void; + setHeading(yaw: number, pitch: number): void; + getThrower(): import('./IEntity').IEntity; + enableEvents(): void; + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IThrowable.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IThrowable.d.ts new file mode 100644 index 000000000..3eb2842f9 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IThrowable.d.ts @@ -0,0 +1,12 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.entity + */ + +export interface IThrowable extends IEntity { + + // Methods + getThrower(): IEntityLivingBase; + kill(): void; + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IVillager.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IVillager.d.ts new file mode 100644 index 000000000..c9a444f4d --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/IVillager.d.ts @@ -0,0 +1,13 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.entity + */ + +export interface IVillager extends IEntityLiving { + + // Methods + getProfession(): number; + getIsTrading(): boolean; + getCustomer(): IEntityLivingBase; + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/data/IMark.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/data/IMark.d.ts new file mode 100644 index 000000000..d7b466ec2 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/data/IMark.d.ts @@ -0,0 +1,16 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.entity.data + */ + +export interface IMark { + + // Methods + getAvailability(): import('../../handler/data/IAvailability').IAvailability; + getColor(): number; + setColor(color: number): void; + getType(): number; + setType(type: number): void; + update(): void; + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/data/IModelData.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/data/IModelData.d.ts new file mode 100644 index 000000000..78239eb82 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/data/IModelData.d.ts @@ -0,0 +1,30 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.entity.data + */ + +export interface IModelData { + + // Methods + headWear(config: byte): void; + headWear(): byte; + bodyWear(config: byte): void; + bodyWear(): byte; + rightArmWear(config: byte): void; + rightArmWear(): byte; + leftArmWear(config: byte): void; + leftArmWear(): byte; + rightLegWear(config: byte): void; + rightLegWear(): byte; + leftLegWear(config: byte): void; + leftLegWear(): byte; + hidePart(part: number, hide: byte): void; + hidden(part: number): number; + enableRotation(enableRotation: boolean): void; + enableRotation(): boolean; + getRotation(): import('./IModelRotate').IModelRotate; + getScale(): import('./IModelScale').IModelScale; + setEntity(string: string): void; + getEntity(): string; + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/data/IModelRotate.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/data/IModelRotate.d.ts new file mode 100644 index 000000000..c873533a7 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/data/IModelRotate.d.ts @@ -0,0 +1,17 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.entity.data + */ + +export interface IModelRotate { + + // Methods + whileStanding(): boolean; + whileStanding(whileStanding: boolean): void; + whileAttacking(): boolean; + whileAttacking(whileAttacking: boolean): void; + whileMoving(): boolean; + whileMoving(whileMoving: boolean): void; + getPart(part: number): import('./IModelRotatePart').IModelRotatePart; + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/data/IModelRotatePart.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/data/IModelRotatePart.d.ts new file mode 100644 index 000000000..58df0518b --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/data/IModelRotatePart.d.ts @@ -0,0 +1,16 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.entity.data + */ + +export interface IModelRotatePart { + + // Methods + setRotation(x: number, y: number, z: number): void; + getRotateX(): number; + getRotateY(): number; + getRotateZ(): number; + disabled(enabled: boolean): void; + disabled(): boolean; + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/data/IModelScale.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/data/IModelScale.d.ts new file mode 100644 index 000000000..a47b29f59 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/data/IModelScale.d.ts @@ -0,0 +1,11 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.entity.data + */ + +export interface IModelScale { + + // Methods + getPart(part: number): import('./IModelScalePart').IModelScalePart; + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/data/IModelScalePart.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/data/IModelScalePart.d.ts new file mode 100644 index 000000000..d0c089eb8 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/entity/data/IModelScalePart.d.ts @@ -0,0 +1,14 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.entity.data + */ + +export interface IModelScalePart { + + // Methods + setScale(x: number, y: number, z: number): void; + getScaleX(): number; + getScaleY(): number; + getScaleZ(): number; + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IAnimationEvent.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IAnimationEvent.d.ts new file mode 100644 index 000000000..906f120e5 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IAnimationEvent.d.ts @@ -0,0 +1,27 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.event + */ + +export interface IAnimationEvent extends ICustomNPCsEvent { + + // Methods + getAnimation(): import('../handler/data/IAnimation').IAnimation; + getAnimationData(): import('../handler/data/IAnimationData').IAnimationData; + getEntity(): import('../entity/IAnimatable').IAnimatable; + + // Nested interfaces + interface Started extends IAnimationEvent { + } + interface Ended extends IAnimationEvent { + } + interface IFrameEvent extends IAnimationEvent { + getIndex(): number; + getFrame(): import('../handler/data/IFrame').IFrame; + } + interface Entered extends IFrameEvent { + } + interface Exited extends IFrameEvent { + } + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IBlockEvent.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IBlockEvent.d.ts new file mode 100644 index 000000000..38f60b47d --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IBlockEvent.d.ts @@ -0,0 +1,51 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.event + */ + +export interface IBlockEvent extends ICustomNPCsEvent { + getBlock(): import('../IBlock').IBlock; +} + +export namespace IBlockEvent { + export interface EntityFallenUponEvent extends IBlockEvent { + getEntity(): import('../entity/IEntity').IEntity; + getDistanceFallen(): number; + } + export interface InteractEvent extends IBlockEvent { + getPlayer(): import('../entity/IPlayer').IPlayer; + getHitX(): number; + getHitY(): number; + getHitZ(): number; + getSide(): number; + } + export interface RedstoneEvent extends IBlockEvent { + getPrevPower(): number; + getPower(): number; + } + export interface BreakEvent extends IBlockEvent { + } + export interface ExplodedEvent extends IBlockEvent { + } + export interface RainFillEvent extends IBlockEvent { + } + export interface NeighborChangedEvent extends IBlockEvent { + getChangedPos(): import('../IPos').IPos; + } + export interface InitEvent extends IBlockEvent { + } + export interface UpdateEvent extends IBlockEvent { + } + export interface ClickedEvent extends IBlockEvent { + getPlayer(): import('../entity/IPlayer').IPlayer; + } + export interface HarvestedEvent extends IBlockEvent { + getPlayer(): import('../entity/IPlayer').IPlayer; + } + export interface CollidedEvent extends IBlockEvent { + getEntity(): import('../entity/IEntity').IEntity; + } + export interface TimerEvent extends IBlockEvent { + getId(): number; + } +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/ICustomGuiEvent.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/ICustomGuiEvent.d.ts new file mode 100644 index 000000000..ae87a3319 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/ICustomGuiEvent.d.ts @@ -0,0 +1,32 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.event + */ + +export interface ICustomGuiEvent extends IPlayerEvent { + + // Methods + getGui(): import('../gui/ICustomGui').ICustomGui; + getId(): number; + + // Nested interfaces + interface ButtonEvent extends ICustomGuiEvent { + } + interface UnfocusedEvent extends ICustomGuiEvent { + } + interface CloseEvent extends ICustomGuiEvent { + } + interface ScrollEvent extends ICustomGuiEvent { + getSelection(): string[]; + doubleClick(): boolean; + getScrollIndex(): number; + } + interface SlotEvent extends ICustomGuiEvent { + getStack(): import('../item/IItemStack').IItemStack; + } + interface SlotClickEvent extends ICustomGuiEvent { + getStack(): import('../item/IItemStack').IItemStack; + getDragType(): number; + } + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/ICustomNPCsEvent.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/ICustomNPCsEvent.d.ts new file mode 100644 index 000000000..d09f119fb --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/ICustomNPCsEvent.d.ts @@ -0,0 +1,29 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.event + */ + +export interface ICustomNPCsEvent { + getHookName(): string; +} + +export namespace ICustomNPCsEvent { + export interface CNPCNaturalSpawnEvent extends ICustomNPCsEvent { + getNaturalSpawn(): import('../handler/data/INaturalSpawn').INaturalSpawn; + setAttemptPosition(attemptPosition: import('../IPos').IPos): void; + getAttemptPosition(): import('../IPos').IPos; + animalSpawnPassed(): boolean; + monsterSpawnPassed(): boolean; + liquidSpawnPassed(): boolean; + airSpawnPassed(): boolean; + } + export interface ScriptedCommandEvent extends ICustomNPCsEvent { + getSenderWorld(): import('../IWorld').IWorld; + getSenderPosition(): import('../IPos').IPos; + getSenderName(): string; + setReplyMessage(message: string): void; + getId(): string; + getArgs(): string[]; + } + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IDialogEvent.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IDialogEvent.d.ts new file mode 100644 index 000000000..ad4624e5d --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IDialogEvent.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.event + */ + +export interface IDialogEvent extends IPlayerEvent { + + // Methods + getDialog(): import('../handler/data/IDialog').IDialog; + + // Nested interfaces + interface DialogOpen extends IDialogEvent { + } + interface DialogOption extends IDialogEvent { + } + interface DialogClosed extends IDialogEvent { + } + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IFactionEvent.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IFactionEvent.d.ts new file mode 100644 index 000000000..f2e62ec13 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IFactionEvent.d.ts @@ -0,0 +1,17 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.event + */ + +export interface IFactionEvent extends IPlayerEvent { + + // Methods + getFaction(): import('../handler/data/IFaction').IFaction; + + // Nested interfaces + interface FactionPoints extends IFactionEvent { + decreased(): boolean; + getPoints(): number; + } + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IForgeEvent.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IForgeEvent.d.ts new file mode 100644 index 000000000..454e3963c --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IForgeEvent.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.event + */ + +export interface IForgeEvent extends ICustomNPCsEvent { + getEvent(): any; +} + +export namespace IForgeEvent { + export interface WorldEvent extends IForgeEvent { + getWorld(): import('../IWorld').IWorld; + } + export interface EntityEvent extends IForgeEvent { + getEntity(): import('../entity/IEntity').IEntity; + } + export interface InitEvent extends IForgeEvent { + } +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IItemEvent.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IItemEvent.d.ts new file mode 100644 index 000000000..58a1cd805 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IItemEvent.d.ts @@ -0,0 +1,66 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.event + */ + +export interface IItemEvent extends ICustomNPCsEvent { + getItem(): import('../item/IItemCustomizable').IItemCustomizable; +} + +export namespace IItemEvent { + export type InitEvent = IItemEvent + export interface UpdateEvent extends IItemEvent { + getEntity(): import('../entity/IEntity').IEntity; + } + export interface TossedEvent extends IItemEvent { + getEntity(): import('../entity/IEntity').IEntity; + getPlayer(): import('../entity/IPlayer').IPlayer; + } + export interface PickedUpEvent extends IItemEvent { + getPlayer(): import('../entity/IPlayer').IPlayer; + } + export interface SpawnEvent extends IItemEvent { + getEntity(): import('../entity/IEntity').IEntity; + } + export interface InteractEvent extends IItemEvent { + getType(): number; + getTarget(): import('../entity/IEntity').IEntity; + getPlayer(): import('../entity/IPlayer').IPlayer; + } + export interface RightClickEvent extends IItemEvent { + getType(): number; + getTarget(): any; + getPlayer(): import('../entity/IPlayer').IPlayer; + } + export interface AttackEvent extends IItemEvent { + getType(): number; + getTarget(): import('../entity/IEntity').IEntity; + getSwingingEntity(): import('../entity/IEntity').IEntity; + } + export interface StartUsingItem extends IItemEvent { + getPlayer(): import('../entity/IPlayer').IPlayer; + getDuration(): number; + } + export interface UsingItem extends IItemEvent { + getPlayer(): import('../entity/IPlayer').IPlayer; + getDuration(): number; + } + export interface StopUsingItem extends IItemEvent { + getPlayer(): import('../entity/IPlayer').IPlayer; + getDuration(): number; + } + export interface FinishUsingItem extends IItemEvent { + getPlayer(): import('../entity/IPlayer').IPlayer; + getDuration(): number; + } + export interface BreakItem extends IItemEvent { + getBrokenStack(): import('../item/IItemStack').IItemStack; + getPlayer(): import('../entity/IPlayer').IPlayer; + } + export interface RepairItem extends IItemEvent { + getLeft(): import('../item/IItemStack').IItemStack; + getRight(): import('../item/IItemStack').IItemStack; + getOutput(): import('../item/IItemStack').IItemStack; + getAnvilBreakChance(): number; + } +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/ILinkedItemEvent.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/ILinkedItemEvent.d.ts new file mode 100644 index 000000000..b2274486e --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/ILinkedItemEvent.d.ts @@ -0,0 +1,16 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.event + */ + +export interface ILinkedItemEvent extends IItemEvent { + + // Nested interfaces + interface VersionChangeEvent extends IItemEvent { + getVersion(): number; + getPreviousVersion(): number; + } + interface BuildEvent extends IItemEvent { + } + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/INpcEvent.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/INpcEvent.d.ts new file mode 100644 index 000000000..742aae138 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/INpcEvent.d.ts @@ -0,0 +1,79 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.event + */ + +export interface INpcEvent extends ICustomNPCsEvent { + getNpc(): import('../entity/ICustomNpc').ICustomNpc; +} + +export namespace INpcEvent { + export interface TimerEvent extends INpcEvent { + getId(): number; + } + export interface CollideEvent extends INpcEvent { + getEntity(): import('../entity/IEntity').IEntity; + } + export interface DamagedEvent extends INpcEvent { + getSource(): import('../entity/IEntity').IEntity; + getDamageSource(): import('../IDamageSource').IDamageSource; + getDamage(): number; + setDamage(damage: number): void; + setClearTarget(bo: boolean): void; + getClearTarget(): boolean; + getType(): string; + } + export interface RangedLaunchedEvent extends INpcEvent { + getTarget(): IEntityLivingBase; + setDamage(damage: number): void; + getDamage(): number; + } + export interface MeleeAttackEvent extends INpcEvent { + getTarget(): IEntityLivingBase; + setDamage(damage: number): void; + getDamage(): number; + } + export interface SwingEvent extends INpcEvent { + getItemStack(): import('../item/IItemStack').IItemStack; + } + export interface KilledEntityEvent extends INpcEvent { + getEntity(): IEntityLivingBase; + } + export interface DiedEvent extends INpcEvent { + getSource(): import('../entity/IEntity').IEntity; + getDamageSource(): import('../IDamageSource').IDamageSource; + getType(): string; + setDroppedItems(droppedItems: import('../item/IItemStack').IItemStack[]): void; + getDroppedItems(): import('../item/IItemStack').IItemStack[]; + setExpDropped(expDropped: number): void; + getExpDropped(): number; + } + export interface InteractEvent extends INpcEvent { + getPlayer(): import('../entity/IPlayer').IPlayer; + } + export interface DialogEvent extends INpcEvent { + getPlayer(): import('../entity/IPlayer').IPlayer; + getDialog(): import('../handler/data/IDialog').IDialog; + getDialogId(): number; + getOptionId(): number; + } + export interface DialogClosedEvent extends INpcEvent { + getPlayer(): import('../entity/IPlayer').IPlayer; + getDialog(): import('../handler/data/IDialog').IDialog; + getDialogId(): number; + getOptionId(): number; + } + export interface TargetLostEvent extends INpcEvent { + getTarget(): IEntityLivingBase; + getNewTarget(): IEntityLivingBase; + } + export interface TargetEvent extends INpcEvent { + setTarget(entity: IEntityLivingBase): void; + getTarget(): IEntityLivingBase; + } + export interface UpdateEvent extends INpcEvent { + } + export interface InitEvent extends INpcEvent { + } + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IPartyEvent.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IPartyEvent.d.ts new file mode 100644 index 000000000..200eb3567 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IPartyEvent.d.ts @@ -0,0 +1,34 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.event + */ + +export interface IPartyEvent { + + // Methods + getParty(): import('../handler/data/IParty').IParty; + getQuest(): import('../handler/data/IQuest').IQuest; + + // Nested interfaces + interface PartyQuestCompletedEvent extends IPartyEvent { + } + interface PartyQuestSetEvent extends IPartyEvent { + } + interface PartyQuestTurnedInEvent extends IPartyEvent { + } + interface PartyInviteEvent extends IPartyEvent { + getPlayer(): import('../entity/IPlayer').IPlayer; + getPlayerName(): string; + } + interface PartyKickEvent extends IPartyEvent { + getPlayer(): import('../entity/IPlayer').IPlayer; + getPlayerName(): string; + } + interface PartyLeaveEvent extends IPartyEvent { + getPlayer(): import('../entity/IPlayer').IPlayer; + getPlayerName(): string; + } + interface PartyDisbandEvent extends IPartyEvent { + } + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IPlayerEvent.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IPlayerEvent.d.ts new file mode 100644 index 000000000..e7b6366ca --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IPlayerEvent.d.ts @@ -0,0 +1,191 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.event + */ + +export interface IPlayerEvent extends ICustomNPCsEvent { + getPlayer(): import('../entity/IPlayer').IPlayer; +} + +export namespace IPlayerEvent { + export interface ChatEvent extends IPlayerEvent { + setMessage(message: string): void; + getMessage(): string; + } + export interface KeyPressedEvent extends IPlayerEvent { + getKey(): number; + isCtrlPressed(): boolean; + isAltPressed(): boolean; + isShiftPressed(): boolean; + isMetaPressed(): boolean; + keyDown(): boolean; + getKeysDown(): number[]; + } + export interface MouseClickedEvent extends IPlayerEvent { + getButton(): number; + getMouseWheel(): number; + buttonDown(): boolean; + isCtrlPressed(): boolean; + isAltPressed(): boolean; + isShiftPressed(): boolean; + isMetaPressed(): boolean; + getKeysDown(): number[]; + } + export interface PickupXPEvent extends IPlayerEvent { + getAmount(): number; + } + export interface LevelUpEvent extends IPlayerEvent { + getChange(): number; + } + export type LogoutEvent = IPlayerEvent + export type LoginEvent = IPlayerEvent + export type RespawnEvent = IPlayerEvent + export interface ChangedDimension extends IPlayerEvent { + getFromDim(): number; + getToDim(): number; + } + export interface TimerEvent extends IPlayerEvent { + getId(): number; + } + export interface AttackedEvent extends IPlayerEvent { + getDamageSource(): import('../IDamageSource').IDamageSource; + getSource(): import('../entity/IEntity').IEntity; + getDamage(): number; + } + export interface DamagedEvent extends IPlayerEvent { + getDamageSource(): import('../IDamageSource').IDamageSource; + getSource(): import('../entity/IEntity').IEntity; + getDamage(): number; + } + export type LightningEvent = IPlayerEvent + export interface SoundEvent extends IPlayerEvent { + getName(): string; + getPitch(): number; + getVolume(): number; + } + export interface FallEvent extends IPlayerEvent { + getDistance(): number; + } + export type JumpEvent = IPlayerEvent + export interface KilledEntityEvent extends IPlayerEvent { + getEntity(): IEntityLivingBase; + } + export interface DiedEvent extends IPlayerEvent { + getDamageSource(): import('../IDamageSource').IDamageSource; + getType(): string; + getSource(): import('../entity/IEntity').IEntity; + } + export interface RangedLaunchedEvent extends IPlayerEvent { + getBow(): import('../item/IItemStack').IItemStack; + getCharge(): number; + } + export interface AttackEvent extends IPlayerEvent { + getDamageSource(): import('../IDamageSource').IDamageSource; + getTarget(): import('../entity/IEntity').IEntity; + getDamage(): number; + } + export interface DamagedEntityEvent extends IPlayerEvent { + getDamageSource(): import('../IDamageSource').IDamageSource; + getTarget(): import('../entity/IEntity').IEntity; + getDamage(): number; + } + export interface ContainerClosed extends IPlayerEvent { + getContainer(): import('../IContainer').IContainer; + } + export interface ContainerOpen extends IPlayerEvent { + getContainer(): import('../IContainer').IContainer; + } + export interface PickUpEvent extends IPlayerEvent { + getItem(): import('../item/IItemStack').IItemStack; + } + export interface DropEvent extends IPlayerEvent { + getItems(): import('../item/IItemStack').IItemStack[]; + } + export interface TossEvent extends IPlayerEvent { + getItem(): import('../item/IItemStack').IItemStack; + } + export interface InteractEvent extends IPlayerEvent { + getType(): number; + getTarget(): import('../entity/IEntity').IEntity; + } + export interface RightClickEvent extends IPlayerEvent { + getType(): number; + getTarget(): any; + + } + export type UpdateEvent = IPlayerEvent + export type InitEvent = IPlayerEvent + export interface StartUsingItem extends IPlayerEvent { + getItem(): import('../item/IItemStack').IItemStack; + getDuration(): number; + } + export interface UsingItem extends IPlayerEvent { + getItem(): import('../item/IItemStack').IItemStack; + getDuration(): number; + } + export interface StopUsingItem extends IPlayerEvent { + getItem(): import('../item/IItemStack').IItemStack; + getDuration(): number; + } + export interface FinishUsingItem extends IPlayerEvent { + getItem(): import('../item/IItemStack').IItemStack; + getDuration(): number; + } + export interface BreakEvent extends IPlayerEvent { + getBlock(): import('../IBlock').IBlock; + getExp(): number; + } + export interface UseHoeEvent extends IPlayerEvent { + getHoe(): import('../item/IItemStack').IItemStack; + getX(): number; + getY(): number; + getZ(): number; + } + export interface WakeUpEvent extends IPlayerEvent { + setSpawn(): boolean; + } + export interface SleepEvent extends IPlayerEvent { + getX(): number; + getY(): number; + getZ(): number; + } + export interface AchievementEvent extends IPlayerEvent { + getDescription(): string; + } + export interface FillBucketEvent extends IPlayerEvent { + getCurrent(): import('../item/IItemStack').IItemStack; + getFilled(): import('../item/IItemStack').IItemStack; + } + export interface BonemealEvent extends IPlayerEvent { + getBlock(): import('../IBlock').IBlock; + getX(): number; + getY(): number; + getZ(): number; + } + export type RangedChargeEvent = IPlayerEvent + export interface EffectEvent extends IPlayerEvent { + getEffect(): import('../handler/data/IPlayerEffect').IPlayerEffect; + } + export namespace EffectEvent { + export type Added = EffectEvent + export type Ticked = EffectEvent + export interface Removed extends EffectEvent { + hasTimerRunOut(): boolean; + causedByDeath(): boolean; + } + } + + export interface ProfileEvent extends IPlayerEvent { + getProfile(): import('../handler/data/IProfile').IProfile; + getSlot(): number; + isPost(): boolean; + } + export namespace ProfileEvent { + export interface Changed extends ProfileEvent { + getPrevSlot(): number; + } + export type Create = ProfileEvent + export type Removed = ProfileEvent + } + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IProjectileEvent.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IProjectileEvent.d.ts new file mode 100644 index 000000000..69debbbd0 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IProjectileEvent.d.ts @@ -0,0 +1,21 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.event + */ + +export interface IProjectileEvent extends ICustomNPCsEvent { + + // Methods + getProjectile(): import('../entity/IProjectile').IProjectile; + getSource(): import('../entity/IEntity').IEntity; + + // Nested interfaces + interface UpdateEvent extends IProjectileEvent { + } + interface ImpactEvent extends IProjectileEvent { + getType(): number; + getEntity(): import('../entity/IEntity').IEntity; + getBlock(): import('../IBlock').IBlock; + } + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IQuestEvent.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IQuestEvent.d.ts new file mode 100644 index 000000000..a5fa1d3d5 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IQuestEvent.d.ts @@ -0,0 +1,23 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.event + */ + +export interface IQuestEvent extends IPlayerEvent { + + // Methods + getQuest(): import('../handler/data/IQuest').IQuest; + + // Nested interfaces + interface QuestCompletedEvent extends IQuestEvent { + } + interface QuestStartEvent extends IQuestEvent { + } + interface QuestTurnedInEvent extends IQuestEvent { + setExpReward(expReward: number): void; + setItemRewards(itemRewards: import('../item/IItemStack').IItemStack[]): void; + getExpReward(): number; + getItemRewards(): import('../item/IItemStack').IItemStack[]; + } + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IRecipeEvent.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IRecipeEvent.d.ts new file mode 100644 index 000000000..6c6ad56b3 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/event/IRecipeEvent.d.ts @@ -0,0 +1,33 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.event + */ + +export interface IRecipeEvent extends IPlayerEvent { + + // Methods + getRecipe(): any; + getItems(): import('../item/IItemStack').IItemStack[]; + isAnvil(): boolean; + setMessage(message: string): void; + getMessage(): string; + getXpCost(): number; + setXpCost(xpCost: number): void; + getMaterialUsage(): number; + setMaterialUsage(materialUsage: number): void; + + // Nested interfaces + interface Pre extends IRecipeEvent { + setMessage(message: string): void; + getMessage(): string; + getXpCost(): number; + setXpCost(xpCost: number): void; + getMaterialUsage(): number; + setMaterialUsage(materialUsage: number): void; + } + interface Post extends IRecipeEvent { + getCraft(): import('../item/IItemStack').IItemStack; + setResult(stack: import('../item/IItemStack').IItemStack): void; + } + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/gui/IButton.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/gui/IButton.d.ts new file mode 100644 index 000000000..df117e8c9 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/gui/IButton.d.ts @@ -0,0 +1,25 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.gui + */ + +export interface IButton extends ICustomGuiComponent { + + // Methods + getWidth(): number; + getHeight(): number; + setSize(width: number, height: number): import('./IButton').IButton; + getLabel(): string; + setLabel(text: string): import('./IButton').IButton; + getTexture(): string; + hasTexture(): boolean; + setTexture(texture: string): import('./IButton').IButton; + getTextureX(): number; + getTextureY(): number; + setTextureOffset(textureX: number, textureY: number): import('./IButton').IButton; + setScale(scale: number): void; + getScale(): number; + setEnabled(enabled: boolean): void; + isEnabled(): boolean; + +} diff --git a/src/main/resources/assets/customnpcs/api/noppes/npcs/api/gui/ICustomGui.d.ts b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/gui/ICustomGui.d.ts new file mode 100644 index 000000000..4c0dd8d86 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/noppes/npcs/api/gui/ICustomGui.d.ts @@ -0,0 +1,47 @@ +/** + * Generated from Java file for CustomNPC+ Minecraft Mod 1.7.10 + * Package: noppes.npcs.api.gui + */ + +export interface ICustomGui { + + // Methods + getID(): number; + getWidth(): number; + getHeight(): number; + getComponents(): Array +/// +/** + * Ambient declarations for `scripts_examples/item_events.js`. + * These map the function names used by CustomNPC+ item scripts to the + * precise event interface so `event.` autocompletes correctly inside + * each handler. This file is intended to be referenced from the script + * with a triple-slash reference comment. + */ + +declare function init(IItemEvent: IItemEvent.InitEvent): void; +declare function tick(IItemEvent: IItemEvent.UpdateEvent): void; +declare function tossed(IItemEvent: IItemEvent.TossedEvent): void; +declare function pickedUp(IItemEvent: IItemEvent.PickedUpEvent): void; +declare function spawn(IItemEvent: IItemEvent.SpawnEvent): void; +declare function interact(IItemEvent: IItemEvent.InteractEvent): void; +declare function rightClick(IItemEvent: IItemEvent.RightClickEvent): void; +declare function attack(IItemEvent: IItemEvent.AttackEvent): void; +declare function startItem(IItemEvent: IItemEvent.StartUsingItem): void; +declare function usingItem(IItemEvent: IItemEvent.UsingItem): void; +declare function stopItem(IItemEvent: IItemEvent.StopUsingItem): void; +declare function finishItem(IItemEvent: IItemEvent.FinishUsingItem): void; + +export {}; diff --git a/src/main/resources/assets/customnpcs/api/scripts/npc_events.d.ts b/src/main/resources/assets/customnpcs/api/scripts/npc_events.d.ts new file mode 100644 index 000000000..f8e21f6f0 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/scripts/npc_events.d.ts @@ -0,0 +1,32 @@ +/// +/// +/** + * Ambient declarations for `scripts_examples/npc_events.js`. + * These map the function names used by CustomNPC+ NPC scripts to the + * precise event interface so `event.` autocompletes correctly inside + * each handler. Parameter names determine type inference: + * - Use `INpcEvent` for NPC-specific events + * - Use `IProjectileEvent` for projectile events + */ + +declare function init(INpcEvent: INpcEvent.InitEvent): void; +declare function tick(INpcEvent: INpcEvent.UpdateEvent): void; +declare function interact(INpcEvent: INpcEvent.InteractEvent): void; +declare function dialog(INpcEvent: INpcEvent.DialogEvent): void; +declare function damaged(INpcEvent: INpcEvent.DamagedEvent): void; +declare function killed(INpcEvent: INpcEvent.DiedEvent): void; +declare function meleeAttack(INpcEvent: INpcEvent.MeleeAttackEvent): void; +declare function meleeSwing(INpcEvent: INpcEvent.SwingEvent): void; +declare function rangedLaunched(INpcEvent: INpcEvent.RangedLaunchedEvent): void; +declare function target(INpcEvent: INpcEvent.TargetEvent): void; +declare function collide(INpcEvent: INpcEvent.CollideEvent): void; +declare function kills(INpcEvent: INpcEvent.KilledEntityEvent): void; +declare function dialogClose(INpcEvent: INpcEvent.DialogClosedEvent): void; +declare function timer(INpcEvent: INpcEvent.TimerEvent): void; +declare function targetLost(INpcEvent: INpcEvent.TargetLostEvent): void; + +// Projectile-specific +declare function projectileTick(IProjectileEvent: IProjectileEvent.UpdateEvent): void; +declare function projectileImpact(IProjectileEvent: IProjectileEvent.ImpactEvent): void; + +export {}; diff --git a/src/main/resources/assets/customnpcs/api/scripts/player_events.d.ts b/src/main/resources/assets/customnpcs/api/scripts/player_events.d.ts new file mode 100644 index 000000000..e8e7669b2 --- /dev/null +++ b/src/main/resources/assets/customnpcs/api/scripts/player_events.d.ts @@ -0,0 +1,92 @@ +/// +/// +/** + * Ambient declarations for `scripts_examples/player_events.js`. + * These map the function names used by CustomNPC+ player scripts to the + * precise event interface so `event.` autocompletes correctly inside + * each handler. Parameter names determine type inference: + * - Use `IPlayerEvent` for player-specific events + * - Use `IQuestEvent`, `IFactionEvent`, `IDialogEvent`, etc. for specialized event types + */ + +declare function init(IPlayerEvent: IPlayerEvent.InitEvent): void; +declare function tick(IPlayerEvent: IPlayerEvent.UpdateEvent): void; +declare function interact(IPlayerEvent: IPlayerEvent.InteractEvent): void; +declare function rightClick(IPlayerEvent: IPlayerEvent.RightClickEvent): void; +declare function attack(IPlayerEvent: IPlayerEvent.AttackEvent): void; +declare function attacked(IPlayerEvent: IPlayerEvent.AttackedEvent): void; +declare function damagedEntity(IPlayerEvent: IPlayerEvent.DamagedEntityEvent): void; +declare function damaged(IPlayerEvent: IPlayerEvent.DamagedEvent): void; +declare function kills(IPlayerEvent: IPlayerEvent.KilledEntityEvent): void; +declare function killed(IPlayerEvent: IPlayerEvent.DiedEvent): void; +declare function drop(IPlayerEvent: IPlayerEvent.DropEvent): void; +declare function respawn(IPlayerEvent: IPlayerEvent.RespawnEvent): void; +declare function breakBlock(IPlayerEvent: IPlayerEvent.BreakEvent): void; +declare function chat(IPlayerEvent: IPlayerEvent.ChatEvent): void; +declare function login(IPlayerEvent: IPlayerEvent.LoginEvent): void; +declare function logout(IPlayerEvent: IPlayerEvent.LogoutEvent): void; +declare function keyPressed(IPlayerEvent: IPlayerEvent.KeyPressedEvent): void; +declare function mouseClicked(IPlayerEvent: IPlayerEvent.MouseClickedEvent): void; +declare function toss(IPlayerEvent: IPlayerEvent.TossEvent): void; +declare function pickUp(IPlayerEvent: IPlayerEvent.PickUpEvent): void; +declare function pickupXP(IPlayerEvent: IPlayerEvent.PickupXPEvent): void; +declare function rangedCharge(IPlayerEvent: IPlayerEvent.RangedChargeEvent): void; +declare function rangedLaunched(IPlayerEvent: IPlayerEvent.RangedLaunchedEvent): void; +declare function timer(IPlayerEvent: IPlayerEvent.TimerEvent): void; +declare function startItem(IPlayerEvent: IPlayerEvent.StartUsingItem): void; +declare function usingItem(IPlayerEvent: IPlayerEvent.UsingItem): void; +declare function stopItem(IPlayerEvent: IPlayerEvent.StopUsingItem): void; +declare function finishItem(IPlayerEvent: IPlayerEvent.FinishUsingItem): void; +declare function containerOpen(IPlayerEvent: IPlayerEvent.ContainerOpen): void; +declare function useHoe(IPlayerEvent: IPlayerEvent.UseHoeEvent): void; +declare function bonemeal(IPlayerEvent: IPlayerEvent.BonemealEvent): void; +declare function fillBucket(IPlayerEvent: IPlayerEvent.FillBucketEvent): void; +declare function jump(IPlayerEvent: IPlayerEvent.JumpEvent): void; +declare function fall(IPlayerEvent: IPlayerEvent.FallEvent): void; +declare function wakeUp(IPlayerEvent: IPlayerEvent.WakeUpEvent): void; +declare function sleep(IPlayerEvent: IPlayerEvent.SleepEvent): void; +declare function playSound(IPlayerEvent: IPlayerEvent.SoundEvent): void; +declare function lightning(IPlayerEvent: IPlayerEvent.LightningEvent): void; +declare function changedDim(IPlayerEvent: IPlayerEvent.ChangedDimension): void; + +// Quest / faction / dialog / custom events +declare function questStart(IQuestEvent: IQuestEvent.QuestStartEvent): void; +declare function questCompleted(IQuestEvent: IQuestEvent.QuestCompletedEvent): void; +declare function questTurnIn(IQuestEvent: IQuestEvent.QuestTurnedInEvent): void; +declare function factionPoints(IFactionEvent: IFactionEvent.FactionPoints): void; + +declare function dialogOpen(IDialogEvent: IDialogEvent.DialogClosed): void; +declare function dialogOption(IDialogEvent: IDialogEvent.DialogOption): void; +declare function dialogClose(IDialogEvent: IDialogEvent.DialogClosed): void; + +declare function scriptCommand(ICustomNPCsEvent: ICustomNPCsEvent.ScriptedCommandEvent): void; +declare function customGuiClosed(ICustomGuiEvent: ICustomGuiEvent.CloseEvent): void; +declare function customGuiButton(ICustomGuiEvent: ICustomGuiEvent.ButtonEvent): void; +declare function customGuiSlot(ICustomGuiEvent: ICustomGuiEvent.SlotEvent): void; +declare function customGuiSlotClicked(ICustomGuiEvent: ICustomGuiEvent.SlotClickEvent): void; +declare function customGuiScroll(ICustomGuiEvent: ICustomGuiEvent.ScrollEvent): void; + +// Party events +declare function partyQuestCompleted(IPartyEvent: IPartyEvent.PartyQuestCompletedEvent): void; +declare function partyQuestSet(IPartyEvent: IPartyEvent.PartyQuestSetEvent): void; +declare function partyQuestTurnedIn(IPartyEvent: IPartyEvent.PartyQuestTurnedInEvent): void; +declare function partyInvite(IPartyEvent: IPartyEvent.PartyInviteEvent): void; +declare function partyKick(IPartyEvent: IPartyEvent.PartyKickEvent): void; +declare function partyLeave(IPartyEvent: IPartyEvent.PartyLeaveEvent): void; +declare function partyDisband(IPartyEvent: IPartyEvent.PartyDisbandEvent): void; + +// Animation events +declare function animationStart(IAnimationEvent: IAnimationEvent.Started): void; +declare function animationEnd(IAnimationEvent: IAnimationEvent.Ended): void; +declare function frameEnter(IAnimationEvent: IAnimationEvent.IFrameEvent): void; +declare function frameExit(IAnimationEvent: IAnimationEvent.IFrameEvent): void; + +// Profile / effect events +declare function profileChange(IPlayerEvent: IPlayerEvent.ProfileEvent): void; +declare function profileRemove(IPlayerEvent: IPlayerEvent.ProfileEvent): void; +declare function profileCreate(IPlayerEvent: IPlayerEvent.ProfileEvent): void; +declare function onEffectAdd(IPlayerEvent: IPlayerEvent.EffectEvent): void; +declare function onEffectTick(IPlayerEvent: IPlayerEvent.EffectEvent): void; +declare function onEffectRemove(IPlayerEvent: IPlayerEvent.EffectEvent): void; + +export {};