/*
    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 : ǥХå˥塼Ѵؿ
    ǥХå˥塼ޤȤ᤿