TNT-MOD [Мод Взрывчатых Веществ]

[ZloyPetrushkO]

тэкс, посмарел цепочку.
в общем бомба летит летит летит и встречаеться с землей. происходят всякие перетурьации, и запускаеться вот что

protected void doExplosion(Actor actor, String s, Point3d point3d) {
/* 250*/        Class class1 = getClass();
/* 251*/        float f = Property.floatValue(class1, "power", 1000F);
/* 252*/        int i = Property.intValue(class1, "powerType", 0);
/* 253*/        float f1 = Property.floatValue(class1, "radius", 150F);
/* 254*/        MsgExplosion.send(actor, s, point3d, getOwner(), M, f, i, f1);
/* 256*/        ActorCrater.initOwner = getOwner();
/* 257*/        Explosions.generate(actor, point3d, f, i, f1);
/* 258*/        ActorCrater.initOwner = null;
/* 260*/        destroy();
            }

explosions generate отвечает за визуальные эффекты, нам мало интересно

нас интересует

MsgExplosion.send

вот он:

{
00024         explosion.chunkName = s;
00025         explosion.p.set(point3d);
00026         explosion.radius = f2;
00027         explosion.initiator = actor1;
00028         explosion.power = f1;
00029         explosion.powerType = i;
00030         if(i == 1)
00031             explosion.computeSplinterParams(f);
00032         if(!Actor.isValid(actor1) && Mission.isSingle() && (Mission.cur().netObj() == null || Mission.cur().netObj().isMaster()))
00033             explosion.initiator = actor1 = Engine.actorLand();
00034         if(!Actor.isValid(actor1))
00035             return;
00036         if(actor1.isNet() && actor1.net.isMirror())
00037             return;
00038         if(Actor.isValid(actor))
00039         {
00040             msg.setListener(actor);
00041             msg.send();
00042         }
00043         if(f2 <= 0.0F)
00044             return;
00045         Engine.collideEnv().getSphere(lst, point3d, f2);
00046         int j = lst.size();
00047         if(j <= 0)
00048             return;
00049         explosion.chunkName = null;
00050         for(int k = 0; k < j; k++)
00051         {
00052             Actor actor2 = (Actor)lst.get(k);
00053             if(Actor.isValid(actor2) && actor != actor2)
00054             {
00055                 msg.setListener(actor2);
00056                 msg.send();
00057             }
00058         }
00059 
00060         lst.clear();
00061     }

а вот тута запускаецца собна и обсчитываеться сам взрыв.
выделено- там где powertype 1 запускаеться 1 лишний метод(условно моно перевести как "пересчет осколков", т.е. вычисление кол-ва осколков. так что есть разделение )

правда пока неизвестно, рассчитываеться ли повреждение от осколков...мб ето токо заготовка

а вот собсна сам код взырвов:

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
00002 // Jad home page: http://www.kpdus.com/jad.html
00003 // Decompiler options: packimports(3) 
00004 // Source File Name:   Explosion.java
00005 
00006 package com.maddox.il2.ai;
00007 
00008 import com.maddox.JGP.Point3d;
00009 import com.maddox.il2.engine.*;
00010 
00011 // Referenced classes of package com.maddox.il2.ai:
00012 //            World, RangeRandom
00013 
00014 public class Explosion
00015 {
00016 
00017     public Explosion()
00018     {
00019         p = new Point3d();
00020     }
00021 
00022     void computeSplinterParams(float f)
00023     {
00024         float f1 = f * 0.9F;
00025         nSplinters = f1 / 0.015F;
00026         if(nSplinters < 0.5F)
00027         {
00028             nSplinters = 0.0F;
00029             return;
00030         } else
00031         {
00032             return;
00033         }
00034     }
00035 
00036     public float computeSplinterSpeed(float f)
00037     {
00038         if(f <= 0.01F)
00039             return 650F;
00040         if(f >= radius)
00041         {
00042             return 150F;
00043         } else
00044         {
00045             float f1 = f / radius;
00046             return 650F * (1.0F - f1) + 150F * f1;
00047         }
00048     }
00049 
00050     public void computeSplintersHit(Point3d point3d, float f, float f1, float af[])
00051     {
00052         float f2 = (float)point3d.distance(p) - f;
00053         if(f2 <= 0.001F)
00054         {
00055             af[0] = nSplinters * 0.5F;
00056             af[1] = computeSplinterSpeed(f2);
00057         }
00058         float f3 = 3.141593F * f * f;
00059         float f4 = 12.56637F * f2 * f2;
00060         float f5 = (nSplinters * f3) / f4;
00061         if(f5 >= nSplinters * 0.5F)
00062             f5 = nSplinters * 0.5F;
00063         af[0] = f5;
00064         af[1] = computeSplinterSpeed(f2);
00065     }
00066 
00067     public boolean isMirage()
00068     {
00069         if(!Actor.isValid(initiator))
00070             return true;
00071         else
00072             return initiator.isNetMirror();
00073     }
00074 
00075     public float receivedPower(ActorMesh actormesh)
00076     {
00077         float f = actormesh.collisionR();
00078         float f1 = (float)((Actor) (actormesh)).pos.getAbsPoint().distance(p);
00079         f1 -= f;
00080         if(f1 >= radius)
00081             return 0.0F;
00082         float f2 = 1.0F - f1 / radius;
00083         f2 *= f2;
00084         if(f2 >= 1.0F)
00085             return power;
00086         else
00087             return f2 * power;
00088     }
00089 
00090     public float receivedTNT_1meter(float f)
00091     {
00092         if(f >= radius)
00093             return 0.0F;
00094         if(f < 1.0F)
00095             return power;
00096         else
00097             return power / (f * f);
00098     }
00099 
00100     public float receivedTNT_1meter(Point3d point3d, float f)
00101     {
00102         float f1 = (float)point3d.distance(p) - f;
00103         return receivedTNT_1meter(f1);
00104     }
00105 
00106     public float receivedTNT_1meter(ActorMesh actormesh)
00107     {
00108         float f = (float)((Actor) (actormesh)).pos.getAbsPoint().distance(p) - actormesh.collisionR();
00109         return receivedTNT_1meter(f);
00110     }
00111 
00112     public float receivedTNTpower(ActorMesh actormesh)
00113     {
00114         float f = actormesh.collisionR();
00115         float f1 = (float)((Actor) (actormesh)).pos.getAbsPoint().distance(p) - f;
00116         if(f1 <= 0.0F)
00117             return 0.5F * power;
00118         float f2 = 1.0F / (float)Math.pow(f1, 1.2000000476837158D);
00119         if(f2 <= 0.0F)
00120             return 0.0F;
00121         if(f2 >= 0.5F)
00122             f2 = 0.5F;
00123         return f2 * power;
00124     }
00125 
00126     public static boolean killable(ActorMesh actormesh, float f, float f1, float f2, float f3)
00127     {
00128         float f4 = f;
00129         if(f4 <= f1)
00130             return false;
00131         if(f4 >= f2)
00132         {
00133             return true;
00134         } else
00135         {
00136             float f5 = (f4 - f1) / (f2 - f1);
00137             f3 += (1.0F - f3) * f5;
00138             return World.Rnd().nextFloat(0.0F, 1.0F) < f3;
00139         }
00140     }
00141 
00142     public static final int POWER_SPLASH = 0;
00143     public static final int POWER_SPLINTERS = 1;
00144     public static final int POWER_NAPALM = 2;
00145     public static final float SPLINTER_MASS = 0.015F;
00146     private static final float SPLINTERS_K = 0.9F;
00147     public String chunkName;
00148     public Point3d p;
00149     public float radius;
00150     public Actor initiator;
00151     public float power;
00152     public int powerType;
00153     private float nSplinters;
00154 
00155 }

собсна вот ото всего вот етого можете отталкиваеться...вот формулы моделирования взрыва в игре...сами формулы моно если что подрихтовать
исходя из этого и стоитпересчитывать пармеетры бомб
по воводу добавлений. скажу сразу, ето можно делать только В КРАЙНЕМ случае, если ето координально меняет картину. ибо сделать можно, но работы много( грю про ся, мб программер опытнее лучше сделает)