12496

SKILLAPI里粒子动画效果(particle animation)中，有着角度angle的选项。
它可以让粒子在2D平面上生成，但是做不到在3D平面中做出立体的圆环形
另外skllapi作者写的代码计算机图形没学过的我也读不懂
只是知道球形生成是通过两个for循环套里面搞出来的
若能解决，必定重谢 我QQ1250447239
  1. //
  2. // Source code recreated from a .class file by IntelliJ IDEA
  3. // (powered by Fernflower decompiler)
  4. //

  6. package com.sucy.skill.dynamic.mechanic;

  8. import com.sucy.skill.SkillAPI;
  9. import com.sucy.skill.api.util.ParticleHelper;
  10. import java.util.Iterator;
  11. import java.util.List;
  12. import org.bukkit.Location;
  13. import org.bukkit.entity.LivingEntity;
  14. import org.bukkit.scheduler.BukkitRunnable;
  15. import org.bukkit.util.Vector;

  17. public class ParticleAnimationMechanic extends MechanicComponent {
  18.     public ParticleAnimationMechanic() {
  19.     }

  21.     public String getKey() {
  22.         return "particle animation";
  23.     }

  25.     public boolean execute(LivingEntity caster, int level, List<LivingEntity> targets) {
  26.         if (targets.size() == 0) {
  27.             return false;
  28.         } else {
  29.             this.settings.set("level", level);
  30.             double ht = this.parseValues(caster, "h-translation", level, 0.0D);
  31.             double vt = this.parseValues(caster, "v-translation", level, 0.0D);
  32.             double dr = this.parseValues(caster, "duration", level, 3.0D);
  33.             double radius = this.parseValues(caster, "radius", level, 3.0D);
  34.             int particles = (int)this.parseValues(caster, "particles", level, 10.0D);
  35.             new ParticleAnimationMechanic.ParticleTask(caster, targets, level, ht, vt, dr, radius, particles);
  36.             return targets.size() > 0;
  37.         }
  38.     }

  40.     private class ParticleTask extends BukkitRunnable {
  41.         private List<LivingEntity> targets;
  42.         private double[] rots;
  43.         private Vector offset;
  44.         private Vector dir;
  45.         private double forward;
  46.         private double right;
  47.         private double upward;
  48.         private int steps;
  49.         private int freq;
  50.         private int angle;
  51.         private int startAngle;
  52.         private int duration;
  53.         private int life;
  54.         private int hc;
  55.         private int vc;
  56.         private int hl;
  57.         private int vl;
  58.         private double ht;
  59.         private double vt;
  60.         private double radius;
  61.         private double cos;
  62.         private double sin;
  63.         private int particles;
  64.         int step = 0;

  66.         public ParticleTask(LivingEntity caster, List<LivingEntity> targets, int level, double ht, double vt, double dr, double radius, int particles) {
  67.             this.targets = targets;
  68.             this.forward = ParticleAnimationMechanic.this.settings.getDouble("forward", 0.0D);
  69.             this.upward = ParticleAnimationMechanic.this.settings.getDouble("upward", 0.0D);
  70.             this.right = ParticleAnimationMechanic.this.settings.getDouble("right", 0.0D);
  71.             this.steps = ParticleAnimationMechanic.this.settings.getInt("steps", 1);
  72.             this.freq = (int)(ParticleAnimationMechanic.this.settings.getDouble("frequency", 1.0D) * 20.0D);
  73.             this.angle = ParticleAnimationMechanic.this.settings.getInt("angle", 0);
  74.             this.startAngle = ParticleAnimationMechanic.this.settings.getInt("start", 0);
  75.             this.duration = this.steps * (int)(20.0D * dr);
  76.             this.life = 0;
  77.             this.hc = ParticleAnimationMechanic.this.settings.getInt("h-cycles", 1);
  78.             this.vc = ParticleAnimationMechanic.this.settings.getInt("v-cycles", 1);
  79.             this.ht = ht;
  80.             this.vt = vt;
  81.             this.hl = this.duration / this.hc;
  82.             this.vl = this.duration / this.vc;
  83.             this.cos = Math.cos((double)this.angle * 3.141592653589793D / (double)(180 * this.duration));
  84.             this.sin = Math.sin((double)this.angle * 3.141592653589793D / (double)(180 * this.duration));
  85.             this.rots = new double[targets.size() * 2];
  86.             this.radius = radius;
  87.             this.particles = particles;

  89.             for(int i = 0; i < targets.size(); ++i) {
  90.                 Vector dir = ((LivingEntity)targets.get(i)).getLocation().getDirection().setY(0).normalize();
  91.                 this.rots[i * 2] = dir.getX();
  92.                 this.rots[i * 2 + 1] = dir.getZ();
  93.             }

  95.             this.dir = new Vector(1, 0, 0);
  96.             this.offset = new Vector(this.forward, this.upward, this.right);
  97.             double sc = Math.cos((double)this.startAngle * 3.141592653589793D / 180.0D);
  98.             double ss = Math.sin((double)this.startAngle * 3.141592653589793D / 180.0D);
  99.             this.rotate(this.offset, sc, ss);
  100.             this.rotate(this.dir, sc, ss);
  101.             SkillAPI.schedule(this, 0, 1);
  102.         }

  104.         public void run() {
  105.             ++this.step;
  106.             if (this.step >= this.freq) {
  107.                 this.step = 0;

  109.                 try {
  110.                     for(int i = 0; i < this.steps; ++i) {
  111.                         int j = 0;
  112.                         Iterator var3 = this.targets.iterator();

  114.                         while(var3.hasNext()) {
  115.                             LivingEntity target = (LivingEntity)var3.next();
  116.                             Location tlc = target.getLocation();
  117.                             this.rotate(this.offset, this.rots[j], this.rots[j + 1]);
  118.                             tlc.add(this.offset);


  121.                             ParticleHelper.play(tlc, ParticleAnimationMechanic.this.settings,target.getLocation());
  122.                             tlc.subtract(this.offset);
  123.                             this.rotate(this.offset, this.rots[j++], -this.rots[j++]);
  124.                         }

  126.                         ++this.life;
  127.                         this.rotate(this.offset, this.cos, this.sin);
  128.                         this.rotate(this.dir, this.cos, this.sin);
  129.                         double dx = this.radAt(this.life) - this.radAt(this.life - 1);
  130.                         this.offset.setX(this.offset.getX() + dx * this.dir.getX());
  131.                         this.offset.setZ(this.offset.getZ() + dx * this.dir.getZ());
  132.                         this.offset.setY(this.upward + this.heightAt(this.life));
  133.                     }
  134.                 } catch (Exception var6) {
  135.                     this.cancel();
  136.                 }

  138.                 if (this.life >= this.duration) {
  139.                     this.cancel();
  140.                 }

  142.             }
  143.         }

  145.         private double heightAt(int step) {
  146.             return this.vt * (double)(this.vl - Math.abs(this.vl - step % (2 * this.vl))) / (double)this.vl;
  147.         }

  149.         private double radAt(int step) {
  150.             return this.ht * (double)(this.hl - Math.abs(this.hl - step % (2 * this.hl))) / (double)this.hl;
  151.         }

  153.         private void rotate(Vector vec, double cos, double sin) {
  154.             double x = vec.getX() * cos - vec.getZ() * sin;
  155.             vec.setZ(vec.getX() * sin + vec.getZ() * cos);
  156.             vec.setX(x);
  157.         }
  158.     }
  159. }
复制代码


粘兽
你可以看看莫老的粒子教程
里面有说如何绘制一个3D的球
https://www.jianshu.com/p/d5af0392194c
William_Shi
粘兽 发表于 2020-10-29 01:34
你可以看看莫老的粒子教程
里面有说如何绘制一个3D的球
https://www.jianshu.com/p/d5af0392194c ...

我考虑的是先画一个xy平面的圆，再把这个圆上每一个点通过向量操作全部绕中心旋转一圈达到绘制xz平面的圆的效果，但是这样做我不会算怎么画一个与xz平面有夹角的圆，考虑了如何上下变化向量，但是绕垂直轴旋转后是不是还需要进行y轴上的移动确保起点在中心坐标？有点想不通了。
602723113
https://github.com/602723113/Par ... pobject/Sphere.java

可以来看看这个的代码，可以生成出一个致密的球
zwmsPVP
。。。。。。。
zwmsPVP
其实命令方块也能还原
zwmsPVP
。。。。。
npcman001
粒子，向量运算，角度运算。。。。