overpy 9.6.8 → 9.6.10

package/overpy.js

@@ -4187,8 +4187,7 @@ var mapKw = (
         "skirmish"
       ],
       "variants": {
-        "evening": "972777519512068292",
-        "morning": "972777519512068154"
+        "default": "972777519512099996"
       },
       "en-US": "Watchpoint: Gibraltar",
       "es-ES": "Observatorio: Gibraltar",
@@ -39408,7 +39407,8 @@ function addSubroutine(content, index, fileStack7, isFromDefStatement = false) {
     name: content,
     index: index ?? subroutines.length,
     fileStack: fileStack7,
-    isFromDefStatement
+    isFromDefStatement,
+    callsSubroutines: []
   });
 }
 function translateNameToAvoidKeywords(initialName, nameType) {
@@ -43906,6 +43906,23 @@ astParsingFunctions.__assignTo__ = function(content) {
   return content;
 };
 
+// src/compiler/functions/__callSubroutine__.ts
+astParsingFunctions.__callSubroutine__ = function(content) {
+  let parent = content.parent;
+  while (parent?.parent) {
+    parent = parent.parent;
+  }
+  if (parent?.name === "__rule__") {
+    if (parent.ruleAttributes?.subroutineName) {
+      let subroutine = subroutines.find((x) => x.name === parent.ruleAttributes?.subroutineName);
+      if (!subroutine.callsSubroutines.includes(content.args[0].name)) {
+        subroutine.callsSubroutines.push(content.args[0].name);
+      }
+    }
+  }
+  return content;
+};
+
 // src/compiler/functions/__customString__.ts
 astParsingFunctions.__customString__ = function(content) {
   if (!content.stringTokens) {
@@ -46022,6 +46039,9 @@ astParsingFunctions.asinDeg = function(content) {
   return content;
 };
 
+// src/compiler/functions/async.ts
+astParsingFunctions.async = astParsingFunctions.__callSubroutine__;
+
 // src/compiler/functions/atan2.ts
 astParsingFunctions.atan2 = function(content) {
   if (enableOptimization) {
@@ -46042,14 +46062,6 @@ astParsingFunctions.atan2Deg = function(content) {
   return content;
 };
 
-// src/compiler/functions/attacker.ts
-astParsingFunctions.attacker = function(content) {
-  if (["global", "eachPlayer", "playerDealtHealing", "playerReceivedHealing", "playerJoined", "playerLeft"].includes(currentRuleEvent)) {
-    error("Cannot use '" + content.name + "' with rule event '" + currentRuleEvent + "'");
-  }
-  return content;
-};
-
 // src/compiler/functions/break.ts
 astParsingFunctions.break = function(content) {
   let innermostStructure = content.parent;
@@ -46595,12 +46607,88 @@ astParsingFunctions.dotProduct = function(content) {
 
 // src/compiler/functions/eventPlayer.ts
 astParsingFunctions.eventPlayer = function(content) {
-  if (currentRuleEvent === "global") {
-    error("Cannot use 'eventPlayer' with rule event 'global'");
+  let categories = {
+    eventPlayer: ["player"],
+    attacker: ["damage"],
+    victim: ["damage"],
+    eventDamage: ["damage"],
+    eventWasEnvironment: ["damage"],
+    healer: ["healing"],
+    healee: ["healing"],
+    eventHealing: ["healing"],
+    eventWasHealthPack: ["healing"],
+    eventWasCriticalHit: ["damageOrHealing"],
+    eventAbility: ["damageOrHealing"],
+    eventDirection: ["damageOrHealing"]
+  }[content.name];
+  let ruleEventCategories = getRuleEventCategories(currentRuleEvent);
+  if (currentRuleEvent === "__subroutine__") {
+    let parent = content.parent;
+    while (parent?.parent) {
+      parent = parent.parent;
+    }
+    if (parent?.name === "__rule__") {
+      if (parent.ruleAttributes?.subroutineName) {
+        let subroutine = subroutines.find((x) => x.name === parent.ruleAttributes?.subroutineName);
+        if (categories?.includes("player")) {
+          subroutine.hasEventPlayerVars = true;
+        }
+        if (categories?.includes("damage")) {
+          subroutine.hasEventDamageVars = true;
+        }
+        if (categories?.includes("healing")) {
+          subroutine.hasEventHealingVars = true;
+        }
+        if (categories?.includes("damageOrHealing")) {
+          subroutine.hasEventDamageOrHealingVars = true;
+        }
+      }
+    }
+  } else {
+    if (ruleEventCategories && categories && !categories.some((c) => ruleEventCategories.includes(c))) {
+      if (["eventPlayer", "attacker", "victim", "healer", "healee"].includes(content.name)) {
+        error("Cannot use '" + content.name + "' with rule event '" + currentRuleEvent + "'");
+      } else {
+        warn("w_mismatched_event", "Cannot use '" + content.name + "' with rule event '" + currentRuleEvent + "'");
+      }
+    }
   }
   return content;
 };
 
+// src/compiler/functions/attacker.ts
+astParsingFunctions.attacker = astParsingFunctions.eventPlayer;
+
+// src/compiler/functions/eventAbility.ts
+astParsingFunctions.eventAbility = astParsingFunctions.eventPlayer;
+
+// src/compiler/functions/eventDamage.ts
+astParsingFunctions.eventDamage = astParsingFunctions.eventPlayer;
+
+// src/compiler/functions/eventDirection.ts
+astParsingFunctions.eventDirection = astParsingFunctions.eventPlayer;
+
+// src/compiler/functions/eventHealing.ts
+astParsingFunctions.eventHealing = astParsingFunctions.eventPlayer;
+
+// src/compiler/functions/eventWasCriticalHit.ts
+astParsingFunctions.eventWasCriticalHit = astParsingFunctions.eventPlayer;
+
+// src/compiler/functions/eventWasEnvironment.ts
+astParsingFunctions.eventWasEnvironment = astParsingFunctions.eventPlayer;
+
+// src/compiler/functions/eventWasHealthPack.ts
+astParsingFunctions.eventWasHealthPack = astParsingFunctions.eventPlayer;
+
+// src/compiler/functions/healee.ts
+astParsingFunctions.healee = astParsingFunctions.eventPlayer;
+
+// src/compiler/functions/healer.ts
+astParsingFunctions.healer = astParsingFunctions.eventPlayer;
+
+// src/compiler/functions/victim.ts
+astParsingFunctions.victim = astParsingFunctions.eventPlayer;
+
 // src/compiler/functions/floor.ts
 astParsingFunctions.floor = function(content) {
   if (enableOptimization) {
@@ -46655,22 +46743,6 @@ astParsingFunctions.getOppositeTeam = function(content) {
   return content;
 };
 
-// src/compiler/functions/healee.ts
-astParsingFunctions.healee = function(content) {
-  if (["global", "eachPlayer", "playerTookDamage", "playerDealtDamage", "playerDealtFinalBlow", "playerDied", "playerEarnedElimination", "playerJoined", "playerLeft", "playerDealtKnockback", "playerReceivedKnockback"].includes(currentRuleEvent)) {
-    error("Cannot use '" + content.name + "' with rule event '" + currentRuleEvent + "'");
-  }
-  return content;
-};
-
-// src/compiler/functions/healer.ts
-astParsingFunctions.healer = function(content) {
-  if (["global", "eachPlayer", "playerTookDamage", "playerDealtDamage", "playerDealtFinalBlow", "playerDied", "playerEarnedElimination", "playerJoined", "playerLeft", "playerDealtKnockback", "playerReceivedKnockback"].includes(currentRuleEvent)) {
-    error("Cannot use '" + content.name + "' with rule event '" + currentRuleEvent + "'");
-  }
-  return content;
-};
-
 // src/compiler/functions/hsl.ts
 astParsingFunctions.hsl = function(content) {
   let h = "$h";
@@ -47134,14 +47206,6 @@ astParsingFunctions.vectorTowards = function(content) {
   return content;
 };
 
-// src/compiler/functions/victim.ts
-astParsingFunctions.victim = function(content) {
-  if (["global", "eachPlayer", "playerDealtHealing", "playerReceivedHealing", "playerJoined", "playerLeft"].includes(currentRuleEvent)) {
-    error("Cannot use '" + content.name + "' with rule event '" + currentRuleEvent + "'");
-  }
-  return content;
-};
-
 // src/compiler/functions/wait.ts
 astParsingFunctions.wait = function(content) {
   if (enableOptimization && optimizeForSize2) {
@@ -47355,6 +47419,9 @@ function parseAstRules(rules) {
       if (rule.ruleAttributes.name === void 0) {
         rule.ruleAttributes.name = "Subroutine " + rule.ruleAttributes.subroutineName;
       }
+      if (defaultSubroutineNames.includes(rule.ruleAttributes.subroutineName)) {
+        addSubroutine(rule.ruleAttributes.subroutineName, defaultSubroutineNames.indexOf(rule.ruleAttributes.subroutineName), rule.fileStack);
+      }
       rule.name = "__rule__";
       rule.originalName = "__def__";
     } else if (rule.name in astMacros) {
@@ -63979,6 +64046,7 @@ function astRulesToWs(rules) {
     result += ") {\n";
     result += tabLevel(1) + tows("__event__", ruleKw) + " {\n";
     result += tabLevel(2) + tows(rule.ruleAttributes.event, eventKw) + ";\n";
+    setCurrentRuleEvent(rule.ruleAttributes.event);
     if (rule.ruleAttributes.eventTeam) {
       result += tabLevel(2) + tows(rule.ruleAttributes.eventTeam, eventTeamKw) + ";\n";
     }
@@ -64285,6 +64353,22 @@ function astToWs(content) {
       }
     }
   }
+  if (content.name === "async" || content.name === "__callSubroutine__") {
+    let subroutineName = content.args[0].name;
+    let subroutine = subroutines.find((s) => s.name === subroutineName);
+    if (subroutine) {
+      let categories = getRuleEventCategories(currentRuleEvent);
+      if (subroutine.hasEventPlayerVars && !categories.includes("player")) {
+        warn("w_mismatched_subroutine_event", "Calling subroutine " + subroutineName + ", which uses event player variables, from a " + currentRuleEvent + " rule", content.fileStack);
+      } else if (subroutine.hasEventDamageOrHealingVars && !categories.includes("damageOrHealing")) {
+        warn("w_mismatched_subroutine_event", "Calling subroutine " + subroutineName + ", which uses event damage or healing variables, from a " + currentRuleEvent + " rule", content.fileStack);
+      } else if (subroutine.hasEventDamageVars && !categories.includes("damage")) {
+        warn("w_mismatched_subroutine_event", "Calling subroutine " + subroutineName + ", which uses event damage variables, from a " + currentRuleEvent + " rule", content.fileStack);
+      } else if (subroutine.hasEventHealingVars && !categories.includes("healing")) {
+        warn("w_mismatched_subroutine_event", "Calling subroutine " + subroutineName + ", which uses event healing variables, from a " + currentRuleEvent + " rule", content.fileStack);
+      }
+    }
+  }
   if (content.name in equalityFuncToOpMapping) {
     content.args.splice(1, 0, new Ast2(equalityFuncToOpMapping[content.name], [], [], "__Operator__"));
     content.name = "__compare__";
@@ -65203,6 +65287,24 @@ function compileRules(astRules) {
   if (DEBUG_MODE) {
     console.log(parsedAstRules);
   }
+  let hasModification = false;
+  do {
+    hasModification = false;
+    for (let subroutine of subroutines) {
+      for (let calledSubroutineName of subroutine.callsSubroutines) {
+        let calledSubroutine = subroutines.find((s) => s.name === calledSubroutineName);
+        if (!calledSubroutine) {
+          error("Subroutine '" + subroutine.name + "' calls unknown subroutine '" + calledSubroutineName + "'");
+        }
+        for (let key of ["hasEventPlayerVars", "hasEventDamageVars", "hasEventHealingVars", "hasEventDamageOrHealingVars"]) {
+          if (calledSubroutine[key] && !subroutine[key]) {
+            subroutine[key] = true;
+            hasModification = true;
+          }
+        }
+      }
+    }
+  } while (hasModification);
   setOptimizationEnabled2(true);
   setOptimizeStrict2(false);
   setOptimizationForSize2(false);
@@ -65479,9 +65581,10 @@ function compileCustomGameSettings(customGameSettings) {
               let mapVariants = mapKw[mapName].variants ?? {};
               for (var variant of map[mapName]) {
                 if (!(variant in mapVariants)) {
-                  error("Unknown variant '" + variant + "' for map '" + mapName + "'");
+                  variants.push(variant + "");
+                } else {
+                  variants.push(mapVariants[variant]);
                 }
-                variants.push(mapVariants[variant]);
               }
               encounteredMaps.push(mapName);
               result[wsGamemodes][wsGamemode][wsMapsKey].push(tows(mapName, mapKw) + " " + variants.join(" "));
@@ -67675,6 +67778,24 @@ function getUniqueNumber() {
   incrementUniqueNumber();
   return uniqueNumber;
 }
+function getRuleEventCategories(ruleEvent) {
+  return {
+    global: [],
+    eachPlayer: ["player"],
+    playerDealtDamage: ["player", "damage"],
+    playerDealtFinalBlow: ["player", "damage"],
+    playerDealtHealing: ["player", "healing"],
+    playerDealtKnockback: ["player", "damageOrHealing", "damage", "healing"],
+    playerDied: ["player", "damage"],
+    playerEarnedElimination: ["player", "damage"],
+    playerJoined: ["player"],
+    playerLeft: ["player"],
+    playerTookDamage: ["player", "damage"],
+    playerReceivedHealing: ["player", "healing"],
+    playerReceivedKnockback: ["player", "damageOrHealing", "damage", "healing"],
+    __subroutine__: ["player", "damageOrHealing", "damage", "healing"]
+  }[ruleEvent] || [];
+}
 
 // src/types.d.ts
 var ow_languages = /* @__PURE__ */ ((ow_languages2) => {
@@ -71034,11 +71155,12 @@ function decompileCustomGameSettings(content) {
                   for (var variant of variants) {
                     var variantName = Object.keys(mapKw[mapName].variants).filter((x) => mapKw[mapName].variants[x] === variant);
                     if (variantName.length === 0) {
-                      error("Unknown variant '" + variant + "' for map '" + mapName + "'");
+                      mapVariants.push(variant);
+                    } else {
+                      mapVariants.push(variantName[0]);
                     }
-                    mapVariants.push(variantName[0]);
                   }
-                  if (mapVariants.length === Object.keys(mapKw[mapName].variants).length) {
+                  if (mapVariants.length === Object.keys(mapKw[mapName].variants).length && mapVariants.every((x) => Object.keys(mapKw[mapName].variants).includes(x))) {
                     result[opyCategory][opyGamemode][opyPropName].push(mapName);
                   } else {
                     var mapObj = {};

package/package.json

@@ -7,7 +7,7 @@
         "url": "https://github.com/Zezombye/overpy"
     },
     "description": "High-level language for the Overwatch Workshop, with decompilation and compilation.",
-    "version": "9.6.8",
+    "version": "9.6.10",
     "readme": "README.md",
     "keywords": [
         "overpy",