zoukankan      html  css  js  c++  java
  • 罗喉

    当前问题:令body.alpha = 0.5 后,会变得很卡,同时当执行到其他动作帧的时候alpha会自动恢复到1。

      1 package export.monster 
      2 {
      3     import base.*;
      4     import com.greensock.*;
      5     import event.*;
      6     import export.bullet.*;
      7     import export.hero.*;
      8     import manager.*;
      9     import my.*;
     10     import user.*;
     11     
     12     public class Monster46 extends base.BaseMonster
     13     {
     14         public function Monster46()
     15         {
     16             this.wuDi = false;
     17             hasZhaoHuanPoYaZhi = false;
     18             this.control = false;
     19             this.flyBulletArray = new Array();
     20             eyes = 0;
     21             var loc1:*=null;
     22             super();
     23             this.isBoss = true;
     24             this.monsterName = "罗喉";
     25             this.horizenSpeed = 9;
     26             var loc2:*=true;
     27             var loc3:*=gc.getPlayerArray();
     28             var loc4:*=0;
     29             while (loc4 < loc3.length) 
     30             {
     31                 if ((loc1 = loc3[loc4] as base.BaseHero).roleProperies.getLevel() > 15) 
     32                 {
     33                     loc2 = false;
     34                     break;
     35                 }
     36                 ++loc4;
     37             }
     38             this.protectedParamsObject.Hp = 200000;
     39             this.protectedParamsObject.def = 433;
     40             this.protectedParamsObject.mDef = 0.4;
     41             this.protectedParamsObject.sHp = this.protectedParamsObject.Hp;
     42             this.attackBackInfoDict["hit1"] = {"hitMaxCount":99, "attackBackSpeed":[6, -5], "attackInterval":4, "power":650, "attackKind":"physics"};
     43             this.attackBackInfoDict["hit2"] = {"hitMaxCount":30, "attackBackSpeed":[2, -7], "attackInterval":4, "power":670, "attackKind":"physics"};
     44             this.attackBackInfoDict["hit3"] = {"hitMaxCount":40, "attackBackSpeed":[2, -4], "attackInterval":4, "power":780, "attackKind":"magic"};
     45             this.attackBackInfoDict["hit4"] = {"hitMaxCount":30, "attackBackSpeed":[8, -2], "attackInterval":4, "power":750, "attackKind":"magic"};
     46             this.protectedParamsObject.mysee = 300;
     47             this.protectedParamsObject.isattback = 50;
     48             this.attackRange = 180;
     49             this.protectedParamsObject.exp = 100;
     50             this.protectedParamsObject.gxp = 80;
     51             this.protectedParamsObject.stoneFallRate = 1;
     52             this.protectedParamsObject.probability = 1;
     53             this.fallList = [{"name":"xhmt", "bigtype":"zb"}];
     54             return;
     55         }
     56 
     57         public override function beAttack(arg1:base.BaseHero):void
     58         {
     59             if (this.wuDi)
     60             return;
     61             var param1:base.BaseHero;
     62             var _target:base.BaseHero;
     63             var m:int;
     64             var bb:base.BaseBullet;
     65             var obj:Object;
     66             var hurt:int;
     67             var basehurt:int;
     68             var isCrit:Boolean;
     69             var lastint:int;
     70             var equip:my.MyEquipObj;
     71             var bloodRate:Number;
     72             var stunRate:Number;
     73             var loc1:*;
     74             var loc2:*;
     75             var loc3:*;
     76             var arg1:base.BaseHero;
     77 
     78             var loc1:*;
     79             param1 = arg1;
     80             _target = null;
     81             m = 0;
     82             bb = null;
     83             obj = null;
     84             hurt = 0;
     85             basehurt = 0;
     86             isCrit = false;
     87             lastint = 0;
     88             equip = null;
     89             bloodRate = NaN;
     90             stunRate = NaN;
     91             loc1 = undefined;
     92             loc2 = undefined;
     93             loc3 = undefined;
     94             arg1 = param1;
     95             if (this.curAction == "hit4") 
     96             {
     97                 if (eyes < 2) 
     98                 {
     99                     var loc2:*;
    100                     eyes++;
    101                     my.MainGame.getInstance().createMonster(662, this.x, this.y - 500);
    102                 }
    103             }
    104             if (!hasZhaoHuanPoYaZhi && this.protectedParamsObject.Hp < 200000) 
    105             {
    106                 my.MainGame.getInstance().createMonster(664, this.x, this.y);
    107                 hasZhaoHuanPoYaZhi = true;
    108             }
    109             if (this.protectedParamsObject.Hp < this.protectedParamsObject.sHp) 
    110             {
    111                 ++this.protectedParamsObject.Hp;
    112             }
    113             m = 0;
    114             bb = null;
    115             obj = null;
    116             hurt = 0;
    117             basehurt = 0;
    118             isCrit = false;
    119             lastint = 0;
    120             equip = null;
    121             bloodRate = NaN;
    122             stunRate = NaN;
    123             _target = arg1;
    124             if (_target.body) 
    125             {
    126                 if (_target.body.stick) 
    127                 {
    128                     m = 0;
    129                     while (m < this.magicBulletArray.length) 
    130                     {
    131                         bb = this.magicBulletArray[m] as base.BaseBullet;
    132                         if (bb.isCanBeAttack) 
    133                         {
    134                             if (bb.hitTestObject(_target.body.stick)) 
    135                             {
    136                                 bb.setDisable();
    137                                 com.greensock.TweenMax.to(bb, 1, {"alpha":0, "onCompleteParams":[bb], "onComplete":function (arg1:*):*
    138                                 {
    139                                     arg1.destroy();
    140                                     return;
    141                                 }})
    142                             }
    143                         }
    144                         ++m;
    145                     }
    146                 }
    147             }
    148             if (this.beAttackIdArray.indexOf(_target.getAttackId()) != -1) 
    149             {
    150                 return;
    151             }
    152             if (this.isBoss && this.curAction == "dead") 
    153             {
    154                 return;
    155             }
    156             if (gc.protectedPerproty.getProperty(this, "isYourFather")) 
    157             {
    158                 return;
    159             }
    160             if (_target.body && this.colipse) 
    161             {
    162                 if (_target.body.stick) 
    163                 {
    164                     if (my.HitTest.complexHitTestObject(this.colipse, _target.body.stick)) 
    165                     {
    166 
    167                         loc2 = loc2 = user.User;
    168                         loc3 = (loc2.batterNum + 1);
    169                         loc2.batterNum = loc3;
    170                         this.isattack = true;
    171                         if (_target is export.hero.Role2Shadow) 
    172                         {
    173                             this.curAttackTarget = export.hero.Role2Shadow(_target).source;
    174                         }
    175                         else 
    176                         {
    177                             this.curAttackTarget = _target;
    178                         }
    179                         if (_target is export.hero.Role1) 
    180                         {
    181                             manager.SoundManager.play("BeattackByRole1");
    182                         }
    183                         else if (_target is export.hero.Role2 || _target is export.hero.Role2Shadow) 
    184                         {
    185                             manager.SoundManager.play("BeattackByRole2");
    186                         }
    187                         this.drawMonsterHp();
    188                         this.showHpSlip();
    189                         obj = _target.attackBackInfoDict[_target.curAction];
    190                         hurt = _target.getRealPower(_target.lastHit);
    191                         basehurt = _target.getRealPower(_target.lastHit, false);
    192                         isCrit = false;
    193                         if (hurt / basehurt > 1.9) 
    194                         {
    195                             isCrit = true;
    196                         }
    197                         lastint = this.getRealHurt(hurt, obj);
    198                         if (obj && obj.attackKind == "physics") 
    199                         {
    200                             if (_target is export.hero.Role1) 
    201                             {
    202                                 equip = _target.getPlayer().getCurEquipByType("zbwq");
    203                                 if (equip) 
    204                                 {
    205                                     if (equip.fillName == "gwj" || equip.fillName == "ryjgb") 
    206                                     {
    207                                         bloodRate = base.BaseHero(_target).roleProperies.getproperiesObj().eatblood;
    208                                         _target.cureHp(2);
    209                                     }
    210                                 }
    211                             }
    212                         }
    213                         if (obj && obj.attackKind == "physics") 
    214                         {
    215                             if (_target is export.hero.Role3) 
    216                             {
    217                                 equip = _target.getPlayer().getCurEquipByType("zbwq");
    218                                 if (equip) 
    219                                 {
    220                                     if (equip.fillName == "ssc" || equip.fillName == "jcdp") 
    221                                     {
    222                                         stunRate = base.BaseHero(_target).roleProperies.getproperiesObj().deephit;
    223                                         if (Math.random() < stunRate) 
    224                                         {
    225                                             this.addStunEffect();
    226                                         }
    227                                     }
    228                                 }
    229                             }
    230                         }
    231                         if (this.curAction != "hit4")
    232                         {
    233                         this.protectedParamsObject = AUtils.clone(this.protectedParamsObject);
    234                         this.protectedParamsObject.Hp = this.protectedParamsObject.Hp - lastint;
    235                         }
    236                         if (obj) 
    237                         {
    238                             if (!this.isAttacking()) 
    239                             {
    240                                 this.beAttackBack(_target, obj.attackBackSpeed[0], obj.attackBackSpeed[1]);
    241                             }
    242                             if (obj.addEffect) 
    243                             {
    244                                 this.addCurAddEffect(obj.addEffect);
    245                             }
    246                         }
    247                         if (this.isDead()) 
    248                         {
    249                             if (this.curAction != "dead") 
    250                             {
    251                                 base.BaseHero(this.curAttackTarget).roleProperies.setExper(this.protectedParamsObject.exp);
    252                                 this.curAction = "dead";
    253                             }
    254                         }
    255                         else if (this.curAction == "wait" || this.curAction == "walk") 
    256                         {
    257                             this.curAction = "hurt";
    258                         }
    259                         else if (this.curAction != "hurt") 
    260                         {
    261                             if (this.curAction == "hit4") 
    262                             {
    263                                 _target.reduceHp(90);
    264                                 _target.reduceMp(80);
    265                                 return;
    266                             }
    267                         }
    268                         else 
    269                         {
    270                             this.body.gotoAndPlay(1);
    271                         }
    272                         this.beAttackIdArray.push(_target.getAttackId());
    273                         this.addMonHurtMc(lastint, isCrit);
    274                         this.addBeAttackEffect(_target);
    275                     }
    276                 }
    277             }
    278             return;
    279         }
    280 
    281         public override function beMagicAttack(arg1:*, arg2:base.BaseObject, arg3:Boolean=false):Boolean
    282         {
    283             var loc9:*=undefined;
    284             var loc10:*=undefined;
    285             if (this.wuDi) 
    286             {
    287                 return;
    288             }
    289             var loc1:*=null;
    290             var loc2:*=0;
    291             var loc3:*=0;
    292             var loc4:*=false;
    293             var loc5:*=0;
    294             var loc6:*=null;
    295             var loc7:*=0;
    296             var loc8:*=NaN;
    297             if (gc.protectedPerproty.getProperty(this, "isYourFather")) 
    298             {
    299                 return false;
    300             }
    301             if (arg3 || this.colipse && my.HitTest.complexHitTestObject(this, arg1)) 
    302             {
    303                 loc10 = ((loc9 = user.User).batterNum + 1);
    304                 loc9.batterNum = loc10;
    305                 if (arg2 is export.hero.Role2Shadow) 
    306                 {
    307                     this.curAttackTarget = export.hero.Role2Shadow(arg2).source;
    308                 }
    309                 else 
    310                 {
    311                     this.curAttackTarget = arg2;
    312                 }
    313                 if (loc1 = arg2.attackBackInfoDict[arg1.curAction]) 
    314                 {
    315                     if (!this.isAttacking()) 
    316                     {
    317                         this.beAttackBack(arg1, loc1.attackBackSpeed[0], loc1.attackBackSpeed[1]);
    318                     }
    319                     if (loc1.addEffect) 
    320                     {
    321                         this.addCurAddEffect(loc1.addEffect);
    322                     }
    323                 }
    324                 this.drawMonsterHp();
    325                 this.isattack = true;
    326                 this.showHpSlip();
    327                 loc4 = false;
    328                 if (arg2 is export.hero.Role2Shadow) 
    329                 {
    330                     loc2 = arg2.getRealPower(arg2.curAction);
    331                 }
    332                 else 
    333                 {
    334                     loc2 = arg2.getRealPower(arg1.curAction);
    335                 }
    336                 if (arg2 is export.hero.Role2Shadow) 
    337                 {
    338                     loc3 = arg2.getRealPower(arg2.curAction, false);
    339                 }
    340                 else 
    341                 {
    342                     loc3 = arg2.getRealPower(arg1.curAction, false);
    343                 }
    344                 if (loc2 / loc3 >= 1.9) 
    345                 {
    346                     loc4 = true;
    347                 }
    348                 if (arg2 is export.hero.Role1) 
    349                 {
    350                     manager.SoundManager.play("BeattackByRole1");
    351                 }
    352                 else if (arg2 is export.hero.Role2 || arg2 is export.hero.Role2Shadow) 
    353                 {
    354                     manager.SoundManager.play("BeattackByRole2");
    355                 }
    356                 if (this.curAction == "hit4") 
    357                 {
    358                     this.curAttackTarget.reduceHp(80);
    359                     this.curAttackTarget.reduceMp(80);
    360                     return;
    361                 }
    362                 loc5 = this.getRealHurt(loc2, loc1);
    363                 if (loc5 > 5000) 
    364                 {
    365                     loc5 = 5000;
    366                 }
    367                 if (this.curAction != "hit4")
    368                 {
    369                 this.protectedParamsObject = AUtils.clone(this.protectedParamsObject);
    370                 this.protectedParamsObject.Hp = this.protectedParamsObject.Hp - loc5;
    371                 }
    372                 if (loc1 && loc1.attackKind == "physics") 
    373                 {
    374                     if (arg2 is export.hero.Role1) 
    375                     {
    376                         if (loc6 = export.hero.Role1(arg2).getPlayer().getCurEquipByType("zbwq")) 
    377                         {
    378                             loc7 = loc6.getStrengthValue();
    379                             loc8 = 0.05 + loc7 * 0.02;
    380                             if (loc6.fillName == "gwj") 
    381                             {
    382                                 export.hero.Role1(arg2).cureHp(loc5 * loc8);
    383                             }
    384                         }
    385                     }
    386                 }
    387                 if (arg2 is base.BaseHero) 
    388                 {
    389                     if (this is export.monster.Monster38) 
    390                     {
    391                         if (base.BaseHero(arg2).getCurAddEffect(base.BaseAddEffect.DEADLINK)) 
    392                         {
    393                             base.BaseHero(arg2).reduceHp(loc5);
    394                         }
    395                     }
    396                 }
    397                 gc.eventManger.dispatchEvent(new event.CommonEvent("MonsterIsBeat", [loc2, this.curAttackTarget]));
    398                 if (arg2 is export.hero.Role2Shadow) 
    399                 {
    400                     this.addMonHurtMc(loc5, false);
    401                 }
    402                 else 
    403                 {
    404                     this.addMonHurtMc(loc5, false);
    405                 }
    406                 if (this.isDead()) 
    407                 {
    408                     if (this.curAction != "dead") 
    409                     {
    410                         base.BaseHero(this.curAttackTarget).roleProperies.setExper(this.protectedParamsObject.exp);
    411                         this.curAction = "dead";
    412                     }
    413                 }
    414                 else if (this.curAction == "wait" || this.curAction == "walk") 
    415                 {
    416                     this.curAction = "hurt";
    417                 }
    418                 else if (this.curAction == "hurt") 
    419                 {
    420                     this.body.gotoAndPlay(4);
    421                 }
    422                 this.addBeAttackEffect(arg2);
    423                 return true;
    424             }
    425             return false;
    426         }
    427 
    428         public override function isCanMoveWhenAttack():Boolean
    429         {
    430             return this.curAction == "hit2";
    431         }
    432 
    433         protected override function myIntelligence():void
    434         {
    435             super.myIntelligence();
    436             return;
    437         }
    438 
    439         protected override function hasAttackTarget():void
    440         {
    441             if (this.count % 99 == 0)
    442             if (this.getHp() / this.getSHp())
    443                         {
    444                             this.protectedParamsObject.Hp += 3000;
    445                             this.drawMonsterHp();
    446                             this.showHpSlip();
    447                         }
    448             if (this.count % 98 == 0)
    449             this.wuDi = true;
    450             if (this.count % 111 == 0)
    451             this.wuDi = false;
    452 
    453             if (this.isAttacking() || this.curAction == "hurt") 
    454             {
    455                 return;
    456             }
    457             var loc1:*=NaN;
    458             if (Math.random() > 0.7) 
    459             {
    460                 this.normalWalk();
    461             }
    462             if (this.curAttackTarget && !this.isInSky()) 
    463             {
    464                 if (Math.abs(this.x - this.curAttackTarget.x) <= 150) 
    465                 {
    466                     if (this.protectedParamsObject.skillCD3 == 0) 
    467                     {
    468                         this.releSkill3();
    469                         this.protectedParamsObject = AUtils.clone(this.protectedParamsObject);
    470                         this.protectedParamsObject.skillCD3 = 360;
    471                     }
    472                     else if (this.count % 24 == 0) 
    473                     {
    474                         if (Math.random() < 0.7) 
    475                         {
    476                             this.attackTarget();
    477                         }
    478                         else 
    479                         {
    480                             this.normalWalk();
    481                         }
    482                     }
    483                 }
    484                 else if (Math.abs(this.x - this.curAttackTarget.x) <= 300) 
    485                 {
    486                     if (this.protectedParamsObject.skillCD2 == 0) 
    487                     {
    488                         loc1 = Math.random();
    489                         if (loc1 < 0.8) 
    490                         {
    491                             this.releSkill2();
    492                             this.protectedParamsObject = AUtils.clone(this.protectedParamsObject);
    493                             this.protectedParamsObject.skillCD2 = 240;
    494                         }
    495                     }
    496                     else if (this.count % 24 == 0) 
    497                     {
    498                         if (Math.random() < 0.7) 
    499                         {
    500                             this.attackTarget();
    501                         }
    502                         else 
    503                         {
    504                             this.normalWalk();
    505                         }
    506                     }
    507                 }
    508                 else if (Math.abs(this.x - this.curAttackTarget.x) <= 800) 
    509                 {
    510                     if (this.protectedParamsObject.skillCD1 == 0) 
    511                     {
    512                         this.releSkill1();
    513                         this.protectedParamsObject = AUtils.clone(this.protectedParamsObject);
    514                         this.protectedParamsObject.skillCD1 = 140 + int(Math.random() * 100);
    515                     }
    516                     else 
    517                     {
    518                         this.normalWalk();
    519                     }
    520                 }
    521                 else 
    522                 {
    523                     this.normalWalk();
    524                 }
    525             }
    526             return;
    527         }
    528 
    529         protected override function releSkill1():void
    530         {
    531             this.newAttackId();
    532             this.faceToTarget();
    533             this.setYourFather(15);
    534             this.lastHit = "hit2";
    535             this.curAction = "hit2";
    536             return;
    537         }
    538 
    539         protected override function releSkill2():void
    540         {
    541             this.setYourFather(20);
    542             this.faceToTarget();
    543             this.newAttackId();
    544             this.lastHit = "hit3";
    545             this.curAction = "hit3";
    546             return;
    547         }
    548 
    549         protected override function releSkill3():void
    550         {
    551             this.setYourFather(20);
    552             this.faceToTarget();
    553             this.newAttackId();
    554             this.lastHit = "hit4";
    555             this.curAction = "hit4";
    556             return;
    557         }
    558 
    559         public override function isAttacking():Boolean
    560         {
    561             return this.curAction == "hit1" || this.curAction == "hit2" || this.curAction == "hit3" || this.curAction == "hit4";
    562         }
    563 
    564         public override function destroy():void
    565         {
    566             if (this.protectedParamsObject.Hp <= 0) 
    567             {
    568                 my.MainGame.getInstance().createMonster(663, 500, 100);
    569             }
    570             var loc1:*=null;
    571             var loc2:*=0;
    572             var loc3:*=null;
    573             if (!gc.openPig) 
    574             {
    575                 if (this.protectedParamsObject.Hp <= 0) 
    576                 {
    577                     gc.openPig = true;
    578                     gc.memory.setOtherStorage();
    579                 }
    580             }
    581             super.destroy();
    582             return;
    583         }
    584 
    585         public function jiGuang():void
    586         {
    587             var loc1:*=new export.bullet.EnemyMoveBullet("Monster46Bullet1");
    588             if (this.isLeft) 
    589             {
    590                 loc1.x = this.x + 168;
    591             }
    592             else 
    593             {
    594                 loc1.x = this.x - 168;
    595             }
    596             loc1.y = this.y - 139;
    597             loc1.setRole(this);
    598             loc1.setAction("hit1");
    599             loc1.setDistance(1500);
    600             var loc2:*=this.curAttackTarget.x - loc1.x;
    601             var loc3:*=this.curAttackTarget.y - loc1.y;
    602             if (this.isLeft) 
    603             {
    604                 loc1.rotation = 180 + Math.atan2(loc3, loc2) * 60;
    605             }
    606             else 
    607             {
    608                 loc1.rotation = Math.atan2(loc3, loc2) * 60;
    609             }
    610             gc.gameSence.addChild(loc1);
    611             this.magicBulletArray.push(loc1);
    612             return;
    613         }
    614 
    615         public var control:Boolean;
    616 
    617         public var flyBulletArray:Array;
    618 
    619 
    620         public static var eyes:int;
    621 
    622         public static var hasZhaoHuanPoYaZhi:Boolean;
    623         
    624         public var wuDi:Boolean;
    625     }
    626 }
  • 相关阅读:
    c# asp.net 鼠标改变控件坐标位置,更改控件坐标,注册表保存读取,打印,查找局域网内打印机等等收集
    jquery,extjs中的extend用法小结
    JavaScript创建Map对象(转)
    ExtJS与jQuery的一点细节上的对比
    jQuery 的原型关系图,整体把握jQuery
    github网站介绍、并使用git命令管理github(详细描述)
    1.移植3.4内核-分析内核启动过程,重新分区,烧写jffs2文件系统
    6.移植uboot-支持yaffs烧写,打补丁
    5.移植uboot-设置默认环境变量,裁剪,并分区
    4.移植uboot-使uboot支持DM9000网卡
  • 原文地址:https://www.cnblogs.com/kamishiroshinchi/p/12814021.html
Copyright © 2011-2022 走看看