ProjectileMovement Class

​

@Component
export default class Example_ProjectileMovement_Destroy extends Script {

   protected async onStart(): Promise<void> {

       // 下列逻辑在服务端执行
       if(SystemUtil.isServer()) {

           // 创建一个模型数组balls和标识curBall。
           let balls = new Array<Model>();
           let curBall = 0;

           // 在前方异步生成5个球，放入数组balls中。
           for (let i = 0;
i < 5;
i++) {
               let ball = await GameObject.asyncSpawn("84121") as Model;
               ball.worldTransform.position = new Vector(200, i * 100, 25);
               ball.name = "ball" + i;
               ball.setCollision(CollisionStatus.QueryCollisionOnly);
               balls.push(ball);
           }

           // 创建投掷物。
           let projectile = new ProjectileMovement(balls[curBall]);

           // 设置初始发射速度为1000。
           projectile.initialSpeed = 1000;

           // 给击中委托绑定一个函数，当击中对象是目标时，播放一个击中特效，0.5s后删除目标。
           projectile.onProjectileHit.add((hitGameObject, HitResult) => {
               EffectService.playAtPosition("99599", HitResult.impactPoint, {scale: new Vector(5, 5, 5)});
           });

           // 添加客户端发送的”LAUNCH“事件监听器，将球右前方发射。
           Event.addClientListener("LAUNCH", async (player: Player) => {
               projectile.launch(new Vector(1, 1, 1));
           });

           // 添加客户端发送的”DESTROY“事件监听器，从数组里面删除球对象，并切换投掷物关联的对象。
           Event.addClientListener("DESTROY", async (player: Player) => {
               console.error("DESTROY");
               let deleteBall = projectile.getRelatedGameObject() as Model;
               let deleteIndex = balls.indexOf(deleteBall);
               balls.splice(deleteIndex, 1);
               if(balls.length > 0) {
                   curBall = (deleteIndex) % balls.length;
                   projectile.setRelatedGameObject(balls[curBall]);
                   deleteBall.destroy();
               } else {
                   projectile.destroy(true);
               }
           });
       }

       // 下列逻辑在客户端执行
       if(SystemUtil.isClient()) {
           // 添加一个按键方法：按下按键”1“，向服务端派送一个”LAUNCH“事件，发射球。
           InputUtil.onKeyDown(Keys.One, () => {
               Event.dispatchToServer("LAUNCH");
           });

           // 添加一个按键方法：按下按键”2“，向服务端派送一个”DESTROY“事件，切换至下一个球并删除上一个。
           InputUtil.onKeyDown(Keys.Two, () => {
               Event.dispatchToServer("DESTROY");
           });
       }
   }
}

@Component
export default class Example_ProjectileMovement_Destroy extends Script {

   protected async onStart(): Promise<void> {

       // 下列逻辑在服务端执行
       if(SystemUtil.isServer()) {

           // 创建一个模型数组balls和标识curBall。
           let balls = new Array<Model>();
           let curBall = 0;

           // 在前方异步生成5个球，放入数组balls中。
           for (let i = 0;
i < 5;
i++) {
               let ball = await GameObject.asyncSpawn("84121") as Model;
               ball.worldTransform.position = new Vector(200, i * 100, 25);
               ball.name = "ball" + i;
               ball.setCollision(CollisionStatus.QueryCollisionOnly);
               balls.push(ball);
           }

           // 创建投掷物。
           let projectile = new ProjectileMovement(balls[curBall]);

           // 设置初始发射速度为1000。
           projectile.initialSpeed = 1000;

           // 给击中委托绑定一个函数，当击中对象是目标时，播放一个击中特效，0.5s后删除目标。
           projectile.onProjectileHit.add((hitGameObject, HitResult) => {
               EffectService.playAtPosition("99599", HitResult.impactPoint, {scale: new Vector(5, 5, 5)});
           });

           // 添加客户端发送的”LAUNCH“事件监听器，将球右前方发射。
           Event.addClientListener("LAUNCH", async (player: Player) => {
               projectile.launch(new Vector(1, 1, 1));
           });

           // 添加客户端发送的”DESTROY“事件监听器，从数组里面删除球对象，并切换投掷物关联的对象。
           Event.addClientListener("DESTROY", async (player: Player) => {
               console.error("DESTROY");
               let deleteBall = projectile.getRelatedGameObject() as Model;
               let deleteIndex = balls.indexOf(deleteBall);
               balls.splice(deleteIndex, 1);
               if(balls.length > 0) {
                   curBall = (deleteIndex) % balls.length;
                   projectile.setRelatedGameObject(balls[curBall]);
                   deleteBall.destroy();
               } else {
                   projectile.destroy(true);
               }
           });
       }

       // 下列逻辑在客户端执行
       if(SystemUtil.isClient()) {
           // 添加一个按键方法：按下按键”1“，向服务端派送一个”LAUNCH“事件，发射球。
           InputUtil.onKeyDown(Keys.One, () => {
               Event.dispatchToServer("LAUNCH");
           });

           // 添加一个按键方法：按下按键”2“，向服务端派送一个”DESTROY“事件，切换至下一个球并删除上一个。
           InputUtil.onKeyDown(Keys.Two, () => {
               Event.dispatchToServer("DESTROY");
           });
       }
   }
}

@Component
export default class Example_ProjectileMovement extends Script {

   protected async onStart(): Promise<void> {

       // 下列逻辑在服务端执行
       if(SystemUtil.isServer()) {

           // 创建一个模型数组balls和标识curBall。
           let balls = new Array<Model>();
           let curBall = 0;

           // 在前方异步生成5个球，放入数组balls中。
           for (let i = 0;
i < 5;
i++) {
               let ball = await GameObject.asyncSpawn("84121") as Model;
               ball.worldTransform.position = new Vector(200, i * 100, 25);
               ball.name = "ball" + i;
               ball.setCollision(CollisionStatus.QueryCollisionOnly);
               balls.push(ball);
           }

           // 创建投掷物。
           let projectile = new ProjectileMovement(balls[curBall]);

           // 设置初始发射速度为1000。
           projectile.initialSpeed = 1000;

           // 给击中委托绑定一个函数，当击中对象是目标时，播放一个击中特效，0.5s后删除目标。
           projectile.onProjectileHit.add((hitGameObject, HitResult) => {
               EffectService.playAtPosition("99599", HitResult.impactPoint, {scale: new Vector(5, 5, 5)});
           });

           // 添加客户端发送的”LAUNCH“事件监听器，将球右前方发射。
           Event.addClientListener("LAUNCH", async (player: Player) => {
               projectile.launch(new Vector(1, 1, 1));
           });

           // 添加客户端发送的”DESTROY“事件监听器，从数组里面删除球对象，并切换投掷物关联的对象。
           Event.addClientListener("DESTROY", async (player: Player) => {
               console.error("DESTROY");
               let deleteBall = projectile.getRelatedGameObject() as Model;
               let deleteIndex = balls.indexOf(deleteBall);
               balls.splice(deleteIndex, 1);
               if(balls.length > 0) {
                   curBall = (deleteIndex) % balls.length;
                   projectile.setRelatedGameObject(balls[curBall]);
                   deleteBall.destroy();
               } else {
                   projectile.destroy(true);
               }
           });
       }

       // 下列逻辑在客户端执行
       if(SystemUtil.isClient()) {
           // 添加一个按键方法：按下按键”1“，向服务端派送一个”LAUNCH“事件，发射球。
           InputUtil.onKeyDown(Keys.One, () => {
               Event.dispatchToServer("LAUNCH");
           });

           // 添加一个按键方法：按下按键”2“，向服务端派送一个”DESTROY“事件，切换至下一个球并删除上一个。
           InputUtil.onKeyDown(Keys.Two, () => {
               Event.dispatchToServer("DESTROY");
           });
       }
   }
}

@Component
export default class Example_ProjectileMovement extends Script {

   protected async onStart(): Promise<void> {

       // 下列逻辑在服务端执行
       if(SystemUtil.isServer()) {

           // 创建一个模型数组balls和标识curBall。
           let balls = new Array<Model>();
           let curBall = 0;

           // 在前方异步生成5个球，放入数组balls中。
           for (let i = 0;
i < 5;
i++) {
               let ball = await GameObject.asyncSpawn("84121") as Model;
               ball.worldTransform.position = new Vector(200, i * 100, 25);
               ball.name = "ball" + i;
               ball.setCollision(CollisionStatus.QueryCollisionOnly);
               balls.push(ball);
           }

           // 创建投掷物。
           let projectile = new ProjectileMovement(balls[curBall]);

           // 设置初始发射速度为1000。
           projectile.initialSpeed = 1000;

           // 给击中委托绑定一个函数，当击中对象是目标时，播放一个击中特效，0.5s后删除目标。
           projectile.onProjectileHit.add((hitGameObject, HitResult) => {
               EffectService.playAtPosition("99599", HitResult.impactPoint, {scale: new Vector(5, 5, 5)});
           });

           // 添加客户端发送的”LAUNCH“事件监听器，将球右前方发射。
           Event.addClientListener("LAUNCH", async (player: Player) => {
               projectile.launch(new Vector(1, 1, 1));
           });

           // 添加客户端发送的”DESTROY“事件监听器，从数组里面删除球对象，并切换投掷物关联的对象。
           Event.addClientListener("DESTROY", async (player: Player) => {
               console.error("DESTROY");
               let deleteBall = projectile.getRelatedGameObject() as Model;
               let deleteIndex = balls.indexOf(deleteBall);
               balls.splice(deleteIndex, 1);
               if(balls.length > 0) {
                   curBall = (deleteIndex) % balls.length;
                   projectile.setRelatedGameObject(balls[curBall]);
                   deleteBall.destroy();
               } else {
                   projectile.destroy(true);
               }
           });
       }

       // 下列逻辑在客户端执行
       if(SystemUtil.isClient()) {
           // 添加一个按键方法：按下按键”1“，向服务端派送一个”LAUNCH“事件，发射球。
           InputUtil.onKeyDown(Keys.One, () => {
               Event.dispatchToServer("LAUNCH");
           });

           // 添加一个按键方法：按下按键”2“，向服务端派送一个”DESTROY“事件，切换至下一个球并删除上一个。
           InputUtil.onKeyDown(Keys.Two, () => {
               Event.dispatchToServer("DESTROY");
           });
       }
   }
}

@Component
export default class Example_ProjectileMovement extends Script {

   protected async onStart(): Promise<void> {

       // 下列逻辑在服务端执行
       if(SystemUtil.isServer()) {

           // 在r(2000, 0, 0)生成一个火箭模型。
           let rocket = await GameObject.asyncSpawn("162807") as Model;
           rocket.worldTransform.position = new Vector(2000, 0, 0);

           // 将火箭的碰撞状态修改为无碰撞
           rocket.setCollision(CollisionStatus.Off);

           // 创建投掷物。
           let projectile = new ProjectileMovement(rocket);

           // 设置初始发射速度为1。
           projectile.initialSpeed = 1;
           // 设置最大速度为1000。
           projectile.maxSpeed = 1000;
           // 设置发射加速度为200
           projectile.acceleration = 200;
           // 设置重力缩放为0。
           projectile.gravityScale = 0;
           // 设置投掷物旋转不跟随速度方向。
           projectile.isRotationFollowsVelocity = false;
           // 设置投掷物运动时间10秒。
           projectile.lifeSpan = 10;

           // 添加客户端发送的”LAUNCH“事件监听器，将火箭朝上方发射。
           Event.addClientListener("LAUNCH", async (player: Player) => {
               projectile.launch(new Vector(0, 0, 1));
               // 广播客户端给火箭挂载尾焰特效
               Event.dispatchToAllClient("TAIL", rocket.gameObjectId);
               // 每0.1秒都会给客户端广播火箭当前速度
               let scaleInterval = TimeUtil.setInterval(() => {
                   if(projectile.getVelocity().length > 999) {
                       projectile.setVelocity(Vector.zero);
                       TimeUtil.clearInterval(scaleInterval);
                       rocket.worldTransform.position = new Vector(2000, 0, 0);
                   }
                   Event.dispatchToAllClient("SCALING", rocket.gameObjectId, projectile.getVelocity());
               }, 0.1);
           });
       }

       // 下列逻辑在客户端执行
       if(SystemUtil.isClient()) {
           // 添加一个按键方法：按下按键”1“，向服务端派送一个”LAUNCH“事件，发射火箭
           InputUtil.onKeyDown(Keys.One, () => {
               Event.dispatchToServer("LAUNCH");
           });

           // 添加服务端发送的”TAIL“事件监听器，给火箭挂载尾焰。
           Event.addServerListener("TAIL", async (rocketId: string) => {
               let rocket = await GameObject.asyncFindGameObjectById(rocketId);
               if(typeof(rocket.getChildByName("tail")) != "undefined") {
                   return;
               }
               let tail = await GameObject.asyncSpawn("144098") as Effect;
               tail.name = "tail";
               tail.parent = rocket;
               tail.localTransform.position = Vector.zero;
           });

           // 添加服务端发送的”SCALING“事件监听器，根据速度对尾焰进行缩放
           Event.addServerListener("SCALING", async (rocketId: string, velocity: Vector) => {
               let rocket = await GameObject.asyncFindGameObjectById(rocketId);
               let tail = rocket.getChildByName("tail");
               if(tail) {
                   tail.worldTransform.scale = Vector.one.multiply(velocity.length / 250);
               }
           });
       }
   }
}

@Component
export default class Example_ProjectileMovement extends Script {

   protected async onStart(): Promise<void> {

       // 下列逻辑在服务端执行
       if(SystemUtil.isServer()) {

           // 在r(2000, 0, 0)生成一个火箭模型。
           let rocket = await GameObject.asyncSpawn("162807") as Model;
           rocket.worldTransform.position = new Vector(2000, 0, 0);

           // 将火箭的碰撞状态修改为无碰撞
           rocket.setCollision(CollisionStatus.Off);

           // 创建投掷物。
           let projectile = new ProjectileMovement(rocket);

           // 设置初始发射速度为1。
           projectile.initialSpeed = 1;
           // 设置最大速度为1000。
           projectile.maxSpeed = 1000;
           // 设置发射加速度为200
           projectile.acceleration = 200;
           // 设置重力缩放为0。
           projectile.gravityScale = 0;
           // 设置投掷物旋转不跟随速度方向。
           projectile.isRotationFollowsVelocity = false;
           // 设置投掷物运动时间10秒。
           projectile.lifeSpan = 10;

           // 添加客户端发送的”LAUNCH“事件监听器，将火箭朝上方发射。
           Event.addClientListener("LAUNCH", async (player: Player) => {
               projectile.launch(new Vector(0, 0, 1));
               // 广播客户端给火箭挂载尾焰特效
               Event.dispatchToAllClient("TAIL", rocket.gameObjectId);
               // 每0.1秒都会给客户端广播火箭当前速度
               let scaleInterval = TimeUtil.setInterval(() => {
                   if(projectile.getVelocity().length > 999) {
                       projectile.setVelocity(Vector.zero);
                       TimeUtil.clearInterval(scaleInterval);
                       rocket.worldTransform.position = new Vector(2000, 0, 0);
                   }
                   Event.dispatchToAllClient("SCALING", rocket.gameObjectId, projectile.getVelocity());
               }, 0.1);
           });
       }

       // 下列逻辑在客户端执行
       if(SystemUtil.isClient()) {
           // 添加一个按键方法：按下按键”1“，向服务端派送一个”LAUNCH“事件，发射火箭
           InputUtil.onKeyDown(Keys.One, () => {
               Event.dispatchToServer("LAUNCH");
           });

           // 添加服务端发送的”TAIL“事件监听器，给火箭挂载尾焰。
           Event.addServerListener("TAIL", async (rocketId: string) => {
               let rocket = await GameObject.asyncFindGameObjectById(rocketId);
               if(typeof(rocket.getChildByName("tail")) != "undefined") {
                   return;
               }
               let tail = await GameObject.asyncSpawn("144098") as Effect;
               tail.name = "tail";
               tail.parent = rocket;
               tail.localTransform.position = Vector.zero;
           });

           // 添加服务端发送的”SCALING“事件监听器，根据速度对尾焰进行缩放
           Event.addServerListener("SCALING", async (rocketId: string, velocity: Vector) => {
               let rocket = await GameObject.asyncFindGameObjectById(rocketId);
               let tail = rocket.getChildByName("tail");
               if(tail) {
                   tail.worldTransform.scale = Vector.one.multiply(velocity.length / 250);
               }
           });
       }
   }
}

@Component
export default class Example_ProjectileMovement_Launch extends Script {

   protected async onStart(): Promise<void> {

       // 下列逻辑在服务端执行
       if(SystemUtil.isServer()) {

           // 在世界坐标（200，0，25）异步生成一个球
           let ball = await GameObject.asyncSpawn("84121") as Model;
           ball.worldTransform.position = new Vector(200, 0, 25);
           ball.name = "ball";
           ball.setCollision(CollisionStatus.QueryCollisionOnly);

           // 在世界坐标（1000，0，0）异步生成一面墙
           let wall = await GameObject.asyncSpawn("197386") as Model;
           wall.worldTransform.position = new Vector(1000, 0, 0);
           wall.worldTransform.scale = new Vector(1, 5, 5);
           wall.name = "wall";

           // 创建投掷物。
           let projectile = new ProjectileMovement(ball);

           // 设置初始发射速度为1500。
           projectile.initialSpeed = 1500;
           // 设置重力缩放为1。
           projectile.gravityScale = 1;
           // 设置投掷物旋转跟随速度方向。
           projectile.isRotationFollowsVelocity = true;
           // 设置投掷物碰撞维持速度比例为0.4。
           projectile.speedRetention = 0.4;

           // 给击中委托绑定一个函数，打印击中信息：角色X 发射 对象Y 击中 对象Z，并播放一个击中特效。
           projectile.onProjectileHit.add((hitGameObject, HitResult) => {
               console.log( "Projectile " + projectile.getRelatedGameObject().name + " thrown by Character " + projectile.owner.displayName + " hits the " + hitGameObject.name);
               EffectService.playAtPosition("99599", HitResult.impactPoint);
           });

           // 给投掷物生命结束委托绑定一个函数，播放一个销毁特效。
           projectile.onProjectileLifeEnd.add(() => {
               EffectService.playAtPosition("133276", ball.worldTransform.position);
           });

           // 添加客户端发送的”LAUNCH“事件监听器，将球朝上方发射。
           Event.addClientListener("LAUNCH", async (player: Player) => {
               // 设置owner为玩家角色。
               projectile.owner = player.character;
               projectile.launch(new Vector(1, 0, 1));
           });

           // 添加客户端发送的”PAUSE“事件监听器，将暂停投掷物运动并打印状态。
           Event.addClientListener("PAUSE", async (player: Player) => {
               projectile.pause();
               console.log("Projectile status " + projectile.status);
           });

           // 添加客户端发送的”RESUME“事件监听器，将恢复投掷物运动并打印状态。
           Event.addClientListener("RESUME", async (player: Player) => {
               projectile.resume();
               console.log("Projectile status " + projectile.status);
           });
       }

       // 下列逻辑在客户端执行
       if(SystemUtil.isClient()) {
           // 添加一个按键方法：按下按键”1“，向服务端派送一个”LAUNCH“事件，发射球
           InputUtil.onKeyDown(Keys.One, () => {
               Event.dispatchToServer("LAUNCH");
           });

           // 添加一个按键方法：按下按键”2“，向服务端派送一个”PAUSE“事件，发射球
           InputUtil.onKeyDown(Keys.Two, () => {
               Event.dispatchToServer("PAUSE");
           });

           // 添加一个按键方法：按下按键”3“，向服务端派送一个”RESUME“事件，发射球
           InputUtil.onKeyDown(Keys.Three, () => {
               Event.dispatchToServer("RESUME");
           });
       }
   }
}

@Component
export default class Example_ProjectileMovement_Launch extends Script {

   protected async onStart(): Promise<void> {

       // 下列逻辑在服务端执行
       if(SystemUtil.isServer()) {

           // 在世界坐标（200，0，25）异步生成一个球
           let ball = await GameObject.asyncSpawn("84121") as Model;
           ball.worldTransform.position = new Vector(200, 0, 25);
           ball.name = "ball";
           ball.setCollision(CollisionStatus.QueryCollisionOnly);

           // 在世界坐标（1000，0，0）异步生成一面墙
           let wall = await GameObject.asyncSpawn("197386") as Model;
           wall.worldTransform.position = new Vector(1000, 0, 0);
           wall.worldTransform.scale = new Vector(1, 5, 5);
           wall.name = "wall";

           // 创建投掷物。
           let projectile = new ProjectileMovement(ball);

           // 设置初始发射速度为1500。
           projectile.initialSpeed = 1500;
           // 设置重力缩放为1。
           projectile.gravityScale = 1;
           // 设置投掷物旋转跟随速度方向。
           projectile.isRotationFollowsVelocity = true;
           // 设置投掷物碰撞维持速度比例为0.4。
           projectile.speedRetention = 0.4;

           // 给击中委托绑定一个函数，打印击中信息：角色X 发射 对象Y 击中 对象Z，并播放一个击中特效。
           projectile.onProjectileHit.add((hitGameObject, HitResult) => {
               console.log( "Projectile " + projectile.getRelatedGameObject().name + " thrown by Character " + projectile.owner.displayName + " hits the " + hitGameObject.name);
               EffectService.playAtPosition("99599", HitResult.impactPoint);
           });

           // 给投掷物生命结束委托绑定一个函数，播放一个销毁特效。
           projectile.onProjectileLifeEnd.add(() => {
               EffectService.playAtPosition("133276", ball.worldTransform.position);
           });

           // 添加客户端发送的”LAUNCH“事件监听器，将球朝上方发射。
           Event.addClientListener("LAUNCH", async (player: Player) => {
               // 设置owner为玩家角色。
               projectile.owner = player.character;
               projectile.launch(new Vector(1, 0, 1));
           });

           // 添加客户端发送的”PAUSE“事件监听器，将暂停投掷物运动并打印状态。
           Event.addClientListener("PAUSE", async (player: Player) => {
               projectile.pause();
               console.log("Projectile status " + projectile.status);
           });

           // 添加客户端发送的”RESUME“事件监听器，将恢复投掷物运动并打印状态。
           Event.addClientListener("RESUME", async (player: Player) => {
               projectile.resume();
               console.log("Projectile status " + projectile.status);
           });
       }

       // 下列逻辑在客户端执行
       if(SystemUtil.isClient()) {
           // 添加一个按键方法：按下按键”1“，向服务端派送一个”LAUNCH“事件，发射球
           InputUtil.onKeyDown(Keys.One, () => {
               Event.dispatchToServer("LAUNCH");
           });

           // 添加一个按键方法：按下按键”2“，向服务端派送一个”PAUSE“事件，发射球
           InputUtil.onKeyDown(Keys.Two, () => {
               Event.dispatchToServer("PAUSE");
           });

           // 添加一个按键方法：按下按键”3“，向服务端派送一个”RESUME“事件，发射球
           InputUtil.onKeyDown(Keys.Three, () => {
               Event.dispatchToServer("RESUME");
           });
       }
   }
}

@Component
export default class Example_ProjectileMovement_Launch extends Script {

   protected async onStart(): Promise<void> {

       // 下列逻辑在服务端执行
       if(SystemUtil.isServer()) {

           // 在世界坐标（200，0，25）异步生成一个球
           let ball = await GameObject.asyncSpawn("84121") as Model;
           ball.worldTransform.position = new Vector(200, 0, 25);
           ball.name = "ball";
           ball.setCollision(CollisionStatus.QueryCollisionOnly);

           // 在世界坐标（1000，0，0）异步生成一面墙
           let wall = await GameObject.asyncSpawn("197386") as Model;
           wall.worldTransform.position = new Vector(1000, 0, 0);
           wall.worldTransform.scale = new Vector(1, 5, 5);
           wall.name = "wall";

           // 创建投掷物。
           let projectile = new ProjectileMovement(ball);

           // 设置初始发射速度为1500。
           projectile.initialSpeed = 1500;
           // 设置重力缩放为1。
           projectile.gravityScale = 1;
           // 设置投掷物旋转跟随速度方向。
           projectile.isRotationFollowsVelocity = true;
           // 设置投掷物碰撞维持速度比例为0.4。
           projectile.speedRetention = 0.4;

           // 给击中委托绑定一个函数，打印击中信息：角色X 发射 对象Y 击中 对象Z，并播放一个击中特效。
           projectile.onProjectileHit.add((hitGameObject, HitResult) => {
               console.log( "Projectile " + projectile.getRelatedGameObject().name + " thrown by Character " + projectile.owner.displayName + " hits the " + hitGameObject.name);
               EffectService.playAtPosition("99599", HitResult.impactPoint);
           });

           // 给投掷物生命结束委托绑定一个函数，播放一个销毁特效。
           projectile.onProjectileLifeEnd.add(() => {
               EffectService.playAtPosition("133276", ball.worldTransform.position);
           });

           // 添加客户端发送的”LAUNCH“事件监听器，将球朝上方发射。
           Event.addClientListener("LAUNCH", async (player: Player) => {
               // 设置owner为玩家角色。
               projectile.owner = player.character;
               projectile.launch(new Vector(1, 0, 1));
           });

           // 添加客户端发送的”PAUSE“事件监听器，将暂停投掷物运动并打印状态。
           Event.addClientListener("PAUSE", async (player: Player) => {
               projectile.pause();
               console.log("Projectile status " + projectile.status);
           });

           // 添加客户端发送的”RESUME“事件监听器，将恢复投掷物运动并打印状态。
           Event.addClientListener("RESUME", async (player: Player) => {
               projectile.resume();
               console.log("Projectile status " + projectile.status);
           });
       }

       // 下列逻辑在客户端执行
       if(SystemUtil.isClient()) {
           // 添加一个按键方法：按下按键”1“，向服务端派送一个”LAUNCH“事件，发射球
           InputUtil.onKeyDown(Keys.One, () => {
               Event.dispatchToServer("LAUNCH");
           });

           // 添加一个按键方法：按下按键”2“，向服务端派送一个”PAUSE“事件，发射球
           InputUtil.onKeyDown(Keys.Two, () => {
               Event.dispatchToServer("PAUSE");
           });

           // 添加一个按键方法：按下按键”3“，向服务端派送一个”RESUME“事件，发射球
           InputUtil.onKeyDown(Keys.Three, () => {
               Event.dispatchToServer("RESUME");
           });
       }
   }
}

@Component
export default class Example_ProjectileMovement_Launch extends Script {

   protected async onStart(): Promise<void> {

       // 下列逻辑在服务端执行
       if(SystemUtil.isServer()) {

           // 在世界坐标（200，0，25）异步生成一个球
           let ball = await GameObject.asyncSpawn("84121") as Model;
           ball.worldTransform.position = new Vector(200, 0, 25);
           ball.name = "ball";
           ball.setCollision(CollisionStatus.QueryCollisionOnly);

           // 在世界坐标（1000，0，0）异步生成一面墙
           let wall = await GameObject.asyncSpawn("197386") as Model;
           wall.worldTransform.position = new Vector(1000, 0, 0);
           wall.worldTransform.scale = new Vector(1, 5, 5);
           wall.name = "wall";

           // 创建投掷物。
           let projectile = new ProjectileMovement(ball);

           // 设置初始发射速度为1500。
           projectile.initialSpeed = 1500;
           // 设置重力缩放为1。
           projectile.gravityScale = 1;
           // 设置投掷物旋转跟随速度方向。
           projectile.isRotationFollowsVelocity = true;
           // 设置投掷物碰撞维持速度比例为0.4。
           projectile.speedRetention = 0.4;

           // 给击中委托绑定一个函数，打印击中信息：角色X 发射 对象Y 击中 对象Z，并播放一个击中特效。
           projectile.onProjectileHit.add((hitGameObject, HitResult) => {
               console.log( "Projectile " + projectile.getRelatedGameObject().name + " thrown by Character " + projectile.owner.displayName + " hits the " + hitGameObject.name);
               EffectService.playAtPosition("99599", HitResult.impactPoint);
           });

           // 给投掷物生命结束委托绑定一个函数，播放一个销毁特效。
           projectile.onProjectileLifeEnd.add(() => {
               EffectService.playAtPosition("133276", ball.worldTransform.position);
           });

           // 添加客户端发送的”LAUNCH“事件监听器，将球朝上方发射。
           Event.addClientListener("LAUNCH", async (player: Player) => {
               // 设置owner为玩家角色。
               projectile.owner = player.character;
               projectile.launch(new Vector(1, 0, 1));
           });

           // 添加客户端发送的”PAUSE“事件监听器，将暂停投掷物运动并打印状态。
           Event.addClientListener("PAUSE", async (player: Player) => {
               projectile.pause();
               console.log("Projectile status " + projectile.status);
           });

           // 添加客户端发送的”RESUME“事件监听器，将恢复投掷物运动并打印状态。
           Event.addClientListener("RESUME", async (player: Player) => {
               projectile.resume();
               console.log("Projectile status " + projectile.status);
           });
       }

       // 下列逻辑在客户端执行
       if(SystemUtil.isClient()) {
           // 添加一个按键方法：按下按键”1“，向服务端派送一个”LAUNCH“事件，发射球
           InputUtil.onKeyDown(Keys.One, () => {
               Event.dispatchToServer("LAUNCH");
           });

           // 添加一个按键方法：按下按键”2“，向服务端派送一个”PAUSE“事件，发射球
           InputUtil.onKeyDown(Keys.Two, () => {
               Event.dispatchToServer("PAUSE");
           });

           // 添加一个按键方法：按下按键”3“，向服务端派送一个”RESUME“事件，发射球
           InputUtil.onKeyDown(Keys.Three, () => {
               Event.dispatchToServer("RESUME");
           });
       }
   }
}

@Component
export default class Example_ProjectileMovement_Launch extends Script {

   protected async onStart(): Promise<void> {

       // 下列逻辑在服务端执行
       if(SystemUtil.isServer()) {

           // 在世界坐标（200，0，25）异步生成一个球
           let ball = await GameObject.asyncSpawn("84121") as Model;
           ball.worldTransform.position = new Vector(200, 0, 25);
           ball.name = "ball";
           ball.setCollision(CollisionStatus.QueryCollisionOnly);

           // 在世界坐标（1000，0，0）异步生成一面墙
           let wall = await GameObject.asyncSpawn("197386") as Model;
           wall.worldTransform.position = new Vector(1000, 0, 0);
           wall.worldTransform.scale = new Vector(1, 5, 5);
           wall.name = "wall";

           // 创建投掷物。
           let projectile = new ProjectileMovement(ball);

           // 设置初始发射速度为1500。
           projectile.initialSpeed = 1500;
           // 设置重力缩放为1。
           projectile.gravityScale = 1;
           // 设置投掷物旋转跟随速度方向。
           projectile.isRotationFollowsVelocity = true;
           // 设置投掷物碰撞维持速度比例为0.4。
           projectile.speedRetention = 0.4;

           // 给击中委托绑定一个函数，打印击中信息：角色X 发射 对象Y 击中 对象Z，并播放一个击中特效。
           projectile.onProjectileHit.add((hitGameObject, HitResult) => {
               console.log( "Projectile " + projectile.getRelatedGameObject().name + " thrown by Character " + projectile.owner.displayName + " hits the " + hitGameObject.name);
               EffectService.playAtPosition("99599", HitResult.impactPoint);
           });

           // 给投掷物生命结束委托绑定一个函数，播放一个销毁特效。
           projectile.onProjectileLifeEnd.add(() => {
               EffectService.playAtPosition("133276", ball.worldTransform.position);
           });

           // 添加客户端发送的”LAUNCH“事件监听器，将球朝上方发射。
           Event.addClientListener("LAUNCH", async (player: Player) => {
               // 设置owner为玩家角色。
               projectile.owner = player.character;
               projectile.launch(new Vector(1, 0, 1));
           });

           // 添加客户端发送的”PAUSE“事件监听器，将暂停投掷物运动并打印状态。
           Event.addClientListener("PAUSE", async (player: Player) => {
               projectile.pause();
               console.log("Projectile status " + projectile.status);
           });

           // 添加客户端发送的”RESUME“事件监听器，将恢复投掷物运动并打印状态。
           Event.addClientListener("RESUME", async (player: Player) => {
               projectile.resume();
               console.log("Projectile status " + projectile.status);
           });
       }

       // 下列逻辑在客户端执行
       if(SystemUtil.isClient()) {
           // 添加一个按键方法：按下按键”1“，向服务端派送一个”LAUNCH“事件，发射球
           InputUtil.onKeyDown(Keys.One, () => {
               Event.dispatchToServer("LAUNCH");
           });

           // 添加一个按键方法：按下按键”2“，向服务端派送一个”PAUSE“事件，发射球
           InputUtil.onKeyDown(Keys.Two, () => {
               Event.dispatchToServer("PAUSE");
           });

           // 添加一个按键方法：按下按键”3“，向服务端派送一个”RESUME“事件，发射球
           InputUtil.onKeyDown(Keys.Three, () => {
               Event.dispatchToServer("RESUME");
           });
       }
   }
}

@Component
export default class Example_ProjectileMovement_Launch extends Script {

   protected async onStart(): Promise<void> {

       // 下列逻辑在服务端执行
       if(SystemUtil.isServer()) {

           // 在世界坐标（200，0，25）异步生成一个球
           let ball = await GameObject.asyncSpawn("84121") as Model;
           ball.worldTransform.position = new Vector(200, 0, 25);
           ball.name = "ball";
           ball.setCollision(CollisionStatus.QueryCollisionOnly);

           // 在世界坐标（1000，0，0）异步生成一面墙
           let wall = await GameObject.asyncSpawn("197386") as Model;
           wall.worldTransform.position = new Vector(1000, 0, 0);
           wall.worldTransform.scale = new Vector(1, 5, 5);
           wall.name = "wall";

           // 创建投掷物。
           let projectile = new ProjectileMovement(ball);

           // 设置初始发射速度为1500。
           projectile.initialSpeed = 1500;
           // 设置重力缩放为1。
           projectile.gravityScale = 1;
           // 设置投掷物旋转跟随速度方向。
           projectile.isRotationFollowsVelocity = true;
           // 设置投掷物碰撞维持速度比例为0.4。
           projectile.speedRetention = 0.4;

           // 给击中委托绑定一个函数，打印击中信息：角色X 发射 对象Y 击中 对象Z，并播放一个击中特效。
           projectile.onProjectileHit.add((hitGameObject, HitResult) => {
               console.log( "Projectile " + projectile.getRelatedGameObject().name + " thrown by Character " + projectile.owner.displayName + " hits the " + hitGameObject.name);
               EffectService.playAtPosition("99599", HitResult.impactPoint);
           });

           // 给投掷物生命结束委托绑定一个函数，播放一个销毁特效。
           projectile.onProjectileLifeEnd.add(() => {
               EffectService.playAtPosition("133276", ball.worldTransform.position);
           });

           // 添加客户端发送的”LAUNCH“事件监听器，将球朝上方发射。
           Event.addClientListener("LAUNCH", async (player: Player) => {
               // 设置owner为玩家角色。
               projectile.owner = player.character;
               projectile.launch(new Vector(1, 0, 1));
           });

           // 添加客户端发送的”PAUSE“事件监听器，将暂停投掷物运动并打印状态。
           Event.addClientListener("PAUSE", async (player: Player) => {
               projectile.pause();
               console.log("Projectile status " + projectile.status);
           });

           // 添加客户端发送的”RESUME“事件监听器，将恢复投掷物运动并打印状态。
           Event.addClientListener("RESUME", async (player: Player) => {
               projectile.resume();
               console.log("Projectile status " + projectile.status);
           });
       }

       // 下列逻辑在客户端执行
       if(SystemUtil.isClient()) {
           // 添加一个按键方法：按下按键”1“，向服务端派送一个”LAUNCH“事件，发射球
           InputUtil.onKeyDown(Keys.One, () => {
               Event.dispatchToServer("LAUNCH");
           });

           // 添加一个按键方法：按下按键”2“，向服务端派送一个”PAUSE“事件，发射球
           InputUtil.onKeyDown(Keys.Two, () => {
               Event.dispatchToServer("PAUSE");
           });

           // 添加一个按键方法：按下按键”3“，向服务端派送一个”RESUME“事件，发射球
           InputUtil.onKeyDown(Keys.Three, () => {
               Event.dispatchToServer("RESUME");
           });
       }
   }
}

@Component
export default class Example_ProjectileMovement extends Script {

   protected async onStart(): Promise<void> {

       // 下列逻辑在服务端执行
       if(SystemUtil.isServer()) {

           // 创建一个模型数组balls和标识curBall。
           let balls = new Array<Model>();
           let curBall = 0;

           // 在前方异步生成5个球，放入数组balls中。
           for (let i = 0;
i < 5;
i++) {
               let ball = await GameObject.asyncSpawn("84121") as Model;
               ball.worldTransform.position = new Vector(200, i * 100, 25);
               ball.name = "ball" + i;
               ball.setCollision(CollisionStatus.QueryCollisionOnly);
               balls.push(ball);
           }

           // 创建投掷物。
           let projectile = new ProjectileMovement(balls[curBall]);

           // 设置初始发射速度为1000。
           projectile.initialSpeed = 1000;

           // 给击中委托绑定一个函数，当击中对象是目标时，播放一个击中特效，0.5s后删除目标。
           projectile.onProjectileHit.add((hitGameObject, HitResult) => {
               EffectService.playAtPosition("99599", HitResult.impactPoint, {scale: new Vector(5, 5, 5)});
           });

           // 添加客户端发送的”LAUNCH“事件监听器，将球右前方发射。
           Event.addClientListener("LAUNCH", async (player: Player) => {
               projectile.launch(new Vector(1, 1, 1));
           });

           // 添加客户端发送的”DESTROY“事件监听器，从数组里面删除球对象，并切换投掷物关联的对象。
           Event.addClientListener("DESTROY", async (player: Player) => {
               console.error("DESTROY");
               let deleteBall = projectile.getRelatedGameObject() as Model;
               let deleteIndex = balls.indexOf(deleteBall);
               balls.splice(deleteIndex, 1);
               if(balls.length > 0) {
                   curBall = (deleteIndex) % balls.length;
                   projectile.setRelatedGameObject(balls[curBall]);
                   deleteBall.destroy();
               } else {
                   projectile.destroy(true);
               }
           });
       }

       // 下列逻辑在客户端执行
       if(SystemUtil.isClient()) {
           // 添加一个按键方法：按下按键”1“，向服务端派送一个”LAUNCH“事件，发射球。
           InputUtil.onKeyDown(Keys.One, () => {
               Event.dispatchToServer("LAUNCH");
           });

           // 添加一个按键方法：按下按键”2“，向服务端派送一个”DESTROY“事件，切换至下一个球并删除上一个。
           InputUtil.onKeyDown(Keys.Two, () => {
               Event.dispatchToServer("DESTROY");
           });
       }
   }
}

@Component
export default class Example_ProjectileMovement extends Script {

   protected async onStart(): Promise<void> {

       // 下列逻辑在服务端执行
       if(SystemUtil.isServer()) {

           // 创建一个模型数组balls和标识curBall。
           let balls = new Array<Model>();
           let curBall = 0;

           // 在前方异步生成5个球，放入数组balls中。
           for (let i = 0;
i < 5;
i++) {
               let ball = await GameObject.asyncSpawn("84121") as Model;
               ball.worldTransform.position = new Vector(200, i * 100, 25);
               ball.name = "ball" + i;
               ball.setCollision(CollisionStatus.QueryCollisionOnly);
               balls.push(ball);
           }

           // 创建投掷物。
           let projectile = new ProjectileMovement(balls[curBall]);

           // 设置初始发射速度为1000。
           projectile.initialSpeed = 1000;

           // 给击中委托绑定一个函数，当击中对象是目标时，播放一个击中特效，0.5s后删除目标。
           projectile.onProjectileHit.add((hitGameObject, HitResult) => {
               EffectService.playAtPosition("99599", HitResult.impactPoint, {scale: new Vector(5, 5, 5)});
           });

           // 添加客户端发送的”LAUNCH“事件监听器，将球右前方发射。
           Event.addClientListener("LAUNCH", async (player: Player) => {
               projectile.launch(new Vector(1, 1, 1));
           });

           // 添加客户端发送的”DESTROY“事件监听器，从数组里面删除球对象，并切换投掷物关联的对象。
           Event.addClientListener("DESTROY", async (player: Player) => {
               console.error("DESTROY");
               let deleteBall = projectile.getRelatedGameObject() as Model;
               let deleteIndex = balls.indexOf(deleteBall);
               balls.splice(deleteIndex, 1);
               if(balls.length > 0) {
                   curBall = (deleteIndex) % balls.length;
                   projectile.setRelatedGameObject(balls[curBall]);
                   deleteBall.destroy();
               } else {
                   projectile.destroy(true);
               }
           });
       }

       // 下列逻辑在客户端执行
       if(SystemUtil.isClient()) {
           // 添加一个按键方法：按下按键”1“，向服务端派送一个”LAUNCH“事件，发射球。
           InputUtil.onKeyDown(Keys.One, () => {
               Event.dispatchToServer("LAUNCH");
           });

           // 添加一个按键方法：按下按键”2“，向服务端派送一个”DESTROY“事件，切换至下一个球并删除上一个。
           InputUtil.onKeyDown(Keys.Two, () => {
               Event.dispatchToServer("DESTROY");
           });
       }
   }
}

@Component
export default class Example_ProjectileMovement extends Script {

   protected async onStart(): Promise<void> {

       // 下列逻辑在服务端执行
       if(SystemUtil.isServer()) {

           // 在r(2000, 0, 0)生成一个火箭模型。
           let rocket = await GameObject.asyncSpawn("162807") as Model;
           rocket.worldTransform.position = new Vector(2000, 0, 0);

           // 将火箭的碰撞状态修改为无碰撞
           rocket.setCollision(CollisionStatus.Off);

           // 创建投掷物。
           let projectile = new ProjectileMovement(rocket);

           // 设置初始发射速度为1。
           projectile.initialSpeed = 1;
           // 设置最大速度为1000。
           projectile.maxSpeed = 1000;
           // 设置发射加速度为200
           projectile.acceleration = 200;
           // 设置重力缩放为0。
           projectile.gravityScale = 0;
           // 设置投掷物旋转不跟随速度方向。
           projectile.isRotationFollowsVelocity = false;
           // 设置投掷物运动时间10秒。
           projectile.lifeSpan = 10;

           // 添加客户端发送的”LAUNCH“事件监听器，将火箭朝上方发射。
           Event.addClientListener("LAUNCH", async (player: Player) => {
               projectile.launch(new Vector(0, 0, 1));
               // 广播客户端给火箭挂载尾焰特效
               Event.dispatchToAllClient("TAIL", rocket.gameObjectId);
               // 每0.1秒都会给客户端广播火箭当前速度
               let scaleInterval = TimeUtil.setInterval(() => {
                   if(projectile.getVelocity().length > 999) {
                       projectile.setVelocity(Vector.zero);
                       TimeUtil.clearInterval(scaleInterval);
                       rocket.worldTransform.position = new Vector(2000, 0, 0);
                   }
                   Event.dispatchToAllClient("SCALING", rocket.gameObjectId, projectile.getVelocity());
               }, 0.1);
           });
       }

       // 下列逻辑在客户端执行
       if(SystemUtil.isClient()) {
           // 添加一个按键方法：按下按键”1“，向服务端派送一个”LAUNCH“事件，发射火箭
           InputUtil.onKeyDown(Keys.One, () => {
               Event.dispatchToServer("LAUNCH");
           });

           // 添加服务端发送的”TAIL“事件监听器，给火箭挂载尾焰。
           Event.addServerListener("TAIL", async (rocketId: string) => {
               let rocket = await GameObject.asyncFindGameObjectById(rocketId);
               if(typeof(rocket.getChildByName("tail")) != "undefined") {
                   return;
               }
               let tail = await GameObject.asyncSpawn("144098") as Effect;
               tail.name = "tail";
               tail.parent = rocket;
               tail.localTransform.position = Vector.zero;
           });

           // 添加服务端发送的”SCALING“事件监听器，根据速度对尾焰进行缩放
           Event.addServerListener("SCALING", async (rocketId: string, velocity: Vector) => {
               let rocket = await GameObject.asyncFindGameObjectById(rocketId);
               let tail = rocket.getChildByName("tail");
               if(tail) {
                   tail.worldTransform.scale = Vector.one.multiply(velocity.length / 250);
               }
           });
       }
   }
}

@Component
export default class Example_ProjectileMovement extends Script {

   protected async onStart(): Promise<void> {

       // 下列逻辑在服务端执行
       if(SystemUtil.isServer()) {

           // 在r(2000, 0, 0)生成一个火箭模型。
           let rocket = await GameObject.asyncSpawn("162807") as Model;
           rocket.worldTransform.position = new Vector(2000, 0, 0);

           // 将火箭的碰撞状态修改为无碰撞
           rocket.setCollision(CollisionStatus.Off);

           // 创建投掷物。
           let projectile = new ProjectileMovement(rocket);

           // 设置初始发射速度为1。
           projectile.initialSpeed = 1;
           // 设置最大速度为1000。
           projectile.maxSpeed = 1000;
           // 设置发射加速度为200
           projectile.acceleration = 200;
           // 设置重力缩放为0。
           projectile.gravityScale = 0;
           // 设置投掷物旋转不跟随速度方向。
           projectile.isRotationFollowsVelocity = false;
           // 设置投掷物运动时间10秒。
           projectile.lifeSpan = 10;

           // 添加客户端发送的”LAUNCH“事件监听器，将火箭朝上方发射。
           Event.addClientListener("LAUNCH", async (player: Player) => {
               projectile.launch(new Vector(0, 0, 1));
               // 广播客户端给火箭挂载尾焰特效
               Event.dispatchToAllClient("TAIL", rocket.gameObjectId);
               // 每0.1秒都会给客户端广播火箭当前速度
               let scaleInterval = TimeUtil.setInterval(() => {
                   if(projectile.getVelocity().length > 999) {
                       projectile.setVelocity(Vector.zero);
                       TimeUtil.clearInterval(scaleInterval);
                       rocket.worldTransform.position = new Vector(2000, 0, 0);
                   }
                   Event.dispatchToAllClient("SCALING", rocket.gameObjectId, projectile.getVelocity());
               }, 0.1);
           });
       }

       // 下列逻辑在客户端执行
       if(SystemUtil.isClient()) {
           // 添加一个按键方法：按下按键”1“，向服务端派送一个”LAUNCH“事件，发射火箭
           InputUtil.onKeyDown(Keys.One, () => {
               Event.dispatchToServer("LAUNCH");
           });

           // 添加服务端发送的”TAIL“事件监听器，给火箭挂载尾焰。
           Event.addServerListener("TAIL", async (rocketId: string) => {
               let rocket = await GameObject.asyncFindGameObjectById(rocketId);
               if(typeof(rocket.getChildByName("tail")) != "undefined") {
                   return;
               }
               let tail = await GameObject.asyncSpawn("144098") as Effect;
               tail.name = "tail";
               tail.parent = rocket;
               tail.localTransform.position = Vector.zero;
           });

           // 添加服务端发送的”SCALING“事件监听器，根据速度对尾焰进行缩放
           Event.addServerListener("SCALING", async (rocketId: string, velocity: Vector) => {
               let rocket = await GameObject.asyncFindGameObjectById(rocketId);
               let tail = rocket.getChildByName("tail");
               if(tail) {
                   tail.worldTransform.scale = Vector.one.multiply(velocity.length / 250);
               }
           });
       }
   }
}