Downloads containing academy_networking.asc

Downloads
Name Author Game Mode Rating
TSF with JJ2+ Only: Anniversary Bash 21 Levels Jazz2Online Multiple N/A Download file

File preview

  1. namespace acNetworking {
  2.  
  3.         void doReceive(jjSTREAM &in packet, int clientID) {
  4.                 int8 senderPlayerID;
  5.                 packet.pop(senderPlayerID);
  6.                
  7.                 if (jjIsServer && clientID != jjPlayers[senderPlayerID].clientID) return; //Check for packet validity
  8.                
  9.                 uint8 packetType;
  10.                 packet.pop(packetType);
  11.                
  12.                 switch (packetType) {
  13.                         case PACKET_AOE:
  14.                         {
  15.                                 uint8 spellID;
  16.                                 packet.pop(spellID);
  17.                                 jjPLAYER@ caster = jjPlayers[senderPlayerID];
  18.                                
  19.                                 if (jjIsServer) {
  20.                                         sendAOEPacket(senderPlayerID, spellID);
  21.                                 }
  22.                                 acSpells::doAOE(caster, spellID, caster.xPos, caster.yPos);
  23.                         }
  24.                         break;
  25.                         case PACKET_EFFECT:
  26.                         {
  27.                                 uint8 effectID;
  28.                                 int8 targetPlayerID;
  29.                                 uint duration;
  30.                                 packet.pop(effectID);
  31.                                 packet.pop(targetPlayerID);
  32.                                 packet.pop(duration);
  33.                                
  34.                                 if (jjIsServer) {
  35.                                         sendEffectPacket(senderPlayerID, effectID, targetPlayerID, duration);
  36.                                 }
  37.                                 acSpells::doEffect(effectID, targetPlayerID, duration);
  38.                         }
  39.                         break;
  40.                         case PACKET_MASS_EFFECT:
  41.                         {
  42.                                 uint8 effectID;
  43.                                 uint duration;
  44.                                 int8[] targets;
  45.                                 packet.pop(effectID);
  46.                                 packet.pop(duration);
  47.                                 while (!packet.isEmpty()) {
  48.                                         int8 target;
  49.                                         packet.pop(target);
  50.                                         targets.insertLast(target);
  51.                                 }
  52.                                
  53.                                 if (jjIsServer) {
  54.                                         sendMassEffectPacket(senderPlayerID, effectID, targets, duration);
  55.                                 }
  56.                                 acSpells::doMassEffect(effectID, targets, duration);
  57.                         }
  58.                         break;
  59.                         case PACKET_CHANNELING_STARTED:
  60.                         {
  61.                                 uint8 spellEnumValue;
  62.                                 packet.pop(spellEnumValue);
  63.                                 if (debugModeOn) jjAlert("Channeling started");
  64.                                
  65.                                 if (jjIsServer) {
  66.                                         sendChannelingStartedPacket(senderPlayerID, spellEnumValue);
  67.                                         string channeledSpellKey = acSpells::getSpellKeyByEnumValue(spellEnumValue);
  68.                                         if (channeledSpellKey != "") {
  69.                                                 players[senderPlayerID].setChanneledSpellKey(channeledSpellKey);
  70.                                         }
  71.                                 }
  72.                                 else {
  73.                                         string channeledSpellKey = acSpells::getSpellKeyByEnumValue(spellEnumValue);
  74.                                         if (channeledSpellKey != "" && !jjPlayers[senderPlayerID].isLocal) {
  75.                                                 players[senderPlayerID].setChanneledSpellKey(channeledSpellKey);
  76.                                         }
  77.                                 }
  78.                         }
  79.                         break;
  80.                         case PACKET_CHANNELING_STOPPED:
  81.                         {
  82.                                 if (jjIsServer) {
  83.                                         sendChannelingStoppedPacket(senderPlayerID);
  84.                                         players[senderPlayerID].unSetChanneledSpellKey();
  85.                                 }
  86.                                 else {
  87.                                         players[senderPlayerID].unSetChanneledSpellKey();
  88.                                 }
  89.                         }
  90.                         break;
  91.                         case PACKET_PLAYER_DEAD:
  92.                         {
  93.                                 if (debugModeOn) jjAlert("Received");
  94.                                 if (jjIsServer) {
  95.                                         sendPlayerDeadPacket(senderPlayerID);
  96.                                 }
  97.                                 acEngine::doDeadPlayer(senderPlayerID);
  98.                         }
  99.                         break;
  100.                         case PACKET_WALL_OF_FIRE:
  101.                         {
  102.                                 float xOrigin;
  103.                                 float yOrigin;
  104.                                 int height;
  105.                                 packet.pop(xOrigin);
  106.                                 packet.pop(yOrigin);
  107.                                 packet.pop(height);
  108.                                
  109.                                 if (jjIsServer) {
  110.                                         sendWallOfFirePacket(senderPlayerID, xOrigin, yOrigin, height);
  111.                                 }
  112.                                
  113.                                 Spell@ spell = cast<Spell@>(spells["I"]);
  114.                                 uint duration = (spell.baseDuration + players[senderPlayerID].spellDurationBonus) * SECOND;
  115.                                 acSpells::doWallOfFire(jjPlayers[senderPlayerID], spell, xOrigin, yOrigin, height, duration);
  116.                         }
  117.                         break;
  118.                         case PACKET_CHAIN_LIGHTNING_SERVER:
  119.                         {
  120.                                 int8[] targets;
  121.                                 while (!packet.isEmpty()) {
  122.                                         int8 target;
  123.                                         packet.pop(target);
  124.                                         targets.insertLast(target);
  125.                                 }
  126.                                 array<ChainLightningTarget@> chainLightningTargets = acSpells::doChainLightning(senderPlayerID, targets);
  127.                                 sendChainLightningPacketToClients(senderPlayerID, chainLightningTargets);
  128.                                 chainLightningTargetGroups.insertLast(chainLightningTargets);
  129.                         }
  130.                         break;
  131.                         case PACKET_CHAIN_LIGHTNING_CLIENT:
  132.                         {
  133.                                 array<ChainLightningTarget@> chainLightningTargets;
  134.                                 while (!packet.isEmpty()) {
  135.                                         int8 id;
  136.                                         int8 parentID;
  137.                                         int8 playerID;
  138.                                         packet.pop(id);
  139.                                         packet.pop(parentID);
  140.                                         packet.pop(playerID);
  141.                                         chainLightningTargets.insertLast(ChainLightningTarget(id, playerID, 0, CHAIN_LIGHTNING_DEFAULT_DURATION, parentID));
  142.                                 }
  143.                                 chainLightningTargetGroups.insertLast(chainLightningTargets);
  144.                         }
  145.                         break;
  146.                         case PACKET_CAPTURE_GEM_MINE:
  147.                         {
  148.                                 if (jjIsServer) {
  149.                                         sendCaptureGemMinePacket(senderPlayerID);
  150.                                 }
  151.                                 if (gemMine.ownerID == jjLocalPlayers[0].playerID) {
  152.                                         jjAlert("Your gem mine was captured by " + jjPlayers[senderPlayerID].name + "!",
  153.                                                         false, STRING::MEDIUM);
  154.                                 }
  155.                                 gemMine.capture(senderPlayerID);
  156.                         }
  157.                         break;
  158.                         case PACKET_SKILL_DAMAGE:
  159.                         {
  160.                                 if (jjIsServer) {
  161.                                         sendSkillPacket(senderPlayerID, packetType);
  162.                                 }
  163.                                 players[senderPlayerID].spellDamageBonus++;
  164.                         }
  165.                         break;
  166.                         case PACKET_SKILL_DURATION:
  167.                         {
  168.                                 if (jjIsServer) {
  169.                                         sendSkillPacket(senderPlayerID, packetType);
  170.                                 }
  171.                                 players[senderPlayerID].spellDurationBonus += 10;
  172.                         }
  173.                         break;
  174.                         case PACKET_REQ_SYNC_DATA:
  175.                         {
  176.                                 sendSkillData(clientID);
  177.                                 sendEffectData(clientID);
  178.                                 sendWallOfFireData(clientID);
  179.                                 sendGemMineOwnerData(clientID);
  180.                                 sendDemoModeData(clientID);
  181.                         }
  182.                         break;
  183.                         case PACKET_SYNC_EFFECTS:
  184.                         {
  185.                                 while (!packet.isEmpty()) {
  186.                                         int8 effectPlayerID;
  187.                                         uint8 effectID;
  188.                                         uint duration;
  189.                                         packet.pop(effectPlayerID);
  190.                                         packet.pop(effectID);
  191.                                         packet.pop(duration);
  192.                                         acSpells::doEffect(effectID, effectPlayerID, duration, false);
  193.                                 }
  194.                         }
  195.                         break;
  196.                         case PACKET_SYNC_SKILLS:
  197.                         {
  198.                                 while (!packet.isEmpty()) {
  199.                                         int8 skillPlayerID;
  200.                                         packet.pop(skillPlayerID);
  201.                                         packet.pop(players[skillPlayerID].spellDamageBonus);
  202.                                         packet.pop(players[skillPlayerID].magicResist);
  203.                                 }
  204.                         }
  205.                         break;
  206.                         case PACKET_SYNC_WALLS_OF_FIRE:
  207.                         {
  208.                                 while (!packet.isEmpty()) {
  209.                                         int8 wallPlayerID;
  210.                                         float xOrigin;
  211.                                         float yOrigin;
  212.                                         int8 height;
  213.                                         uint duration;
  214.                                         packet.pop(wallPlayerID);
  215.                                         packet.pop(xOrigin);
  216.                                         packet.pop(yOrigin);
  217.                                         packet.pop(height);
  218.                                         packet.pop(duration);
  219.                                         jjPLAYER@ caster = jjPlayers[wallPlayerID];
  220.                                         Spell@ spell = cast<Spell@>(spells["I"]);
  221.                                         acSpells::doWallOfFire(caster, spell, xOrigin, yOrigin, height, duration);
  222.                                 }
  223.                         }
  224.                         break;
  225.                         case PACKET_SYNC_GEM_MINE:
  226.                         {
  227.                                 int lockElapsed;
  228.                                 packet.pop(lockElapsed);
  229.                                 gemMine.lockElapsed = lockElapsed;
  230.                                 gemMine.ownerID = senderPlayerID;
  231.                         }
  232.                         break;
  233.                         case PACKET_SYNC_DEMO_MODE:
  234.                         {
  235.                                 packet.pop(demoModeOn);
  236.                                 if (demoModeOn) ownSpells = acInit::loadSpells();
  237.                                 else acUtils::disableDemoMode();
  238.                         }
  239.                         break;
  240.                 }
  241.         }
  242.         void sendAOEPacket(int8 senderPlayerID, uint8 spellID) {
  243.                 jjSTREAM packet;
  244.                 packet.push(senderPlayerID);
  245.                 packet.push(uint8(PACKET_AOE));
  246.                 packet.push(spellID);
  247.                 jjSendPacket(packet);
  248.         }
  249.  
  250.         void sendSkillPacket(int8 senderPlayerID, uint8 skill) {
  251.                 jjSTREAM packet;
  252.                 packet.push(senderPlayerID);
  253.                 packet.push(skill);
  254.                 jjSendPacket(packet);
  255.         }
  256.  
  257.         void sendEffectPacket(int8 senderPlayerID, uint8 effectID, int8 targetPlayerID, uint duration) {
  258.                 jjSTREAM packet;
  259.                 packet.push(senderPlayerID); //This is always jjLocalPlayers[0].playerID, unless it is a forwarded packet by the server
  260.                 packet.push(uint8(PACKET_EFFECT));
  261.                 packet.push(effectID);
  262.                 packet.push(targetPlayerID);
  263.                 packet.push(duration);
  264.                 jjSendPacket(packet);
  265.         }
  266.  
  267.         void sendMassEffectPacket(int8 senderPlayerID, uint8 effectID, int8[] targets, uint duration) {
  268.                 jjSTREAM packet;
  269.                 packet.push(senderPlayerID);
  270.                 packet.push(uint8(PACKET_MASS_EFFECT));
  271.                 packet.push(effectID);
  272.                 packet.push(duration);
  273.                 for (uint i = 0; i < targets.length; i++) {
  274.                         packet.push(targets[i]);
  275.                 }
  276.                 jjSendPacket(packet);
  277.         }
  278.  
  279.         void sendChannelingStartedPacket(int8 senderPlayerID, uint8 spellEnumValue) {
  280.                 if (jjGameState == GAME::STOPPED) return;
  281.                 jjSTREAM packet;
  282.                 packet.push(senderPlayerID);
  283.                 packet.push(uint8(PACKET_CHANNELING_STARTED));
  284.                 packet.push(spellEnumValue);
  285.                 jjSendPacket(packet);
  286.         }
  287.  
  288.         void sendChannelingStoppedPacket(int8 senderPlayerID) {
  289.                 jjSTREAM packet;
  290.                 packet.push(senderPlayerID);
  291.                 packet.push(uint8(PACKET_CHANNELING_STOPPED));
  292.                 jjSendPacket(packet);
  293.         }
  294.  
  295.         void sendPlayerDeadPacket(int8 senderPlayerID) {
  296.                 jjSTREAM packet;
  297.                 packet.push(senderPlayerID);
  298.                 packet.push(uint8(PACKET_PLAYER_DEAD));
  299.                 jjSendPacket(packet);
  300.         }
  301.  
  302.         void sendChainLightningPacketToServer(int8 playerID, int8[] targets) {
  303.                 jjSTREAM packet;
  304.                 packet.push(playerID);
  305.                 packet.push(uint8(PACKET_CHAIN_LIGHTNING_SERVER));
  306.                 for (uint i = 0; i < targets.length; i++) {
  307.                         packet.push(targets[i]);
  308.                 }
  309.                 jjSendPacket(packet);
  310.         }
  311.  
  312.         void sendChainLightningPacketToClients(int8 playerID, array<ChainLightningTarget@> chainLightningTargets) {
  313.                 jjSTREAM packet;
  314.                 packet.push(playerID);
  315.                 packet.push(uint8(PACKET_CHAIN_LIGHTNING_CLIENT));
  316.                 for (uint i = 0; i < chainLightningTargets.length; i++) {
  317.                         ChainLightningTarget@ target = chainLightningTargets[i];
  318.                         packet.push(target.id);
  319.                         packet.push(target.parentID);
  320.                         packet.push(target.playerID);
  321.                 }
  322.                 jjSendPacket(packet);
  323.         }
  324.  
  325.         void sendWallOfFirePacket(int8 playerID, float xOrigin, float yOrigin, int height) {
  326.                 jjSTREAM packet;
  327.                 packet.push(playerID);
  328.                 packet.push(uint8(PACKET_WALL_OF_FIRE));
  329.                 packet.push(xOrigin);
  330.                 packet.push(yOrigin);
  331.                 packet.push(height);
  332.                 jjSendPacket(packet);
  333.         }
  334.  
  335.         void sendCaptureGemMinePacket(int8 playerID) {
  336.                 jjSTREAM packet;
  337.                 packet.push(playerID);
  338.                 packet.push(uint8(PACKET_CAPTURE_GEM_MINE));
  339.                 jjSendPacket(packet, -jjPlayers[playerID].clientID);
  340.         }
  341.  
  342.         void sendReqSyncDataPacket() {
  343.                 jjSTREAM packet;
  344.                 packet.push(jjLocalPlayers[0].playerID);
  345.                 packet.push(uint8(PACKET_REQ_SYNC_DATA));
  346.                 jjSendPacket(packet);
  347.         }
  348.  
  349.         void sendEffectData(int clientID) {
  350.                 jjSTREAM packet;
  351.                 packet.push(jjLocalPlayers[0].playerID);
  352.                 packet.push(uint8(PACKET_SYNC_EFFECTS));
  353.                 for (uint i = 0; i < 32; i++) {
  354.                         jjPLAYER@ play = jjPlayers[i];
  355.                         if (play.isInGame) {
  356.                                 Player@ asPlayer = players[play.playerID];
  357.                                 for (uint j = 0; j < asPlayer.activeEffects.length; j++) {
  358.                                         Effect@ effect = asPlayer.activeEffects[j];
  359.                                         packet.push(play.playerID);
  360.                                         packet.push(uint8(effect.enumValue));
  361.                                         packet.push(effect.elapsed);
  362.                                 }
  363.                         }
  364.                 }
  365.                 jjSendPacket(packet, clientID);
  366.         }
  367.  
  368.         void sendSkillData(int clientID) {
  369.                 jjSTREAM packet;
  370.                 packet.push(jjLocalPlayers[0].playerID);
  371.                 packet.push(uint8(PACKET_SYNC_SKILLS));
  372.                 for (uint i = 0; i < 32; i++) {
  373.                         jjPLAYER@ play = jjPlayers[i];
  374.                         if (play.isInGame) {
  375.                                 Player@ asPlayer = players[play.playerID];
  376.                                 packet.push(play.playerID);
  377.                                 packet.push(asPlayer.spellDamageBonus);
  378.                                 packet.push(asPlayer.magicResist);
  379.                         }
  380.                 }
  381.                 jjSendPacket(packet, clientID);
  382.         }
  383.  
  384.         void sendWallOfFireData(int clientID) {
  385.                 jjSTREAM packet;
  386.                 packet.push(jjLocalPlayers[0].playerID);
  387.                 packet.push(uint8(PACKET_SYNC_WALLS_OF_FIRE));
  388.                 for (uint i = 0; i < activeWallsOfFire.length; i++) {
  389.                         WallOfFire@ wallOfFire = activeWallsOfFire[i];
  390.                         packet.push(wallOfFire.caster.playerID);
  391.                         packet.push(wallOfFire.xOrigin);
  392.                         packet.push(wallOfFire.yOrigin);
  393.                         packet.push(wallOfFire.height);
  394.                         packet.push(wallOfFire.elapsed);
  395.                 }
  396.                 jjSendPacket(packet, clientID);
  397.         }
  398.  
  399.         void sendGemMineOwnerData(int clientID) {
  400.                 jjSTREAM packet;
  401.                 packet.push(gemMine.ownerID);
  402.                 packet.push(uint8(PACKET_SYNC_GEM_MINE));
  403.                 packet.push(gemMine.lockElapsed);
  404.                 jjSendPacket(packet, clientID);
  405.         }
  406.  
  407.         void sendDemoModeData(int clientID) {
  408.                 jjSTREAM packet;
  409.                 packet.push(jjLocalPlayers[0].playerID);
  410.                 packet.push(uint8(PACKET_SYNC_DEMO_MODE));
  411.                 packet.push(demoModeOn);
  412.                 jjSendPacket(packet, clientID);
  413.         }
  414. }