Downloads containing lockOnMissile.asc

Downloads
Name Author Game Mode Rating
TSF with JJ2+ Only: Anniversary Bash 22 levels Jazz2Online Multiple N/A Download file
JJ2+ Only: Tech Tree Violet CLM Capture the flag 7.8 Download file
Custom Weapons...Featured Download Violet CLM Other 10 Download file

File preview

  1. #pragma require "lockOnMissile.asc"
  2. #pragma require "lockOnMissile.j2a"
  3. #pragma offer "lock-on.wav"
  4. #include "MLLE-Weapons.asc"
  5.  
  6. /***Lock-on Missile**/
  7. /**Author: szmol96**/
  8.  
  9. namespace SzmolWeaponPack {
  10.         namespace LockOnMissile {
  11.                 class PlayerX {
  12.                         int prevClosest = 0;
  13.                         int missileCounter = 0;
  14.                         uint mCounterDelay = 0;
  15.                 }
  16.                 array<PlayerX> PlayersX(jjLocalPlayerCount);
  17.                 array<int> closestPlayers(32, -1); //needed even for non-local players
  18.                
  19.                 class Weapon : MLLEWeapons::WeaponInterface {
  20.                         Weapon() {
  21.                                 super(
  22.                                         regularObjectTemplate: MLLEWeapons::ObjectTemplate(
  23.                                                 xSpeed: 7,
  24.                                                 animSpeed: 2,
  25.                                                 curAnim: 0
  26.                                         ),
  27.                                         powerupObjectTemplate: MLLEWeapons::ObjectTemplate(
  28.                                                 xSpeed: 7.5,
  29.                                                 animSpeed: 3,
  30.                                                 curAnim: 1,
  31.                                                 doesHurt: 8
  32.                                         ),
  33.                                         sampleFilenames: array<string> = {"lock-on.wav"},
  34.                                         animSetFilename: "lockOnMissile.j2a",
  35.                                         pickupAnimation: 3,
  36.                                         poweredUpPickupAnimation: 4,
  37.                                         powerupAnimation: 5,
  38.                                         style: WEAPON::MISSILE,
  39.                                         traits: se::weapon_default_traits,
  40.                                         onDrawAmmo: se::DrawingCallback(DrawMissiles),
  41.                                         onMain: TrackNearestPlayers,
  42.                                         onPlayer: se::PlayerCallback(DoLockOnTarget),
  43.                                         weaponHookRequired: false, //it can get by
  44.                                         behavior: function(obj, powerup) { obj.behavior = Behavior; }
  45.                                 );
  46.                         }
  47.                
  48.                         bool DrawMissiles(jjPLAYER@ p, jjCANVAS@ canvas, const jjANIMATION@) const {
  49.                                 for (int i = 0; i != PlayersX[p.localPlayerID].missileCounter; ++i)
  50.                                         canvas.drawSprite(jjSubscreenWidth - 64, jjSubscreenHeight - 32 - i * 8, SetID,2,1, (i % 2 == 0) ? 1 : -1);
  51.                                 return false;
  52.                         }
  53.                         void DoLockOnTarget(jjPLAYER@ p, int number) {
  54.                                 const int closestID = closestPlayers[p.playerID];
  55.                                 PlayerX@ px = PlayersX[p.localPlayerID];
  56.                                
  57.                                 if (int(p.currWeapon) == number) {
  58.                                         if (closestID >= 0) {
  59.                                                 const jjPLAYER@ target = jjPlayers[closestID];
  60.                                                 jjDrawSprite(target.xPos, target.yPos, SetID,2,0, 0, SPRITE::NORMAL,0, 1,4, p.playerID);
  61.                                                 if (SamplesLoaded[0] && closestID != px.prevClosest)
  62.                                                         jjSample(p.xPos, p.yPos, Samples[0]);
  63.                                         }
  64.                                                
  65.                                         if (p.keyFire) {
  66.                                                 if (px.mCounterDelay++ > 70 && px.mCounterDelay % 17 == 0 && px.missileCounter < 8 && px.missileCounter < p.ammo[WEAPON::CURRENT])
  67.                                                         px.missileCounter += 1;
  68.                                         } else {
  69.                                                 if (px.missileCounter > 0) {
  70.                                                         for (int i = 0; i < px.missileCounter; ++i)
  71.                                                                 p.fireBullet(number, true, true, i * 6.2831853 / px.missileCounter);
  72.                                                         px.missileCounter = 0;
  73.                                                         p.keySelect = p.ammo[WEAPON::CURRENT] == 0;
  74.                                                 }
  75.                                                 px.mCounterDelay = 0;
  76.                                         }
  77.                                 }
  78.                                
  79.                                 px.prevClosest = closestID;
  80.                         }
  81.                 }
  82.                
  83.                 void TrackNearestPlayers(int) {
  84.                         if (jjGameMode <= GAME::COOP)
  85.                                 return;
  86.                         jjOBJ@ bogus = jjObjects[0];
  87.                         bogus.creator = CREATOR::PLAYER;
  88.                         for (uint playerID = 0; playerID < 32; ++playerID, ++bogus.creator) {
  89.                                 const jjPLAYER@ p = jjPlayers[playerID];
  90.                                 if (p.isInGame) {
  91.                                         bogus.xPos = p.xPos;
  92.                                         bogus.yPos = p.yPos;
  93.                                         closestPlayers[playerID] = MLLEWeapons::HelpfulBulletFunctions::GetNearestEnemyPlayer(bogus, 450);
  94.                                 }
  95.                         }
  96.                 }
  97.  
  98.                 void Behavior(jjOBJ@ obj) {
  99.                         if (obj.state == STATE::START) {
  100.                                 obj.points = int(atan2(obj.xSpeed, obj.ySpeed) * 162.974636 /*+ (jjCos(jjRandom() % 512) * 10)*/); //angle
  101.                                 obj.state = STATE::FLY;
  102.                                 obj.xSpeed += obj.var[7] / 65536.f;
  103.                         } else if (obj.age > 17) { //redirect
  104.                                 array<float>@ target = null;
  105.                                 if (obj.creatorType == CREATOR::PLAYER && jjGameMode > GAME::COOP) {
  106.                                         const int targetPlayerID = closestPlayers[obj.creatorID]; //closest to player who fired this
  107.                                         if (targetPlayerID >= 0)
  108.                                                 @target = array<float> = { jjPlayers[targetPlayerID].xPos, jjPlayers[targetPlayerID].yPos };
  109.                                 }
  110.                                 if (target is null)
  111.                                         @target = MLLEWeapons::HelpfulBulletFunctions::GetNearestEnemyPosition(obj, 450); //closest to bullet itself... this part is new to the .asc reimplementation
  112.                                
  113.                                 if (target !is null) {
  114.                                         int difference = ((int(atan2(obj.xPos - target[0], obj.yPos - target[1]) * 162.974636) + 512 - obj.points) & 1023);
  115.                                         if (difference >= 512) difference -= 1024;
  116.                                         obj.points += difference / 8;
  117.                                         const float speed = MLLEWeapons::HelpfulBulletFunctions::IsPowerup(obj) ? 7.5f : 7;
  118.                                         obj.xSpeed = speed * jjSin(obj.points);
  119.                                         obj.ySpeed = speed * jjCos(obj.points);
  120.                                 }
  121.                         }
  122.                        
  123.                         obj.xPos += obj.xSpeed;
  124.                         obj.yPos += obj.ySpeed;
  125.                         ++obj.age;
  126.                        
  127.                         if (obj.age > 105 || obj.state == STATE::EXPLODE || MLLEWeapons::HelpfulBulletFunctions::MaskedPixel(obj)) {
  128.                                 for (uint8 i = 0; i < 10; ++i) {
  129.                                         jjPARTICLE@ spark1 = jjAddParticle(PARTICLE::SPARK);
  130.                                         if (spark1 !is null) {
  131.                                                 spark1.spark.color = 32 + obj.doesHurt;
  132.                                                 spark1.spark.colorDelta = 1;
  133.                                                 spark1.spark.colorStop = 38 + obj.doesHurt;
  134.                                                 spark1.xPos = obj.xPos;
  135.                                                 spark1.yPos = obj.yPos;
  136.                                                 spark1.xSpeed = obj.xSpeed / 3 + (jjCos(jjRandom() % 512));
  137.                                                 spark1.ySpeed = obj.ySpeed / 3 + (jjCos(jjRandom() % 512));
  138.                                         }
  139.                                 }
  140.                                 obj.delete();
  141.                         } else {
  142.                                 jjAddObject(OBJECT::EXPLOSION, obj.xPos, obj.yPos, obj.objectID, CREATOR::OBJECT, missileTrail);
  143.                                 obj.draw();
  144.                         }
  145.                 }
  146.                 void missileTrail(jjOBJ@ trail) {
  147.                         if (trail.state == STATE::START) {
  148.                                 trail.age = 0;
  149.                                 trail.curAnim = jjObjects[trail.creatorID].curAnim;
  150.                                 trail.direction = jjObjects[trail.creatorID].direction;
  151.                                 trail.lightType = LIGHT::NONE;
  152.                                 trail.playerHandling = HANDLING::EXPLOSION;
  153.                                 trail.state = STATE::FLY;
  154.                         }
  155.                        
  156.                         if (trail.age > 15)
  157.                                 trail.delete();
  158.                         else
  159.                                 jjDrawSpriteFromCurFrame(trail.xPos, trail.yPos, jjAnimations[trail.curAnim] + (trail.age++ / 3), trail.direction, SPRITE::TRANSLUCENT);
  160.                 }
  161.         }
  162. }