Downloads containing academy_utils.asc

Downloads
Name Author Game Mode Rating
TSF with JJ2+ Only: Academy Superjazz Battle N/A Download file

File preview

  1. namespace acUtils {
  2.  
  3.         void addMagicMirrorAnimation(int8 playerID) {
  4.                 magicMirrorAnimations.insertLast(MagicMirrorAnimation(jjPlayers[playerID],
  5.                                 jjPlayers[playerID].direction));
  6.         }
  7.        
  8.         void addMagicMirrorAnimation(int8 playerID, int direction) {
  9.                 magicMirrorAnimations.insertLast(MagicMirrorAnimation(jjPlayers[playerID], direction));
  10.         }
  11.        
  12.         void addMagicMirrorAnimationOnTargetsWithMagicMirror(int8[] targets) {
  13.                 for (uint i = 0; i < targets.length(); i++) {
  14.                         if (players[targets[i]].hasEffect(SPELL_MAGIC_MIRROR)) {
  15.                                 magicMirrorAnimations.insertLast(MagicMirrorAnimation(
  16.                                                 jjPlayers[targets[i]], jjPlayers[targets[i]].direction));
  17.                         }
  18.                 }
  19.         }
  20.        
  21.         void alertOfLearnedSkill(string playerName, SKILL skillEnum) {
  22.                 Skill@ skill = skills[skills.find(Skill(skillEnum))];
  23.                 jjAlert("" + playerName + " learned |||" + skill.name + "|||||! (" + skill.description + ")",
  24.                                 true);
  25.         }
  26.  
  27.         void alertOfLearnedSpell(string playerName, string spellName) {
  28.                 jjAlert("" + playerName + " has learned the spell |||" + spellName + "|||||!", true);
  29.         }
  30.        
  31.         bool areAllTargetsMagicMirrors(int8[] targets) {
  32.                 for (uint i = 0; i < targets.length(); i++) {
  33.                         if (!players[targets[i]].hasEffect(SPELL_MAGIC_MIRROR)) {
  34.                                 return false;
  35.                         }
  36.                 }
  37.                 return true;
  38.         }
  39.  
  40.         bool checkIfPlayerIsInRange(jjPLAYER@ source, jjPLAYER@ potentialTarget, float scaledRadius) {
  41.                 float xDistance = potentialTarget.xPos - source.xPos;
  42.                 float yDistance = potentialTarget.yPos - source.yPos;
  43.                 return xDistance*xDistance + yDistance*yDistance < scaledRadius*scaledRadius;
  44.         }
  45.        
  46.         bool checkIfPlayerIsVulnerable(jjPLAYER@ caster, jjPLAYER@ potentialTarget, Spell@ spell,
  47.                         bool excludeMagicMirrorTargets = false) {
  48.                 if (players[potentialTarget.playerID].hasEffect(SPELL_MAGIC_MIRROR) && excludeMagicMirrorTargets) {
  49.                         return false;
  50.                 }
  51.                 if (spell.enumValue == SPELL_DEATH_RIPPLE && potentialTarget.isZombie) {
  52.                         return false;
  53.                 }
  54.                 if (spell.damagesAll) {
  55.                         return true;
  56.                 }
  57.                 return potentialTarget.isEnemy(caster);
  58.         }
  59.        
  60.         void closeOtherBoxes(BOX activeBox, Player@ asPlayer) {
  61.                 if (activeBox != BOX_SPELL_BOOK && @asPlayer != null) {
  62.                         asPlayer.unSetChanneledSpellKey();
  63.                         spellBookOpen = false;
  64.                 }
  65.                 if (activeBox != BOX_INFO) infoOpen = false;
  66.                 if (activeBox != BOX_SKILLS) skillsOpen = false;
  67.                 if (activeBox != BOX_KEY_MENU) keyMenuState = keyMenuState >= 1 ? 1 : 0;
  68.         }
  69.        
  70.         void disableDemoMode() {
  71.                 for (uint i = 0; i < 32; i++) {
  72.                         players[i].unSetChanneledSpellKey();
  73.                 }
  74.                 ownSpells.removeRange(0, ownSpells.length);
  75.                 ownSpells = acInit::loadSpells(LOWEST_TIER, HIGHEST_STARTING_TIER);
  76.         }
  77.        
  78.         void filterOutMagicMirrorTargets(int8[] &inout targets, SPELL spell,
  79.                         bool drawMagicMirrorAnimationOnMagicMirrorTarget = false) {
  80.                 int j = 0;
  81.                 uint targetsLength = targets.length();
  82.                 for (uint i = 0; i < targetsLength; i++) {
  83.                         if ((!players[targets[i]].hasEffect(SPELL_MAGIC_MIRROR)
  84.                                         || spell == SPELL_DEATH_RIPPLE
  85.                                         || spell == SPELL_ARMAGEDDON)) {
  86.                                 targets[j] = targets[i];
  87.                                 j++;
  88.                         } else if (drawMagicMirrorAnimationOnMagicMirrorTarget) {
  89.                                 acUtils::addMagicMirrorAnimation(targets[i]);
  90.                         }
  91.                 }
  92.                 targets.removeRange(j, targetsLength - j);
  93.         }
  94.        
  95.         bool findFromChainLightningTargets(array<ChainLightningTarget@> chainLightningTargets, int8 playerID) {
  96.                 for (uint i = 0; i < chainLightningTargets.length; i++) {
  97.                         if (chainLightningTargets[i].playerID == playerID) {
  98.                                 return true;
  99.                         }
  100.                 }
  101.                 return false;
  102.         }
  103.        
  104.         ChainLightningTarget@ findParentTarget(array<ChainLightningTarget@> chainLightningTargets, int8 id) {
  105.                 for (uint i = 0; i < chainLightningTargets.length; i++) {
  106.                         ChainLightningTarget@ target = chainLightningTargets[i];
  107.                         if (target.id == id) {
  108.                                 return target;
  109.                         }
  110.                 }
  111.                 return null;
  112.         }
  113.  
  114.         bool gameIsRunning() {
  115.                 return jjGameState == GAME::STARTED || jjGameState == GAME::OVERTIME || !jjNoMovement;
  116.         }
  117.        
  118.         int getBulletPointerDistance(float xOrigin, float yOrigin, int direction) {
  119.                 int distance = 0;
  120.                 if (direction >= 0) {
  121.                         for (float x = xOrigin; x < xOrigin+BULLET_POINTER_MAX_DISTANCE*TILE; x++) {
  122.                                 if (jjMaskedVLine(int(x+TILE), int(yOrigin), 1)) {
  123.                                         return distance;
  124.                                 }
  125.                                 distance++;
  126.                         }
  127.                 }
  128.                 else {
  129.                         for (float x = xOrigin; x > xOrigin-BULLET_POINTER_MAX_DISTANCE*TILE; x--) {
  130.                                 if (jjMaskedVLine(int(x-TILE), int(yOrigin), 1)) {
  131.                                         return distance;
  132.                                 }
  133.                                 distance++;
  134.                         }
  135.                 }
  136.                 return distance;
  137.         }
  138.        
  139.         int getDamageModifier(Player@ attacker, Player@ victim) {
  140.                 int damageModifier = 0;
  141.                 for (uint i = 0; i < attacker.activeEffects.length; i++) {
  142.                         SPELL effect = attacker.activeEffects[i].enumValue;
  143.                         damageModifier += getDamageModifierByAttacker(effect);
  144.                 }
  145.                 for (uint i = 0; i < victim.activeEffects.length; i++) {
  146.                         SPELL effect = victim.activeEffects[i].enumValue;
  147.                         damageModifier += getDamageModifierByVictim(effect);
  148.                 }
  149.                 return damageModifier;
  150.         }
  151.  
  152.         int getDamageModifierByAttacker(SPELL effect) {
  153.                 switch (effect) {
  154.                         case SPELL_BLESS: return 1;
  155.                         case SPELL_WEAKNESS: return -1;
  156.                         case SPELL_PRECISION: return 2;
  157.                         case SPELL_FRENZY: return 4;
  158.                 }
  159.                 return 0;
  160.         }
  161.  
  162.         int getDamageModifierByVictim(SPELL effect) {
  163.                 switch (effect) {
  164.                         case SPELL_STONE_SKIN: return -1;
  165.                         case SPELL_DISRUPTING_RAY: return 2;
  166.                         case SPELL_FRENZY: return 4;
  167.                 }
  168.                 return 0;
  169.         }
  170.        
  171.         string getFirstLearnableSpell() {
  172.                 for (uint i = 0; i < learnableSpells.length; i++) {
  173.                         string learnableSpell = learnableSpells[i];
  174.                         if (ownSpells.find(learnableSpell) >= 0) continue;
  175.                         else return learnableSpell;
  176.                 }
  177.                 return "";
  178.         }
  179.        
  180.         array<int8> getMagicMirrorPlayerIdsFromTargets(int8[] targets) {
  181.                 array<int8> magicMirrorPlayerIds;
  182.                 for (uint i = 0; i < targets.length(); i++) {
  183.                         if (players[targets[i]].hasEffect(SPELL_MAGIC_MIRROR)) {
  184.                                 magicMirrorPlayerIds.insertLast(targets[i]);
  185.                         }
  186.                 }
  187.                 return magicMirrorPlayerIds;
  188.         }
  189.        
  190.         float getScaledRadius(float radius, ANIM::Set animSet, int frameCount, int animCount = 0) {
  191.                 jjANIMFRAME@ sprite = jjAnimFrames[jjAnimations[jjAnimSets[animSet].firstAnim + animCount].firstFrame + frameCount];
  192.                 return float(sprite.width * radius / 2);
  193.         }
  194.        
  195.         string getSpellKeyByNumpadIndex(uint numpadIndex) {
  196.                 array<string> spellKeys = spells.getKeys();
  197.                 for (uint i = 0; i < spellKeys.length; i++) {
  198.                         Spell@ spell = cast<Spell@>(spells[spellKeys[i]]);
  199.                         if (spell.numpad == numpadIndex) return spell.key;
  200.                 }
  201.                 return "";
  202.         }
  203.        
  204.         int getSpellPriceByTier(uint tier) {
  205.                 if (tier == 3) return SPELL_COST_TIER_3;
  206.                 if (tier == 4) return SPELL_COST_TIER_4;
  207.                 if (tier == 5) return SPELL_COST_TIER_5;
  208.                 return 0;
  209.         }
  210.        
  211.         int8[] getTargets(jjPLAYER@ source, Spell@ spell, float scaledRadius,
  212.                         bool excludeMagicMirrorTargets = false) {
  213.                 int8[] targets;
  214.                 for (int8 i = 0; i < 32; i++) {
  215.                         if (jjPlayers[i].isInGame) {
  216.                                 jjPLAYER@ potentialTarget = jjPlayers[i];
  217.                                 bool inRange = acUtils::checkIfPlayerIsInRange(source, potentialTarget, scaledRadius);
  218.                                 if (inRange) {
  219.                                         bool isVulnerable = acUtils::checkIfPlayerIsVulnerable(source, potentialTarget, spell,
  220.                                                         excludeMagicMirrorTargets);
  221.                                         if (isVulnerable) {
  222.                                                 targets.insertLast(i);
  223.                                         }
  224.                                 }
  225.                         }
  226.                 }
  227.                 return targets;
  228.         }
  229.        
  230.         uint getTierChanceByRoasts(int roasts) {
  231.                 uint chance = 5;
  232.                 if (jjMaxScore <= SHORT_GAME_THRESHOLD) {
  233.                         chance = roasts;
  234.                 }
  235.                 else {
  236.                         chance = uint(roasts / 2);
  237.                 }
  238.                 if (debugModeOn) {
  239.                         jjAlert("roasts: " + roasts);
  240.                         jjAlert("chance: " + chance);
  241.                 }
  242.                 if (chance < 1) {
  243.                         chance = 1;
  244.                 }
  245.                 else if (chance > 5) {
  246.                         chance = 5;
  247.                 }
  248.                 return chance;
  249.         }
  250.  
  251.         int getWallOfFireHeightInTiles(float xOrigin, float yOrigin) {
  252.                 int height = 0;
  253.                 for (float x = xOrigin; x < xOrigin + 64; x++) {
  254.                         if (!jjMaskedHLine(int(x), 1, int(yOrigin+8))) {
  255.                                 return 0;
  256.                         }
  257.                 }
  258.                 for (float y = yOrigin; y > yOrigin - WALL_OF_FIRE_MAX_HEIGHT*TILE; y--) {
  259.                         for (float x = xOrigin; x < xOrigin + 64; x++) {
  260.                                 if (jjMaskedHLine(int(x), 1, int(y-TILE))) {
  261.                                         return int(height/TILE);
  262.                                 }
  263.                         }
  264.                         height++;
  265.                 }
  266.                 return int(height/TILE);
  267.         }
  268.        
  269.         bool infoViewIsAboveBottom() {
  270.                 int spellsLength = spells.getKeys().length;
  271.                 if (spellsLength % 2 == 1) spellsLength++;
  272.                 return infoScrollY > -(spellsLength / 2 * INFO_BOX_HEIGHT -
  273.                                 (jjSubscreenHeight-(SPELL_BOXES_INIT_Y+HINT_BOX_HEIGHT)+4));
  274.         }
  275.        
  276.         bool mouseIsInSelection(int x, int y, int width, int height) {
  277.                 return jjMouseX >= x && jjMouseY >= y && jjMouseX <= x+width && jjMouseY <= y+height;
  278.         }
  279.  
  280.         bool mouseIsOutsideKeyMenu() {
  281.                 return (jjMouseX < jjSubscreenWidth / 4 || jjMouseX > jjSubscreenWidth / 4 * 3) ||
  282.                                 jjMouseY < jjSubscreenHeight / 4 || jjMouseY > jjSubscreenHeight / 4 * 3;
  283.         }
  284.  
  285.         bool mouseIsWithinKeyMenuChoices() {
  286.                 return (jjMouseX > jjSubscreenWidth / 4 && jjMouseX < jjSubscreenWidth / 4 * 3)
  287.                                 && (jjMouseY > jjSubscreenHeight / 4 + 102
  288.                                 && jjMouseY < jjSubscreenHeight / 4 + 102 + keyBindings.length*16 );
  289.         }
  290.        
  291.         int parseNumpadIndex(array<uint> buffer) {
  292.                 string numberString = "";
  293.                 for (uint j = 0; j < buffer.length; j++) {
  294.                         numberString += ("" + buffer[j]);
  295.                 }
  296.                 if (numberString.length >= 1) return parseInt(numberString);
  297.                 else return -1;
  298.         }
  299.        
  300.         void saveHotkeyToFile(int selection, uint keyIndex) {
  301.                 jjSTREAM file(HOTKEY_FILENAME);
  302.                 file.push(selection);
  303.                 file.push(keyIndex);
  304.                 file.save(HOTKEY_FILENAME);
  305.         }
  306.        
  307.         void setHotkey(int selection, uint keyIndex, bool overwrite = false) {
  308.                 if (!overwrite) {
  309.                         array<int> hotkeys = {
  310.                                         hotkeyInfo, hotkeySkills, hotkeyCycleSpells,
  311.                                         hotkeySpellbook, hotkeyKeyMenu, hotkeyResources};
  312.                         if (hotkeys.find(keyIndex) >= 0) {
  313.                                 hotkeyInUse = true;
  314.                                 return;
  315.                         }
  316.                 }
  317.                
  318.                 switch (selection) {
  319.                         case 0:
  320.                         {
  321.                                 hotkeyInfo = keyIndex;
  322.                         }
  323.                         break;
  324.                         case 1:
  325.                         {
  326.                                 hotkeySkills = keyIndex;
  327.                         }
  328.                         break;
  329.                         case 2:
  330.                         {
  331.                                 hotkeyCycleSpells = keyIndex;
  332.                         }
  333.                         break;
  334.                         case 3:
  335.                         {
  336.                                 hotkeySpellbook = keyIndex;
  337.                         }
  338.                         break;
  339.                         case 4:
  340.                         {
  341.                                 hotkeyKeyMenu = keyIndex;
  342.                         }
  343.                         break;
  344.                         case 5:
  345.                         {
  346.                                 hotkeyResources = keyIndex;
  347.                         }
  348.                         break;
  349.                 }
  350.                 if (!overwrite) {
  351.                         saveHotkeyToFile(selection, keyIndex);
  352.                 }
  353.                 hotkeyInUse = false;
  354.                 acInit::loadKeyBindings();
  355.         }
  356.        
  357.         void setSkillBonus(Player@ asPlayer, SKILL skill, int8 playerID) {
  358.                 switch (skill) {
  359.                         case SKILL_MAX_MANA:
  360.                         {
  361.                                 asPlayer.maxMana += 100;
  362.                         }
  363.                         break;
  364.                         case SKILL_MANA_REGEN:
  365.                         {
  366.                                 asPlayer.manaRegenRate++;
  367.                         }
  368.                         break;
  369.                         case SKILL_SPELL_DAMAGE:
  370.                         {
  371.                                 acNetworking::sendSkillPacket(playerID, PACKET_SKILL_DAMAGE);
  372.                                 if (jjIsServer) asPlayer.spellDamageBonus++;
  373.                         }
  374.                         break;
  375.                         case SKILL_SPELL_DURATION:
  376.                         {
  377.                                 acNetworking::sendSkillPacket(playerID, PACKET_SKILL_DURATION);
  378.                                 if (jjIsServer) asPlayer.spellDurationBonus += 10;
  379.                         }
  380.                         break;
  381.                         case SKILL_MAGIC_RESIST:
  382.                         {
  383.                                 asPlayer.magicResist++;
  384.                         }
  385.                         break;
  386.                 }
  387.         }
  388.        
  389.         array<string> sortSpellKeys(array<string> spellKeys) {
  390.                 array<string> sortedKeys;
  391.                 array<Spell@> spellArray;
  392.                 for (uint i = 0; i < spellKeys.length; i++) {
  393.                         string key = spellKeys[i];
  394.                         spellArray.insertLast(cast<Spell@>(spells[spellKeys[i]]));
  395.                 }
  396.                 spellArray.sortAsc();
  397.                 for (uint i = 0; i < spellArray.length; i++) {
  398.                         sortedKeys.insertLast(spellArray[i].key);
  399.                 }
  400.                 return sortedKeys;
  401.         }
  402.        
  403.         string splitText(string textToSplit, int rowWidth) {
  404.                 string newText = "";
  405.                 int lines = 1;
  406.                 for (uint i = 0; i < textToSplit.length(); i++) {
  407.                         newText += textToSplit.substr(i, 1);
  408.                         if (jjGetStringWidth(newText, STRING::SMALL, STRING::NORMAL) >= lines * rowWidth
  409.                                         && textToSplit.substr(i+1, 1) == " ") {
  410.                                 newText += "\n";
  411.                                 lines++;
  412.                                 i++;
  413.                         }
  414.                 }
  415.                 return newText;
  416.         }
  417. }