/*

    fatman.txt                                             

    Metal Gear Solid 2 - SONS OF LIBERTY-                

    եåȥޥϻͥ                                   

    2001/10/19 Masafumi Okuta                            

    $Id: fatman.txt,v 1.1.1.3 2002/11/19 11:48:11 Yoshizawa1 Exp $                                                 

*/



ơw20cΥեåȥޥΥեåȥޥ󥭥ѤΥɷ



ܥƥsource/user/korekado/npcʲNPCƥѤƤ롣



fatman.h : եåȥޥϢإå

    ¤Τޥ,ҤƤ롣Ȼ

fatman.c : եåȥޥ󥭥ActorϢ

    եåȥޥ󥭥θƽСưؿ˴ؿ롣



        FatmanMain( Work* work );

            եåȥޥΥᥤԤʤ



        FAT_ActControl( NPCWORK *npc );

            NPC_ActControlΥޥ

            κɸư̤



        Act( Work* work);

            GV_ACTORưؿ

            NPCƥνȥեåȥޥΥᥤؿ򤷤Ƥ



        Die( Work* work);

            GV_ACTOR˴ؿ

            



        GetResource( Work* work,                // եåȥޥ

                     int   name,                // GCL̾ID

                     int   where);              // GCLޥåID

            ؿ

            ƼؿΥФԤʤ



        NewFatman( int   name,                  // GCL̾ID

                   int   where);                // GCLޥåID    

            GCL饳뤵եåȥޥؿ



        NewCmdFatInvisible( void );

            GCL command ǥեåȥޥɽˤؿ

            ǥǥեåȥޥä˻



        NewCmdFatVisible( void );

            GCL command ǥեåȥޥɽˤؿ



fatman.def : եåȥޥؿե

    եåȥޥδؿ



fatdata.c : եåȥޥŪǡ



fatnpc.c : NPCƥϢ

    NPCƥफեåȥޥѤ˥饤ؿ



        FAT_SetModeFromPad( NPCWORK*   npc,                // NPC

                            NPCACTMODE actmode,            // ư⡼

                            int        mar,                // marեstrcode

                            int        mot,                // ⡼ֹ

                            int        pad );              // ѥåɥ⡼

            ư⡼ѹؿ⡼֥ɤǤ褦˥ޥ



        FAT_SetActMotion( NPCWORK* npc,                    // NPC

                          int      base_mar,               // marեstrcode

                          int      mot)                    // ⡼ֹ

            base_marmotܤΥ⡼롣            



        FAT_SetActMotionEX( NPCWORK* npc,       // NPC

                            int      n_layer,   // 쥤䡼ֹ 

                            int      mar,       // marեstrcode

                            int      mot,       // ⡼ֹ 

                            u_long   mask,      // ޥӥå 

                            int      interp,    // 䴰 

                            float    speed);    // ԡ 

            FAT_SetActMotionγĥ֡



        FAT_Incline( CONTROL* ctrl );

            Τη׻ɸYȸߤYǥˤZž򤫤



fatsound.c : ̲ȥ꡼ߥ󥰴Ϣ

        FAT_SeManager( Work*    work);                    

            ̲ޥ͡ ¢SEĤ餹ֳ֤



        FAT_CallSe( Work*    work,        // եåȥޥ

                    int      nSeIndex,    // SEֹʥǥå

                    FVECTOR* pvecPos,     // ȯ

                    int      nMode);      // Υ⡼

            ¢SEĤ餹ȥ꡼ߥ󥰤Ȥη͹礤ʤɤȽꤷĤ餹ɤ



        FAT_Say( Work*    work,         // եåȥޥ

                 int      nSeIndex,     // SEֹʥǥå

                 int      nMode)        // Υ⡼

            ¢SEեåȥޥȤƺ롣

            FAT_CallSeȯ֤եåȥޥƬΰ֤ˤ



        FAT_StreamRequest( Work* work,           // եåȥޥ

                           int   nIndex);        // ȥ꡼ơ֥륤ǥå

            ȥ꡼ߥ󥰥ꥯȤ˻ꤵ줿ǥåƺ򤵤롣

            ȥ꡼ߥ󥰤ʤ餽κΤԤäƤ롣

            ºݤ˺̿ΤFAT_StreamUpdate



        FAT_StreamRequestJustTime( Work* work,    // եåȥޥ

                                   int   nIndex); // ȥ꡼ơ֥륤ǥå

            ȥ꡼ߥ󥰥ꥯȤ˻ꤵ줿ǥåƺ򤵤롣

            ȥ꡼ߥ󥰤ʤ餢

            ºݤ˺̿ΤFAT_StreamUpdate



        FAT_StreamRequestWithProc( Work* work,    // եåȥޥ

                                   int   nIndex,  // ȥ꡼ơ֥륤ǥå

                                   int   nProc);  // λ˸ƤӤץ

            ȥ꡼ߥ󥰥ꥯȤ˻ꤵ줿ǥåƺ򤵤롣

            λnProc򥳡뤹롣

            ȥ꡼ߥ󥰤ʤ餽κΤԤäƤ롣

            ºݤ˺̿ΤFAT_StreamUpdate



        FAT_StreamUpdate( Work* work );

            ȥ꡼ߥ󥰥ޥ͡㡣

            ꥯȤˤ륤ǥåͭʤ饹ȥ꡼ߥ󥰺̿Ф



        FAT_DamageVoice( Work*  work,             // եåȥޥ

                         int    weapon,           // 

                         int    part,             // ᡼

                         int    bNoDmg);          // Ρ᡼ե饰

            ᡼¢SEƤӤ櫓μ̤Ƚꤷƥ뤹ؿ



        FAT_ResidentRollerSe( Work* work );

            顼

            եåȥޥΥ⡼֤åʤSEŪ˥뤹

            

fatarea.c : ¸ߥꥢȽϢ

    եåȥޥ󥹥ơ7ĤΥꥢʬ䤷ƻ׹ͤȽȤƻȤδؿ

    (ץ쥤䡼ֱ󤤥ꥢΤɤƨ)



        FAT_InitAreaPos2Zone( Work* work );            

            ꥢбɸǡ(fatdata.c)饾ֹ 



        FAT_GetArea( FVECTOR vecPos);       // Ĵ٤

            ֤饨ꥢֹ֤



        FAT_GetContArea( int nArea);        // ȽȤʤ륨ꥢ

            nAreaˤФȤʤ륨ꥢ򥨥ꥢֹ֤



        FAT_GetContAreaBit( int nArea);     // ȽȤʤ륨ꥢ

            nAreaˤФȤʤ륨ꥢӥåȥե饰֤



        FAT_GetContRunPutArea( Work* work, int nArea); 

            // ̤

            ФȤʤ֥ꥢ֤



fatzone.c : Ϣ

    ȽꤷŬֹ֤    



        GetRandZone( Work* work );

            ǥ

        FAT_GetSafetyZoneNear( Work* work );

            ʬǤᤤ򥾡ֹ

            Ԥϥꥢб󤫤ɸ(ץ쥤䡼)ФȤʤ륾ֹ

        FAT_GetZoneFromInnerMin( NPCWORK* npc,          // NPC

                                 int      nZoneAddr,    // оݥ󥢥ɥ쥹

                                 FVECTOR* pfvec,        // ٥ȥ

                                 float*   pfRes)        // ѷ̤

            nZoneAddrܥΤʤpfvecФƺǤͤξ֤

        FAT_GetZoneFromInnerMax( NPCWORK* npc,          // NPC

                                 int      nZoneAddr,    // оݥ󥢥ɥ쥹

                                 FVECTOR* pfvec,        // ٥ȥ

                                 float*   pfRes)        // ѷ̤

            nZoneAddrܥΤʤpfvecФƺǤͤ礭֤



        GetFarZoneDir( NPCWORK* npc,            // NPC

                       int      nAddr,          // Ȥʤ륢ɥ쥹

                       FVECTOR  vecDir,         // 

                       int      nDistMax,       // Υ

                       int*     pnResDist)      // ̵Υ

            ˤäƻΥʾΥƤ륾



        GetFarZonePlayerDir(NPCWORK*    npc,            // NPC

                            int         nDistMax,       // Υ

                            int*        pnResDist)      // ̵Υ

            // ̤

            ץ쥤䡼θƤˤäƻΥʾΥƤ륾



        FAT_GetEvadeVector( Work*       work,           // եåȥޥ

                            int*        pnDir);         // Y

            // ̤

            ץ쥤䡼򤱤ưμ



        FAT_GetAreaDataZoneEx( Work* work,              // եåȥޥ

                               int   nArea );           // ꥨꥢ

            ꥢ̸ǡꥨꥢФȤʤ륾ֹ



        FAT_GetAreaDataZone( Work* work );

            ꥢ̸ǡץ쥤䡼ФȤʤ륾ֹ



        FAT_InitTurnPutRef( Work* work );

            žѻȥǡ



        FAT_GetTurnPutRefZone( Work* work );

            Υʾ־žѻȥ



        FAT_FarZoneInFan( Work* work,       // եåȥޥ

                          int*  pnDist,     // ̵Υ

                          int   nFromAddr,  // ॾ󥢥ɥ쥹

                          int   nDir,       // 

                          int   nChkDir);   // Ƚ

            ǰΥƤ륾ֹȵΥ֤



        FAT_CheckBackShoot( Work* work);

            // ̤

            ظå :: Ωɸ,Ω-1֤



        FAT_ChkFarZoneFromCrossDir( Work* work,             // եåȥޥ

                                    int   nDirCurrent,      // 

                                    int   nDistMin);        // Υ

            Υ줿󤬤뤫1024ʬ,ΥȤƥå

            Ωɸ,Ω-1֤



        FAT_GetNearZoneNotPass( Work* work, int nZone);

            // ̤

            ꤵ줿ܥ󤫤餽Υ̲ᤷʤ



        FAT_GetNearZoneNotPassDirPrio( Work* work,      // եåȥޥ

                                       int   nZone,     // ꥾

                                       int   nAimDir);  // 

            ꤵ줿ܥ󤫤餽Υ̲ᤷʤ

            ׻ưξʤ֤



fatintrude.c : Хȥ롼ѻ׹ʹϢ

    ץ쥤䡼ȥ롼ɤƤȤλ׹Ƚ



        FAT_GetIntrudeArea( void );          

            ץ쥤䡼ΰ֤饤ȥ롼ɥꥢ

            ϥꥢֹ桢Ի-1֤



        FAT_InitEscPos2Zone( Work* work);

            ץ쥤䡼ȥ롼ɤƤȤƨȤƻȤ֥ǡ򥾡ǡѴ

            

        FAT_GetIntrudeEscZone( Work* work,              // եåȥޥ

                               int   nIntrudeZone );    // ץ쥤䡼ȥ롼ɤƤ륾

            ץ쥤䡼ȥ롼ɤƤȤƨ֤



fatextern.c : ΥȤ̿Ϣ

    եåȥޥ󤬲Υե;ǹԤʤȵݤΥåؿ



        FAT_CallKamome( Work*      work,      // եåȥޥ

                        int        nNode,     // տ蘆ֹ

                        int        x,         // nNodeΥեåȡX

                        int        y,         // nNodeΥեåȡY

                        int        z,         // nNodeΥեåȡZ

                        int        nDir);     // ΤȤޤä

            ӥåȯԴؿ

            ꤵ줿nNodeΥޥȥꥯа(x,y,z)ΤȤޤ

        

        FAT_TakeOffKamome( Work* work,        // եåȥޥ

                           int   nDelay)      // ǥ쥤

            եåȥޥˤȤޤäƤ륫Ω



fatact.c : եåȥޥưؿ

    եåȥޥιưؿpadͤ򸵤˥եåȥޥưؿ

        FAT_GetDownTime( void);   

            եåȥޥžݤݤΥ֤֤



	// ̾ưؿ

        ActRun( NPCWORK *npc, int time );                       :: ưؿ

            Իư

        ActTurnSide( NPCWORK *npc, int time );                  :: ưؿ

            ư

        ActTurn180( NPCWORK *npc, int time );                   :: ưؿ

            180ȿžư

        ActStop( NPCWORK *npc, int time );                      :: ưؿ

            ߻ư

        ActPointMove( NPCWORK *npc, int time );                 :: ưؿ

            ˰ưư

        ActRunReload( NPCWORK *npc, int time );                 :: ưؿ

            ˥ɤư

        ActGunStand( NPCWORK *npc, int time );                  :: ưؿ

            ˽Ƥ򹽤ư

        ActGunShoot( NPCWORK *npc, int time );                  :: ưؿ

            ˽ƤĻư

        ActRunShotReady( NPCWORK *npc, int time );              :: ưؿ

            ˽Ƥ򹽤ư

        ActRunShotAct( NPCWORK *npc, int time );                :: ưؿ

            ˽ƤĻư

        ActBackShotReady( NPCWORK *npc, int time );             :: ưؿ

            ˽Ƥ򹽤ư

        ActActBackShotAct( NPCWORK *npc, int time );            :: ưؿ

            ˽ƤĻư

        ActReload( NPCWORK *npc, int time );                    :: ưؿ

            ˥ɤư

        ActWakeup( NPCWORK *npc, int time );                    :: ưؿ

            夬ư

        ActBombSetStop( NPCWORK *npc, int time );               :: ưؿ

            ֤ư

        ActBombSetRun( NPCWORK *npc, int time );                :: ưؿ

            ֤ư

        ActBombSetTurn( NPCWORK *npc, int time );               :: ưؿ

            Ƥž֤ư

        ActCountDownStart( NPCWORK *npc, int time );            :: ưؿ

            Ƥưư

        ActCountDownStartFromDmg( NPCWORK *npc, int time );     :: ưؿ

            ᡼ˤܤäƤưư

        ActCountDownStartFailed( NPCWORK *npc, int time );      :: ưؿ

            ƤΤƤޤưǤʤäư

        ActFeintShoot( NPCWORK *npc, int time );                :: ưؿ

            ˽ƤĻư

        ActLimitShoot( NPCWORK *npc, int time );                :: ưؿ

            ƷĻư

        ActTobidasi( NPCWORK *npc, int time );                  :: ưؿ

            ӽФư

        ActSlideShoot( NPCWORK *npc, int time );                :: ưؿ

            饤ɷư

        ActBodyAttack( NPCWORK *npc, int time );                :: ưؿ

            ư

        ActOverLook( NPCWORK *npc, int time );                  :: ưؿ

            Ϥư

        ActBleathless( NPCWORK *npc, int time );                :: ưؿ

            ©ڤФƤФƻư

        ActOdori( NPCWORK *npc, int time );                     :: ưؿ

            ;ư

        ActSquat( NPCWORK *npc, int time );                     :: ưؿ

            ¤ư

        ActEludeKill( NPCWORK *npc, int time );                 :: ưؿ

            롼ɻؤư

        ActHoldUp( NPCWORK *npc, int time );                    :: ưؿ

            ۡɥå׻ư

        ActCircleDance( NPCWORK *npc, int time );               :: ưؿ

            ߥ󥹻ư

        ActKamome( NPCWORK *npc, int time );                    :: ưؿ

            ȵư

        ActRepair( NPCWORK *npc, int time );                    :: ưؿ

            顼֥졼ɽư

        ActShootPhaseStart( NPCWORK *npc, int time );           :: ưؿ

            Ʒեϻư

        ActActBombPhaseStart( NPCWORK *npc, int time );         :: ưؿ

            ƥեư

        ActBackNavi( NPCWORK *npc, int time );                  :: ưؿ

            Ʋλ˥ץ쥤䡼ظˤĤư



	SampleCheckPad( NPCWORK *npc );

            ѥåɥåؿưؿϤꤵ

            

	// ᡼ưؿ

        ActDamage( NPCWORK *npc, int time );                    :: ưؿ

            ᡼ư

        ActRunDamage( NPCWORK *npc, int time );                 :: ưؿ

            ˥᡼ư

        ActFall( NPCWORK *npc, int time );                      :: ưؿ

            žݻư

        ActRunFall( NPCWORK *npc, int time );                   :: ưؿ

            Իžݤư

        ActDownDamage( NPCWORK *npc, int time );                :: ưؿ

            ˥᡼ư

        ActDown( NPCWORK *npc, int time );                      :: ưؿ

            ư

        ActHang( NPCWORK *npc, int time );                      :: ưؿ

            ᡢꤲ򤫤줿ư

        ActNearDeath( NPCWORK *npc, int time );                 :: ưؿ

            λư

        ActDead( NPCWORK *npc, int time );                      :: ưؿ

            ˴ư

        ActDeadFall( NPCWORK *npc, int time );                  :: ưؿ

            ˴ݤư



        Action( Work* work);

            ưؿΥ



fatparty.c : եåȥޥѴؿ

    եåȥޥɤȤؿޤȤ᤿            

        FAT_SetStep( Work*  work,     // եåȥޥ

	             int    nStep);   // ƥå    

            ƥåؿ

        FAT_SetThink1( Work* work,              // եåȥޥ

                       int   nNewThink1,        // 롼:ͥ٥

                       int   nNewThink2,        // 롼:ե٥

                       int   nNewThink3);       // 롼:ư٥

            think1ؿ

        FAT_SetThink2( Work* work,              // եåȥޥ

                       int   nNewThink2,        // 롼:ե٥

                       int   nNewThink3);       // 롼:ư٥

            think2ؿ

        FAT_SetTh3( Work* work,              // եåȥޥ

                    int   nNewThink3);       // 롼:ư٥

            think3ؿ

        FAT_SetNextThink3( Work* work,              // եåȥޥ

			   int   nNextThink3);      // 롼:ư٥

            Υ롼nNextThink3ꤹ

        FAT_SetThink3FromNext( Work* work,          // եåȥޥ

			       int   nNewThink3);   // ͽο롼:ư٥

            think3˼䤬nNextThink3򡢤ʤnNewThink3Ŭ



	FAT_SetNAim( Work*    work,      // եåȥޥ          

                     int      nNextZone, // Υ

                     FVECTOR* pvec);      // ɸ

            ɸ֡򥻥åȤꤹ



        FAT_SetNZone( Work* work,        // եåȥޥ

                      int   nNextZone);  // Υ

            ˸



        FAT_SetNZone2( Work* work,        // եåȥޥ

                       int   nNextZone);  // μΥ

            μ˸



        FAT_SetNZoneFrom2( Work* work,        // եåȥޥ

                           int   nNextZone);  // Υ

            Next2ͭʤNext2򡢤ʤnNextZone򼡤˸˻



        FAT_SetNPoint( Work*    work, 		// եåȥޥ

                       int	nNextZone,	// ˸

                       FVECTOR* pvecNext);	// ˸:NULLλϥ濴

            ɸ֤ޤ᤿Υ



        FAT_SetNZoneWithRelayPoint( Work*    work,       // եåȥޥ

                                    int      nRelayZone, // ѥ

                                    int	     nAimZone,	 // ɸ

                                    FVECTOR* pvecRelay,	 //  : NULLλϥ濴

                                    FVECTOR* pvecAim);   // ɸ : NULLλϥ濴

            ꤷɸظ



        FAT_SetNewPhase( Work* work, int nPhase);    

            եؿ



        FAT_AdjustAimPoint( Work*    work,     // եåȥޥ

                            FVECTOR* pvecTrg); // ɸ 

            Ƹɸظʥ㥹ȲǽϰϤǡ

            

        FAT_ClearAdjust( Work* work);    

            㥹ȥꥢ



        FAT_GetAimParts( Work* work );

            Ļѡľ󤫤֤



        FAT_ShootGlock( NPCWORK* npc,     // NPC

                        int      nRandX,  // xž

                        int      nRandY,  // yž

                        int      nRandZ); // zž

            åȯͤ

	

	CheckPointLookableObject( FVECTOR* pfvec,  // ꤹ

				  OBJECT*  pobj,   // оݥ֥

				  int      hzx_id, // ϥID

				  int      dir,    // 	

				  int      ang);   // 	

            ΰ֤饪֥뤫ɤ



	FAT_ChgPhase( Work* work );

            Υեեѹ

    

        FAT_GetDirNext( Work* work );

            ΥȼμΥγ٤



        FAT_GetZoneInPoint( FVECTOR* pvecRes, // 

                            FVECTOR* pvec,    // ߰

                            int      addr);   // Ȥ륾

            pvecΰ֤addr֤׻



        FAT_CheckNearZoneIn( int nCharaAddr,	// ꥭΥֹ

			     int nAimAddr); 	// ꥾ֹ

            nCharaAddrnAimAddrܥˤʤäɤȽ



        ChildTargCallBack( TARGET* off,         // ⥿å

                           TARGET* def,         // ɸ楿å

                           void*   ptr );       // ɸ楿åȤν°ؤΥݥ

            åȤ᡼ݤ˸ƤФ륳Хåؿ



        FAT_CheckMotionMove( Work* work);

            ⡼ư椫ɤȽ



        FAT_CheckTurnLR( Work* work );

            󤹤뤫ɤȽ



        FAT_EludeFall( Work* work );

            롼ɻؤ



        FAT_CheckReverse( Work* work, int nNextZone);

            ˸󤬼ʬθƤεդˤ뤫å



        FAT_SetNPointWithNavigate( Work*    work,  // եåȥޥ

                                   int      nZone, // ɸ

                                   FVECTOR* pvec); // ɸ

            ˰ư֤ȥʥӥåȤ



        FAT_CheckNextZone( Work* work);

            䥾å



        FAT_CheckZone( Work* work);

            å



        FAT_ChkZoneWrong( NPCWORK* npc, int nZone);

            å



        FAT_EvadeIntoWall( NPCWORK* npc);

            ɤꤳ߲



        FAT_CalcNockBack( Work* work);

            ץ쥤䡼򲡤᤹



        FAT_CalcPushPlayer( Work* work);

            ץ쥤䡼򲡤ᤷޥ͡



        FAT_IntrptZoneCheck( HZX_GROUP_ID hzx_id, int nFromZone, int nToZone);

            nFromZonenToZoneδ֤ǤƤ뤫å



fateye.c : ȽϢ

    եåȥޥμվ뤿δؿޤȤ᤿Ρ

    ׹˹



        FAT_InitEyeWork( Work* work);

            ȽϢФνؿ



        FAT_CheckEye( Work* work );

            ̤

            ץ쥤䡼볦ˤ뤫Ƚ



        FAT_CheckAimVisible( Work* work );

            ɸ뤫ɤȽꤹ



        FAT_CheckNoise( Work* work );

            ̤

            ʪȿȽ



        CheckFatmanInfo( Work* work );

            ׹Ƚ˹եåȥޥξؿ

            

fatc4.c : C4֥ƥϢ

    եåȥޥ֤C4ϢδؿޤȤ᤿

    C4٤4ʳʳ16ѥ1ѥˤĤ8֥ݥȡˤη512֥ݥȤ롣

    ٤ϥեåȥޥѵͤ͡ˤäѲ롣ߤ٤Τʤƥե֤ͽ

    ƿ̤֥ݥȤ¿(¿)ѥƤ֤Ƥ



        InitC4Work( Work* work );

            C4ϢФν



        UpdateC4Work( Work* work );

            C4󹹿

            C4ξ֡ȽꡢȽϤǹԤʤ

        

        SetNewFatmanC4( Work*              work,

                        FAT_PUTPOINT_DATA* pput,   // ־깽¤ΤؤΥݥ

                        int                nMapID, // ֤ޥåID

                        int                nTime); // ȯޤǤλ

            C4֤

            C4򤵤ꤹ

            ߤĤʤϲκѤߤΥ򥯥ꥢƤѤ

        

        FAT_StartBombCount( Work* work );

            C4Υȥ󳫻



        FAT_PUTPOINT_DATA* FAT_GetPosData( Work* work, 

                                           int   nLevel,    // 

                                           int   nPattern,  // ѥֹ

                                           int   nIndex);   // ǥå

            ١ѥֹ桢ǥåꤷư֥ǡؤΥݥ󥿤



        FAT_PUTPOINT_DATA* FAT_GetCurrPosData( Work* work, int nIndex);

            ߤ١ѥֹλꥤǥåΰ֥ǡؤΥݥ󥿤

        

        FAT_GetPosPatternPtr( Work* work, int nLevel, int nPattern);

            ߤ٤λѥֹ桢ꥤǥåΰ֥ǡؤΥݥ󥿤

        

        FAT_GetC4PosNum( Work* work, int nLevel, int nPattern);

            ̤

        

        FAT_GetCurrentC4PosNum( Work* work );

            ̤



        FAT_GetGclBombData( Work* work );

            GCL饷ʥꥪȤϤ줿C4ϢΥǡ



        FAT_GetC4PosRandom( Work* work );

            C4־:̤֤Ǽ



        FAT_GetC4PosAreaPrio( Work* work,   

                              int   nArea);      // Ȥʤ륨ꥢ

            C4־:ץ쥤䡼Хꥢͥ踡

        

        FAT_GetC4PosDistPrio( Work* work,   

                              int   nJudgeDist); // ȽΥ

            C4־:nJudgeDistȤƵΥˤ븡򤹤

            nJudgeDistλ:Υ줿ݥȤ֤

            nJudgeDistλ:ΥʾΥ줿ݥȤ֤



        FAT_GetC4PosDirPrio( Work* work,   

                             int   nDiff);       // Ƚ

            C4־:κȽȤƸ

            nDiffλ:ꤷ֥ݥȤ򸡺

            nDiffλ:ξʤ֥ݥȤ֤



        FAT_GetC4PosTypePrio( Work* work,   

                              int   nType);      // ּ

            C4־:ꤵ줿ּΥݥȤ֤



        FAT_GetC4PosOtherPrio( Work* work);       

            C4־:򤷤Ƥ륤ǥåʳͥ踡



        FAT_GetCurrPutPosData( Work* work );

            ߤΥǡؤΥݥ󥿼



        FAT_UpdatePatternInfo( Work* work, 

                               int   nDifficult);  // 

            ꤵ줿٤ΥѥѾ򹹿

        

        FAT_ChangeC4Difficult( Work* work, 

                               int   nLevel);      // 

            ٥٥ְ֤ꤹ롣

            ٤ˤʤ˻Ѥ롣



        FAT_ChangeC4Pattern( Work* work);

            ѥ٥ְ֤ꤹ롣

            ͽ¿ѥ򸡺

            

        

        FAT_ChangeC4Index( Work* work,             // եåȥޥ

                           int   nSearch,          // ˡ

                           int   nParam);          // ѥ᡼:ˡƤϰۤʤ

            ǥå٥ְ֤

            ˡȥѥ᡼ϤƤξ˸礦֥ݥȤΥǥå֤

            ˹礦ݥȤĤʤϥǷ

 

        FAT_SetNewC4Point( Work* work);

            ֥ݥȤꤹ

        

        FAT_SetNewC4Position( Work* work, int nIndex );

            ߤC4֥ݥȤظ褦˰ưꤹ

        

        FAT_GetCurrentC4Zone( Work* work);

            ߤC4֥ݥȥֹ

        

        FAT_GetCurrentC4Put( Work* work, FVECTOR* pvec);

            ߤC4֥ݥȤΥեåȥޥΩ֤

        

        FAT_GetCurrentC4Pos( Work* work, FVECTOR* pvec);

            ߤC4֥ݥȤְ֤

        

        FAT_GetTurnPutDir( Work* work);

            ž֤ư֤ȥեåȥޥ

        

        FAT_VisibleC4Check( Work* work );

            Ư֤C4ˤ뤫å

        

        FAT_SearchKaitaiC4( Work* work, FAT_C4_DATA* pbombRes );

            ץ쥤䡼C4Υǡ



        FAT_SearchKaitaiC4FarPlayer( Work* work );

            ȥƤץ쥤䡼Ǥʪõ



        FAT_SearchKaitaiC4DistNearest( Work* work );

            ȥƤץ쥤䡼Ǥᤤʪõ

        

fatmove.c : ưϢ

    եåȥޥΰư˴ؤؿޤȤ᤿

    եåȥޥϴ¸Υ롼ȥƥǰưȥưΤǥ顼֥졼ɤưȤƤ

    ǥơ˥٥Υ롼ȤҤƱ󤯤˰ưϤΥ롼Ȥ˾äưưɸ

    Ť⤷Ŭ롼ȤĤʤä饾ưؤȤƥȤäƤ

    ٥롼ȤθȤʤɸǡfatdata.cˤ٤Ƥ롣



        FAT_SetRSphereFromMot(Work* work);

            եåȥޥΥ⡼ɤꤳ߷ڸ

            

        FAT_CalcBezierIncMod( Work*    work, 

                              FVECTOR* pvec1,  // ٥λ

                              FVECTOR* pvec2,  // ٥

                              FVECTOR* pvec3); // ٥ν

            ꤵ줿٥η׻Ѥη

            

        FAT_BezierInc( FVECTOR* pvec, 

                       FVECTOR* pvecIncMod1,   // 

                       FVECTOR* pvecIncMod2,   // 

                       float    fRate);        // (0.f1.f)

            그礫鷹

            

        FAT_GetBezierRate( FVECTOR* pvec1,     // ٥λ

                           FVECTOR* pvec2,     // ٥

                           FVECTOR* pvec3,     // ٥ν

                           float    fSpeed);   // ®

            ꤵ줿٥ꤵ줿®٤ǿʤݤ1ե졼Ǥ֤

            1ե졼Ǥ = fSpeed / (pvec1pvec2εΥ + pvec2pvec3εΥ)

            

        FAT_SetupMove( Work*    work, 

                       FVECTOR* pvec1,         // ٥λ

                       FVECTOR* pvec2,         // ٥

                       FVECTOR* pvec3);        // ٥ν

            ٥ưѥ

            

        FAT_InitBezierMove( Work* work);

            ٥ưϢ

            

        FAT_SetupRouteMove( Work* work,        

                            int   nRouteIndex, // 롼ֹ

                            int   nReverse);   // 롼ȿžե饰

            ꤵ줿롼ֹ桢Ѥ٥ư򤹤뤿򤹤

            

        FAT_SetupNavigateMove( Work* work, 

                               int nZoneTo );  // ɸ

            ɸظ٤Υʥӥȥƥν

            

        FAT_SetupToRouteMove( Work* work, 

                              int   nIndex,    // 롼ֹ

                              int   nReverse); // 롼ȿžե饰

            ư٥롼Ȱưؤ

            

        FAT_MakeZoneDataFromRoute( Work* work);

            ٥롼ȥǡ饾ǡ

            

        FAT_SelectRoute( Work* work, int nAimZone);

            ɸ˸Υ٥롼Ȥ򤹤

            

        FAT_ChkRegularRoute( Work* work, int nIndex, int nFromZone, int nToZone );

            Υ롼ȥǡ롼Ȥɸ˸ȤΤǤ롼Ȥɤå

            

        FAT_ChkCounterRoute( Work* work, int nIndex, int nFromZone, int nToZone );

            Υ롼ȥǡե롼Ȥɸ˸ȤΤǤ롼Ȥɤå

            

        FAT_CheckRouteInNextZone( Work* work, int* pnIndex, int* pnReverse );

            ʬ˸Ǻǽɸ˸ȤΤǤ롼Ȥ¸ߤ뤫٤

            

        FAT_CheckRouteZone( Work* work, int nZoneFrom, int nZoneTo);

            󹹿Υå

            ʥӥȰưΥؤԤʤ, 롼Ƚü

            

        FAT_ZoneMove( Work* work );

            Ѥư

            

        FAT_RouteMove( Work* work );

            ٥롼ȤѤư

            

        FAT_CheckBezierInTetra( Work* work, int nZone, int nRoute );

            ȥ롼Ȥܿ뤫å

            

        FAT_RouteZoneMove( Work* work );

            եåȥޥΥ롼ȡ¸ư

            夹1֤

        

fatattack.c : Ϣ

    եåȥޥι˴طؿޤȤ᤿

    ⥿åȤ乶׹ͤ

        HitCallBack( TARGET* off,      // ⥿å

                     TARGET* def,      // ɸ楿å

                     void*   ptr );    // եåȥޥ

            ꥿åȥХå



        CrashCallBack( TARGET* off,    // ⥿å

                       TARGET* def,    // ɸ楿å

                       void*   ptr );  // եåȥޥ

            ܿåȥХå



        Attack( NPCWORK* npc );

            깶Ѥι⥿å



        Clash( NPCWORK* npc );

            ܿѤι⥿å



        CaptureCounter( NPCWORK* npc );

            ϤƨѤι⥿å



        RollerBladeAttack( NPCWORK* npc );

            顼֥졼Ѥι⥿å



        BodyEvade( NPCWORK* npc );

            ƤѤι⥿å

            ܿžФ륿å



        Think3_Reload( Work* work );

            ׹ͥ롼󡧥åΥ



        Think3_RunReload( Work* work );

            ׹ͥ롼ΥåΥ



        FAT_GetBodyAttackZone( Work* work );

            ꥨꥢå



        Think3_BodyAttack( Work* work );

            ׹ͥ롼



        Think3_BackShoot( Work* work );

            ׹ͥ롼󡧸νƷ



fatdamage.c : ᡼Ϣ

    եåȥޥΥ᡼ޤȤ᤿

    եåȥޥΥ᡼ȽΩ֡֡֡ƬΤȽ֡λ֤5ĤΥ᡼⡼ɤ

    եåȥޥξ֤ؤԤʤ롣



        FAT_GetDamageValue( int nDmgType );

            ᡼׻Ԥʤ᡼֤ͤ



        FAT_CheckGameClear( Work* work, 

                            int   nKillFlag);  // ˴ե饰

            ९ꥢ



        FAT_SetWepDmgWork( Work* work, 

                           int   weapon);      // μ

            ü᡼ˤ



        FAT_SetChildDmgWork( Work* work, 

                             int   dam_child_num); // ҥåֹ

            ᡼̤ˤ



        Think3_StartDamage( Work *work );

            ᡼ľ



        Think3_SysDamageWait( Work *work );

            ᡼ľ:ƥ

 

        Think3_WakeUp( Work *work );

            ׹ͥ롼:夬



        CheckDamageStand( NPCWORK* npc );

            ᡼Ƚ:߻Υ᡼å



        CheckDamageRun( NPCWORK* npc );

            ᡼Ƚ:ԻΥ᡼å



        CheckDamageDown( NPCWORK* npc );

            ᡼Ƚ:Υ᡼å



        CheckDamageHeadOnly( NPCWORK* npc );

            ᡼Ƚ:ƬΤߥ᡼å



        CheckDamageNearDead( NPCWORK* npc );

            ᡼Ƚ:λΥ᡼å

        

fatbomb.c : ƥե׹ʹϢ

    եåȥޥƥեλ׹ʹؿޤȤ᤿

    Think3_BombReadyȤƾ׹ʬ



        Think3_BombStart( Work* work );

            ׹ʹؿƥե



        Think3_BombPointMove( Work *work );

            ׹ʹؿ֤˰ư



        Think3_RunningPut( Work* work );

            ̤

            ׹ʹؿƤ֤



        Think3_TurnPut( Work* work );

            ׹ʹؿƤ֤



        Think3_StopPut( Work* work );

            ׹ʹؿƤ򤿤ɤޤä֤



        Think3_BombReady( Work* work );

            ׹Ƚؿ



fatdemine.c : Υե׹ʹϢ

    եåȥޥβΥեλ׹ʹؿޤȤ᤿

    Think3_DemineReadyȤƾ׹ʬ

        FAT_ChkAttractZoneIn( Work* work );

            ;򤪤ʤˤ뤫ɤå

            

        FAT_InitAttractPos2Zone( Work* work );

            ;ݥǡ饾ǡ

            

        FAT_GetAttractZone( Work* work );

            ;Ԥʤ֤

            

        Think3_CountDownStart( Work* work );

            ׹ʹؿƵư

            

        Think3_CountDownFirst( Work* work );

            ׹ʹؿƵư

            

        Think3_DemineReady( Work* work );

            Υեλ׹Ƚ

            

        Think3_DisposalAttract( Work* work );

            ;Ƚ

            

        FAT_NavigateC4( Work* work);

            եåȥޥ󤬥ץ쥤䡼ξ֤Ŭڤĩȯβ뤿δؿ

            

        Think3_DisposalDance( Work* work );

            ׹ʹؿեåȥޥ󤬱ߤƲե

            

        Think3_DisposalKamome( Work* work );

            ׹ʹؿȵ

            

        Think3_DisposalKamomeNeck( Work* work );

            ׹ʹؿȵʶߤ1ߤޤ륿ס

            

        Think3_DisposalBackNavi( Work* work );

            ׹ʹؿץ쥤䡼ζ᤯˸ĩȯ

            

        Think3_CountDownBombGuard( Work* work );

            ׹ʹؿư֤ƤԤ

            

fatshoot.c : Ʒե׹ʹϢ

    եåȥޥνƷեλ׹ʹؿޤȤ᤿

    Think3_ShootReadyȤƾ׹ʬ

        Think3_ShootStart( Work* work );

            ׹ʹؿƷե

        Think3_ShootFeint( Work* work );

            ׹ʹؿ

        Think3_ShootReady( Work* work );

            Ʒեλ׹Ƚ

        FAT_ChkThkShootMove( Work* work);

            ׹ͥ󥻥ѴؿưΥ󥻥



fatpre.c : ׹νϢ

    եåȥޥλ׹͡ưԤʤ



        FAT_GetDurRecoverTime( void );

            ̤ѵͲ֤֤



        CheckMessage( Work *work );

            åå



        InfoCheck( Work *work );

            վι



        BombCheck( Work* work );

            ƥι



        PreProcess( Work *work );

            ׹ͤ



        AfterProcess( Work *work );

            ׹ͤ



fatthink.c : ׹ʹؿ

    եåȥޥλ׹ʹؿΤȤޤȤ᤿

    think1,2ʬ



fatinit.c : ؿ

    ϢޤȤ᤿



        Think2_ShootPhase( Work *work );

            Ʒե



        Think2_BombPhase( Work *work );

            ƥե



        Think2_DisposalPhase( Work *work );

            Υե



        Think2_StartDamage( Work *work );

            ᡼ե



        Think2_SystemDamage( Work *work );

            NPCƥΥ᡼ե



        Think2_Event( Work *work );

            ٥ȥե



        DamageCheck( Work *work );

            ᡼å



        Think1_Normal( Work *work );

            ̾



        Think1_Damage( Work *work );

            ᡼



        Think1_Event( Work *work );

            ٥Ⱦ



        Think( Work *work );

            ׹ʹؿ



        StartThink( Work *work );

            ׹ͥ



fatcommon.c : եֶѴؿ

    ׹ʹϢǥե̤δؿޤȤ᤿

        Think3_Stand( Work *work );

            ׹ʹؿΩ



        Think3_Move( Work *work );

            ׹ʹؿư



        Think3_Stop( Work *work );

            ׹ʹؿ



        Think3_Turn180( Work *work );

            ׹ʹؿ



        Think3_PointMove( Work *work );

            ׹ʹؿ֤ذư



        Think3_Bleathless( Work *work );

            ׹ʹؿ©ڤФƤФ



        Think3_OverLook( Work* work );

            ׹ʹؿϤ



        Think3_Feint( Work* work );

            ׹ʹؿƷ



        Think3_RunShoot( Work* work );

            ׹ʹؿ



        FAT_CheckElude( Work* work );

            롼ɸ



        Think3_EludeFall( Work* work);

            ׹ʹؿ롼ɻؤ



        Think3_EludeKill( Work *work );

            ̤

            ׹ʹؿ롼ɻؤʵ



        Think3_EludeShoot( Work* work);

            ̤

            ׹ʹؿ롼ɥץ쥤䡼



        Think3_Standby( Work* work);

            ׹ʹؿ֤֤ĩȯ



        Think3_EventStand( Work* work );

            ׹ʹؿ४Сĩȯ



fatutil.c : ؿ

    ؿNPCϤζ̱ФԤʤؿޤȤ᤿

        FATUTL_BezierPassCheck( Work* work);

            ꤵ줿٥ɤΥ̲᤹뤫ǡ



        FAT_SpillBlood( Work*    work, 

                        FVECTOR* pvecHit,    // ä

                        FVECTOR* pvecForce); // 

            Ф

            

        FAT_BlastSuitEvadeShootEffect( Work*    work, 

                                       FVECTOR* pvecPos,  // ä

                                       FVECTOR* pvecDir); // Ƥ

            ֥饹ȥƥե



        FAT_Quake( Work* work, 

                   int   nVibTime,           // ư

                   int   nIntence,           // ɤ춯

                   int   nShakeTime);        // ɤ

            ɤ



        FAT_QuakeUpdate( Work* work);

            ɤޥ͡㹹



        FAT_ChkThkTemporary( Work* work);

            ׹ͥ󥻥Υƥݥؿ



        FAT_ClearNeedl( OBJECT* body );

            ƤϤ



        FAT_SendFaceMess( Work* work, 

                          int   nType);      // 

            饢˥ᥭ˥⡼å(ܥѥ)



fatdebug.c : եåȥޥѥǥХåؿ

    ǥХåؿޤȤ᤿

        FAT_DbgPutLevelView(DebugView *DbgWork );

            ѥưɽ



        FAT_DbgPutTypeView(DebugView *DbgWork );

            ̤



        FAT_DbgPutContView(DebugView *DbgWork );

            ̤



        DbgViewDie(void);

            ưɽ˴ؿ



        DbgViewAct(DebugView *DbgWork );

            ưɽưؿ



        NewFatC4PointView( Work* work, int name , int where );

            ưɽ



        Think3_DbgStand( Work* work );

            ǥХå׹ʹؿΩ



        Think3_DbgMove( Work* work );

            ǥХå׹ʹؿư



        Think3_DbgShoot( Work* work );

            ǥХå׹ʹؿƷ



        Think3_DbgReload( Work* work );

            ǥХå׹ʹؿ



        Think3_DbgPointMove( Work *work );

            ǥХå׹ʹؿְư



        Think3_RunningDbgPut( Work* work );

            ǥХå׹ʹؿ֤



        Think3_TurnDbgPut( Work* work )

            ǥХå׹ʹؿƲž֤



        Think3_StopDbgPut( Work* work );

            ǥХå׹ʹؿ֤



        FAT_DbgThink(Work* work);

            ǥХå׹͸ƽ



        FAT_DbgViewStatus( Work* work );

            ơɽ



        FAT_DbgDrawEyePos( Work* work );

            ɸåɽ



        FAT_DbgDrawRoute( Work* work );

            롼ɽ



        FAT_DbgSound(Work* work);

            ɥå



        FAT_DbgDrawTrgBox( Work* work );

            åɽȢ



        FAT_DbgStatusUpdate( Work* work );

            ǥХåϢι



        FAT_CallDbgDump(void);

            ǥХåƽСץå



        FAT_CallDbgViewer(void);

            ǥХåƽСƥå



        FAT_CallDbgStatus(void);

            ǥХåƽСơå



        FAT_CallDbgThink(void);

            ǥХåƽС׹ͥå



        FAT_CallDbgMotion(void);

            ǥХåƽС⡼å



        FAT_CallDbgBomb(void);

            ǥХåƽСƥå



        FAT_UpdatePutPos(Work* work);

            ǥХåֹ



        FAT_DbgMotionUpdate( Work* work);

            ǥХåѥ⡼ֹ湹



        FAT_DbgBombThink(Work* work);

            ֥ǥХå׹



        FAT_Debug( Work* work);

            ǥХåϢ

        

fatdbgmenu.c : ǥХå˥塼Ѵؿ

    ǥХå˥塼ޤȤ᤿