namespace acUtils {
void addMagicMirrorAnimation(int8 playerID) {
magicMirrorAnimations.insertLast(MagicMirrorAnimation(jjPlayers[playerID],
jjPlayers[playerID].direction));
}
void addMagicMirrorAnimation(int8 playerID, int direction) {
magicMirrorAnimations.insertLast(MagicMirrorAnimation(jjPlayers[playerID], direction));
}
void addMagicMirrorAnimationOnTargetsWithMagicMirror(int8[] targets) {
for (uint i = 0; i < targets.length(); i++) {
if (players[targets[i]].hasEffect(SPELL_MAGIC_MIRROR)) {
magicMirrorAnimations.insertLast(MagicMirrorAnimation(
jjPlayers[targets[i]], jjPlayers[targets[i]].direction));
}
}
}
void alertOfLearnedSkill(string playerName, SKILL skillEnum) {
Skill@ skill = skills[skills.find(Skill(skillEnum))];
jjAlert("" + playerName + " learned |||" + skill.name + "|||||! (" + skill.description + ")",
true);
}
void alertOfLearnedSpell(string playerName, string spellName) {
jjAlert("" + playerName + " has learned the spell |||" + spellName + "|||||!", true);
}
bool areAllTargetsMagicMirrors(int8[] targets) {
for (uint i = 0; i < targets.length(); i++) {
if (!players[targets[i]].hasEffect(SPELL_MAGIC_MIRROR)) {
return false;
}
}
return true;
}
bool checkIfPlayerIsInRange(jjPLAYER@ source, jjPLAYER@ potentialTarget, float scaledRadius) {
float xDistance = potentialTarget.xPos - source.xPos;
float yDistance = potentialTarget.yPos - source.yPos;
return xDistance*xDistance + yDistance*yDistance < scaledRadius*scaledRadius;
}
bool checkIfPlayerIsVulnerable(jjPLAYER@ caster, jjPLAYER@ potentialTarget, Spell@ spell,
bool excludeMagicMirrorTargets = false) {
if (players[potentialTarget.playerID].hasEffect(SPELL_MAGIC_MIRROR) && excludeMagicMirrorTargets) {
return false;
}
if (spell.enumValue == SPELL_DEATH_RIPPLE && potentialTarget.isZombie) {
return false;
}
if (spell.damagesAll) {
return true;
}
return potentialTarget.isEnemy(caster);
}
void closeOtherBoxes(BOX activeBox, Player@ asPlayer) {
if (activeBox != BOX_SPELL_BOOK && @asPlayer != null) {
asPlayer.unSetChanneledSpellKey();
spellBookOpen = false;
}
if (activeBox != BOX_INFO) infoOpen = false;
if (activeBox != BOX_SKILLS) skillsOpen = false;
if (activeBox != BOX_KEY_MENU) keyMenuState = keyMenuState >= 1 ? 1 : 0;
}
void disableDemoMode() {
for (uint i = 0; i < 32; i++) {
players[i].unSetChanneledSpellKey();
}
ownSpells.removeRange(0, ownSpells.length);
ownSpells = acInit::loadSpells(LOWEST_TIER, HIGHEST_STARTING_TIER);
}
void filterOutMagicMirrorTargets(int8[] &inout targets, SPELL spell,
bool drawMagicMirrorAnimationOnMagicMirrorTarget = false) {
int j = 0;
uint targetsLength = targets.length();
for (uint i = 0; i < targetsLength; i++) {
if ((!players[targets[i]].hasEffect(SPELL_MAGIC_MIRROR)
|| spell == SPELL_DEATH_RIPPLE
|| spell == SPELL_ARMAGEDDON)) {
targets[j] = targets[i];
j++;
} else if (drawMagicMirrorAnimationOnMagicMirrorTarget) {
acUtils::addMagicMirrorAnimation(targets[i]);
}
}
targets.removeRange(j, targetsLength - j);
}
bool findFromChainLightningTargets(array<ChainLightningTarget@> chainLightningTargets, int8 playerID) {
for (uint i = 0; i < chainLightningTargets.length; i++) {
if (chainLightningTargets[i].playerID == playerID) {
return true;
}
}
return false;
}
ChainLightningTarget@ findParentTarget(array<ChainLightningTarget@> chainLightningTargets, int8 id) {
for (uint i = 0; i < chainLightningTargets.length; i++) {
ChainLightningTarget@ target = chainLightningTargets[i];
if (target.id == id) {
return target;
}
}
return null;
}
bool gameIsRunning() {
return jjGameState == GAME::STARTED || jjGameState == GAME::OVERTIME || !jjNoMovement;
}
int getBulletPointerDistance(float xOrigin, float yOrigin, int direction) {
int distance = 0;
if (direction >= 0) {
for (float x = xOrigin; x < xOrigin+BULLET_POINTER_MAX_DISTANCE*TILE; x++) {
if (jjMaskedVLine(int(x+TILE), int(yOrigin), 1)) {
return distance;
}
distance++;
}
}
else {
for (float x = xOrigin; x > xOrigin-BULLET_POINTER_MAX_DISTANCE*TILE; x--) {
if (jjMaskedVLine(int(x-TILE), int(yOrigin), 1)) {
return distance;
}
distance++;
}
}
return distance;
}
int getDamageModifier(Player@ attacker, Player@ victim) {
int damageModifier = 0;
for (uint i = 0; i < attacker.activeEffects.length; i++) {
SPELL effect = attacker.activeEffects[i].enumValue;
damageModifier += getDamageModifierByAttacker(effect);
}
for (uint i = 0; i < victim.activeEffects.length; i++) {
SPELL effect = victim.activeEffects[i].enumValue;
damageModifier += getDamageModifierByVictim(effect);
}
return damageModifier;
}
int getDamageModifierByAttacker(SPELL effect) {
switch (effect) {
case SPELL_BLESS: return 1;
case SPELL_WEAKNESS: return -1;
case SPELL_PRECISION: return 2;
case SPELL_FRENZY: return 4;
}
return 0;
}
int getDamageModifierByVictim(SPELL effect) {
switch (effect) {
case SPELL_STONE_SKIN: return -1;
case SPELL_DISRUPTING_RAY: return 2;
case SPELL_FRENZY: return 4;
}
return 0;
}
string getFirstLearnableSpell() {
for (uint i = 0; i < learnableSpells.length; i++) {
string learnableSpell = learnableSpells[i];
if (ownSpells.find(learnableSpell) >= 0) continue;
else return learnableSpell;
}
return "";
}
array<int8> getMagicMirrorPlayerIdsFromTargets(int8[] targets) {
array<int8> magicMirrorPlayerIds;
for (uint i = 0; i < targets.length(); i++) {
if (players[targets[i]].hasEffect(SPELL_MAGIC_MIRROR)) {
magicMirrorPlayerIds.insertLast(targets[i]);
}
}
return magicMirrorPlayerIds;
}
float getScaledRadius(float radius, ANIM::Set animSet, int frameCount, int animCount = 0) {
jjANIMFRAME@ sprite = jjAnimFrames[jjAnimations[jjAnimSets[animSet].firstAnim + animCount].firstFrame + frameCount];
return float(sprite.width * radius / 2);
}
string getSpellKeyByNumpadIndex(uint numpadIndex) {
array<string> spellKeys = spells.getKeys();
for (uint i = 0; i < spellKeys.length; i++) {
Spell@ spell = cast<Spell@>(spells[spellKeys[i]]);
if (spell.numpad == numpadIndex) return spell.key;
}
return "";
}
int getSpellPriceByTier(uint tier) {
if (tier == 3) return SPELL_COST_TIER_3;
if (tier == 4) return SPELL_COST_TIER_4;
if (tier == 5) return SPELL_COST_TIER_5;
return 0;
}
int8[] getTargets(jjPLAYER@ source, Spell@ spell, float scaledRadius,
bool excludeMagicMirrorTargets = false) {
int8[] targets;
for (int8 i = 0; i < 32; i++) {
if (jjPlayers[i].isInGame) {
jjPLAYER@ potentialTarget = jjPlayers[i];
bool inRange = acUtils::checkIfPlayerIsInRange(source, potentialTarget, scaledRadius);
if (inRange) {
bool isVulnerable = acUtils::checkIfPlayerIsVulnerable(source, potentialTarget, spell,
excludeMagicMirrorTargets);
if (isVulnerable) {
targets.insertLast(i);
}
}
}
}
return targets;
}
uint getTierChanceByRoasts(int roasts) {
uint chance = 5;
if (jjMaxScore <= SHORT_GAME_THRESHOLD) {
chance = roasts;
}
else {
chance = uint(roasts / 2);
}
if (debugModeOn) {
jjAlert("roasts: " + roasts);
jjAlert("chance: " + chance);
}
if (chance < 1) {
chance = 1;
}
else if (chance > 5) {
chance = 5;
}
return chance;
}
int getWallOfFireHeightInTiles(float xOrigin, float yOrigin) {
int height = 0;
for (float x = xOrigin; x < xOrigin + 64; x++) {
if (!jjMaskedHLine(int(x), 1, int(yOrigin+8))) {
return 0;
}
}
for (float y = yOrigin; y > yOrigin - WALL_OF_FIRE_MAX_HEIGHT*TILE; y--) {
for (float x = xOrigin; x < xOrigin + 64; x++) {
if (jjMaskedHLine(int(x), 1, int(y-TILE))) {
return int(height/TILE);
}
}
height++;
}
return int(height/TILE);
}
bool infoViewIsAboveBottom() {
int spellsLength = spells.getKeys().length;
if (spellsLength % 2 == 1) spellsLength++;
return infoScrollY > -(spellsLength / 2 * INFO_BOX_HEIGHT -
(jjSubscreenHeight-(SPELL_BOXES_INIT_Y+HINT_BOX_HEIGHT)+4));
}
bool mouseIsInSelection(int x, int y, int width, int height) {
return jjMouseX >= x && jjMouseY >= y && jjMouseX <= x+width && jjMouseY <= y+height;
}
bool mouseIsOutsideKeyMenu() {
return (jjMouseX < jjSubscreenWidth / 4 || jjMouseX > jjSubscreenWidth / 4 * 3) ||
jjMouseY < jjSubscreenHeight / 4 || jjMouseY > jjSubscreenHeight / 4 * 3;
}
bool mouseIsWithinKeyMenuChoices() {
return (jjMouseX > jjSubscreenWidth / 4 && jjMouseX < jjSubscreenWidth / 4 * 3)
&& (jjMouseY > jjSubscreenHeight / 4 + 102
&& jjMouseY < jjSubscreenHeight / 4 + 102 + keyBindings.length*16 );
}
int parseNumpadIndex(array<uint> buffer) {
string numberString = "";
for (uint j = 0; j < buffer.length; j++) {
numberString += ("" + buffer[j]);
}
if (numberString.length >= 1) return parseInt(numberString);
else return -1;
}
void saveHotkeyToFile(int selection, uint keyIndex) {
jjSTREAM file(HOTKEY_FILENAME);
file.push(selection);
file.push(keyIndex);
file.save(HOTKEY_FILENAME);
}
void setHotkey(int selection, uint keyIndex, bool overwrite = false) {
if (!overwrite) {
array<int> hotkeys = {
hotkeyInfo, hotkeySkills, hotkeyCycleSpells,
hotkeySpellbook, hotkeyKeyMenu, hotkeyResources};
if (hotkeys.find(keyIndex) >= 0) {
hotkeyInUse = true;
return;
}
}
switch (selection) {
case 0:
{
hotkeyInfo = keyIndex;
}
break;
case 1:
{
hotkeySkills = keyIndex;
}
break;
case 2:
{
hotkeyCycleSpells = keyIndex;
}
break;
case 3:
{
hotkeySpellbook = keyIndex;
}
break;
case 4:
{
hotkeyKeyMenu = keyIndex;
}
break;
case 5:
{
hotkeyResources = keyIndex;
}
break;
}
if (!overwrite) {
saveHotkeyToFile(selection, keyIndex);
}
hotkeyInUse = false;
acInit::loadKeyBindings();
}
void setSkillBonus(Player@ asPlayer, SKILL skill, int8 playerID) {
switch (skill) {
case SKILL_MAX_MANA:
{
asPlayer.maxMana += 100;
}
break;
case SKILL_MANA_REGEN:
{
asPlayer.manaRegenRate++;
}
break;
case SKILL_SPELL_DAMAGE:
{
acNetworking::sendSkillPacket(playerID, PACKET_SKILL_DAMAGE);
if (jjIsServer) asPlayer.spellDamageBonus++;
}
break;
case SKILL_SPELL_DURATION:
{
acNetworking::sendSkillPacket(playerID, PACKET_SKILL_DURATION);
if (jjIsServer) asPlayer.spellDurationBonus += 10;
}
break;
case SKILL_MAGIC_RESIST:
{
asPlayer.magicResist++;
}
break;
}
}
array<string> sortSpellKeys(array<string> spellKeys) {
array<string> sortedKeys;
array<Spell@> spellArray;
for (uint i = 0; i < spellKeys.length; i++) {
string key = spellKeys[i];
spellArray.insertLast(cast<Spell@>(spells[spellKeys[i]]));
}
spellArray.sortAsc();
for (uint i = 0; i < spellArray.length; i++) {
sortedKeys.insertLast(spellArray[i].key);
}
return sortedKeys;
}
string splitText(string textToSplit, int rowWidth) {
string newText = "";
int lines = 1;
for (uint i = 0; i < textToSplit.length(); i++) {
newText += textToSplit.substr(i, 1);
if (jjGetStringWidth(newText, STRING::SMALL, STRING::NORMAL) >= lines * rowWidth
&& textToSplit.substr(i+1, 1) == " ") {
newText += "\n";
lines++;
i++;
}
}
return newText;
}
}
